[hwc] drm_hwcomposer: Remove GL compositing support

Submitted by Rob Herring on May 4, 2018, 7:18 p.m.

Details

Message ID 20180504191833.6967-1-robh@kernel.org
State New
Headers show
Series "drm_hwcomposer: Remove GL compositing support" ( rev: 1 ) in DRI devel

Not browsing as part of any series.

Commit Message

Rob Herring May 4, 2018, 7:18 p.m.
The GL based compositing adds alot of complexity and was only ever well
tested on closed stacks. It also only supports GLES3.x and still relies
on sw_sync timeline which is now a debugfs feature. Those are just the
known issues.

Removing the GL compositor means everything related to squashing layers
and pre-compositing can be removed. The planner is left as it may be
useful when adding back support for overlay planes. With this change,
only a single plane is supported until ValidateDisplay learns to do
atomic modesetting test for overlay planes.

Signed-off-by: Rob Herring <robh@kernel.org>
---
I've lightly tested this with virgl. John tested an earlier version on Hikey.

This depends on reverting these commits:
"drm_hwcomposer: Cleanup gl precompositor init and provide uses_GL flag"
"drm_hwcomposer: Fall back to client compositon if the gl precompostior fails"

 Android.mk                  |   4 -
 autogl.h                    | 110 -----
 drmcompositorworker.cpp     |  78 ----
 drmdisplaycomposition.cpp   | 315 +-------------
 drmdisplaycomposition.h     |  34 +-
 drmdisplaycompositor.cpp    | 529 +----------------------
 drmdisplaycompositor.h      |  56 ---
 drmhwctwo.cpp               |   6 +-
 glworker.cpp                | 840 -----------------------------------
 glworker.h                  |  94 ----
 hwcomposer.cpp              | 841 ------------------------------------
 platform.cpp                |  93 +---
 platform.h                  |  49 +--
 platformdrmgeneric.cpp      |  17 -
 platformdrmgeneric.h        |   1 -
 platformhisi.cpp            |  23 -
 platformhisi.h              |   1 -
 platformminigbm.cpp         |  16 -
 platformminigbm.h           |   1 -
 virtualcompositorworker.cpp | 168 -------
 virtualcompositorworker.h   |  56 ---
 21 files changed, 21 insertions(+), 3311 deletions(-)
 delete mode 100644 autogl.h
 delete mode 100644 drmcompositorworker.cpp
 delete mode 100644 glworker.cpp
 delete mode 100644 glworker.h
 delete mode 100644 hwcomposer.cpp
 delete mode 100644 virtualcompositorworker.cpp
 delete mode 100644 virtualcompositorworker.h

Patch hide | download patch | download mbox

diff --git a/Android.mk b/Android.mk
index c0a1d0e7cdce..0d05f9c52de5 100644
--- a/Android.mk
+++ b/Android.mk
@@ -37,8 +37,6 @@  include $(CLEAR_VARS)
 LOCAL_SHARED_LIBRARIES := \
 	libcutils \
 	libdrm \
-	libEGL \
-	libGLESv2 \
 	libhardware \
 	liblog \
 	libsync \
@@ -63,12 +61,10 @@  LOCAL_SRC_FILES := \
 	drmmode.cpp \
 	drmplane.cpp \
 	drmproperty.cpp \
-	glworker.cpp \
 	hwcutils.cpp \
 	platform.cpp \
 	platformdrmgeneric.cpp \
 	separate_rects.cpp \
-	virtualcompositorworker.cpp \
 	vsyncworker.cpp
 
 LOCAL_CPPFLAGS += \
diff --git a/autogl.h b/autogl.h
deleted file mode 100644
index fc77fb0c1bf0..000000000000
--- a/autogl.h
+++ /dev/null
@@ -1,110 +0,0 @@ 
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_AUTO_GL_H_
-#define ANDROID_AUTO_GL_H_
-
-#include <memory>
-#define EGL_EGLEXT_PROTOTYPES
-#define GL_GLEXT_PROTOTYPES
-
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-
-// TODO(zachr): use hwc_drm_bo to turn buffer handles into textures
-#ifndef EGL_NATIVE_HANDLE_ANDROID_NVX
-#define EGL_NATIVE_HANDLE_ANDROID_NVX 0x322A
-#endif
-
-namespace android {
-
-#define AUTO_GL_TYPE(name, type, zero, deleter) \
-  struct name##Deleter {                        \
-    typedef type pointer;                       \
-                                                \
-    void operator()(pointer p) const {          \
-      if (p != zero) {                          \
-        deleter;                                \
-      }                                         \
-    }                                           \
-  };                                            \
-  typedef std::unique_ptr<type, name##Deleter> name;
-
-AUTO_GL_TYPE(AutoGLFramebuffer, GLuint, 0, glDeleteFramebuffers(1, &p))
-AUTO_GL_TYPE(AutoGLBuffer, GLuint, 0, glDeleteBuffers(1, &p))
-AUTO_GL_TYPE(AutoGLTexture, GLuint, 0, glDeleteTextures(1, &p))
-AUTO_GL_TYPE(AutoGLShader, GLint, 0, glDeleteShader(p))
-AUTO_GL_TYPE(AutoGLProgram, GLint, 0, glDeleteProgram(p))
-
-struct AutoEGLDisplayImage {
-  AutoEGLDisplayImage() = default;
-
-  AutoEGLDisplayImage(EGLDisplay display, EGLImageKHR image)
-      : display_(display), image_(image) {
-  }
-
-  AutoEGLDisplayImage(const AutoEGLDisplayImage& rhs) = delete;
-  AutoEGLDisplayImage(AutoEGLDisplayImage&& rhs) {
-    display_ = rhs.display_;
-    image_ = rhs.image_;
-    rhs.display_ = EGL_NO_DISPLAY;
-    rhs.image_ = EGL_NO_IMAGE_KHR;
-  }
-
-  ~AutoEGLDisplayImage() {
-    clear();
-  }
-
-  AutoEGLDisplayImage& operator=(const AutoEGLDisplayImage& rhs) = delete;
-  AutoEGLDisplayImage& operator=(AutoEGLDisplayImage&& rhs) {
-    clear();
-    std::swap(display_, rhs.display_);
-    std::swap(image_, rhs.image_);
-    return *this;
-  }
-
-  void reset(EGLDisplay display, EGLImageKHR image) {
-    clear();
-    display_ = display;
-    image_ = image;
-  }
-
-  void clear() {
-    if (image_ != EGL_NO_IMAGE_KHR) {
-      eglDestroyImageKHR(display_, image_);
-      display_ = EGL_NO_DISPLAY;
-      image_ = EGL_NO_IMAGE_KHR;
-    }
-  }
-
-  EGLImageKHR image() const {
-    return image_;
-  }
-
- private:
-  EGLDisplay display_ = EGL_NO_DISPLAY;
-  EGLImageKHR image_ = EGL_NO_IMAGE_KHR;
-};
-
-struct AutoEGLImageAndGLTexture {
-  AutoEGLDisplayImage image;
-  AutoGLTexture texture;
-};
-}
-
-#endif
diff --git a/drmcompositorworker.cpp b/drmcompositorworker.cpp
deleted file mode 100644
index 695876d7ae70..000000000000
--- a/drmcompositorworker.cpp
+++ /dev/null
@@ -1,78 +0,0 @@ 
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "hwc-drm-compositor-worker"
-
-#include "drmdisplaycompositor.h"
-#include "drmcompositorworker.h"
-#include "worker.h"
-
-#include <stdlib.h>
-
-#include <log/log.h>
-#include <hardware/hardware.h>
-
-namespace android {
-
-static const int64_t kSquashWait = 500000000LL;
-
-DrmCompositorWorker::DrmCompositorWorker(DrmDisplayCompositor *compositor)
-    : Worker("drm-compositor", HAL_PRIORITY_URGENT_DISPLAY),
-      compositor_(compositor) {
-}
-
-DrmCompositorWorker::~DrmCompositorWorker() {
-}
-
-int DrmCompositorWorker::Init() {
-  return InitWorker();
-}
-
-void DrmCompositorWorker::Routine() {
-  int ret;
-  if (!compositor_->HaveQueuedComposites()) {
-    Lock();
-
-    // Only use a timeout if we didn't do a SquashAll last time. This will
-    // prevent wait_ret == -ETIMEDOUT which would trigger a SquashAll and be a
-    // pointless drain on resources.
-    int wait_ret = did_squash_all_ ? WaitForSignalOrExitLocked()
-                                   : WaitForSignalOrExitLocked(kSquashWait);
-    Unlock();
-
-    switch (wait_ret) {
-      case 0:
-        break;
-      case -EINTR:
-        return;
-      case -ETIMEDOUT:
-        ret = compositor_->SquashAll();
-        if (ret)
-          ALOGE("Failed to squash all %d", ret);
-        did_squash_all_ = true;
-        return;
-      default:
-        ALOGE("Failed to wait for signal, %d", wait_ret);
-        return;
-    }
-  }
-
-  ret = compositor_->Composite();
-  if (ret)
-    ALOGE("Failed to composite! %d", ret);
-  did_squash_all_ = false;
-}
-}
diff --git a/drmdisplaycomposition.cpp b/drmdisplaycomposition.cpp
index 24a8e9c9a043..75e01a67564e 100644
--- a/drmdisplaycomposition.cpp
+++ b/drmdisplaycomposition.cpp
@@ -29,18 +29,12 @@ 
 #include <unordered_set>
 
 #include <log/log.h>
-#include <sw_sync.h>
 #include <sync/sync.h>
 #include <xf86drmMode.h>
 
 namespace android {
 
-DrmDisplayComposition::~DrmDisplayComposition() {
-  if (timeline_fd_ >= 0) {
-    SignalCompositionDone();
-    close(timeline_fd_);
-  }
-}
+DrmDisplayComposition::~DrmDisplayComposition() {}
 
 int DrmDisplayComposition::Init(DrmResources *drm, DrmCrtc *crtc,
                                 Importer *importer, Planner *planner,
@@ -51,12 +45,6 @@  int DrmDisplayComposition::Init(DrmResources *drm, DrmCrtc *crtc,
   planner_ = planner;
   frame_no_ = frame_no;
 
-  int ret = sw_sync_timeline_create();
-  if (ret < 0) {
-    ALOGE("Failed to create sw sync timeline %d", ret);
-    return ret;
-  }
-  timeline_fd_ = ret;
   return 0;
 }
 
@@ -64,26 +52,6 @@  bool DrmDisplayComposition::validate_composition_type(DrmCompositionType des) {
   return type_ == DRM_COMPOSITION_TYPE_EMPTY || type_ == des;
 }
 
-int DrmDisplayComposition::CreateNextTimelineFence() {
-  ++timeline_;
-  return sw_sync_fence_create(timeline_fd_, "hwc drm display composition fence",
-                              timeline_);
-}
-
-int DrmDisplayComposition::IncreaseTimelineToPoint(int point) {
-  int timeline_increase = point - timeline_current_;
-  if (timeline_increase <= 0)
-    return 0;
-
-  int ret = sw_sync_timeline_inc(timeline_fd_, timeline_increase);
-  if (ret)
-    ALOGE("Failed to increment sync timeline %d", ret);
-  else
-    timeline_current_ = point;
-
-  return ret;
-}
-
 int DrmDisplayComposition::SetLayers(DrmHwcLayer *layers, size_t num_layers,
                                      bool geometry_changed) {
   if (!validate_composition_type(DRM_COMPOSITION_TYPE_FRAME))
@@ -122,252 +90,38 @@  int DrmDisplayComposition::AddPlaneDisable(DrmPlane *plane) {
   return 0;
 }
 
-static std::vector<size_t> SetBitsToVector(
-    uint64_t in, const std::vector<size_t> &index_map) {
-  std::vector<size_t> out;
-  size_t msb = sizeof(in) * 8 - 1;
-  uint64_t mask = (uint64_t)1 << msb;
-  for (size_t i = msb; mask != (uint64_t)0; i--, mask >>= 1)
-    if (in & mask)
-      out.push_back(index_map[i]);
-  return out;
-}
-
 int DrmDisplayComposition::AddPlaneComposition(DrmCompositionPlane plane) {
   composition_planes_.emplace_back(std::move(plane));
   return 0;
 }
 
-void DrmDisplayComposition::SeparateLayers(DrmHwcRect<int> *exclude_rects,
-                                           size_t num_exclude_rects) {
-  DrmCompositionPlane *comp = NULL;
+void DrmDisplayComposition::SeparateLayers(DrmHwcRect<int> *,
+                                           size_t ) {
   std::vector<size_t> dedicated_layers;
 
-  // Go through the composition and find the precomp layer as well as any
-  // layers that have a dedicated plane located below the precomp layer.
+  // Go through the composition and find the layers that have a dedicated plane.
   for (auto &i : composition_planes_) {
     if (i.type() == DrmCompositionPlane::Type::kLayer) {
       dedicated_layers.insert(dedicated_layers.end(), i.source_layers().begin(),
                               i.source_layers().end());
-    } else if (i.type() == DrmCompositionPlane::Type::kPrecomp) {
-      comp = &i;
-      break;
-    }
-  }
-  if (!comp)
-    return;
-
-  const std::vector<size_t> &comp_layers = comp->source_layers();
-  if (comp_layers.size() > 64) {
-    ALOGE("Failed to separate layers because there are more than 64");
-    return;
-  }
-
-  // Index at which the actual layers begin
-  size_t layer_offset = num_exclude_rects + dedicated_layers.size();
-  if (comp_layers.size() + layer_offset > 64) {
-    ALOGW(
-        "Exclusion rectangles are being truncated to make the rectangle count "
-        "fit into 64");
-    num_exclude_rects = 64 - comp_layers.size() - dedicated_layers.size();
-  }
-
-  // We inject all the exclude rects into the rects list. Any resulting rect
-  // that includes ANY of the first num_exclude_rects is rejected. After the
-  // exclude rects, we add the lower layers. The rects that intersect with
-  // these layers will be inspected and only those which are to be composited
-  // above the layer will be included in the composition regions.
-  std::vector<DrmHwcRect<int>> layer_rects(comp_layers.size() + layer_offset);
-  std::copy(exclude_rects, exclude_rects + num_exclude_rects,
-            layer_rects.begin());
-  std::transform(
-      dedicated_layers.begin(), dedicated_layers.end(),
-      layer_rects.begin() + num_exclude_rects,
-      [=](size_t layer_index) { return layers_[layer_index].display_frame; });
-  std::transform(comp_layers.begin(), comp_layers.end(),
-                 layer_rects.begin() + layer_offset, [=](size_t layer_index) {
-    return layers_[layer_index].display_frame;
-  });
-
-  std::vector<separate_rects::RectSet<uint64_t, int>> separate_regions;
-  separate_rects::separate_rects_64(layer_rects, &separate_regions);
-  uint64_t exclude_mask = ((uint64_t)1 << num_exclude_rects) - 1;
-  uint64_t dedicated_mask = (((uint64_t)1 << dedicated_layers.size()) - 1)
-                            << num_exclude_rects;
-
-  for (separate_rects::RectSet<uint64_t, int> &region : separate_regions) {
-    if (region.id_set.getBits() & exclude_mask)
-      continue;
-
-    // If a rect intersects one of the dedicated layers, we need to remove the
-    // layers from the composition region which appear *below* the dedicated
-    // layer. This effectively punches a hole through the composition layer such
-    // that the dedicated layer can be placed below the composition and not
-    // be occluded.
-    uint64_t dedicated_intersect = region.id_set.getBits() & dedicated_mask;
-    for (size_t i = 0; dedicated_intersect && i < dedicated_layers.size();
-         ++i) {
-      // Only exclude layers if they intersect this particular dedicated layer
-      if (!(dedicated_intersect & (1 << (i + num_exclude_rects))))
-        continue;
-
-      for (size_t j = 0; j < comp_layers.size(); ++j) {
-        if (comp_layers[j] < dedicated_layers[i])
-          region.id_set.subtract(j + layer_offset);
-      }
     }
-    if (!(region.id_set.getBits() >> layer_offset))
-      continue;
-
-    pre_comp_regions_.emplace_back(DrmCompositionRegion{
-        region.rect,
-        SetBitsToVector(region.id_set.getBits() >> layer_offset, comp_layers)});
   }
 }
 
-int DrmDisplayComposition::CreateAndAssignReleaseFences() {
-  std::unordered_set<DrmHwcLayer *> squash_layers;
-  std::unordered_set<DrmHwcLayer *> pre_comp_layers;
-  std::unordered_set<DrmHwcLayer *> comp_layers;
-
-  for (const DrmCompositionRegion &region : squash_regions_) {
-    for (size_t source_layer_index : region.source_layers) {
-      DrmHwcLayer *source_layer = &layers_[source_layer_index];
-      squash_layers.emplace(source_layer);
-    }
-  }
-
-  for (const DrmCompositionRegion &region : pre_comp_regions_) {
-    for (size_t source_layer_index : region.source_layers) {
-      DrmHwcLayer *source_layer = &layers_[source_layer_index];
-      pre_comp_layers.emplace(source_layer);
-      squash_layers.erase(source_layer);
-    }
-  }
-
-  for (const DrmCompositionPlane &plane : composition_planes_) {
-    if (plane.type() == DrmCompositionPlane::Type::kLayer) {
-      for (auto i : plane.source_layers()) {
-        DrmHwcLayer *source_layer = &layers_[i];
-        comp_layers.emplace(source_layer);
-        pre_comp_layers.erase(source_layer);
-      }
-    }
-  }
-
-  for (DrmHwcLayer *layer : squash_layers) {
-    if (!layer->release_fence)
-      continue;
-    int ret = layer->release_fence.Set(CreateNextTimelineFence());
-    if (ret < 0) {
-      ALOGE("Failed to set the release fence (squash) %d", ret);
-      return ret;
-    }
-  }
-  timeline_squash_done_ = timeline_;
-
-  for (DrmHwcLayer *layer : pre_comp_layers) {
-    if (!layer->release_fence)
-      continue;
-    int ret = layer->release_fence.Set(CreateNextTimelineFence());
-    if (ret < 0)
-      return ret;
-  }
-  timeline_pre_comp_done_ = timeline_;
-
-  for (DrmHwcLayer *layer : comp_layers) {
-    if (!layer->release_fence)
-      continue;
-    int ret = layer->release_fence.Set(CreateNextTimelineFence());
-    if (ret < 0) {
-      ALOGE("Failed to set the release fence (comp) %d", ret);
-      return ret;
-    }
-  }
-
-  return 0;
-}
-
-int DrmDisplayComposition::Plan(SquashState *squash,
-                                std::vector<DrmPlane *> *primary_planes,
+int DrmDisplayComposition::Plan(std::vector<DrmPlane *> *primary_planes,
                                 std::vector<DrmPlane *> *overlay_planes) {
   if (type_ != DRM_COMPOSITION_TYPE_FRAME)
     return 0;
 
-  // Used to track which layers should be sent to the planner. We exclude layers
-  // that are entirely squashed so the planner can provision a precomposition
-  // layer as appropriate (ex: if 5 layers are squashed and 1 is not, we don't
-  // want to plan a precomposition layer that will be comprised of the already
-  // squashed layers).
   std::map<size_t, DrmHwcLayer *> to_composite;
 
-  bool use_squash_framebuffer = false;
-  // Used to determine which layers were entirely squashed
-  std::vector<int> layer_squash_area(layers_.size(), 0);
-  // Used to avoid rerendering regions that were squashed
-  std::vector<DrmHwcRect<int>> exclude_rects;
-  if (squash != NULL) {
-    if (geometry_changed_) {
-      squash->Init(layers_.data(), layers_.size());
-    } else {
-      std::vector<bool> changed_regions;
-      squash->GenerateHistory(layers_.data(), layers_.size(), changed_regions);
-
-      std::vector<bool> stable_regions;
-      squash->StableRegionsWithMarginalHistory(changed_regions, stable_regions);
-
-      // Only if SOME region is stable
-      use_squash_framebuffer =
-          std::find(stable_regions.begin(), stable_regions.end(), true) !=
-          stable_regions.end();
-
-      squash->RecordHistory(layers_.data(), layers_.size(), changed_regions);
-
-      // Changes in which regions are squashed triggers a rerender via
-      // squash_regions.
-      bool render_squash = squash->RecordAndCompareSquashed(stable_regions);
-
-      for (size_t region_index = 0; region_index < stable_regions.size();
-           region_index++) {
-        const SquashState::Region &region = squash->regions()[region_index];
-        if (!stable_regions[region_index])
-          continue;
-
-        exclude_rects.emplace_back(region.rect);
-
-        if (render_squash) {
-          squash_regions_.emplace_back();
-          squash_regions_.back().frame = region.rect;
-        }
-
-        int frame_area = region.rect.area();
-        // Source layers are sorted front to back i.e. top layer has lowest
-        // index.
-        for (size_t layer_index = layers_.size();
-             layer_index-- > 0;  // Yes, I double checked this
-             /* See condition */) {
-          if (!region.layer_refs[layer_index])
-            continue;
-          layer_squash_area[layer_index] += frame_area;
-          if (render_squash)
-            squash_regions_.back().source_layers.push_back(layer_index);
-        }
-      }
-    }
-
-    for (size_t i = 0; i < layers_.size(); ++i) {
-      if (layer_squash_area[i] < layers_[i].display_frame.area())
-        to_composite.emplace(std::make_pair(i, &layers_[i]));
-    }
-  } else {
-    for (size_t i = 0; i < layers_.size(); ++i)
-      to_composite.emplace(std::make_pair(i, &layers_[i]));
-  }
+  for (size_t i = 0; i < layers_.size(); ++i)
+    to_composite.emplace(std::make_pair(i, &layers_[i]));
 
   int ret;
   std::vector<DrmCompositionPlane> plan;
   std::tie(ret, composition_planes_) =
-      planner_->ProvisionPlanes(to_composite, use_squash_framebuffer, crtc_,
+      planner_->ProvisionPlanes(to_composite, crtc_,
                                 primary_planes, overlay_planes);
   if (ret) {
     ALOGE("Planner failed provisioning planes ret=%d", ret);
@@ -396,17 +150,7 @@  int DrmDisplayComposition::Plan(SquashState *squash,
     }
   }
 
-  return FinalizeComposition(exclude_rects.data(), exclude_rects.size());
-}
-
-int DrmDisplayComposition::FinalizeComposition() {
-  return FinalizeComposition(NULL, 0);
-}
-
-int DrmDisplayComposition::FinalizeComposition(DrmHwcRect<int> *exclude_rects,
-                                               size_t num_exclude_rects) {
-  SeparateLayers(exclude_rects, num_exclude_rects);
-  return CreateAndAssignReleaseFences();
+  return 0;
 }
 
 static const char *DrmCompositionTypeToString(DrmCompositionType type) {
@@ -506,23 +250,6 @@  static const char *BlendingToString(DrmHwcBlending blending) {
   }
 }
 
-static void DumpRegion(const DrmCompositionRegion &region,
-                       std::ostringstream *out) {
-  *out << "frame";
-  region.frame.Dump(out);
-  *out << " source_layers=(";
-
-  const std::vector<size_t> &source_layers = region.source_layers;
-  for (size_t i = 0; i < source_layers.size(); i++) {
-    *out << source_layers[i];
-    if (i < source_layers.size() - 1) {
-      *out << " ";
-    }
-  }
-
-  *out << ")";
-}
-
 void DrmDisplayComposition::Dump(std::ostringstream *out) const {
   *out << "----DrmDisplayComposition"
        << " crtc=" << (crtc_ ? crtc_->id() : -1)
@@ -540,10 +267,6 @@  void DrmDisplayComposition::Dump(std::ostringstream *out) const {
       break;
   }
 
-  *out << " timeline[current/squash/pre-comp/done]=" << timeline_current_ << "/"
-       << timeline_squash_done_ << "/" << timeline_pre_comp_done_ << "/"
-       << timeline_ << "\n";
-
   *out << "    Layers: count=" << layers_.size() << "\n";
   for (size_t i = 0; i < layers_.size(); i++) {
     const DrmHwcLayer &layer = layers_[i];
@@ -578,12 +301,6 @@  void DrmDisplayComposition::Dump(std::ostringstream *out) const {
       case DrmCompositionPlane::Type::kLayer:
         *out << "LAYER";
         break;
-      case DrmCompositionPlane::Type::kPrecomp:
-        *out << "PRECOMP";
-        break;
-      case DrmCompositionPlane::Type::kSquash:
-        *out << "SQUASH";
-        break;
       default:
         *out << "<invalid>";
         break;
@@ -595,19 +312,5 @@  void DrmDisplayComposition::Dump(std::ostringstream *out) const {
     }
     *out << "\n";
   }
-
-  *out << "    Squash Regions: count=" << squash_regions_.size() << "\n";
-  for (size_t i = 0; i < squash_regions_.size(); i++) {
-    *out << "      [" << i << "] ";
-    DumpRegion(squash_regions_[i], out);
-    *out << "\n";
-  }
-
-  *out << "    Pre-Comp Regions: count=" << pre_comp_regions_.size() << "\n";
-  for (size_t i = 0; i < pre_comp_regions_.size(); i++) {
-    *out << "      [" << i << "] ";
-    DumpRegion(pre_comp_regions_[i], out);
-    *out << "\n";
-  }
 }
 }
diff --git a/drmdisplaycomposition.h b/drmdisplaycomposition.h
index 918392578753..b7fccb9cd283 100644
--- a/drmdisplaycomposition.h
+++ b/drmdisplaycomposition.h
@@ -20,7 +20,6 @@ 
 #include "drmcrtc.h"
 #include "drmhwcomposer.h"
 #include "drmplane.h"
-#include "glworker.h"
 
 #include <sstream>
 #include <vector>
@@ -62,8 +61,6 @@  class DrmCompositionPlane {
   enum class Type : int32_t {
     kDisable,
     kLayer,
-    kPrecomp,
-    kSquash,
   };
 
   DrmCompositionPlane() = default;
@@ -125,34 +122,15 @@  class DrmDisplayComposition {
   int SetDpmsMode(uint32_t dpms_mode);
   int SetDisplayMode(const DrmMode &display_mode);
 
-  int Plan(SquashState *squash, std::vector<DrmPlane *> *primary_planes,
+  int Plan(std::vector<DrmPlane *> *primary_planes,
            std::vector<DrmPlane *> *overlay_planes);
 
   int FinalizeComposition();
 
-  int CreateNextTimelineFence();
-  int SignalSquashDone() {
-    return IncreaseTimelineToPoint(timeline_squash_done_);
-  }
-  int SignalPreCompDone() {
-    return IncreaseTimelineToPoint(timeline_pre_comp_done_);
-  }
-  int SignalCompositionDone() {
-    return IncreaseTimelineToPoint(timeline_);
-  }
-
   std::vector<DrmHwcLayer> &layers() {
     return layers_;
   }
 
-  std::vector<DrmCompositionRegion> &squash_regions() {
-    return squash_regions_;
-  }
-
-  std::vector<DrmCompositionRegion> &pre_comp_regions() {
-    return pre_comp_regions_;
-  }
-
   std::vector<DrmCompositionPlane> &composition_planes() {
     return composition_planes_;
   }
@@ -202,12 +180,9 @@  class DrmDisplayComposition {
  private:
   bool validate_composition_type(DrmCompositionType desired);
 
-  int IncreaseTimelineToPoint(int point);
-
   int FinalizeComposition(DrmHwcRect<int> *exclude_rects,
                           size_t num_exclude_rects);
   void SeparateLayers(DrmHwcRect<int> *exclude_rects, size_t num_exclude_rects);
-  int CreateAndAssignReleaseFences();
 
   DrmResources *drm_ = NULL;
   DrmCrtc *crtc_ = NULL;
@@ -218,17 +193,10 @@  class DrmDisplayComposition {
   uint32_t dpms_mode_ = DRM_MODE_DPMS_ON;
   DrmMode display_mode_;
 
-  int timeline_fd_ = -1;
-  int timeline_ = 0;
-  int timeline_current_ = 0;
-  int timeline_squash_done_ = 0;
-  int timeline_pre_comp_done_ = 0;
   UniqueFd out_fence_ = -1;
 
   bool geometry_changed_;
   std::vector<DrmHwcLayer> layers_;
-  std::vector<DrmCompositionRegion> squash_regions_;
-  std::vector<DrmCompositionRegion> pre_comp_regions_;
   std::vector<DrmCompositionPlane> composition_planes_;
 
   uint64_t frame_no_ = 0;
diff --git a/drmdisplaycompositor.cpp b/drmdisplaycompositor.cpp
index e570923de942..34a729924fc6 100644
--- a/drmdisplaycompositor.cpp
+++ b/drmdisplaycompositor.cpp
@@ -35,153 +35,15 @@ 
 #include "drmcrtc.h"
 #include "drmplane.h"
 #include "drmresources.h"
-#include "glworker.h"
 
 namespace android {
 
-void SquashState::Init(DrmHwcLayer *layers, size_t num_layers) {
-  generation_number_++;
-  valid_history_ = 0;
-  regions_.clear();
-  last_handles_.clear();
-
-  std::vector<DrmHwcRect<int>> in_rects;
-  for (size_t i = 0; i < num_layers; i++) {
-    DrmHwcLayer *layer = &layers[i];
-    in_rects.emplace_back(layer->display_frame);
-    last_handles_.push_back(layer->sf_handle);
-  }
-
-  std::vector<separate_rects::RectSet<uint64_t, int>> out_regions;
-  separate_rects::separate_rects_64(in_rects, &out_regions);
-
-  for (const separate_rects::RectSet<uint64_t, int> &out_region : out_regions) {
-    regions_.emplace_back();
-    Region &region = regions_.back();
-    region.rect = out_region.rect;
-    region.layer_refs = out_region.id_set.getBits();
-  }
-}
-
-void SquashState::GenerateHistory(DrmHwcLayer *layers, size_t num_layers,
-                                  std::vector<bool> &changed_regions) const {
-  changed_regions.resize(regions_.size());
-  if (num_layers != last_handles_.size()) {
-    ALOGE("SquashState::GenerateHistory expected %zu layers but got %zu layers",
-          last_handles_.size(), num_layers);
-    return;
-  }
-  std::bitset<kMaxLayers> changed_layers;
-  for (size_t i = 0; i < last_handles_.size(); i++) {
-    DrmHwcLayer *layer = &layers[i];
-    // Protected layers can't be squashed so we treat them as constantly
-    // changing.
-    if (layer->protected_usage() || last_handles_[i] != layer->sf_handle)
-      changed_layers.set(i);
-  }
-
-  for (size_t i = 0; i < regions_.size(); i++) {
-    changed_regions[i] = (regions_[i].layer_refs & changed_layers).any();
-  }
-}
-
-void SquashState::StableRegionsWithMarginalHistory(
-    const std::vector<bool> &changed_regions,
-    std::vector<bool> &stable_regions) const {
-  stable_regions.resize(regions_.size());
-  for (size_t i = 0; i < regions_.size(); i++) {
-    stable_regions[i] = !changed_regions[i] && is_stable(i);
-  }
-}
-
-void SquashState::RecordHistory(DrmHwcLayer *layers, size_t num_layers,
-                                const std::vector<bool> &changed_regions) {
-  if (num_layers != last_handles_.size()) {
-    ALOGE("SquashState::RecordHistory expected %zu layers but got %zu layers",
-          last_handles_.size(), num_layers);
-    return;
-  }
-  if (changed_regions.size() != regions_.size()) {
-    ALOGE("SquashState::RecordHistory expected %zu regions but got %zu regions",
-          regions_.size(), changed_regions.size());
-    return;
-  }
-
-  for (size_t i = 0; i < last_handles_.size(); i++) {
-    DrmHwcLayer *layer = &layers[i];
-    last_handles_[i] = layer->sf_handle;
-  }
-
-  for (size_t i = 0; i < regions_.size(); i++) {
-    regions_[i].change_history <<= 1;
-    regions_[i].change_history.set(/* LSB */ 0, changed_regions[i]);
-  }
-
-  valid_history_++;
-}
-
-bool SquashState::RecordAndCompareSquashed(
-    const std::vector<bool> &squashed_regions) {
-  if (squashed_regions.size() != regions_.size()) {
-    ALOGE(
-        "SquashState::RecordAndCompareSquashed expected %zu regions but got "
-        "%zu regions",
-        regions_.size(), squashed_regions.size());
-    return false;
-  }
-  bool changed = false;
-  for (size_t i = 0; i < regions_.size(); i++) {
-    if (regions_[i].squashed != squashed_regions[i]) {
-      regions_[i].squashed = squashed_regions[i];
-      changed = true;
-    }
-  }
-  return changed;
-}
-
-void SquashState::Dump(std::ostringstream *out) const {
-  *out << "----SquashState generation=" << generation_number_
-       << " history=" << valid_history_ << "\n"
-       << "    Regions: count=" << regions_.size() << "\n";
-  for (size_t i = 0; i < regions_.size(); i++) {
-    const Region &region = regions_[i];
-    *out << "      [" << i << "]"
-         << " history=" << region.change_history << " rect";
-    region.rect.Dump(out);
-    *out << " layers=(";
-    bool first = true;
-    for (size_t layer_index = 0; layer_index < kMaxLayers; layer_index++) {
-      if ((region.layer_refs &
-           std::bitset<kMaxLayers>((size_t)1 << layer_index))
-              .any()) {
-        if (!first)
-          *out << " ";
-        first = false;
-        *out << layer_index;
-      }
-    }
-    *out << ")";
-    if (region.squashed)
-      *out << " squashed";
-    *out << "\n";
-  }
-}
-
-static bool UsesSquash(const std::vector<DrmCompositionPlane> &comp_planes) {
-  return std::any_of(comp_planes.begin(), comp_planes.end(),
-                     [](const DrmCompositionPlane &plane) {
-    return plane.type() == DrmCompositionPlane::Type::kSquash;
-  });
-}
-
 DrmDisplayCompositor::DrmDisplayCompositor()
     : drm_(NULL),
       display_(-1),
       initialized_(false),
       active_(false),
       use_hw_overlays_(true),
-      framebuffer_index_(0),
-      squash_framebuffer_index_(0),
       dump_frames_composited_(0),
       dump_last_timestamp_ns_(0) {
   struct timespec ts;
@@ -244,112 +106,6 @@  DrmDisplayCompositor::GetActiveModeResolution() {
   return std::make_tuple(mode.h_display(), mode.v_display(), 0);
 }
 
-int DrmDisplayCompositor::PrepareFramebuffer(
-    DrmFramebuffer &fb, DrmDisplayComposition *display_comp) {
-  int ret = fb.WaitReleased(-1);
-  if (ret) {
-    ALOGE("Failed to wait for framebuffer release %d", ret);
-    return ret;
-  }
-  uint32_t width, height;
-  std::tie(width, height, ret) = GetActiveModeResolution();
-  if (ret) {
-    ALOGE(
-        "Failed to allocate framebuffer because the display resolution could "
-        "not be determined %d",
-        ret);
-    return ret;
-  }
-
-  fb.set_release_fence_fd(-1);
-  if (!fb.Allocate(width, height)) {
-    ALOGE("Failed to allocate framebuffer with size %dx%d", width, height);
-    return -ENOMEM;
-  }
-
-  display_comp->layers().emplace_back();
-  DrmHwcLayer &pre_comp_layer = display_comp->layers().back();
-  pre_comp_layer.sf_handle = fb.buffer()->handle;
-  pre_comp_layer.blending = DrmHwcBlending::kPreMult;
-  pre_comp_layer.source_crop = DrmHwcRect<float>(0, 0, width, height);
-  pre_comp_layer.display_frame = DrmHwcRect<int>(0, 0, width, height);
-  ret = pre_comp_layer.buffer.ImportBuffer(fb.buffer()->handle,
-                                           display_comp->importer());
-  if (ret) {
-    ALOGE("Failed to import framebuffer for display %d", ret);
-    return ret;
-  }
-
-  return ret;
-}
-
-int DrmDisplayCompositor::ApplySquash(DrmDisplayComposition *display_comp) {
-  int ret = 0;
-
-  DrmFramebuffer &fb = squash_framebuffers_[squash_framebuffer_index_];
-  ret = PrepareFramebuffer(fb, display_comp);
-  if (ret) {
-    ALOGE("Failed to prepare framebuffer for squash %d", ret);
-    return ret;
-  }
-
-  std::vector<DrmCompositionRegion> &regions = display_comp->squash_regions();
-  ret = pre_compositor_->Composite(display_comp->layers().data(),
-                                   regions.data(), regions.size(), fb.buffer(),
-                                   display_comp->importer());
-  pre_compositor_->Finish();
-
-  if (ret) {
-    ALOGE("Failed to squash layers");
-    return ret;
-  }
-
-  ret = display_comp->CreateNextTimelineFence();
-  if (ret <= 0) {
-    ALOGE("Failed to create squash framebuffer release fence %d", ret);
-    return ret;
-  }
-
-  fb.set_release_fence_fd(ret);
-  display_comp->SignalSquashDone();
-
-  return 0;
-}
-
-int DrmDisplayCompositor::ApplyPreComposite(
-    DrmDisplayComposition *display_comp) {
-  int ret = 0;
-
-  DrmFramebuffer &fb = framebuffers_[framebuffer_index_];
-  ret = PrepareFramebuffer(fb, display_comp);
-  if (ret) {
-    ALOGE("Failed to prepare framebuffer for pre-composite %d", ret);
-    return ret;
-  }
-
-  std::vector<DrmCompositionRegion> &regions = display_comp->pre_comp_regions();
-  ret = pre_compositor_->Composite(display_comp->layers().data(),
-                                   regions.data(), regions.size(), fb.buffer(),
-                                   display_comp->importer());
-  pre_compositor_->Finish();
-
-  if (ret) {
-    ALOGE("Failed to pre-composite layers");
-    return ret;
-  }
-
-  ret = display_comp->CreateNextTimelineFence();
-  if (ret <= 0) {
-    ALOGE("Failed to create pre-composite framebuffer release fence %d", ret);
-    return ret;
-  }
-
-  fb.set_release_fence_fd(ret);
-  display_comp->SignalPreCompDone();
-
-  return 0;
-}
-
 int DrmDisplayCompositor::DisablePlanes(DrmDisplayComposition *display_comp) {
   drmModeAtomicReqPtr pset = drmModeAtomicAlloc();
   if (!pset) {
@@ -384,103 +140,6 @@  int DrmDisplayCompositor::DisablePlanes(DrmDisplayComposition *display_comp) {
   return 0;
 }
 
-int DrmDisplayCompositor::PrepareFrame(DrmDisplayComposition *display_comp) {
-  int ret = 0;
-
-  std::vector<DrmHwcLayer> &layers = display_comp->layers();
-  std::vector<DrmCompositionPlane> &comp_planes =
-      display_comp->composition_planes();
-  std::vector<DrmCompositionRegion> &squash_regions =
-      display_comp->squash_regions();
-  std::vector<DrmCompositionRegion> &pre_comp_regions =
-      display_comp->pre_comp_regions();
-
-  if (!pre_compositor_) {
-    pre_compositor_.reset(new GLWorkerCompositor());
-    int ret = pre_compositor_->Init();
-    if (ret) {
-      ALOGE("Failed to initialize OpenGL compositor %d", ret);
-      return ret;
-    }
-  }
-
-  int squash_layer_index = -1;
-  if (squash_regions.size() > 0) {
-    squash_framebuffer_index_ = (squash_framebuffer_index_ + 1) % 2;
-    ret = ApplySquash(display_comp);
-    if (ret)
-      return ret;
-
-    squash_layer_index = layers.size() - 1;
-  } else {
-    if (UsesSquash(comp_planes)) {
-      DrmFramebuffer &fb = squash_framebuffers_[squash_framebuffer_index_];
-      layers.emplace_back();
-      squash_layer_index = layers.size() - 1;
-      DrmHwcLayer &squash_layer = layers.back();
-      ret = squash_layer.buffer.ImportBuffer(fb.buffer()->handle,
-                                             display_comp->importer());
-      if (ret) {
-        ALOGE("Failed to import old squashed framebuffer %d", ret);
-        return ret;
-      }
-      squash_layer.sf_handle = fb.buffer()->handle;
-      squash_layer.blending = DrmHwcBlending::kPreMult;
-      squash_layer.source_crop = DrmHwcRect<float>(
-          0, 0, squash_layer.buffer->width, squash_layer.buffer->height);
-      squash_layer.display_frame = DrmHwcRect<int>(
-          0, 0, squash_layer.buffer->width, squash_layer.buffer->height);
-      ret = display_comp->CreateNextTimelineFence();
-
-      if (ret <= 0) {
-        ALOGE("Failed to create squash framebuffer release fence %d", ret);
-        return ret;
-      }
-
-      fb.set_release_fence_fd(ret);
-      ret = 0;
-    }
-  }
-
-  bool do_pre_comp = pre_comp_regions.size() > 0;
-  int pre_comp_layer_index = -1;
-  if (do_pre_comp) {
-    ret = ApplyPreComposite(display_comp);
-    if (ret)
-      return ret;
-
-    pre_comp_layer_index = layers.size() - 1;
-    framebuffer_index_ = (framebuffer_index_ + 1) % DRM_DISPLAY_BUFFERS;
-  }
-
-  for (DrmCompositionPlane &comp_plane : comp_planes) {
-    std::vector<size_t> &source_layers = comp_plane.source_layers();
-    switch (comp_plane.type()) {
-      case DrmCompositionPlane::Type::kSquash:
-        if (source_layers.size())
-          ALOGE("Squash source_layers is expected to be empty (%zu/%d)",
-                source_layers[0], squash_layer_index);
-        source_layers.push_back(squash_layer_index);
-        break;
-      case DrmCompositionPlane::Type::kPrecomp:
-        if (!do_pre_comp) {
-          ALOGE(
-              "Can not use pre composite framebuffer with no pre composite "
-              "regions");
-          return -EINVAL;
-        }
-        // Replace source_layers with the output of the precomposite
-        source_layers.clear();
-        source_layers.push_back(pre_comp_layer_index);
-        break;
-      default:
-        break;
-    }
-  }
-
-  return ret;
-}
-
 int DrmDisplayCompositor::CommitFrame(DrmDisplayComposition *display_comp,
                                       bool test_only) {
   ATRACE_CALL();
@@ -778,8 +437,6 @@  void DrmDisplayCompositor::ClearDisplay() {
   if (DisablePlanes(active_composition_.get()))
     return;
 
-  active_composition_->SignalCompositionDone();
-
   active_composition_.reset(NULL);
 }
 
@@ -799,9 +456,6 @@  void DrmDisplayCompositor::ApplyFrame(
   }
   ++dump_frames_composited_;
 
-  if (active_composition_)
-    active_composition_->SignalCompositionDone();
-
   ret = pthread_mutex_lock(&lock_);
   if (ret)
     ALOGE("Failed to acquire lock for active_composition swap");
@@ -819,38 +473,16 @@  int DrmDisplayCompositor::ApplyComposition(
   int ret = 0;
   switch (composition->type()) {
     case DRM_COMPOSITION_TYPE_FRAME:
-      ret = PrepareFrame(composition.get());
-      if (ret) {
-        ALOGE("Failed to prepare frame for display %d", display_);
-        return ret;
-      }
       if (composition->geometry_changed()) {
         // Send the composition to the kernel to ensure we can commit it. This
-        // is just a test, it won't actually commit the frame. If rejected,
-        // squash the frame into one layer and use the squashed composition
+        // is just a test, it won't actually commit the frame.
         ret = CommitFrame(composition.get(), true);
-        if (ret)
-          ALOGI("Commit test failed, squashing frame for display %d", display_);
-        use_hw_overlays_ = !ret;
-      }
-
-      // If use_hw_overlays_ is false, we can't use hardware to composite the
-      // frame. So squash all layers into a single composition and apply that
-      // instead.
-      if (!use_hw_overlays_) {
-        std::unique_ptr<DrmDisplayComposition> squashed = CreateComposition();
-        ret = SquashFrame(composition.get(), squashed.get());
-        if (!ret) {
-          composition = std::move(squashed);
-        } else {
-          ALOGE("Failed to squash frame for display %d", display_);
-          // Disable the hw used by the last active composition. This allows us
-          // to signal the release fences from that composition to avoid
-          // hanging.
-          ClearDisplay();
+        if (ret) {
+          ALOGE("Commit test failed for display %d, FIXME", display_);
           return ret;
         }
       }
+
       ApplyFrame(std::move(composition), ret);
       break;
     case DRM_COMPOSITION_TYPE_DPMS:
@@ -878,154 +510,6 @@  int DrmDisplayCompositor::ApplyComposition(
   return ret;
 }
 
-int DrmDisplayCompositor::SquashAll() {
-  AutoLock lock(&lock_, "compositor");
-  int ret = lock.Lock();
-  if (ret)
-    return ret;
-
-  if (!active_composition_)
-    return 0;
-
-  std::unique_ptr<DrmDisplayComposition> comp = CreateComposition();
-  ret = SquashFrame(active_composition_.get(), comp.get());
-
-  // ApplyFrame needs the lock
-  lock.Unlock();
-
-  if (!ret)
-    ApplyFrame(std::move(comp), 0);
-
-  return ret;
-}
-
-// Returns:
-//   - 0 if src is successfully squashed into dst
-//   - -EALREADY if the src is already squashed
-//   - Appropriate error if the squash fails
-int DrmDisplayCompositor::SquashFrame(DrmDisplayComposition *src,
-                                      DrmDisplayComposition *dst) {
-  if (src->type() != DRM_COMPOSITION_TYPE_FRAME)
-    return -ENOTSUP;
-
-  std::vector<DrmCompositionPlane> &src_planes = src->composition_planes();
-  std::vector<DrmHwcLayer> &src_layers = src->layers();
-
-  // Make sure there is more than one layer to squash.
-  size_t src_planes_with_layer = std::count_if(
-      src_planes.begin(), src_planes.end(), [](DrmCompositionPlane &p) {
-        return p.type() != DrmCompositionPlane::Type::kDisable;
-      });
-  if (src_planes_with_layer <= 1)
-    return -EALREADY;
-
-  int pre_comp_layer_index;
-
-  int ret = dst->Init(drm_, src->crtc(), src->importer(), src->planner(),
-                      src->frame_no());
-  if (ret) {
-    ALOGE("Failed to init squash all composition %d", ret);
-    return ret;
-  }
-
-  DrmCompositionPlane squashed_comp(DrmCompositionPlane::Type::kPrecomp, NULL,
-                                    src->crtc());
-  std::vector<DrmHwcLayer> dst_layers;
-  for (DrmCompositionPlane &comp_plane : src_planes) {
-    // Composition planes without DRM planes should never happen
-    if (comp_plane.plane() == NULL) {
-      ALOGE("Skipping squash all because of NULL plane");
-      ret = -EINVAL;
-      goto move_layers_back;
-    }
-
-    if (comp_plane.plane()->type() == DRM_PLANE_TYPE_PRIMARY)
-      squashed_comp.set_plane(comp_plane.plane());
-    else
-      dst->AddPlaneDisable(comp_plane.plane());
-
-    if (comp_plane.type() == DrmCompositionPlane::Type::kDisable)
-      continue;
-
-    for (auto i : comp_plane.source_layers()) {
-      DrmHwcLayer &layer = src_layers[i];
-
-      // Squashing protected layers is impossible.
-      if (layer.protected_usage()) {
-        ret = -ENOTSUP;
-        goto move_layers_back;
-      }
-
-      // The OutputFds point to freed memory after hwc_set returns. They are
-      // returned to the default to prevent DrmDisplayComposition::Plan from
-      // filling the OutputFds.
-      layer.release_fence = OutputFd();
-      dst_layers.emplace_back(std::move(layer));
-      squashed_comp.source_layers().push_back(
-          squashed_comp.source_layers().size());
-    }
-  }
-
-  if (squashed_comp.plane() == NULL) {
-    ALOGE("Primary plane not found for squash");
-    ret = -ENOTSUP;
-    goto move_layers_back;
-  }
-
-  ret = dst->SetLayers(dst_layers.data(), dst_layers.size(), false);
-  if (ret) {
-    ALOGE("Failed to set layers for squash all composition %d", ret);
-    goto move_layers_back;
-  }
-
-  ret = dst->AddPlaneComposition(std::move(squashed_comp));
-  if (ret) {
-    ALOGE("Failed to add squashed plane composition %d", ret);
-    goto move_layers_back;
-  }
-
-  ret = dst->FinalizeComposition();
-  if (ret) {
-    ALOGE("Failed to plan for squash all composition %d", ret);
-    goto move_layers_back;
-  }
-
-  ret = ApplyPreComposite(dst);
-  if (ret) {
-    ALOGE("Failed to pre-composite for squash all composition %d", ret);
-    goto move_layers_back;
-  }
-
-  pre_comp_layer_index = dst->layers().size() - 1;
-  framebuffer_index_ = (framebuffer_index_ + 1) % DRM_DISPLAY_BUFFERS;
-
-  for (DrmCompositionPlane &plane : dst->composition_planes()) {
-    if (plane.type() == DrmCompositionPlane::Type::kPrecomp) {
-      // Replace source_layers with the output of the precomposite
-      plane.source_layers().clear();
-      plane.source_layers().push_back(pre_comp_layer_index);
-      break;
-    }
-  }
-
-  return 0;
-
-// TODO(zachr): think of a better way to transfer ownership back to the active
-// composition.
-move_layers_back:
-  for (size_t plane_index = 0;
-       plane_index < src_planes.size() && plane_index < dst_layers.size();) {
-    if (src_planes[plane_index].source_layers().empty()) {
-      plane_index++;
-      continue;
-    }
-    for (auto i : src_planes[plane_index].source_layers())
-      src_layers[i] = std::move(dst_layers[plane_index++]);
-  }
-
-  return ret;
-}
-
 void DrmDisplayCompositor::Dump(std::ostringstream *out) const {
   int ret = pthread_mutex_lock(&lock_);
   if (ret)
@@ -1051,11 +535,6 @@  void DrmDisplayCompositor::Dump(std::ostringstream *out) const {
 
   dump_last_timestamp_ns_ = cur_ts;
 
-  if (active_composition_)
-    active_composition_->Dump(out);
-
-  squash_state_.Dump(out);
-
   pthread_mutex_unlock(&lock_);
 }
 }
diff --git a/drmdisplaycompositor.h b/drmdisplaycompositor.h
index f1965fb0ad7f..eaf82fca989d 100644
--- a/drmdisplaycompositor.h
+++ b/drmdisplaycompositor.h
@@ -36,49 +36,6 @@ 
 
 namespace android {
 
-class GLWorkerCompositor;
-
-class SquashState {
- public:
-  static const unsigned kHistoryLength = 6;  // TODO: make this number not magic
-  static const unsigned kMaxLayers = 64;
-
-  struct Region {
-    DrmHwcRect<int> rect;
-    std::bitset<kMaxLayers> layer_refs;
-    std::bitset<kHistoryLength> change_history;
-    bool squashed = false;
-  };
-
-  bool is_stable(int region_index) const {
-    return valid_history_ >= kHistoryLength &&
-           regions_[region_index].change_history.none();
-  }
-
-  const std::vector<Region> &regions() const {
-    return regions_;
-  }
-
-  void Init(DrmHwcLayer *layers, size_t num_layers);
-  void GenerateHistory(DrmHwcLayer *layers, size_t num_layers,
-                       std::vector<bool> &changed_regions) const;
-  void StableRegionsWithMarginalHistory(
-      const std::vector<bool> &changed_regions,
-      std::vector<bool> &stable_regions) const;
-  void RecordHistory(DrmHwcLayer *layers, size_t num_layers,
-                     const std::vector<bool> &changed_regions);
-  bool RecordAndCompareSquashed(const std::vector<bool> &squashed_regions);
-
-  void Dump(std::ostringstream *out) const;
-
- private:
-  size_t generation_number_ = 0;
-  unsigned valid_history_ = 0;
-  std::vector<buffer_handle_t> last_handles_;
-
-  std::vector<Region> regions_;
-};
-
 class DrmDisplayCompositor {
  public:
   DrmDisplayCompositor();
@@ -89,15 +46,10 @@  class DrmDisplayCompositor {
   std::unique_ptr<DrmDisplayComposition> CreateComposition() const;
   int ApplyComposition(std::unique_ptr<DrmDisplayComposition> composition);
   int Composite();
-  int SquashAll();
   void Dump(std::ostringstream *out) const;
 
   std::tuple<uint32_t, uint32_t, int> GetActiveModeResolution();
 
-  SquashState *squash_state() {
-    return &squash_state_;
-  }
-
  private:
   struct ModeState {
     bool needs_modeset = false;
@@ -115,11 +67,8 @@  class DrmDisplayCompositor {
 
   int PrepareFramebuffer(DrmFramebuffer &fb,
                          DrmDisplayComposition *display_comp);
-  int ApplySquash(DrmDisplayComposition *display_comp);
-  int ApplyPreComposite(DrmDisplayComposition *display_comp);
   int PrepareFrame(DrmDisplayComposition *display_comp);
   int CommitFrame(DrmDisplayComposition *display_comp, bool test_only);
-  int SquashFrame(DrmDisplayComposition *src, DrmDisplayComposition *dst);
   int ApplyDpms(DrmDisplayComposition *display_comp);
   int DisablePlanes(DrmDisplayComposition *display_comp);
 
@@ -142,11 +91,6 @@  class DrmDisplayCompositor {
 
   int framebuffer_index_;
   DrmFramebuffer framebuffers_[DRM_DISPLAY_BUFFERS];
-  std::unique_ptr<GLWorkerCompositor> pre_compositor_;
-
-  SquashState squash_state_;
-  int squash_framebuffer_index_;
-  DrmFramebuffer squash_framebuffers_[2];
 
   // mutable since we need to acquire in Dump()
   mutable pthread_mutex_t lock_;
diff --git a/drmhwctwo.cpp b/drmhwctwo.cpp
index 8e00d7150217..60ff384e9a08 100644
--- a/drmhwctwo.cpp
+++ b/drmhwctwo.cpp
@@ -539,7 +539,7 @@  HWC2::Error DrmHwcTwo::HwcDisplay::PresentDisplay(int32_t *retire_fence) {
 
   std::vector<DrmPlane *> primary_planes(primary_planes_);
   std::vector<DrmPlane *> overlay_planes(overlay_planes_);
-  ret = composition->Plan(compositor_.squash_state(), &primary_planes,
+  ret = composition->Plan(&primary_planes,
                          &overlay_planes);
   if (ret) {
     ALOGE("Failed to plan the composition ret=%d", ret);
@@ -692,12 +692,10 @@  HWC2::Error DrmHwcTwo::HwcDisplay::ValidateDisplay(uint32_t *num_types,
       case HWC2::Composition::SolidColor:
       case HWC2::Composition::Cursor:
       case HWC2::Composition::Sideband:
+      default:
         layer.set_validated_type(HWC2::Composition::Client);
         ++*num_types;
         break;
-      default:
-        layer.set_validated_type(layer.sf_type());
-        break;
     }
   }
   return *num_types ? HWC2::Error::HasChanges : HWC2::Error::None;
diff --git a/glworker.cpp b/glworker.cpp
deleted file mode 100644
index ca726bf573ba..000000000000
--- a/glworker.cpp
+++ /dev/null
@@ -1,840 +0,0 @@ 
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define ATRACE_TAG ATRACE_TAG_GRAPHICS
-#define LOG_TAG "hwc-gl-worker"
-
-#include <algorithm>
-#include <string>
-#include <sstream>
-#include <unordered_set>
-
-#include <sys/resource.h>
-
-#include <cutils/properties.h>
-
-#include <hardware/hardware.h>
-#include <hardware/hwcomposer.h>
-
-#include <ui/GraphicBuffer.h>
-#include <ui/PixelFormat.h>
-
-#include <utils/Trace.h>
-
-#include "drmdisplaycomposition.h"
-#include "platform.h"
-
-#include "glworker.h"
-
-#define MAX_OVERLAPPING_LAYERS 64
-
-namespace android {
-
-// clang-format off
-// Column-major order:
-// float mat[4] = { 1, 2, 3, 4 } ===
-// [ 1 3 ]
-// [ 2 4 ]
-float kTextureTransformMatrices[] = {
-   1.0f,  0.0f,  0.0f,  1.0f, // identity matrix
-   0.0f,  1.0f,  1.0f,  0.0f, // swap x and y
-};
-// clang-format on
-
-static const char *GetGLError(void) {
-  switch (glGetError()) {
-    case GL_NO_ERROR:
-      return "GL_NO_ERROR";
-    case GL_INVALID_ENUM:
-      return "GL_INVALID_ENUM";
-    case GL_INVALID_VALUE:
-      return "GL_INVALID_VALUE";
-    case GL_INVALID_OPERATION:
-      return "GL_INVALID_OPERATION";
-    case GL_INVALID_FRAMEBUFFER_OPERATION:
-      return "GL_INVALID_FRAMEBUFFER_OPERATION";
-    case GL_OUT_OF_MEMORY:
-      return "GL_OUT_OF_MEMORY";
-    default:
-      return "Unknown error";
-  }
-}
-
-static const char *GetGLFramebufferError(void) {
-  switch (glCheckFramebufferStatus(GL_FRAMEBUFFER)) {
-    case GL_FRAMEBUFFER_COMPLETE:
-      return "GL_FRAMEBUFFER_COMPLETE";
-    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
-      return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
-    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
-      return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
-    case GL_FRAMEBUFFER_UNSUPPORTED:
-      return "GL_FRAMEBUFFER_UNSUPPORTED";
-    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
-      return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
-    default:
-      return "Unknown error";
-  }
-}
-
-static const char *GetEGLError(void) {
-  switch (eglGetError()) {
-    case EGL_SUCCESS:
-      return "EGL_SUCCESS";
-    case EGL_NOT_INITIALIZED:
-      return "EGL_NOT_INITIALIZED";
-    case EGL_BAD_ACCESS:
-      return "EGL_BAD_ACCESS";
-    case EGL_BAD_ALLOC:
-      return "EGL_BAD_ALLOC";
-    case EGL_BAD_ATTRIBUTE:
-      return "EGL_BAD_ATTRIBUTE";
-    case EGL_BAD_CONTEXT:
-      return "EGL_BAD_CONTEXT";
-    case EGL_BAD_CONFIG:
-      return "EGL_BAD_CONFIG";
-    case EGL_BAD_CURRENT_SURFACE:
-      return "EGL_BAD_CURRENT_SURFACE";
-    case EGL_BAD_DISPLAY:
-      return "EGL_BAD_DISPLAY";
-    case EGL_BAD_SURFACE:
-      return "EGL_BAD_SURFACE";
-    case EGL_BAD_MATCH:
-      return "EGL_BAD_MATCH";
-    case EGL_BAD_PARAMETER:
-      return "EGL_BAD_PARAMETER";
-    case EGL_BAD_NATIVE_PIXMAP:
-      return "EGL_BAD_NATIVE_PIXMAP";
-    case EGL_BAD_NATIVE_WINDOW:
-      return "EGL_BAD_NATIVE_WINDOW";
-    case EGL_CONTEXT_LOST:
-      return "EGL_CONTEXT_LOST";
-    default:
-      return "Unknown error";
-  }
-}
-
-static bool HasExtension(const char *extension, const char *extensions) {
-  const char *start, *where, *terminator;
-  start = extensions;
-  for (;;) {
-    where = (char *)strstr((const char *)start, extension);
-    if (!where)
-      break;
-    terminator = where + strlen(extension);
-    if (where == start || *(where - 1) == ' ')
-      if (*terminator == ' ' || *terminator == '\0')
-        return true;
-    start = terminator;
-  }
-  return false;
-}
-
-int GLWorkerCompositor::BeginContext() {
-  private_.saved_egl_display = eglGetCurrentDisplay();
-  private_.saved_egl_ctx = eglGetCurrentContext();
-
-  if (private_.saved_egl_display != egl_display_ ||
-      private_.saved_egl_ctx != egl_ctx_) {
-    private_.saved_egl_read = eglGetCurrentSurface(EGL_READ);
-    private_.saved_egl_draw = eglGetCurrentSurface(EGL_DRAW);
-  } else {
-    return 0;
-  }
-
-  if (!eglMakeCurrent(egl_display_, EGL_NO_SURFACE, EGL_NO_SURFACE, egl_ctx_)) {
-    ALOGE("BeginContext failed: %s", GetEGLError());
-    return 1;
-  }
-  return 0;
-}
-
-int GLWorkerCompositor::EndContext() {
-  if (private_.saved_egl_display != eglGetCurrentDisplay() ||
-      private_.saved_egl_ctx != eglGetCurrentContext()) {
-    if (!eglMakeCurrent(private_.saved_egl_display, private_.saved_egl_read,
-                        private_.saved_egl_draw, private_.saved_egl_ctx)) {
-      ALOGE("EndContext failed: %s", GetEGLError());
-      return 1;
-    }
-  }
-
-  return 0;
-}
-
-static AutoGLShader CompileAndCheckShader(GLenum type, unsigned source_count,
-                                          const GLchar **sources,
-                                          std::ostringstream *shader_log) {
-  GLint status;
-  AutoGLShader shader(glCreateShader(type));
-  if (shader.get() == 0) {
-    if (shader_log)
-      *shader_log << "Failed glCreateShader call";
-    return 0;
-  }
-
-  glShaderSource(shader.get(), source_count, sources, NULL);
-  glCompileShader(shader.get());
-  glGetShaderiv(shader.get(), GL_COMPILE_STATUS, &status);
-  if (!status) {
-    if (shader_log) {
-      GLint log_length;
-      glGetShaderiv(shader.get(), GL_INFO_LOG_LENGTH, &log_length);
-      std::string info_log(log_length, ' ');
-      glGetShaderInfoLog(shader.get(), log_length, NULL, &info_log.front());
-      *shader_log << "Failed to compile shader:\n" << info_log.c_str()
-                  << "\nShader Source:\n";
-      for (unsigned i = 0; i < source_count; i++) {
-        *shader_log << sources[i];
-      }
-      *shader_log << "\n";
-    }
-    return 0;
-  }
-
-  return shader;
-}
-
-static std::string GenerateVertexShader(int layer_count) {
-  std::ostringstream vertex_shader_stream;
-  vertex_shader_stream
-      << "#version 300 es\n"
-      << "#define LAYER_COUNT " << layer_count << "\n"
-      << "precision mediump int;\n"
-      << "uniform vec4 uViewport;\n"
-      << "uniform vec4 uLayerCrop[LAYER_COUNT];\n"
-      << "uniform mat2 uTexMatrix[LAYER_COUNT];\n"
-      << "in vec2 vPosition;\n"
-      << "in vec2 vTexCoords;\n"
-      << "out vec2 fTexCoords[LAYER_COUNT];\n"
-      << "void main() {\n"
-      << "  for (int i = 0; i < LAYER_COUNT; i++) {\n"
-      << "    vec2 tempCoords = vTexCoords * uTexMatrix[i];\n"
-      << "    fTexCoords[i] =\n"
-      << "        uLayerCrop[i].xy + tempCoords * uLayerCrop[i].zw;\n"
-      << "  }\n"
-      << "  vec2 scaledPosition = uViewport.xy + vPosition * uViewport.zw;\n"
-      << "  gl_Position =\n"
-      << "      vec4(scaledPosition * vec2(2.0) - vec2(1.0), 0.0, 1.0);\n"
-      << "}\n";
-  return vertex_shader_stream.str();
-}
-
-static std::string GenerateFragmentShader(int layer_count) {
-  std::ostringstream fragment_shader_stream;
-  fragment_shader_stream << "#version 300 es\n"
-                         << "#define LAYER_COUNT " << layer_count << "\n"
-                         << "#extension GL_OES_EGL_image_external : require\n"
-                         << "precision mediump float;\n";
-  for (int i = 0; i < layer_count; ++i) {
-    fragment_shader_stream << "uniform samplerExternalOES uLayerTexture" << i
-                           << ";\n";
-  }
-  fragment_shader_stream << "uniform float uLayerAlpha[LAYER_COUNT];\n"
-                         << "uniform float uLayerPremult[LAYER_COUNT];\n"
-                         << "in vec2 fTexCoords[LAYER_COUNT];\n"
-                         << "out vec4 oFragColor;\n"
-                         << "void main() {\n"
-                         << "  vec3 color = vec3(0.0, 0.0, 0.0);\n"
-                         << "  float alphaCover = 1.0;\n"
-                         << "  vec4 texSample;\n"
-                         << "  vec3 multRgb;\n";
-  for (int i = 0; i < layer_count; ++i) {
-    if (i > 0)
-      fragment_shader_stream << "  if (alphaCover > 0.5/255.0) {\n";
-    // clang-format off
-    fragment_shader_stream
-        << "  texSample = texture2D(uLayerTexture" << i << ",\n"
-        << "                        fTexCoords[" << i << "]);\n"
-        << "  multRgb = texSample.rgb *\n"
-        << "            max(texSample.a, uLayerPremult[" << i << "]);\n"
-        << "  color += multRgb * uLayerAlpha[" << i << "] * alphaCover;\n"
-        << "  alphaCover *= 1.0 - texSample.a * uLayerAlpha[" << i << "];\n";
-    // clang-format on
-  }
-  for (int i = 0; i < layer_count - 1; ++i)
-    fragment_shader_stream << "  }\n";
-  fragment_shader_stream << "  oFragColor = vec4(color, 1.0 - alphaCover);\n"
-                         << "}\n";
-  return fragment_shader_stream.str();
-}
-
-static AutoGLProgram GenerateProgram(unsigned num_textures,
-                                     std::ostringstream *shader_log) {
-  std::string vertex_shader_string = GenerateVertexShader(num_textures);
-  const GLchar *vertex_shader_source = vertex_shader_string.c_str();
-  AutoGLShader vertex_shader = CompileAndCheckShader(
-      GL_VERTEX_SHADER, 1, &vertex_shader_source, shader_log);
-  if (!vertex_shader.get())
-    return 0;
-
-  std::string fragment_shader_string = GenerateFragmentShader(num_textures);
-  const GLchar *fragment_shader_source = fragment_shader_string.c_str();
-  AutoGLShader fragment_shader = CompileAndCheckShader(
-      GL_FRAGMENT_SHADER, 1, &fragment_shader_source, shader_log);
-  if (!fragment_shader.get())
-    return 0;
-
-  AutoGLProgram program(glCreateProgram());
-  if (!program.get()) {
-    if (shader_log)
-      *shader_log << "Failed to create program: " << GetGLError() << "\n";
-    return 0;
-  }
-
-  glAttachShader(program.get(), vertex_shader.get());
-  glAttachShader(program.get(), fragment_shader.get());
-  glBindAttribLocation(program.get(), 0, "vPosition");
-  glBindAttribLocation(program.get(), 1, "vTexCoords");
-  glLinkProgram(program.get());
-  glDetachShader(program.get(), vertex_shader.get());
-  glDetachShader(program.get(), fragment_shader.get());
-
-  GLint status;
-  glGetProgramiv(program.get(), GL_LINK_STATUS, &status);
-  if (!status) {
-    if (shader_log) {
-      GLint log_length;
-      glGetProgramiv(program.get(), GL_INFO_LOG_LENGTH, &log_length);
-      std::string program_log(log_length, ' ');
-      glGetProgramInfoLog(program.get(), log_length, NULL,
-                          &program_log.front());
-      *shader_log << "Failed to link program:\n" << program_log.c_str() << "\n";
-    }
-    return 0;
-  }
-
-  return program;
-}
-
-struct RenderingCommand {
-  struct TextureSource {
-    unsigned texture_index;
-    float crop_bounds[4];
-    float alpha;
-    float premult;
-    float texture_matrix[4];
-  };
-
-  float bounds[4];
-  unsigned texture_count = 0;
-  TextureSource textures[MAX_OVERLAPPING_LAYERS];
-};
-
-static void ConstructCommand(const DrmHwcLayer *layers,
-                             const DrmCompositionRegion &region,
-                             RenderingCommand &cmd) {
-  std::copy_n(region.frame.bounds, 4, cmd.bounds);
-
-  for (size_t texture_index : region.source_layers) {
-    const DrmHwcLayer &layer = layers[texture_index];
-
-    DrmHwcRect<float> display_rect(layer.display_frame);
-    float display_size[2] = {display_rect.bounds[2] - display_rect.bounds[0],
-                             display_rect.bounds[3] - display_rect.bounds[1]};
-
-    float tex_width = layer.buffer->width;
-    float tex_height = layer.buffer->height;
-    DrmHwcRect<float> crop_rect(layer.source_crop.left / tex_width,
-                                layer.source_crop.top / tex_height,
-                                layer.source_crop.right / tex_width,
-                                layer.source_crop.bottom / tex_height);
-
-    float crop_size[2] = {crop_rect.bounds[2] - crop_rect.bounds[0],
-                          crop_rect.bounds[3] - crop_rect.bounds[1]};
-
-    RenderingCommand::TextureSource &src = cmd.textures[cmd.texture_count];
-    cmd.texture_count++;
-    src.texture_index = texture_index;
-
-    bool swap_xy = false;
-    bool flip_xy[2] = { false, false };
-
-    if (layer.transform == DrmHwcTransform::kRotate180) {
-      swap_xy = false;
-      flip_xy[0] = true;
-      flip_xy[1] = true;
-    } else if (layer.transform == DrmHwcTransform::kRotate270) {
-      swap_xy = true;
-      flip_xy[0] = true;
-      flip_xy[1] = false;
-    } else if (layer.transform & DrmHwcTransform::kRotate90) {
-      swap_xy = true;
-      if (layer.transform & DrmHwcTransform::kFlipH) {
-        flip_xy[0] = true;
-        flip_xy[1] = true;
-      } else if (layer.transform & DrmHwcTransform::kFlipV) {
-        flip_xy[0] = false;
-        flip_xy[1] = false;
-      } else {
-        flip_xy[0] = false;
-        flip_xy[1] = true;
-      }
-    } else {
-      if (layer.transform & DrmHwcTransform::kFlipH)
-        flip_xy[0] = true;
-      if (layer.transform & DrmHwcTransform::kFlipV)
-        flip_xy[1] = true;
-    }
-
-    if (swap_xy)
-      std::copy_n(&kTextureTransformMatrices[4], 4, src.texture_matrix);
-    else
-      std::copy_n(&kTextureTransformMatrices[0], 4, src.texture_matrix);
-
-    for (int j = 0; j < 4; j++) {
-      int b = j ^ (swap_xy ? 1 : 0);
-      float bound_percent =
-          (cmd.bounds[b] - display_rect.bounds[b % 2]) / display_size[b % 2];
-      if (flip_xy[j % 2]) {
-        src.crop_bounds[j] =
-            crop_rect.bounds[j % 2 + 2] - bound_percent * crop_size[j % 2];
-      } else {
-        src.crop_bounds[j] =
-            crop_rect.bounds[j % 2] + bound_percent * crop_size[j % 2];
-      }
-    }
-
-    if (layer.blending == DrmHwcBlending::kNone) {
-      src.alpha = src.premult = 1.0f;
-      // This layer is opaque. There is no point in using layers below this one.
-      break;
-    }
-
-    src.alpha = layer.alpha / 255.0f;
-    src.premult = (layer.blending == DrmHwcBlending::kPreMult) ? 1.0f : 0.0f;
-  }
-}
-
-static int EGLFenceWait(EGLDisplay egl_display, int acquireFenceFd) {
-  int ret = 0;
-
-  EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, acquireFenceFd,
-                      EGL_NONE};
-  EGLSyncKHR egl_sync =
-      eglCreateSyncKHR(egl_display, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
-  if (egl_sync == EGL_NO_SYNC_KHR) {
-    ALOGE("Failed to make EGLSyncKHR from acquireFenceFd: %s", GetEGLError());
-    close(acquireFenceFd);
-    return 1;
-  }
-
-  EGLint success = eglWaitSyncKHR(egl_display, egl_sync, 0);
-  if (success == EGL_FALSE) {
-    ALOGE("Failed to wait for acquire: %s", GetEGLError());
-    ret = 1;
-  }
-  eglDestroySyncKHR(egl_display, egl_sync);
-
-  return ret;
-}
-
-static int CreateTextureFromHandle(EGLDisplay egl_display,
-                                   buffer_handle_t handle,
-                                   Importer *importer,
-                                   AutoEGLImageAndGLTexture *out) {
-  EGLImageKHR image = importer->ImportImage(egl_display, handle);
-
-  if (image == EGL_NO_IMAGE_KHR) {
-    ALOGE("Failed to make image %s %p", GetEGLError(), handle);
-    return -EINVAL;
-  }
-
-  GLuint texture;
-  glGenTextures(1, &texture);
-  glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
-  glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, (GLeglImageOES)image);
-  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_REPEAT);
-  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_REPEAT);
-  glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
-
-  out->image.reset(egl_display, image);
-  out->texture.reset(texture);
-
-  return 0;
-}
-
-GLWorkerCompositor::GLWorkerCompositor()
-    : egl_display_(EGL_NO_DISPLAY), egl_ctx_(EGL_NO_CONTEXT) {
-}
-
-int GLWorkerCompositor::Init() {
-  int ret = 0;
-  const char *egl_extensions;
-  const char *gl_extensions;
-  EGLint num_configs;
-  EGLConfig egl_config;
-
-  // clang-format off
-  const GLfloat verts[] = {
-    0.0f,  0.0f,    0.0f, 0.0f,
-    0.0f,  2.0f,    0.0f, 2.0f,
-    2.0f,  0.0f,    2.0f, 0.0f
-  };
-  // clang-format on
-
-  const EGLint config_attribs[] = {EGL_RENDERABLE_TYPE,
-                                   EGL_OPENGL_ES2_BIT,
-                                   EGL_RED_SIZE,
-                                   8,
-                                   EGL_GREEN_SIZE,
-                                   8,
-                                   EGL_BLUE_SIZE,
-                                   8,
-                                   EGL_NONE};
-
-  const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
-
-  egl_display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-  if (egl_display_ == EGL_NO_DISPLAY) {
-    ALOGE("Failed to get egl display");
-    return 1;
-  }
-
-  if (!eglInitialize(egl_display_, NULL, NULL)) {
-    ALOGE("Failed to initialize egl: %s", GetEGLError());
-    return 1;
-  }
-
-  egl_extensions = eglQueryString(egl_display_, EGL_EXTENSIONS);
-
-  // These extensions are all technically required but not always reported due
-  // to meta EGL filtering them out.
-  if (!HasExtension("EGL_KHR_image_base", egl_extensions))
-    ALOGW("EGL_KHR_image_base extension not supported");
-
-  if (!HasExtension("EGL_ANDROID_image_native_buffer", egl_extensions))
-    ALOGW("EGL_ANDROID_image_native_buffer extension not supported");
-
-  if (!HasExtension("EGL_ANDROID_native_fence_sync", egl_extensions))
-    ALOGW("EGL_ANDROID_native_fence_sync extension not supported");
-
-  if (!eglChooseConfig(egl_display_, config_attribs, &egl_config, 1,
-                       &num_configs)) {
-    ALOGE("eglChooseConfig() failed with error: %s", GetEGLError());
-    return 1;
-  }
-
-  egl_ctx_ =
-      eglCreateContext(egl_display_, egl_config,
-                       EGL_NO_CONTEXT /* No shared context */, context_attribs);
-
-  if (egl_ctx_ == EGL_NO_CONTEXT) {
-    ALOGE("Failed to create OpenGL ES Context: %s", GetEGLError());
-    return 1;
-  }
-
-  ret = BeginContext();
-  if (ret)
-    return ret;
-
-  gl_extensions = (const char *)glGetString(GL_EXTENSIONS);
-
-  if (!HasExtension("GL_OES_EGL_image", gl_extensions))
-    ALOGW("GL_OES_EGL_image extension not supported");
-
-  if (!HasExtension("GL_OES_EGL_image_external", gl_extensions))
-    ALOGW("GL_OES_EGL_image_external extension not supported");
-
-  GLuint vertex_buffer;
-  glGenBuffers(1, &vertex_buffer);
-  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
-  glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
-  glBindBuffer(GL_ARRAY_BUFFER, 0);
-  vertex_buffer_.reset(vertex_buffer);
-
-  std::ostringstream shader_log;
-  blend_programs_.emplace_back(GenerateProgram(1, &shader_log));
-
-  EndContext();
-
-  if (blend_programs_.back().get() == 0) {
-    ALOGE("%s", shader_log.str().c_str());
-    return 1;
-  }
-
-  return 0;
-}
-
-GLWorkerCompositor::~GLWorkerCompositor() {
-  if (egl_display_ != EGL_NO_DISPLAY && egl_ctx_ != EGL_NO_CONTEXT)
-    if (eglDestroyContext(egl_display_, egl_ctx_) == EGL_FALSE)
-      ALOGE("Failed to destroy OpenGL ES Context: %s", GetEGLError());
-}
-
-int GLWorkerCompositor::Composite(DrmHwcLayer *layers,
-                                  DrmCompositionRegion *regions,
-                                  size_t num_regions,
-                                  const sp<GraphicBuffer> &framebuffer,
-                                  Importer *importer) {
-  ATRACE_CALL();
-  int ret = 0;
-  std::vector<AutoEGLImageAndGLTexture> layer_textures;
-  std::vector<RenderingCommand> commands;
-
-  if (num_regions == 0) {
-    return -EALREADY;
-  }
-
-  ret = BeginContext();
-  if (ret)
-    return -1;
-
-  GLint frame_width = framebuffer->getWidth();
-  GLint frame_height = framebuffer->getHeight();
-  CachedFramebuffer *cached_framebuffer =
-      PrepareAndCacheFramebuffer(framebuffer);
-  if (cached_framebuffer == NULL) {
-    ALOGE("Composite failed because of failed framebuffer");
-    EndContext();
-    return -EINVAL;
-  }
-
-  std::unordered_set<size_t> layers_used_indices;
-  for (size_t region_index = 0; region_index < num_regions; region_index++) {
-    DrmCompositionRegion &region = regions[region_index];
-    layers_used_indices.insert(region.source_layers.begin(),
-                               region.source_layers.end());
-    commands.emplace_back();
-    ConstructCommand(layers, region, commands.back());
-  }
-
-  for (size_t layer_index = 0; layer_index < MAX_OVERLAPPING_LAYERS;
-       layer_index++) {
-    DrmHwcLayer *layer = &layers[layer_index];
-
-    layer_textures.emplace_back();
-
-    if (layers_used_indices.count(layer_index) == 0)
-      continue;
-
-    ret = CreateTextureFromHandle(egl_display_, layer->get_usable_handle(),
-                                  importer, &layer_textures.back());
-
-    if (!ret) {
-      ret = EGLFenceWait(egl_display_, layer->acquire_fence.Release());
-    }
-    if (ret) {
-      layer_textures.pop_back();
-      ret = -EINVAL;
-    }
-  }
-
-  if (ret) {
-    EndContext();
-    return ret;
-  }
-
-  glViewport(0, 0, frame_width, frame_height);
-
-  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-  glClear(GL_COLOR_BUFFER_BIT);
-
-  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_.get());
-  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, NULL);
-  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4,
-                        (void *)(sizeof(float) * 2));
-  glEnableVertexAttribArray(0);
-  glEnableVertexAttribArray(1);
-  glEnable(GL_SCISSOR_TEST);
-
-  for (const RenderingCommand &cmd : commands) {
-    if (cmd.texture_count == 0)
-      continue;
-
-    // TODO(zachr): handle the case of too many overlapping textures for one
-    // area by falling back to rendering as many layers as possible using
-    // multiple blending passes.
-    GLint program = PrepareAndCacheProgram(cmd.texture_count);
-    if (program == 0) {
-      ALOGE("Too many layers to render in one area");
-      continue;
-    }
-
-    glUseProgram(program);
-    GLint gl_viewport_loc = glGetUniformLocation(program, "uViewport");
-    GLint gl_crop_loc = glGetUniformLocation(program, "uLayerCrop");
-    GLint gl_alpha_loc = glGetUniformLocation(program, "uLayerAlpha");
-    GLint gl_premult_loc = glGetUniformLocation(program, "uLayerPremult");
-    GLint gl_tex_matrix_loc = glGetUniformLocation(program, "uTexMatrix");
-    glUniform4f(gl_viewport_loc, cmd.bounds[0] / (float)frame_width,
-                cmd.bounds[1] / (float)frame_height,
-                (cmd.bounds[2] - cmd.bounds[0]) / (float)frame_width,
-                (cmd.bounds[3] - cmd.bounds[1]) / (float)frame_height);
-
-    for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
-      std::ostringstream texture_name_formatter;
-      texture_name_formatter << "uLayerTexture" << src_index;
-      GLint gl_tex_loc =
-          glGetUniformLocation(program, texture_name_formatter.str().c_str());
-
-      const RenderingCommand::TextureSource &src = cmd.textures[src_index];
-      glUniform1f(gl_alpha_loc + src_index, src.alpha);
-      glUniform1f(gl_premult_loc + src_index, src.premult);
-      glUniform4f(gl_crop_loc + src_index, src.crop_bounds[0],
-                  src.crop_bounds[1], src.crop_bounds[2] - src.crop_bounds[0],
-                  src.crop_bounds[3] - src.crop_bounds[1]);
-      glUniform1i(gl_tex_loc, src_index);
-      glUniformMatrix2fv(gl_tex_matrix_loc + src_index, 1, GL_FALSE,
-                         src.texture_matrix);
-      glActiveTexture(GL_TEXTURE0 + src_index);
-      glBindTexture(GL_TEXTURE_EXTERNAL_OES,
-                    layer_textures[src.texture_index].texture.get());
-    }
-
-    glScissor(cmd.bounds[0], cmd.bounds[1], cmd.bounds[2] - cmd.bounds[0],
-              cmd.bounds[3] - cmd.bounds[1]);
-    glDrawArrays(GL_TRIANGLES, 0, 3);
-
-    for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
-      glActiveTexture(GL_TEXTURE0 + src_index);
-      glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
-    }
-  }
-
-  glDisable(GL_SCISSOR_TEST);
-  glActiveTexture(GL_TEXTURE0);
-  glDisableVertexAttribArray(0);
-  glDisableVertexAttribArray(1);
-  glBindBuffer(GL_ARRAY_BUFFER, 0);
-  glUseProgram(0);
-
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
-  EndContext();
-  return ret;
-}
-
-void GLWorkerCompositor::Finish() {
-  ATRACE_CALL();
-  glFinish();
-
-  char use_framebuffer_cache_opt[PROPERTY_VALUE_MAX];
-  property_get("hwc.drm.use_framebuffer_cache", use_framebuffer_cache_opt, "1");
-  bool use_framebuffer_cache = atoi(use_framebuffer_cache_opt);
-
-  if (use_framebuffer_cache) {
-    for (auto &fb : cached_framebuffers_)
-      fb.strong_framebuffer.clear();
-  } else {
-    cached_framebuffers_.clear();
-  }
-}
-
-GLWorkerCompositor::CachedFramebuffer::CachedFramebuffer(
-    const sp<GraphicBuffer> &gb, AutoEGLDisplayImage &&image,
-    AutoGLTexture &&tex, AutoGLFramebuffer &&fb)
-    : strong_framebuffer(gb),
-      weak_framebuffer(gb),
-      egl_fb_image(std::move(image)),
-      gl_fb_tex(std::move(tex)),
-      gl_fb(std::move(fb)) {
-}
-
-bool GLWorkerCompositor::CachedFramebuffer::Promote() {
-  if (strong_framebuffer.get() != NULL)
-    return true;
-  strong_framebuffer = weak_framebuffer.promote();
-  return strong_framebuffer.get() != NULL;
-}
-
-GLWorkerCompositor::CachedFramebuffer *
-GLWorkerCompositor::FindCachedFramebuffer(
-    const sp<GraphicBuffer> &framebuffer) {
-  for (auto &fb : cached_framebuffers_)
-    if (fb.weak_framebuffer == framebuffer)
-      return &fb;
-  return NULL;
-}
-
-GLWorkerCompositor::CachedFramebuffer *
-GLWorkerCompositor::PrepareAndCacheFramebuffer(
-    const sp<GraphicBuffer> &framebuffer) {
-  CachedFramebuffer *cached_framebuffer = FindCachedFramebuffer(framebuffer);
-  if (cached_framebuffer != NULL) {
-    if (cached_framebuffer->Promote()) {
-      glBindFramebuffer(GL_FRAMEBUFFER, cached_framebuffer->gl_fb.get());
-      return cached_framebuffer;
-    }
-
-    for (auto it = cached_framebuffers_.begin();
-         it != cached_framebuffers_.end(); ++it) {
-      if (it->weak_framebuffer == framebuffer) {
-        cached_framebuffers_.erase(it);
-        break;
-      }
-    }
-  }
-
-  AutoEGLDisplayImage egl_fb_image(
-      egl_display_,
-      eglCreateImageKHR(egl_display_, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
-                        (EGLClientBuffer)framebuffer->getNativeBuffer(),
-                        NULL /* no attribs */));
-
-  if (egl_fb_image.image() == EGL_NO_IMAGE_KHR) {
-    ALOGE("Failed to make image from target buffer: %s", GetEGLError());
-    return NULL;
-  }
-
-  GLuint gl_fb_tex;
-  glGenTextures(1, &gl_fb_tex);
-  AutoGLTexture gl_fb_tex_auto(gl_fb_tex);
-  glBindTexture(GL_TEXTURE_2D, gl_fb_tex);
-  glEGLImageTargetTexture2DOES(GL_TEXTURE_2D,
-                               (GLeglImageOES)egl_fb_image.image());
-  glBindTexture(GL_TEXTURE_2D, 0);
-
-  GLuint gl_fb;
-  glGenFramebuffers(1, &gl_fb);
-  AutoGLFramebuffer gl_fb_auto(gl_fb);
-  glBindFramebuffer(GL_FRAMEBUFFER, gl_fb);
-  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-                         gl_fb_tex, 0);
-
-  if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
-    ALOGE("Failed framebuffer check for created target buffer: %s",
-          GetGLFramebufferError());
-    return NULL;
-  }
-
-  cached_framebuffers_.emplace_back(framebuffer, std::move(egl_fb_image),
-                                    std::move(gl_fb_tex_auto),
-                                    std::move(gl_fb_auto));
-  return &cached_framebuffers_.back();
-}
-
-GLint GLWorkerCompositor::PrepareAndCacheProgram(unsigned texture_count) {
-  if (blend_programs_.size() >= texture_count) {
-    GLint program = blend_programs_[texture_count - 1].get();
-    if (program != 0)
-      return program;
-  }
-
-  AutoGLProgram program = GenerateProgram(texture_count, NULL);
-  if (program.get() != 0) {
-    if (blend_programs_.size() < texture_count)
-      blend_programs_.resize(texture_count);
-    blend_programs_[texture_count - 1] = std::move(program);
-    return blend_programs_[texture_count - 1].get();
-  }
-
-  return 0;
-}
-
-}  // namespace android
diff --git a/glworker.h b/glworker.h
deleted file mode 100644
index 26de55d725cd..000000000000
--- a/glworker.h
+++ /dev/null
@@ -1,94 +0,0 @@ 
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_GL_WORKER_H_
-#define ANDROID_GL_WORKER_H_
-
-#include <vector>
-
-#define EGL_EGLEXT_PROTOTYPES
-#define GL_GLEXT_PROTOTYPES
-
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-
-#include <ui/GraphicBuffer.h>
-
-#include "autogl.h"
-
-namespace android {
-
-struct DrmHwcLayer;
-struct DrmCompositionRegion;
-
-class GLWorkerCompositor {
- public:
-  GLWorkerCompositor();
-  ~GLWorkerCompositor();
-
-  int Init();
-  int Composite(DrmHwcLayer *layers, DrmCompositionRegion *regions,
-                size_t num_regions, const sp<GraphicBuffer> &framebuffer,
-                Importer *importer);
-  void Finish();
-
- private:
-  struct CachedFramebuffer {
-    // If the strong_framebuffer is non-NULL, we are holding a strong reference
-    // until we are sure rendering is done. The weak reference will be equal in
-    // that case.
-    sp<GraphicBuffer> strong_framebuffer;
-    wp<GraphicBuffer> weak_framebuffer;
-    AutoEGLDisplayImage egl_fb_image;
-    AutoGLTexture gl_fb_tex;
-    AutoGLFramebuffer gl_fb;
-
-    CachedFramebuffer(const sp<GraphicBuffer> &gb, AutoEGLDisplayImage &&image,
-                      AutoGLTexture &&tex, AutoGLFramebuffer &&fb);
-
-    bool Promote();
-  };
-
-  struct {
-    EGLDisplay saved_egl_display = EGL_NO_DISPLAY;
-    EGLContext saved_egl_ctx = EGL_NO_CONTEXT;
-    EGLSurface saved_egl_read = EGL_NO_SURFACE;
-    EGLSurface saved_egl_draw = EGL_NO_SURFACE;
-  } private_;
-
-  int BeginContext();
-  int EndContext();
-
-  CachedFramebuffer *FindCachedFramebuffer(
-      const sp<GraphicBuffer> &framebuffer);
-  CachedFramebuffer *PrepareAndCacheFramebuffer(
-      const sp<GraphicBuffer> &framebuffer);
-
-  GLint PrepareAndCacheProgram(unsigned texture_count);
-
-  EGLDisplay egl_display_;
-  EGLContext egl_ctx_;
-
-  std::vector<AutoGLProgram> blend_programs_;
-  AutoGLBuffer vertex_buffer_;
-
-  std::vector<CachedFramebuffer> cached_framebuffers_;
-};
-}
-
-#endif
diff --git a/hwcomposer.cpp b/hwcomposer.cpp
deleted file mode 100644
index 338e042895a9..000000000000
--- a/hwcomposer.cpp
+++ /dev/null
@@ -1,841 +0,0 @@ 
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define ATRACE_TAG ATRACE_TAG_GRAPHICS
-#define LOG_TAG "hwcomposer-drm"
-
-#include "drmhwcomposer.h"
-#include "drmeventlistener.h"
-#include "drmresources.h"
-#include "platform.h"
-#include "virtualcompositorworker.h"
-#include "vsyncworker.h"
-
-#include <stdlib.h>
-
-#include <cinttypes>
-#include <map>
-#include <vector>
-#include <sstream>
-
-#include <errno.h>
-#include <fcntl.h>
-#include <pthread.h>
-#include <sys/param.h>
-#include <sys/resource.h>
-#include <xf86drm.h>
-#include <xf86drmMode.h>
-
-#include <log/log.h>
-#include <cutils/properties.h>
-#include <hardware/hardware.h>
-#include <hardware/hwcomposer.h>
-#include <sw_sync.h>
-#include <sync/sync.h>
-#include <utils/Trace.h>
-
-#define UM_PER_INCH 25400
-
-namespace android {
-
-class DummySwSyncTimeline {
- public:
-  int Init() {
-    int ret = timeline_fd_.Set(sw_sync_timeline_create());
-    if (ret < 0)
-      return ret;
-    return 0;
-  }
-
-  UniqueFd CreateDummyFence() {
-    int ret = sw_sync_fence_create(timeline_fd_.get(), "dummy fence",
-                                   timeline_pt_ + 1);
-    if (ret < 0) {
-      ALOGE("Failed to create dummy fence %d", ret);
-      return ret;
-    }
-
-    UniqueFd ret_fd(ret);
-
-    ret = sw_sync_timeline_inc(timeline_fd_.get(), 1);
-    if (ret) {
-      ALOGE("Failed to increment dummy sync timeline %d", ret);
-      return ret;
-    }
-
-    ++timeline_pt_;
-    return ret_fd;
-  }
-
- private:
-  UniqueFd timeline_fd_;
-  int timeline_pt_ = 0;
-};
-
-struct CheckedOutputFd {
-  CheckedOutputFd(int *fd, const char *description,
-                  DummySwSyncTimeline &timeline)
-      : fd_(fd), description_(description), timeline_(timeline) {
-  }
-  CheckedOutputFd(CheckedOutputFd &&rhs)
-      : description_(rhs.description_), timeline_(rhs.timeline_) {
-    std::swap(fd_, rhs.fd_);
-  }
-
-  CheckedOutputFd &operator=(const CheckedOutputFd &rhs) = delete;
-
-  ~CheckedOutputFd() {
-    if (fd_ == NULL)
-      return;
-
-    if (*fd_ >= 0)
-      return;
-
-    *fd_ = timeline_.CreateDummyFence().Release();
-
-    if (*fd_ < 0)
-      ALOGE("Failed to fill %s (%p == %d) before destruction",
-            description_.c_str(), fd_, *fd_);
-  }
-
- private:
-  int *fd_ = NULL;
-  std::string description_;
-  DummySwSyncTimeline &timeline_;
-};
-
-typedef struct hwc_drm_display {
-  struct hwc_context_t *ctx;
-  int display;
-
-  std::vector<uint32_t> config_ids;
-
-  VSyncWorker vsync_worker;
-} hwc_drm_display_t;
-
-class DrmHotplugHandler : public DrmEventHandler {
- public:
-  void Init(DrmResources *drm, const struct hwc_procs *procs) {
-    drm_ = drm;
-    procs_ = procs;
-  }
-
-  void HandleEvent(uint64_t timestamp_us) {
-    for (auto &conn : drm_->connectors()) {
-      drmModeConnection old_state = conn->state();
-
-      conn->UpdateModes();
-
-      drmModeConnection cur_state = conn->state();
-
-      if (cur_state == old_state)
-        continue;
-
-      ALOGI("%s event @%" PRIu64 " for connector %u\n",
-            cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug", timestamp_us,
-            conn->id());
-
-      if (cur_state == DRM_MODE_CONNECTED) {
-        // Take the first one, then look for the preferred
-        DrmMode mode = *(conn->modes().begin());
-        for (auto &m : conn->modes()) {
-          if (m.type() & DRM_MODE_TYPE_PREFERRED) {
-            mode = m;
-            break;
-          }
-        }
-        ALOGI("Setting mode %dx%d for connector %d\n", mode.h_display(),
-              mode.v_display(), conn->id());
-        int ret = drm_->SetDisplayActiveMode(conn->display(), mode);
-        if (ret) {
-          ALOGE("Failed to set active config %d", ret);
-          return;
-        }
-      } else {
-        int ret = drm_->SetDpmsMode(conn->display(), DRM_MODE_DPMS_OFF);
-        if (ret) {
-          ALOGE("Failed to set dpms mode off %d", ret);
-          return;
-        }
-      }
-
-      procs_->hotplug(procs_, conn->display(),
-                      cur_state == DRM_MODE_CONNECTED ? 1 : 0);
-    }
-  }
-
- private:
-  DrmResources *drm_ = NULL;
-  const struct hwc_procs *procs_ = NULL;
-};
-
-struct hwc_context_t {
-  // map of display:hwc_drm_display_t
-  typedef std::map<int, hwc_drm_display_t> DisplayMap;
-
-  ~hwc_context_t() {
-    virtual_compositor_worker.Exit();
-  }
-
-  hwc_composer_device_1_t device;
-  hwc_procs_t const *procs = NULL;
-
-  DisplayMap displays;
-  DrmResources drm;
-  std::unique_ptr<Importer> importer;
-  const gralloc_module_t *gralloc;
-  DummySwSyncTimeline dummy_timeline;
-  VirtualCompositorWorker virtual_compositor_worker;
-  DrmHotplugHandler hotplug_handler;
-};
-
-class DrmVsyncCallback : public VsyncCallback {
- public:
-  DrmVsyncCallback(hwc_procs_t const *procs) : procs_(procs) {
-  }
-
-  void Callback(int display, int64_t timestamp) {
-    procs_->vsync(procs_, display, timestamp);
-  }
- private:
-  hwc_procs_t const *procs_;
-};
-
-static void hwc_dump(struct hwc_composer_device_1 *dev, char *buff,
-                     int buff_len) {
-  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
-  std::ostringstream out;
-
-  ctx->drm.compositor()->Dump(&out);
-  std::string out_str = out.str();
-  strncpy(buff, out_str.c_str(),
-          std::min((size_t)buff_len, out_str.length() + 1));
-  buff[buff_len - 1] = '\0';
-}
-
-static bool hwc_skip_layer(const std::pair<int, int> &indices, int i) {
-  return indices.first >= 0 && i >= indices.first && i <= indices.second;
-}
-
-static int hwc_prepare(hwc_composer_device_1_t *dev, size_t num_displays,
-                       hwc_display_contents_1_t **display_contents) {
-  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
-
-  for (int i = 0; i < (int)num_displays; ++i) {
-    if (!display_contents[i])
-      continue;
-
-    bool use_framebuffer_target = false;
-    DrmMode mode;
-    if (i == HWC_DISPLAY_VIRTUAL) {
-      use_framebuffer_target = true;
-    } else {
-      DrmConnector *c = ctx->drm.GetConnectorForDisplay(i);
-      if (!c) {
-        ALOGE("Failed to get DrmConnector for display %d", i);
-        return -ENODEV;
-      }
-      mode = c->active_mode();
-    }
-
-    // Since we can't composite HWC_SKIP_LAYERs by ourselves, we'll let SF
-    // handle all layers in between the first and last skip layers. So find the
-    // outer indices and mark everything in between as HWC_FRAMEBUFFER
-    std::pair<int, int> skip_layer_indices(-1, -1);
-    int num_layers = display_contents[i]->numHwLayers;
-    for (int j = 0; !use_framebuffer_target && j < num_layers; ++j) {
-      hwc_layer_1_t *layer = &display_contents[i]->hwLayers[j];
-
-      if (!(layer->flags & HWC_SKIP_LAYER))
-        continue;
-
-      if (skip_layer_indices.first == -1)
-        skip_layer_indices.first = j;
-      skip_layer_indices.second = j;
-    }
-
-    for (int j = 0; j < num_layers; ++j) {
-      hwc_layer_1_t *layer = &display_contents[i]->hwLayers[j];
-
-      if (!use_framebuffer_target && !hwc_skip_layer(skip_layer_indices, j)) {
-        // If the layer is off the screen, don't earmark it for an overlay.
-        // We'll leave it as-is, which effectively just drops it from the frame
-        const hwc_rect_t *frame = &layer->displayFrame;
-        if ((frame->right - frame->left) <= 0 ||
-            (frame->bottom - frame->top) <= 0 ||
-            frame->right <= 0 || frame->bottom <= 0 ||
-            frame->left >= (int)mode.h_display() ||
-            frame->top >= (int)mode.v_display())
-            continue;
-
-        if (layer->compositionType == HWC_FRAMEBUFFER)
-          layer->compositionType = HWC_OVERLAY;
-      } else {
-        switch (layer->compositionType) {
-          case HWC_OVERLAY:
-          case HWC_BACKGROUND:
-          case HWC_SIDEBAND:
-          case HWC_CURSOR_OVERLAY:
-            layer->compositionType = HWC_FRAMEBUFFER;
-            break;
-        }
-      }
-    }
-  }
-
-  return 0;
-}
-
-static void hwc_add_layer_to_retire_fence(
-    hwc_layer_1_t *layer, hwc_display_contents_1_t *display_contents) {
-  if (layer->releaseFenceFd < 0)
-    return;
-
-  if (display_contents->retireFenceFd >= 0) {
-    int old_retire_fence = display_contents->retireFenceFd;
-    display_contents->retireFenceFd =
-        sync_merge("dc_retire", old_retire_fence, layer->releaseFenceFd);
-    close(old_retire_fence);
-  } else {
-    display_contents->retireFenceFd = dup(layer->releaseFenceFd);
-  }
-}
-
-static int hwc_set(hwc_composer_device_1_t *dev, size_t num_displays,
-                   hwc_display_contents_1_t **sf_display_contents) {
-  ATRACE_CALL();
-  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
-  int ret = 0;
-
-  std::vector<CheckedOutputFd> checked_output_fences;
-  std::vector<DrmHwcDisplayContents> displays_contents;
-  std::vector<DrmCompositionDisplayLayersMap> layers_map;
-  std::vector<std::vector<size_t>> layers_indices;
-  displays_contents.reserve(num_displays);
-  // layers_map.reserve(num_displays);
-  layers_indices.reserve(num_displays);
-
-  // Phase one does nothing that would cause errors. Only take ownership of FDs.
-  for (size_t i = 0; i < num_displays; ++i) {
-    hwc_display_contents_1_t *dc = sf_display_contents[i];
-    displays_contents.emplace_back();
-    DrmHwcDisplayContents &display_contents = displays_contents.back();
-    layers_indices.emplace_back();
-    std::vector<size_t> &indices_to_composite = layers_indices.back();
-
-    if (!sf_display_contents[i])
-      continue;
-
-    if (i == HWC_DISPLAY_VIRTUAL) {
-      ctx->virtual_compositor_worker.QueueComposite(dc);
-      continue;
-    }
-
-    std::ostringstream display_index_formatter;
-    display_index_formatter << "retire fence for display " << i;
-    std::string display_fence_description(display_index_formatter.str());
-    checked_output_fences.emplace_back(&dc->retireFenceFd,
-                                       display_fence_description.c_str(),
-                                       ctx->dummy_timeline);
-    display_contents.retire_fence = OutputFd(&dc->retireFenceFd);
-
-    size_t num_dc_layers = dc->numHwLayers;
-    int framebuffer_target_index = -1;
-    for (size_t j = 0; j < num_dc_layers; ++j) {
-      hwc_layer_1_t *sf_layer = &dc->hwLayers[j];
-      if (sf_layer->compositionType == HWC_FRAMEBUFFER_TARGET) {
-        framebuffer_target_index = j;
-        break;
-      }
-    }
-
-    for (size_t j = 0; j < num_dc_layers; ++j) {
-      hwc_layer_1_t *sf_layer = &dc->hwLayers[j];
-
-      display_contents.layers.emplace_back();
-      DrmHwcLayer &layer = display_contents.layers.back();
-
-      // In prepare() we marked all layers FRAMEBUFFER between SKIP_LAYER's.
-      // This means we should insert the FB_TARGET layer in the composition
-      // stack at the location of the first skip layer, and ignore the rest.
-      if (sf_layer->flags & HWC_SKIP_LAYER) {
-        if (framebuffer_target_index < 0)
-          continue;
-        int idx = framebuffer_target_index;
-        framebuffer_target_index = -1;
-        hwc_layer_1_t *fbt_layer = &dc->hwLayers[idx];
-        if (!fbt_layer->handle || (fbt_layer->flags & HWC_SKIP_LAYER)) {
-          ALOGE("Invalid HWC_FRAMEBUFFER_TARGET with HWC_SKIP_LAYER present");
-          continue;
-        }
-        indices_to_composite.push_back(idx);
-        continue;
-      }
-
-      if (sf_layer->compositionType == HWC_OVERLAY)
-        indices_to_composite.push_back(j);
-
-      layer.acquire_fence.Set(sf_layer->acquireFenceFd);
-      sf_layer->acquireFenceFd = -1;
-
-      std::ostringstream layer_fence_formatter;
-      layer_fence_formatter << "release fence for layer " << j << " of display "
-                            << i;
-      std::string layer_fence_description(layer_fence_formatter.str());
-      checked_output_fences.emplace_back(&sf_layer->releaseFenceFd,
-                                         layer_fence_description.c_str(),
-                                         ctx->dummy_timeline);
-      layer.release_fence = OutputFd(&sf_layer->releaseFenceFd);
-    }
-
-    // This is a catch-all in case we get a frame without any overlay layers, or
-    // skip layers, but with a value fb_target layer. This _shouldn't_ happen,
-    // but it's not ruled out by the hwc specification
-    if (indices_to_composite.empty() && framebuffer_target_index >= 0) {
-      hwc_layer_1_t *sf_layer = &dc->hwLayers[framebuffer_target_index];
-      if (!sf_layer->handle || (sf_layer->flags & HWC_SKIP_LAYER)) {
-        ALOGE(
-            "Expected valid layer with HWC_FRAMEBUFFER_TARGET when all "
-            "HWC_OVERLAY layers are skipped.");
-        ret = -EINVAL;
-      }
-      indices_to_composite.push_back(framebuffer_target_index);
-    }
-  }
-
-  if (ret)
-    return ret;
-
-  for (size_t i = 0; i < num_displays; ++i) {
-    hwc_display_contents_1_t *dc = sf_display_contents[i];
-    DrmHwcDisplayContents &display_contents = displays_contents[i];
-    if (!sf_display_contents[i] || i == HWC_DISPLAY_VIRTUAL)
-      continue;
-
-    layers_map.emplace_back();
-    DrmCompositionDisplayLayersMap &map = layers_map.back();
-    map.display = i;
-    map.geometry_changed =
-        (dc->flags & HWC_GEOMETRY_CHANGED) == HWC_GEOMETRY_CHANGED;
-    std::vector<size_t> &indices_to_composite = layers_indices[i];
-    for (size_t j : indices_to_composite) {
-      hwc_layer_1_t *sf_layer = &dc->hwLayers[j];
-
-      DrmHwcLayer &layer = display_contents.layers[j];
-
-      ret = layer.InitFromHwcLayer(sf_layer, ctx->importer.get(), ctx->gralloc);
-      if (ret) {
-        ALOGE("Failed to init composition from layer %d", ret);
-        return ret;
-      }
-      map.layers.emplace_back(std::move(layer));
-    }
-  }
-
-  std::unique_ptr<DrmComposition> composition(
-      ctx->drm.compositor()->CreateComposition(ctx->importer.get()));
-  if (!composition) {
-    ALOGE("Drm composition init failed");
-    return -EINVAL;
-  }
-
-  ret = composition->SetLayers(layers_map.size(), layers_map.data());
-  if (ret) {
-    return -EINVAL;
-  }
-
-  ret = ctx->drm.compositor()->QueueComposition(std::move(composition));
-  if (ret) {
-    return -EINVAL;
-  }
-
-  for (size_t i = 0; i < num_displays; ++i) {
-    hwc_display_contents_1_t *dc = sf_display_contents[i];
-    if (!dc)
-      continue;
-
-    size_t num_dc_layers = dc->numHwLayers;
-    for (size_t j = 0; j < num_dc_layers; ++j) {
-      hwc_layer_1_t *layer = &dc->hwLayers[j];
-      if (layer->flags & HWC_SKIP_LAYER)
-        continue;
-      hwc_add_layer_to_retire_fence(layer, dc);
-    }
-  }
-
-  composition.reset(NULL);
-
-  return ret;
-}
-
-static int hwc_event_control(struct hwc_composer_device_1 *dev, int display,
-                             int event, int enabled) {
-  if (event != HWC_EVENT_VSYNC || (enabled != 0 && enabled != 1))
-    return -EINVAL;
-
-  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
-  hwc_drm_display_t *hd = &ctx->displays[display];
-  hd->vsync_worker.VSyncControl(enabled);
-  return 0;
-}
-
-static int hwc_set_power_mode(struct hwc_composer_device_1 *dev, int display,
-                              int mode) {
-  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
-
-  uint64_t dpmsValue = 0;
-  switch (mode) {
-    case HWC_POWER_MODE_OFF:
-      dpmsValue = DRM_MODE_DPMS_OFF;
-      break;
-
-    /* We can't support dozing right now, so go full on */
-    case HWC_POWER_MODE_DOZE:
-    case HWC_POWER_MODE_DOZE_SUSPEND:
-    case HWC_POWER_MODE_NORMAL:
-      dpmsValue = DRM_MODE_DPMS_ON;
-      break;
-  };
-  return ctx->drm.SetDpmsMode(display, dpmsValue);
-}
-
-static int hwc_query(struct hwc_composer_device_1 * /* dev */, int what,
-                     int *value) {
-  switch (what) {
-    case HWC_BACKGROUND_LAYER_SUPPORTED:
-      *value = 0; /* TODO: We should do this */
-      break;
-    case HWC_VSYNC_PERIOD:
-      ALOGW("Query for deprecated vsync value, returning 60Hz");
-      *value = 1000 * 1000 * 1000 / 60;
-      break;
-    case HWC_DISPLAY_TYPES_SUPPORTED:
-      *value = HWC_DISPLAY_PRIMARY_BIT | HWC_DISPLAY_EXTERNAL_BIT |
-               HWC_DISPLAY_VIRTUAL_BIT;
-      break;
-  }
-  return 0;
-}
-
-static void hwc_register_procs(struct hwc_composer_device_1 *dev,
-                               hwc_procs_t const *procs) {
-  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
-
-  ctx->procs = procs;
-
-  for (std::pair<const int, hwc_drm_display> &display_entry : ctx->displays) {
-    auto callback = std::make_shared<DrmVsyncCallback>(procs);
-    display_entry.second.vsync_worker.RegisterCallback(std::move(callback));
-  }
-
-  ctx->hotplug_handler.Init(&ctx->drm, procs);
-  ctx->drm.event_listener()->RegisterHotplugHandler(&ctx->hotplug_handler);
-}
-
-static int hwc_get_display_configs(struct hwc_composer_device_1 *dev,
-                                   int display, uint32_t *configs,
-                                   size_t *num_configs) {
-  if (!*num_configs)
-    return 0;
-
-  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
-  hwc_drm_display_t *hd = &ctx->displays[display];
-  hd->config_ids.clear();
-
-  DrmConnector *connector = ctx->drm.GetConnectorForDisplay(display);
-  if (!connector) {
-    ALOGE("Failed to get connector for display %d", display);
-    return -ENODEV;
-  }
-
-  int ret = connector->UpdateModes();
-  if (ret) {
-    ALOGE("Failed to update display modes %d", ret);
-    return ret;
-  }
-
-  for (const DrmMode &mode : connector->modes()) {
-    size_t idx = hd->config_ids.size();
-    if (idx == *num_configs)
-      break;
-    hd->config_ids.push_back(mode.id());
-    configs[idx] = mode.id();
-  }
-  *num_configs = hd->config_ids.size();
-  return *num_configs == 0 ? -1 : 0;
-}
-
-static int hwc_get_display_attributes(struct hwc_composer_device_1 *dev,
-                                      int display, uint32_t config,
-                                      const uint32_t *attributes,
-                                      int32_t *values) {
-  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
-  DrmConnector *c = ctx->drm.GetConnectorForDisplay(display);
-  if (!c) {
-    ALOGE("Failed to get DrmConnector for display %d", display);
-    return -ENODEV;
-  }
-  DrmMode mode;
-  for (const DrmMode &conn_mode : c->modes()) {
-    if (conn_mode.id() == config) {
-      mode = conn_mode;
-      break;
-    }
-  }
-  if (mode.id() == 0) {
-    ALOGE("Failed to find active mode for display %d", display);
-    return -ENOENT;
-  }
-
-  uint32_t mm_width = c->mm_width();
-  uint32_t mm_height = c->mm_height();
-  for (int i = 0; attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; ++i) {
-    switch (attributes[i]) {
-      case HWC_DISPLAY_VSYNC_PERIOD:
-        values[i] = 1000 * 1000 * 1000 / mode.v_refresh();
-        break;
-      case HWC_DISPLAY_WIDTH:
-        values[i] = mode.h_display();
-        break;
-      case HWC_DISPLAY_HEIGHT:
-        values[i] = mode.v_display();
-        break;
-      case HWC_DISPLAY_DPI_X:
-        /* Dots per 1000 inches */
-        values[i] = mm_width ? (mode.h_display() * UM_PER_INCH) / mm_width : 0;
-        break;
-      case HWC_DISPLAY_DPI_Y:
-        /* Dots per 1000 inches */
-        values[i] =
-            mm_height ? (mode.v_display() * UM_PER_INCH) / mm_height : 0;
-        break;
-    }
-  }
-  return 0;
-}
-
-static int hwc_get_active_config(struct hwc_composer_device_1 *dev,
-                                 int display) {
-  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
-  DrmConnector *c = ctx->drm.GetConnectorForDisplay(display);
-  if (!c) {
-    ALOGE("Failed to get DrmConnector for display %d", display);
-    return -ENODEV;
-  }
-
-  DrmMode mode = c->active_mode();
-  hwc_drm_display_t *hd = &ctx->displays[display];
-  for (size_t i = 0; i < hd->config_ids.size(); ++i) {
-    if (hd->config_ids[i] == mode.id())
-      return i;
-  }
-  return -1;
-}
-
-static int hwc_set_active_config(struct hwc_composer_device_1 *dev, int display,
-                                 int index) {
-  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
-  hwc_drm_display_t *hd = &ctx->displays[display];
-  if (index >= (int)hd->config_ids.size()) {
-    ALOGE("Invalid config index %d passed in", index);
-    return -EINVAL;
-  }
-
-  DrmConnector *c = ctx->drm.GetConnectorForDisplay(display);
-  if (!c) {
-    ALOGE("Failed to get connector for display %d", display);
-    return -ENODEV;
-  }
-
-  if (c->state() != DRM_MODE_CONNECTED)
-    return -ENODEV;
-
-  DrmMode mode;
-  for (const DrmMode &conn_mode : c->modes()) {
-    if (conn_mode.id() == hd->config_ids[index]) {
-      mode = conn_mode;
-      break;
-    }
-  }
-  if (mode.id() != hd->config_ids[index]) {
-    ALOGE("Could not find active mode for %d/%d", index, hd->config_ids[index]);
-    return -ENOENT;
-  }
-  int ret = ctx->drm.SetDisplayActiveMode(display, mode);
-  if (ret) {
-    ALOGE("Failed to set active config %d", ret);
-    return ret;
-  }
-  ret = ctx->drm.SetDpmsMode(display, DRM_MODE_DPMS_ON);
-  if (ret) {
-    ALOGE("Failed to set dpms mode on %d", ret);
-    return ret;
-  }
-  return ret;
-}
-
-static int hwc_device_close(struct hw_device_t *dev) {
-  struct hwc_context_t *ctx = (struct hwc_context_t *)dev;
-  delete ctx;
-  return 0;
-}
-
-/*
- * TODO: This function sets the active config to the first one in the list. This
- * should be fixed such that it selects the preferred mode for the display, or
- * some other, saner, method of choosing the config.
- */
-static int hwc_set_initial_config(hwc_drm_display_t *hd) {
-  uint32_t config;
-  size_t num_configs = 1;
-  int ret = hwc_get_display_configs(&hd->ctx->device, hd->display, &config,
-                                    &num_configs);
-  if (ret || !num_configs)
-    return 0;
-
-  ret = hwc_set_active_config(&hd->ctx->device, hd->display, 0);
-  if (ret) {
-    ALOGE("Failed to set active config d=%d ret=%d", hd->display, ret);
-    return ret;
-  }
-
-  return ret;
-}
-
-static int hwc_initialize_display(struct hwc_context_t *ctx, int display) {
-  hwc_drm_display_t *hd = &ctx->displays[display];
-  hd->ctx = ctx;
-  hd->display = display;
-
-  int ret = hwc_set_initial_config(hd);
-  if (ret) {
-    ALOGE("Failed to set initial config for d=%d ret=%d", display, ret);
-    return ret;
-  }
-
-  ret = hd->vsync_worker.Init(&ctx->drm, display);
-  if (ret) {
-    ALOGE("Failed to create event worker for display %d %d\n", display, ret);
-    return ret;
-  }
-
-  return 0;
-}
-
-static int hwc_enumerate_displays(struct hwc_context_t *ctx) {
-  int ret;
-  for (auto &conn : ctx->drm.connectors()) {
-    ret = hwc_initialize_display(ctx, conn->display());
-    if (ret) {
-      ALOGE("Failed to initialize display %d", conn->display());
-      return ret;
-    }
-  }
-
-  ret = ctx->virtual_compositor_worker.Init();
-  if (ret) {
-    ALOGE("Failed to initialize virtual compositor worker");
-    return ret;
-  }
-  return 0;
-}
-
-static int hwc_device_open(const struct hw_module_t *module, const char *name,
-                           struct hw_device_t **dev) {
-  if (strcmp(name, HWC_HARDWARE_COMPOSER)) {
-    ALOGE("Invalid module name- %s", name);
-    return -EINVAL;
-  }
-
-  std::unique_ptr<hwc_context_t> ctx(new hwc_context_t());
-  if (!ctx) {
-    ALOGE("Failed to allocate hwc context");
-    return -ENOMEM;
-  }
-
-  int ret = ctx->drm.Init();
-  if (ret) {
-    ALOGE("Can't initialize Drm object %d", ret);
-    return ret;
-  }
-
-  ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
-                      (const hw_module_t **)&ctx->gralloc);
-  if (ret) {
-    ALOGE("Failed to open gralloc module %d", ret);
-    return ret;
-  }
-
-  ret = ctx->dummy_timeline.Init();
-  if (ret) {
-    ALOGE("Failed to create dummy sw sync timeline %d", ret);
-    return ret;
-  }
-
-  ctx->importer.reset(Importer::CreateInstance(&ctx->drm));
-  if (!ctx->importer) {
-    ALOGE("Failed to create importer instance");
-    return ret;
-  }
-
-  ret = hwc_enumerate_displays(ctx.get());
-  if (ret) {
-    ALOGE("Failed to enumerate displays: %s", strerror(ret));
-    return ret;
-  }
-
-  ctx->device.common.tag = HARDWARE_DEVICE_TAG;
-  ctx->device.common.version = HWC_DEVICE_API_VERSION_1_4;
-  ctx->device.common.module = const_cast<hw_module_t *>(module);
-  ctx->device.common.close = hwc_device_close;
-
-  ctx->device.dump = hwc_dump;
-  ctx->device.prepare = hwc_prepare;
-  ctx->device.set = hwc_set;
-  ctx->device.eventControl = hwc_event_control;
-  ctx->device.setPowerMode = hwc_set_power_mode;
-  ctx->device.query = hwc_query;
-  ctx->device.registerProcs = hwc_register_procs;
-  ctx->device.getDisplayConfigs = hwc_get_display_configs;
-  ctx->device.getDisplayAttributes = hwc_get_display_attributes;
-  ctx->device.getActiveConfig = hwc_get_active_config;
-  ctx->device.setActiveConfig = hwc_set_active_config;
-  ctx->device.setCursorPositionAsync = NULL; /* TODO: Add cursor */
-
-  *dev = &ctx->device.common;
-  ctx.release();
-
-  return 0;
-}
-}
-
-static struct hw_module_methods_t hwc_module_methods = {
-  .open = android::hwc_device_open
-};
-
-hwc_module_t HAL_MODULE_INFO_SYM = {
-  .common = {
-    .tag = HARDWARE_MODULE_TAG,
-    .version_major = 1,
-    .version_minor = 0,
-    .id = HWC_HARDWARE_MODULE_ID,
-    .name = "DRM hwcomposer module",
-    .author = "The Android Open Source Project",
-    .methods = &hwc_module_methods,
-    .dso = NULL,
-    .reserved = {0},
-  }
-};
diff --git a/platform.cpp b/platform.cpp
index 62b03a881dca..b6c39d05a3a1 100644
--- a/platform.cpp
+++ b/platform.cpp
@@ -37,7 +37,7 @@  std::vector<DrmPlane *> Planner::GetUsablePlanes(
 }
 
 std::tuple<int, std::vector<DrmCompositionPlane>> Planner::ProvisionPlanes(
-    std::map<size_t, DrmHwcLayer *> &layers, bool use_squash_fb, DrmCrtc *crtc,
+    std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc *crtc,
     std::vector<DrmPlane *> *primary_planes,
     std::vector<DrmPlane *> *overlay_planes) {
   std::vector<DrmCompositionPlane> composition;
@@ -48,30 +48,6 @@  std::tuple<int, std::vector<DrmCompositionPlane>> Planner::ProvisionPlanes(
     return std::make_tuple(-ENODEV, std::vector<DrmCompositionPlane>());
   }
 
-  // If needed, reserve the squash plane at the highest z-order
-  DrmPlane *squash_plane = NULL;
-  if (use_squash_fb) {
-    if (!planes.empty()) {
-      squash_plane = planes.back();
-      planes.pop_back();
-    } else {
-      ALOGI("Not enough planes to reserve for squash fb");
-    }
-  }
-
-  // If needed, reserve the precomp plane at the next highest z-order
-  DrmPlane *precomp_plane = NULL;
-  if (layers.size() > planes.size()) {
-    if (!planes.empty()) {
-      precomp_plane = planes.back();
-      planes.pop_back();
-      composition.emplace_back(DrmCompositionPlane::Type::kPrecomp,
-                               precomp_plane, crtc);
-    } else {
-      ALOGE("Not enough planes to reserve for precomp fb");
-    }
-  }
-
   // Go through the provisioning stages and provision planes
   for (auto &i : stages_) {
     int ret = i->ProvisionPlanes(&composition, layers, crtc, &planes);
@@ -81,10 +57,6 @@  std::tuple<int, std::vector<DrmCompositionPlane>> Planner::ProvisionPlanes(
     }
   }
 
-  if (squash_plane)
-    composition.emplace_back(DrmCompositionPlane::Type::kSquash, squash_plane,
-                             crtc);
-
   return std::make_tuple(0, std::move(composition));
 }
 
@@ -109,62 +81,6 @@  int PlanStageProtected::ProvisionPlanes(
     i = layers.erase(i);
   }
 
-  if (protected_zorder == -1)
-    return 0;
-
-  // Add any layers below the protected content to the precomposition since we
-  // need to punch a hole through them.
-  for (auto i = layers.begin(); i != layers.end();) {
-    // Skip layers above the z-order of the protected content
-    if (i->first > static_cast<size_t>(protected_zorder)) {
-      ++i;
-      continue;
-    }
-
-    // If there's no precomp layer already queued, queue one now.
-    DrmCompositionPlane *precomp = GetPrecomp(composition);
-    if (precomp) {
-      precomp->source_layers().emplace_back(i->first);
-    } else {
-      if (!planes->empty()) {
-        DrmPlane *precomp_plane = planes->back();
-        planes->pop_back();
-        composition->emplace_back(DrmCompositionPlane::Type::kPrecomp,
-                                  precomp_plane, crtc, i->first);
-      } else {
-        ALOGE("Not enough planes to reserve for precomp fb");
-      }
-    }
-    i = layers.erase(i);
-  }
-  return 0;
-}
-
-int PlanStagePrecomp::ProvisionPlanes(
-    std::vector<DrmCompositionPlane> *composition,
-    std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc * /*crtc*/,
-    std::vector<DrmPlane *> * /*planes*/) {
-  DrmCompositionPlane *precomp = GetPrecomp(composition);
-  if (!precomp || precomp->source_layers().empty())
-    return 0;
-
-  // Find lowest zorder out of precomp layers
-  size_t precomp_zorder = *std::min_element(
-      precomp->source_layers().begin(), precomp->source_layers().end(),
-      [](size_t a, size_t b) { return a < b; });
-
-  // if there are any remaining layers on top of any of the precomp layers,
-  // add them to precomp to avoid blending issues since precomp is always at
-  // highest zorder
-  for (auto i = layers.begin(); i != layers.end();) {
-    if (i->first < precomp_zorder) {
-      i++;
-      continue;
-    }
-    precomp->source_layers().emplace_back(i->first);
-    i = layers.erase(i);
-  }
-
   return 0;
 }
 
@@ -183,13 +99,6 @@  int PlanStageGreedy::ProvisionPlanes(
       ALOGE("Failed to emplace layer %zu, dropping it", i->first);
   }
 
-  // Put the rest of the layers in the precomp plane
-  DrmCompositionPlane *precomp = GetPrecomp(composition);
-  if (precomp) {
-    for (auto i = layers.begin(); i != layers.end(); i = layers.erase(i))
-      precomp->source_layers().emplace_back(i->first);
-  }
-
   return 0;
 }
 }
diff --git a/platform.h b/platform.h
index e417bf785a2c..639ac884ba3f 100644
--- a/platform.h
+++ b/platform.h
@@ -38,10 +38,6 @@  class Importer {
   // Creates a platform-specific importer instance
   static Importer *CreateInstance(DrmResources *drm);
 
-  // Imports EGLImage for glcompositor, since NV handles this in non-standard
-  // way, and fishing out the details is specific to the gralloc used.
-  virtual EGLImageKHR ImportImage(EGLDisplay egl_display, buffer_handle_t handle) = 0;
-
   // Imports the buffer referred to by handle into bo.
   //
   // Note: This can be called from a different thread than ReleaseBuffer. The
@@ -77,17 +73,7 @@  class Planner {
       return plane;
     }
 
-    // Finds and returns the squash layer from the composition
-    static DrmCompositionPlane *GetPrecomp(
-        std::vector<DrmCompositionPlane> *composition) {
-      auto l = GetPrecompIter(composition);
-      if (l == composition->end())
-        return NULL;
-      return &(*l);
-    }
-
-    // Inserts the given layer:plane in the composition right before the precomp
-    // layer
+    // Inserts the given layer:plane in the composition at the back
     static int Emplace(std::vector<DrmCompositionPlane> *composition,
                        std::vector<DrmPlane *> *planes,
                        DrmCompositionPlane::Type type, DrmCrtc *crtc,
@@ -96,40 +82,25 @@  class Planner {
       if (!plane)
         return -ENOENT;
 
-      auto precomp = GetPrecompIter(composition);
-      composition->emplace(precomp, type, plane, crtc, source_layer);
+      composition->emplace_back(type, plane, crtc, source_layer);
       return 0;
     }
-
-   private:
-    static std::vector<DrmCompositionPlane>::iterator GetPrecompIter(
-        std::vector<DrmCompositionPlane> *composition) {
-      return std::find_if(composition->begin(), composition->end(),
-                          [](const DrmCompositionPlane &p) {
-        return p.type() == DrmCompositionPlane::Type::kPrecomp;
-      });
-    }
   };
 
   // Creates a planner instance with platform-specific planning stages
   static std::unique_ptr<Planner> CreateInstance(DrmResources *drm);
 
   // Takes a stack of layers and provisions hardware planes for them. If the
-  // entire stack can't fit in hardware, the Planner may place the remaining
-  // layers in a PRECOMP plane. Layers in the PRECOMP plane will be composited
-  // using GL. PRECOMP planes should be placed above any 1:1 layer:plane
-  // compositions. If use_squash_fb is true, the Planner should try to reserve a
-  // plane at the highest z-order with type SQUASH.
+  // entire stack can't fit in hardware, FIXME
   //
   // @layers: a map of index:layer of layers to composite
-  // @use_squash_fb: reserve a squash framebuffer
   // @primary_planes: a vector of primary planes available for this frame
   // @overlay_planes: a vector of overlay planes available for this frame
   //
   // Returns: A tuple with the status of the operation (0 for success) and
   //          a vector of the resulting plan (ie: layer->plane mapping).
   std::tuple<int, std::vector<DrmCompositionPlane>> ProvisionPlanes(
-      std::map<size_t, DrmHwcLayer *> &layers, bool use_squash_fb,
+      std::map<size_t, DrmHwcLayer *> &layers,
       DrmCrtc *crtc, std::vector<DrmPlane *> *primary_planes,
       std::vector<DrmPlane *> *overlay_planes);
 
@@ -156,18 +127,6 @@  class PlanStageProtected : public Planner::PlanStage {
                       std::vector<DrmPlane *> *planes);
 };
 
-// This plan stage provisions the precomp plane with any remaining layers that
-// are on top of the current precomp layers. This stage should be included in
-// all platforms before loosely allocating layers (i.e. PlanStageGreedy) if
-// any previous plan could have modified the precomp plane layers
-// (ex. PlanStageProtected).
-class PlanStagePrecomp : public Planner::PlanStage {
- public:
-  int ProvisionPlanes(std::vector<DrmCompositionPlane> *composition,
-                      std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc *crtc,
-                      std::vector<DrmPlane *> *planes);
-};
-
 // This plan stage places as many layers on dedicated planes as possible (first
 // come first serve), and then sticks the rest in a precomposition plane (if
 // needed).
diff --git a/platformdrmgeneric.cpp b/platformdrmgeneric.cpp
index 82539676b229..5b42c4aed5a4 100644
--- a/platformdrmgeneric.cpp
+++ b/platformdrmgeneric.cpp
@@ -27,7 +27,6 @@ 
 #include <log/log.h>
 #include <gralloc_handle.h>
 #include <hardware/gralloc.h>
-#include <EGL/eglext.h>
 
 namespace android {
 
@@ -84,22 +83,6 @@  uint32_t DrmGenericImporter::ConvertHalFormatToDrm(uint32_t hal_format) {
   }
 }
 
-EGLImageKHR DrmGenericImporter::ImportImage(EGLDisplay egl_display, buffer_handle_t handle) {
-  gralloc_handle_t *gr_handle = gralloc_handle(handle);
-  if (!gr_handle)
-    return NULL;
-  EGLint attr[] = {
-    EGL_WIDTH, (EGLint)gr_handle->width,
-    EGL_HEIGHT, (EGLint)gr_handle->height,
-    EGL_LINUX_DRM_FOURCC_EXT, (EGLint)ConvertHalFormatToDrm(gr_handle->format),
-    EGL_DMA_BUF_PLANE0_FD_EXT, gr_handle->prime_fd,
-    EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0,
-    EGL_DMA_BUF_PLANE0_PITCH_EXT, (EGLint)gr_handle->stride,
-    EGL_NONE,
-  };
-  return eglCreateImageKHR(egl_display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL, attr);
-}
-
 int DrmGenericImporter::ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) {
   gralloc_handle_t *gr_handle = gralloc_handle(handle);
   if (!gr_handle)
diff --git a/platformdrmgeneric.h b/platformdrmgeneric.h
index fbe059b49a92..0339e1e3957e 100644
--- a/platformdrmgeneric.h
+++ b/platformdrmgeneric.h
@@ -31,7 +31,6 @@  class DrmGenericImporter : public Importer {
 
   int Init();
 
-  EGLImageKHR ImportImage(EGLDisplay egl_display, buffer_handle_t handle) override;
   int ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) override;
   int ReleaseBuffer(hwc_drm_bo_t *bo) override;
 
diff --git a/platformhisi.cpp b/platformhisi.cpp
index 3f5c31995c57..1ea1d0776648 100644
--- a/platformhisi.cpp
+++ b/platformhisi.cpp
@@ -69,27 +69,6 @@  int HisiImporter::Init() {
   return 0;
 }
 
-EGLImageKHR HisiImporter::ImportImage(EGLDisplay egl_display, buffer_handle_t handle) {
-  private_handle_t const *hnd = reinterpret_cast < private_handle_t const *>(handle);
-  if (!hnd)
-    return NULL;
-
-  EGLint fmt = ConvertHalFormatToDrm(hnd->req_format);
-  if (fmt < 0)
-	return NULL;
-
-  EGLint attr[] = {
-    EGL_WIDTH, hnd->width,
-    EGL_HEIGHT, hnd->height,
-    EGL_LINUX_DRM_FOURCC_EXT, fmt,
-    EGL_DMA_BUF_PLANE0_FD_EXT, hnd->share_fd,
-    EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0,
-    EGL_DMA_BUF_PLANE0_PITCH_EXT, hnd->byte_stride,
-    EGL_NONE,
-  };
-  return eglCreateImageKHR(egl_display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL, attr);
-}
-
 int HisiImporter::ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) {
   private_handle_t const *hnd = reinterpret_cast < private_handle_t const *>(handle);
   if (!hnd)
@@ -131,5 +110,3 @@  std::unique_ptr<Planner> Planner::CreateInstance(DrmResources *) {
   return planner;
 }
 }
-
-
diff --git a/platformhisi.h b/platformhisi.h
index 46f459513dff..a0986923d4d3 100644
--- a/platformhisi.h
+++ b/platformhisi.h
@@ -34,7 +34,6 @@  class HisiImporter : public DrmGenericImporter {
 
   int Init();
 
-  EGLImageKHR ImportImage(EGLDisplay egl_display, buffer_handle_t handle) override;
   int ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) override;
 
  private:
diff --git a/platformminigbm.cpp b/platformminigbm.cpp
index 80e2c0f9f5fd..8e3cc65f0c4c 100644
--- a/platformminigbm.cpp
+++ b/platformminigbm.cpp
@@ -66,22 +66,6 @@  int DrmMinigbmImporter::Init() {
   return 0;
 }
 
-EGLImageKHR DrmMinigbmImporter::ImportImage(EGLDisplay egl_display, buffer_handle_t handle) {
-  cros_gralloc_handle *gr_handle = (cros_gralloc_handle *)handle;
-  if (!gr_handle)
-    return NULL;
-  EGLint attr[] = {
-    EGL_WIDTH, (EGLint)gr_handle->width,
-    EGL_HEIGHT, (EGLint)gr_handle->height,
-    EGL_LINUX_DRM_FOURCC_EXT, (EGLint)gr_handle->format,
-    EGL_DMA_BUF_PLANE0_FD_EXT, gr_handle->fds[0],
-    EGL_DMA_BUF_PLANE0_PITCH_EXT, (EGLint)gr_handle->strides[0],
-    EGL_DMA_BUF_PLANE0_OFFSET_EXT, (EGLint)gr_handle->offsets[0],
-    EGL_NONE,
-  };
-  return eglCreateImageKHR(egl_display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL, attr);
-}
-
 int DrmMinigbmImporter::ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) {
   cros_gralloc_handle *gr_handle = (cros_gralloc_handle *)handle;
   if (!gr_handle)
diff --git a/platformminigbm.h b/platformminigbm.h
index ded4c077e178..f25bf7bc2d19 100644
--- a/platformminigbm.h
+++ b/platformminigbm.h
@@ -32,7 +32,6 @@  class DrmMinigbmImporter : public DrmGenericImporter {
 
   int Init();
 
-  EGLImageKHR ImportImage(EGLDisplay egl_display, buffer_handle_t handle) override;
   int ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) override;
 
  private:
diff --git a/virtualcompositorworker.cpp b/virtualcompositorworker.cpp
deleted file mode 100644
index b64b4148ee50..000000000000
--- a/virtualcompositorworker.cpp
+++ /dev/null
@@ -1,168 +0,0 @@ 
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "hwc-virtual-compositor-worker"
-
-#include "virtualcompositorworker.h"
-#include "worker.h"
-
-#include <errno.h>
-#include <stdlib.h>
-
-#include <log/log.h>
-#include <hardware/hardware.h>
-#include <hardware/hwcomposer.h>
-#include <sched.h>
-#include <sw_sync.h>
-#include <sync/sync.h>
-
-namespace android {
-
-static const int kMaxQueueDepth = 3;
-static const int kAcquireWaitTimeoutMs = 3000;
-
-VirtualCompositorWorker::VirtualCompositorWorker()
-    : Worker("virtual-compositor", HAL_PRIORITY_URGENT_DISPLAY),
-      timeline_fd_(-1),
-      timeline_(0),
-      timeline_current_(0) {
-}
-
-VirtualCompositorWorker::~VirtualCompositorWorker() {
-  if (timeline_fd_ >= 0) {
-    FinishComposition(timeline_);
-    close(timeline_fd_);
-    timeline_fd_ = -1;
-  }
-}
-
-int VirtualCompositorWorker::Init() {
-  int ret = sw_sync_timeline_create();
-  if (ret < 0) {
-    ALOGE("Failed to create sw sync timeline %d", ret);
-    return ret;
-  }
-  timeline_fd_ = ret;
-  return InitWorker();
-}
-
-void VirtualCompositorWorker::QueueComposite(hwc_display_contents_1_t *dc) {
-  std::unique_ptr<VirtualComposition> composition(new VirtualComposition);
-
-  composition->outbuf_acquire_fence.Set(dc->outbufAcquireFenceFd);
-  dc->outbufAcquireFenceFd = -1;
-  if (dc->retireFenceFd >= 0)
-    close(dc->retireFenceFd);
-  dc->retireFenceFd = CreateNextTimelineFence();
-
-  for (size_t i = 0; i < dc->numHwLayers; ++i) {
-    hwc_layer_1_t *layer = &dc->hwLayers[i];
-    if (layer->flags & HWC_SKIP_LAYER)
-      continue;
-    composition->layer_acquire_fences.emplace_back(layer->acquireFenceFd);
-    layer->acquireFenceFd = -1;
-    if (layer->releaseFenceFd >= 0)
-      close(layer->releaseFenceFd);
-    layer->releaseFenceFd = CreateNextTimelineFence();
-  }
-
-  composition->release_timeline = timeline_;
-
-  Lock();
-  while (composite_queue_.size() >= kMaxQueueDepth) {
-    Unlock();
-    sched_yield();
-    Lock();
-  }
-
-  composite_queue_.push(std::move(composition));
-  Unlock();
-  Signal();
-}
-
-void VirtualCompositorWorker::Routine() {
-  int wait_ret = 0;
-
-  Lock();
-  if (composite_queue_.empty()) {
-    wait_ret = WaitForSignalOrExitLocked();
-  }
-
-  std::unique_ptr<VirtualComposition> composition;
-  if (!composite_queue_.empty()) {
-    composition = std::move(composite_queue_.front());
-    composite_queue_.pop();
-  }
-  Unlock();
-
-  if (wait_ret == -EINTR) {
-    return;
-  } else if (wait_ret) {
-    ALOGE("Failed to wait for signal, %d", wait_ret);
-    return;
-  }
-
-  Compose(std::move(composition));
-}
-
-int VirtualCompositorWorker::CreateNextTimelineFence() {
-  ++timeline_;
-  return sw_sync_fence_create(timeline_fd_, "drm_fence", timeline_);
-}
-
-int VirtualCompositorWorker::FinishComposition(int point) {
-  int timeline_increase = point - timeline_current_;
-  if (timeline_increase <= 0)
-    return 0;
-  int ret = sw_sync_timeline_inc(timeline_fd_, timeline_increase);
-  if (ret)
-    ALOGE("Failed to increment sync timeline %d", ret);
-  else
-    timeline_current_ = point;
-  return ret;
-}
-
-void VirtualCompositorWorker::Compose(
-    std::unique_ptr<VirtualComposition> composition) {
-  if (!composition.get())
-    return;
-
-  int ret;
-  int outbuf_acquire_fence = composition->outbuf_acquire_fence.get();
-  if (outbuf_acquire_fence >= 0) {
-    ret = sync_wait(outbuf_acquire_fence, kAcquireWaitTimeoutMs);
-    if (ret) {
-      ALOGE("Failed to wait for outbuf acquire %d/%d", outbuf_acquire_fence,
-            ret);
-      return;
-    }
-    composition->outbuf_acquire_fence.Close();
-  }
-  for (size_t i = 0; i < composition->layer_acquire_fences.size(); ++i) {
-    int layer_acquire_fence = composition->layer_acquire_fences[i].get();
-    if (layer_acquire_fence >= 0) {
-      ret = sync_wait(layer_acquire_fence, kAcquireWaitTimeoutMs);
-      if (ret) {
-        ALOGE("Failed to wait for layer acquire %d/%d", layer_acquire_fence,
-              ret);
-        return;
-      }
-      composition->layer_acquire_fences[i].Close();
-    }
-  }
-  FinishComposition(composition->release_timeline);
-}
-}
diff --git a/virtualcompositorworker.h b/virtualcompositorworker.h
deleted file mode 100644
index 1fc5e435eaac..000000000000
--- a/virtualcompositorworker.h
+++ /dev/null
@@ -1,56 +0,0 @@ 
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_VIRTUAL_COMPOSITOR_WORKER_H_
-#define ANDROID_VIRTUAL_COMPOSITOR_WORKER_H_
-
-#include "drmhwcomposer.h"
-#include "worker.h"
-
-#include <queue>
-
-namespace android {
-
-class VirtualCompositorWorker : public Worker {
- public:
-  VirtualCompositorWorker();
-  ~VirtualCompositorWorker() override;
-
-  int Init();
-  void QueueComposite(hwc_display_contents_1_t *dc);
-
- protected:
-  void Routine() override;
-
- private:
-  struct VirtualComposition {
-    UniqueFd outbuf_acquire_fence;
-    std::vector<UniqueFd> layer_acquire_fences;
-    int release_timeline;
-  };
-
-  int CreateNextTimelineFence();
-  int FinishComposition(int timeline);
-  void Compose(std::unique_ptr<VirtualComposition> composition);
-
-  std::queue<std::unique_ptr<VirtualComposition>> composite_queue_;
-  int timeline_fd_;
-  int timeline_;
-  int timeline_current_;
-};
-}
-
-#endif

Comments

On Fri, May 04, 2018 at 02:18:33PM -0500, Rob Herring wrote:
> The GL based compositing adds alot of complexity and was only ever well
> tested on closed stacks. It also only supports GLES3.x and still relies
> on sw_sync timeline which is now a debugfs feature. Those are just the
> known issues.
> 
> Removing the GL compositor means everything related to squashing layers
> and pre-compositing can be removed. The planner is left as it may be
> useful when adding back support for overlay planes. With this change,
> only a single plane is supported until ValidateDisplay learns to do
> atomic modesetting test for overlay planes.

Hey Rob,
Thanks for posting this so quickly, I think it's definitely a step in the right
direction.

I've posted this as a merge request on gitlab [1] with the reverts squashed into the
change.

I don't think this will conflict too badly with Alex's work, but I want him to
take a look at it first before merging.

Sean

[1]- https://gitlab.freedesktop.org/drm-hwcomposer/drm-hwcomposer/merge_requests/6

> 
> Signed-off-by: Rob Herring <robh@kernel.org>
> ---
> I've lightly tested this with virgl. John tested an earlier version on Hikey.
> 
> This depends on reverting these commits:
> "drm_hwcomposer: Cleanup gl precompositor init and provide uses_GL flag"
> "drm_hwcomposer: Fall back to client compositon if the gl precompostior fails"
> 
>  Android.mk                  |   4 -
>  autogl.h                    | 110 -----
>  drmcompositorworker.cpp     |  78 ----
>  drmdisplaycomposition.cpp   | 315 +-------------
>  drmdisplaycomposition.h     |  34 +-
>  drmdisplaycompositor.cpp    | 529 +----------------------
>  drmdisplaycompositor.h      |  56 ---
>  drmhwctwo.cpp               |   6 +-
>  glworker.cpp                | 840 -----------------------------------
>  glworker.h                  |  94 ----
>  hwcomposer.cpp              | 841 ------------------------------------
>  platform.cpp                |  93 +---
>  platform.h                  |  49 +--
>  platformdrmgeneric.cpp      |  17 -
>  platformdrmgeneric.h        |   1 -
>  platformhisi.cpp            |  23 -
>  platformhisi.h              |   1 -
>  platformminigbm.cpp         |  16 -
>  platformminigbm.h           |   1 -
>  virtualcompositorworker.cpp | 168 -------
>  virtualcompositorworker.h   |  56 ---
>  21 files changed, 21 insertions(+), 3311 deletions(-)
>  delete mode 100644 autogl.h
>  delete mode 100644 drmcompositorworker.cpp
>  delete mode 100644 glworker.cpp
>  delete mode 100644 glworker.h
>  delete mode 100644 hwcomposer.cpp
>  delete mode 100644 virtualcompositorworker.cpp
>  delete mode 100644 virtualcompositorworker.h
> 
> diff --git a/Android.mk b/Android.mk
> index c0a1d0e7cdce..0d05f9c52de5 100644
> --- a/Android.mk
> +++ b/Android.mk
> @@ -37,8 +37,6 @@ include $(CLEAR_VARS)
>  LOCAL_SHARED_LIBRARIES := \
>  	libcutils \
>  	libdrm \
> -	libEGL \
> -	libGLESv2 \
>  	libhardware \
>  	liblog \
>  	libsync \
> @@ -63,12 +61,10 @@ LOCAL_SRC_FILES := \
>  	drmmode.cpp \
>  	drmplane.cpp \
>  	drmproperty.cpp \
> -	glworker.cpp \
>  	hwcutils.cpp \
>  	platform.cpp \
>  	platformdrmgeneric.cpp \
>  	separate_rects.cpp \
> -	virtualcompositorworker.cpp \
>  	vsyncworker.cpp
>  
>  LOCAL_CPPFLAGS += \
> diff --git a/autogl.h b/autogl.h
> deleted file mode 100644
> index fc77fb0c1bf0..000000000000
> --- a/autogl.h
> +++ /dev/null
> @@ -1,110 +0,0 @@
> -/*
> - * Copyright (C) 2015 The Android Open Source Project
> - *
> - * Licensed under the Apache License, Version 2.0 (the "License");
> - * you may not use this file except in compliance with the License.
> - * You may obtain a copy of the License at
> - *
> - *      http://www.apache.org/licenses/LICENSE-2.0
> - *
> - * Unless required by applicable law or agreed to in writing, software
> - * distributed under the License is distributed on an "AS IS" BASIS,
> - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
> - * See the License for the specific language governing permissions and
> - * limitations under the License.
> - */
> -
> -#ifndef ANDROID_AUTO_GL_H_
> -#define ANDROID_AUTO_GL_H_
> -
> -#include <memory>
> -#define EGL_EGLEXT_PROTOTYPES
> -#define GL_GLEXT_PROTOTYPES
> -
> -#include <EGL/egl.h>
> -#include <EGL/eglext.h>
> -#include <GLES2/gl2.h>
> -#include <GLES2/gl2ext.h>
> -
> -// TODO(zachr): use hwc_drm_bo to turn buffer handles into textures
> -#ifndef EGL_NATIVE_HANDLE_ANDROID_NVX
> -#define EGL_NATIVE_HANDLE_ANDROID_NVX 0x322A
> -#endif
> -
> -namespace android {
> -
> -#define AUTO_GL_TYPE(name, type, zero, deleter) \
> -  struct name##Deleter {                        \
> -    typedef type pointer;                       \
> -                                                \
> -    void operator()(pointer p) const {          \
> -      if (p != zero) {                          \
> -        deleter;                                \
> -      }                                         \
> -    }                                           \
> -  };                                            \
> -  typedef std::unique_ptr<type, name##Deleter> name;
> -
> -AUTO_GL_TYPE(AutoGLFramebuffer, GLuint, 0, glDeleteFramebuffers(1, &p))
> -AUTO_GL_TYPE(AutoGLBuffer, GLuint, 0, glDeleteBuffers(1, &p))
> -AUTO_GL_TYPE(AutoGLTexture, GLuint, 0, glDeleteTextures(1, &p))
> -AUTO_GL_TYPE(AutoGLShader, GLint, 0, glDeleteShader(p))
> -AUTO_GL_TYPE(AutoGLProgram, GLint, 0, glDeleteProgram(p))
> -
> -struct AutoEGLDisplayImage {
> -  AutoEGLDisplayImage() = default;
> -
> -  AutoEGLDisplayImage(EGLDisplay display, EGLImageKHR image)
> -      : display_(display), image_(image) {
> -  }
> -
> -  AutoEGLDisplayImage(const AutoEGLDisplayImage& rhs) = delete;
> -  AutoEGLDisplayImage(AutoEGLDisplayImage&& rhs) {
> -    display_ = rhs.display_;
> -    image_ = rhs.image_;
> -    rhs.display_ = EGL_NO_DISPLAY;
> -    rhs.image_ = EGL_NO_IMAGE_KHR;
> -  }
> -
> -  ~AutoEGLDisplayImage() {
> -    clear();
> -  }
> -
> -  AutoEGLDisplayImage& operator=(const AutoEGLDisplayImage& rhs) = delete;
> -  AutoEGLDisplayImage& operator=(AutoEGLDisplayImage&& rhs) {
> -    clear();
> -    std::swap(display_, rhs.display_);
> -    std::swap(image_, rhs.image_);
> -    return *this;
> -  }
> -
> -  void reset(EGLDisplay display, EGLImageKHR image) {
> -    clear();
> -    display_ = display;
> -    image_ = image;
> -  }
> -
> -  void clear() {
> -    if (image_ != EGL_NO_IMAGE_KHR) {
> -      eglDestroyImageKHR(display_, image_);
> -      display_ = EGL_NO_DISPLAY;
> -      image_ = EGL_NO_IMAGE_KHR;
> -    }
> -  }
> -
> -  EGLImageKHR image() const {
> -    return image_;
> -  }
> -
> - private:
> -  EGLDisplay display_ = EGL_NO_DISPLAY;
> -  EGLImageKHR image_ = EGL_NO_IMAGE_KHR;
> -};
> -
> -struct AutoEGLImageAndGLTexture {
> -  AutoEGLDisplayImage image;
> -  AutoGLTexture texture;
> -};
> -}
> -
> -#endif
> diff --git a/drmcompositorworker.cpp b/drmcompositorworker.cpp
> deleted file mode 100644
> index 695876d7ae70..000000000000
> --- a/drmcompositorworker.cpp
> +++ /dev/null
> @@ -1,78 +0,0 @@
> -/*
> - * Copyright (C) 2015 The Android Open Source Project
> - *
> - * Licensed under the Apache License, Version 2.0 (the "License");
> - * you may not use this file except in compliance with the License.
> - * You may obtain a copy of the License at
> - *
> - *      http://www.apache.org/licenses/LICENSE-2.0
> - *
> - * Unless required by applicable law or agreed to in writing, software
> - * distributed under the License is distributed on an "AS IS" BASIS,
> - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
> - * See the License for the specific language governing permissions and
> - * limitations under the License.
> - */
> -
> -#define LOG_TAG "hwc-drm-compositor-worker"
> -
> -#include "drmdisplaycompositor.h"
> -#include "drmcompositorworker.h"
> -#include "worker.h"
> -
> -#include <stdlib.h>
> -
> -#include <log/log.h>
> -#include <hardware/hardware.h>
> -
> -namespace android {
> -
> -static const int64_t kSquashWait = 500000000LL;
> -
> -DrmCompositorWorker::DrmCompositorWorker(DrmDisplayCompositor *compositor)
> -    : Worker("drm-compositor", HAL_PRIORITY_URGENT_DISPLAY),
> -      compositor_(compositor) {
> -}
> -
> -DrmCompositorWorker::~DrmCompositorWorker() {
> -}
> -
> -int DrmCompositorWorker::Init() {
> -  return InitWorker();
> -}
> -
> -void DrmCompositorWorker::Routine() {
> -  int ret;
> -  if (!compositor_->HaveQueuedComposites()) {
> -    Lock();
> -
> -    // Only use a timeout if we didn't do a SquashAll last time. This will
> -    // prevent wait_ret == -ETIMEDOUT which would trigger a SquashAll and be a
> -    // pointless drain on resources.
> -    int wait_ret = did_squash_all_ ? WaitForSignalOrExitLocked()
> -                                   : WaitForSignalOrExitLocked(kSquashWait);
> -    Unlock();
> -
> -    switch (wait_ret) {
> -      case 0:
> -        break;
> -      case -EINTR:
> -        return;
> -      case -ETIMEDOUT:
> -        ret = compositor_->SquashAll();
> -        if (ret)
> -          ALOGE("Failed to squash all %d", ret);
> -        did_squash_all_ = true;
> -        return;
> -      default:
> -        ALOGE("Failed to wait for signal, %d", wait_ret);
> -        return;
> -    }
> -  }
> -
> -  ret = compositor_->Composite();
> -  if (ret)
> -    ALOGE("Failed to composite! %d", ret);
> -  did_squash_all_ = false;
> -}
> -}
> diff --git a/drmdisplaycomposition.cpp b/drmdisplaycomposition.cpp
> index 24a8e9c9a043..75e01a67564e 100644
> --- a/drmdisplaycomposition.cpp
> +++ b/drmdisplaycomposition.cpp
> @@ -29,18 +29,12 @@
>  #include <unordered_set>
>  
>  #include <log/log.h>
> -#include <sw_sync.h>
>  #include <sync/sync.h>
>  #include <xf86drmMode.h>
>  
>  namespace android {
>  
> -DrmDisplayComposition::~DrmDisplayComposition() {
> -  if (timeline_fd_ >= 0) {
> -    SignalCompositionDone();
> -    close(timeline_fd_);
> -  }
> -}
> +DrmDisplayComposition::~DrmDisplayComposition() {}
>  
>  int DrmDisplayComposition::Init(DrmResources *drm, DrmCrtc *crtc,
>                                  Importer *importer, Planner *planner,
> @@ -51,12 +45,6 @@ int DrmDisplayComposition::Init(DrmResources *drm, DrmCrtc *crtc,
>    planner_ = planner;
>    frame_no_ = frame_no;
>  
> -  int ret = sw_sync_timeline_create();
> -  if (ret < 0) {
> -    ALOGE("Failed to create sw sync timeline %d", ret);
> -    return ret;
> -  }
> -  timeline_fd_ = ret;
>    return 0;
>  }
>  
> @@ -64,26 +52,6 @@ bool DrmDisplayComposition::validate_composition_type(DrmCompositionType des) {
>    return type_ == DRM_COMPOSITION_TYPE_EMPTY || type_ == des;
>  }
>  
> -int DrmDisplayComposition::CreateNextTimelineFence() {
> -  ++timeline_;
> -  return sw_sync_fence_create(timeline_fd_, "hwc drm display composition fence",
> -                              timeline_);
> -}
> -
> -int DrmDisplayComposition::IncreaseTimelineToPoint(int point) {
> -  int timeline_increase = point - timeline_current_;
> -  if (timeline_increase <= 0)
> -    return 0;
> -
> -  int ret = sw_sync_timeline_inc(timeline_fd_, timeline_increase);
> -  if (ret)
> -    ALOGE("Failed to increment sync timeline %d", ret);
> -  else
> -    timeline_current_ = point;
> -
> -  return ret;
> -}
> -
>  int DrmDisplayComposition::SetLayers(DrmHwcLayer *layers, size_t num_layers,
>                                       bool geometry_changed) {
>    if (!validate_composition_type(DRM_COMPOSITION_TYPE_FRAME))
> @@ -122,252 +90,38 @@ int DrmDisplayComposition::AddPlaneDisable(DrmPlane *plane) {
>    return 0;
>  }
>  
> -static std::vector<size_t> SetBitsToVector(
> -    uint64_t in, const std::vector<size_t> &index_map) {
> -  std::vector<size_t> out;
> -  size_t msb = sizeof(in) * 8 - 1;
> -  uint64_t mask = (uint64_t)1 << msb;
> -  for (size_t i = msb; mask != (uint64_t)0; i--, mask >>= 1)
> -    if (in & mask)
> -      out.push_back(index_map[i]);
> -  return out;
> -}
> -
>  int DrmDisplayComposition::AddPlaneComposition(DrmCompositionPlane plane) {
>    composition_planes_.emplace_back(std::move(plane));
>    return 0;
>  }
>  
> -void DrmDisplayComposition::SeparateLayers(DrmHwcRect<int> *exclude_rects,
> -                                           size_t num_exclude_rects) {
> -  DrmCompositionPlane *comp = NULL;
> +void DrmDisplayComposition::SeparateLayers(DrmHwcRect<int> *,
> +                                           size_t ) {
>    std::vector<size_t> dedicated_layers;
>  
> -  // Go through the composition and find the precomp layer as well as any
> -  // layers that have a dedicated plane located below the precomp layer.
> +  // Go through the composition and find the layers that have a dedicated plane.
>    for (auto &i : composition_planes_) {
>      if (i.type() == DrmCompositionPlane::Type::kLayer) {
>        dedicated_layers.insert(dedicated_layers.end(), i.source_layers().begin(),
>                                i.source_layers().end());
> -    } else if (i.type() == DrmCompositionPlane::Type::kPrecomp) {
> -      comp = &i;
> -      break;
> -    }
> -  }
> -  if (!comp)
> -    return;
> -
> -  const std::vector<size_t> &comp_layers = comp->source_layers();
> -  if (comp_layers.size() > 64) {
> -    ALOGE("Failed to separate layers because there are more than 64");
> -    return;
> -  }
> -
> -  // Index at which the actual layers begin
> -  size_t layer_offset = num_exclude_rects + dedicated_layers.size();
> -  if (comp_layers.size() + layer_offset > 64) {
> -    ALOGW(
> -        "Exclusion rectangles are being truncated to make the rectangle count "
> -        "fit into 64");
> -    num_exclude_rects = 64 - comp_layers.size() - dedicated_layers.size();
> -  }
> -
> -  // We inject all the exclude rects into the rects list. Any resulting rect
> -  // that includes ANY of the first num_exclude_rects is rejected. After the
> -  // exclude rects, we add the lower layers. The rects that intersect with
> -  // these layers will be inspected and only those which are to be composited
> -  // above the layer will be included in the composition regions.
> -  std::vector<DrmHwcRect<int>> layer_rects(comp_layers.size() + layer_offset);
> -  std::copy(exclude_rects, exclude_rects + num_exclude_rects,
> -            layer_rects.begin());
> -  std::transform(
> -      dedicated_layers.begin(), dedicated_layers.end(),
> -      layer_rects.begin() + num_exclude_rects,
> -      [=](size_t layer_index) { return layers_[layer_index].display_frame; });
> -  std::transform(comp_layers.begin(), comp_layers.end(),
> -                 layer_rects.begin() + layer_offset, [=](size_t layer_index) {
> -    return layers_[layer_index].display_frame;
> -  });
> -
> -  std::vector<separate_rects::RectSet<uint64_t, int>> separate_regions;
> -  separate_rects::separate_rects_64(layer_rects, &separate_regions);
> -  uint64_t exclude_mask = ((uint64_t)1 << num_exclude_rects) - 1;
> -  uint64_t dedicated_mask = (((uint64_t)1 << dedicated_layers.size()) - 1)
> -                            << num_exclude_rects;
> -
> -  for (separate_rects::RectSet<uint64_t, int> &region : separate_regions) {
> -    if (region.id_set.getBits() & exclude_mask)
> -      continue;
> -
> -    // If a rect intersects one of the dedicated layers, we need to remove the
> -    // layers from the composition region which appear *below* the dedicated
> -    // layer. This effectively punches a hole through the composition layer such
> -    // that the dedicated layer can be placed below the composition and not
> -    // be occluded.
> -    uint64_t dedicated_intersect = region.id_set.getBits() & dedicated_mask;
> -    for (size_t i = 0; dedicated_intersect && i < dedicated_layers.size();
> -         ++i) {
> -      // Only exclude layers if they intersect this particular dedicated layer
> -      if (!(dedicated_intersect & (1 << (i + num_exclude_rects))))
> -        continue;
> -
> -      for (size_t j = 0; j < comp_layers.size(); ++j) {
> -        if (comp_layers[j] < dedicated_layers[i])
> -          region.id_set.subtract(j + layer_offset);
> -      }
>      }
> -    if (!(region.id_set.getBits() >> layer_offset))
> -      continue;
> -
> -    pre_comp_regions_.emplace_back(DrmCompositionRegion{
> -        region.rect,
> -        SetBitsToVector(region.id_set.getBits() >> layer_offset, comp_layers)});
>    }
>  }
>  
> -int DrmDisplayComposition::CreateAndAssignReleaseFences() {
> -  std::unordered_set<DrmHwcLayer *> squash_layers;
> -  std::unordered_set<DrmHwcLayer *> pre_comp_layers;
> -  std::unordered_set<DrmHwcLayer *> comp_layers;
> -
> -  for (const DrmCompositionRegion &region : squash_regions_) {
> -    for (size_t source_layer_index : region.source_layers) {
> -      DrmHwcLayer *source_layer = &layers_[source_layer_index];
> -      squash_layers.emplace(source_layer);
> -    }
> -  }
> -
> -  for (const DrmCompositionRegion &region : pre_comp_regions_) {
> -    for (size_t source_layer_index : region.source_layers) {
> -      DrmHwcLayer *source_layer = &layers_[source_layer_index];
> -      pre_comp_layers.emplace(source_layer);
> -      squash_layers.erase(source_layer);
> -    }
> -  }
> -
> -  for (const DrmCompositionPlane &plane : composition_planes_) {
> -    if (plane.type() == DrmCompositionPlane::Type::kLayer) {
> -      for (auto i : plane.source_layers()) {
> -        DrmHwcLayer *source_layer = &layers_[i];
> -        comp_layers.emplace(source_layer);
> -        pre_comp_layers.erase(source_layer);
> -      }
> -    }
> -  }
> -
> -  for (DrmHwcLayer *layer : squash_layers) {
> -    if (!layer->release_fence)
> -      continue;
> -    int ret = layer->release_fence.Set(CreateNextTimelineFence());
> -    if (ret < 0) {
> -      ALOGE("Failed to set the release fence (squash) %d", ret);
> -      return ret;
> -    }
> -  }
> -  timeline_squash_done_ = timeline_;
> -
> -  for (DrmHwcLayer *layer : pre_comp_layers) {
> -    if (!layer->release_fence)
> -      continue;
> -    int ret = layer->release_fence.Set(CreateNextTimelineFence());
> -    if (ret < 0)
> -      return ret;
> -  }
> -  timeline_pre_comp_done_ = timeline_;
> -
> -  for (DrmHwcLayer *layer : comp_layers) {
> -    if (!layer->release_fence)
> -      continue;
> -    int ret = layer->release_fence.Set(CreateNextTimelineFence());
> -    if (ret < 0) {
> -      ALOGE("Failed to set the release fence (comp) %d", ret);
> -      return ret;
> -    }
> -  }
> -
> -  return 0;
> -}
> -
> -int DrmDisplayComposition::Plan(SquashState *squash,
> -                                std::vector<DrmPlane *> *primary_planes,
> +int DrmDisplayComposition::Plan(std::vector<DrmPlane *> *primary_planes,
>                                  std::vector<DrmPlane *> *overlay_planes) {
>    if (type_ != DRM_COMPOSITION_TYPE_FRAME)
>      return 0;
>  
> -  // Used to track which layers should be sent to the planner. We exclude layers
> -  // that are entirely squashed so the planner can provision a precomposition
> -  // layer as appropriate (ex: if 5 layers are squashed and 1 is not, we don't
> -  // want to plan a precomposition layer that will be comprised of the already
> -  // squashed layers).
>    std::map<size_t, DrmHwcLayer *> to_composite;
>  
> -  bool use_squash_framebuffer = false;
> -  // Used to determine which layers were entirely squashed
> -  std::vector<int> layer_squash_area(layers_.size(), 0);
> -  // Used to avoid rerendering regions that were squashed
> -  std::vector<DrmHwcRect<int>> exclude_rects;
> -  if (squash != NULL) {
> -    if (geometry_changed_) {
> -      squash->Init(layers_.data(), layers_.size());
> -    } else {
> -      std::vector<bool> changed_regions;
> -      squash->GenerateHistory(layers_.data(), layers_.size(), changed_regions);
> -
> -      std::vector<bool> stable_regions;
> -      squash->StableRegionsWithMarginalHistory(changed_regions, stable_regions);
> -
> -      // Only if SOME region is stable
> -      use_squash_framebuffer =
> -          std::find(stable_regions.begin(), stable_regions.end(), true) !=
> -          stable_regions.end();
> -
> -      squash->RecordHistory(layers_.data(), layers_.size(), changed_regions);
> -
> -      // Changes in which regions are squashed triggers a rerender via
> -      // squash_regions.
> -      bool render_squash = squash->RecordAndCompareSquashed(stable_regions);
> -
> -      for (size_t region_index = 0; region_index < stable_regions.size();
> -           region_index++) {
> -        const SquashState::Region &region = squash->regions()[region_index];
> -        if (!stable_regions[region_index])
> -          continue;
> -
> -        exclude_rects.emplace_back(region.rect);
> -
> -        if (render_squash) {
> -          squash_regions_.emplace_back();
> -          squash_regions_.back().frame = region.rect;
> -        }
> -
> -        int frame_area = region.rect.area();
> -        // Source layers are sorted front to back i.e. top layer has lowest
> -        // index.
> -        for (size_t layer_index = layers_.size();
> -             layer_index-- > 0;  // Yes, I double checked this
> -             /* See condition */) {
> -          if (!region.layer_refs[layer_index])
> -            continue;
> -          layer_squash_area[layer_index] += frame_area;
> -          if (render_squash)
> -            squash_regions_.back().source_layers.push_back(layer_index);
> -        }
> -      }
> -    }
> -
> -    for (size_t i = 0; i < layers_.size(); ++i) {
> -      if (layer_squash_area[i] < layers_[i].display_frame.area())
> -        to_composite.emplace(std::make_pair(i, &layers_[i]));
> -    }
> -  } else {
> -    for (size_t i = 0; i < layers_.size(); ++i)
> -      to_composite.emplace(std::make_pair(i, &layers_[i]));
> -  }
> +  for (size_t i = 0; i < layers_.size(); ++i)
> +    to_composite.emplace(std::make_pair(i, &layers_[i]));
>  
>    int ret;
>    std::vector<DrmCompositionPlane> plan;
>    std::tie(ret, composition_planes_) =
> -      planner_->ProvisionPlanes(to_composite, use_squash_framebuffer, crtc_,
> +      planner_->ProvisionPlanes(to_composite, crtc_,
>                                  primary_planes, overlay_planes);
>    if (ret) {
>      ALOGE("Planner failed provisioning planes ret=%d", ret);
> @@ -396,17 +150,7 @@ int DrmDisplayComposition::Plan(SquashState *squash,
>      }
>    }
>  
> -  return FinalizeComposition(exclude_rects.data(), exclude_rects.size());
> -}
> -
> -int DrmDisplayComposition::FinalizeComposition() {
> -  return FinalizeComposition(NULL, 0);
> -}
> -
> -int DrmDisplayComposition::FinalizeComposition(DrmHwcRect<int> *exclude_rects,
> -                                               size_t num_exclude_rects) {
> -  SeparateLayers(exclude_rects, num_exclude_rects);
> -  return CreateAndAssignReleaseFences();
> +  return 0;
>  }
>  
>  static const char *DrmCompositionTypeToString(DrmCompositionType type) {
> @@ -506,23 +250,6 @@ static const char *BlendingToString(DrmHwcBlending blending) {
>    }
>  }
>  
> -static void DumpRegion(const DrmCompositionRegion &region,
> -                       std::ostringstream *out) {
> -  *out << "frame";
> -  region.frame.Dump(out);
> -  *out << " source_layers=(";
> -
> -  const std::vector<size_t> &source_layers = region.source_layers;
> -  for (size_t i = 0; i < source_layers.size(); i++) {
> -    *out << source_layers[i];
> -    if (i < source_layers.size() - 1) {
> -      *out << " ";
> -    }
> -  }
> -
> -  *out << ")";
> -}
> -
>  void DrmDisplayComposition::Dump(std::ostringstream *out) const {
>    *out << "----DrmDisplayComposition"
>         << " crtc=" << (crtc_ ? crtc_->id() : -1)
> @@ -540,10 +267,6 @@ void DrmDisplayComposition::Dump(std::ostringstream *out) const {
>        break;
>    }
>  
> -  *out << " timeline[current/squash/pre-comp/done]=" << timeline_current_ << "/"
> -       << timeline_squash_done_ << "/" << timeline_pre_comp_done_ << "/"
> -       << timeline_ << "\n";
> -
>    *out << "    Layers: count=" << layers_.size() << "\n";
>    for (size_t i = 0; i < layers_.size(); i++) {
>      const DrmHwcLayer &layer = layers_[i];
> @@ -578,12 +301,6 @@ void DrmDisplayComposition::Dump(std::ostringstream *out) const {
>        case DrmCompositionPlane::Type::kLayer:
>          *out << "LAYER";
>          break;
> -      case DrmCompositionPlane::Type::kPrecomp:
> -        *out << "PRECOMP";
> -        break;
> -      case DrmCompositionPlane::Type::kSquash:
> -        *out << "SQUASH";
> -        break;
>        default:
>          *out << "<invalid>";
>          break;
> @@ -595,19 +312,5 @@ void DrmDisplayComposition::Dump(std::ostringstream *out) const {
>      }
>      *out << "\n";
>    }
> -
> -  *out << "    Squash Regions: count=" << squash_regions_.size() << "\n";
> -  for (size_t i = 0; i < squash_regions_.size(); i++) {
> -    *out << "      [" << i << "] ";
> -    DumpRegion(squash_regions_[i], out);
> -    *out << "\n";
> -  }
> -
> -  *out << "    Pre-Comp Regions: count=" << pre_comp_regions_.size() << "\n";
> -  for (size_t i = 0; i < pre_comp_regions_.size(); i++) {
> -    *out << "      [" << i << "] ";
> -    DumpRegion(pre_comp_regions_[i], out);
> -    *out << "\n";
> -  }
>  }
>  }
> diff --git a/drmdisplaycomposition.h b/drmdisplaycomposition.h
> index 918392578753..b7fccb9cd283 100644
> --- a/drmdisplaycomposition.h
> +++ b/drmdisplaycomposition.h
> @@ -20,7 +20,6 @@
>  #include "drmcrtc.h"
>  #include "drmhwcomposer.h"
>  #include "drmplane.h"
> -#include "glworker.h"
>  
>  #include <sstream>
>  #include <vector>
> @@ -62,8 +61,6 @@ class DrmCompositionPlane {
>    enum class Type : int32_t {
>      kDisable,
>      kLayer,
> -    kPrecomp,
> -    kSquash,
>    };
>  
>    DrmCompositionPlane() = default;
> @@ -125,34 +122,15 @@ class DrmDisplayComposition {
>    int SetDpmsMode(uint32_t dpms_mode);
>    int SetDisplayMode(const DrmMode &display_mode);
>  
> -  int Plan(SquashState *squash, std::vector<DrmPlane *> *primary_planes,
> +  int Plan(std::vector<DrmPlane *> *primary_planes,
>             std::vector<DrmPlane *> *overlay_planes);
>  
>    int FinalizeComposition();
>  
> -  int CreateNextTimelineFence();
> -  int SignalSquashDone() {
> -    return IncreaseTimelineToPoint(timeline_squash_done_);
> -  }
> -  int SignalPreCompDone() {
> -    return IncreaseTimelineToPoint(timeline_pre_comp_done_);
> -  }
> -  int SignalCompositionDone() {
> -    return IncreaseTimelineToPoint(timeline_);
> -  }
> -
>    std::vector<DrmHwcLayer> &layers() {
>      return layers_;
>    }
>  
> -  std::vector<DrmCompositionRegion> &squash_regions() {
> -    return squash_regions_;
> -  }
> -
> -  std::vector<DrmCompositionRegion> &pre_comp_regions() {
> -    return pre_comp_regions_;
> -  }
> -
>    std::vector<DrmCompositionPlane> &composition_planes() {
>      return composition_planes_;
>    }
> @@ -202,12 +180,9 @@ class DrmDisplayComposition {
>   private:
>    bool validate_composition_type(DrmCompositionType desired);
>  
> -  int IncreaseTimelineToPoint(int point);
> -
>    int FinalizeComposition(DrmHwcRect<int> *exclude_rects,
>                            size_t num_exclude_rects);
>    void SeparateLayers(DrmHwcRect<int> *exclude_rects, size_t num_exclude_rects);
> -  int CreateAndAssignReleaseFences();
>  
>    DrmResources *drm_ = NULL;
>    DrmCrtc *crtc_ = NULL;
> @@ -218,17 +193,10 @@ class DrmDisplayComposition {
>    uint32_t dpms_mode_ = DRM_MODE_DPMS_ON;
>    DrmMode display_mode_;
>  
> -  int timeline_fd_ = -1;
> -  int timeline_ = 0;
> -  int timeline_current_ = 0;
> -  int timeline_squash_done_ = 0;
> -  int timeline_pre_comp_done_ = 0;
>    UniqueFd out_fence_ = -1;
>  
>    bool geometry_changed_;
>    std::vector<DrmHwcLayer> layers_;
> -  std::vector<DrmCompositionRegion> squash_regions_;
> -  std::vector<DrmCompositionRegion> pre_comp_regions_;
>    std::vector<DrmCompositionPlane> composition_planes_;
>  
>    uint64_t frame_no_ = 0;
> diff --git a/drmdisplaycompositor.cpp b/drmdisplaycompositor.cpp
> index e570923de942..34a729924fc6 100644
> --- a/drmdisplaycompositor.cpp
> +++ b/drmdisplaycompositor.cpp
> @@ -35,153 +35,15 @@
>  #include "drmcrtc.h"
>  #include "drmplane.h"
>  #include "drmresources.h"
> -#include "glworker.h"
>  
>  namespace android {
>  
> -void SquashState::Init(DrmHwcLayer *layers, size_t num_layers) {
> -  generation_number_++;
> -  valid_history_ = 0;
> -  regions_.clear();
> -  last_handles_.clear();
> -
> -  std::vector<DrmHwcRect<int>> in_rects;
> -  for (size_t i = 0; i < num_layers; i++) {
> -    DrmHwcLayer *layer = &layers[i];
> -    in_rects.emplace_back(layer->display_frame);
> -    last_handles_.push_back(layer->sf_handle);
> -  }
> -
> -  std::vector<separate_rects::RectSet<uint64_t, int>> out_regions;
> -  separate_rects::separate_rects_64(in_rects, &out_regions);
> -
> -  for (const separate_rects::RectSet<uint64_t, int> &out_region : out_regions) {
> -    regions_.emplace_back();
> -    Region &region = regions_.back();
> -    region.rect = out_region.rect;
> -    region.layer_refs = out_region.id_set.getBits();
> -  }
> -}
> -
> -void SquashState::GenerateHistory(DrmHwcLayer *layers, size_t num_layers,
> -                                  std::vector<bool> &changed_regions) const {
> -  changed_regions.resize(regions_.size());
> -  if (num_layers != last_handles_.size()) {
> -    ALOGE("SquashState::GenerateHistory expected %zu layers but got %zu layers",
> -          last_handles_.size(), num_layers);
> -    return;
> -  }
> -  std::bitset<kMaxLayers> changed_layers;
> -  for (size_t i = 0; i < last_handles_.size(); i++) {
> -    DrmHwcLayer *layer = &layers[i];
> -    // Protected layers can't be squashed so we treat them as constantly
> -    // changing.
> -    if (layer->protected_usage() || last_handles_[i] != layer->sf_handle)
> -      changed_layers.set(i);
> -  }
> -
> -  for (size_t i = 0; i < regions_.size(); i++) {
> -    changed_regions[i] = (regions_[i].layer_refs & changed_layers).any();
> -  }
> -}
> -
> -void SquashState::StableRegionsWithMarginalHistory(
> -    const std::vector<bool> &changed_regions,
> -    std::vector<bool> &stable_regions) const {
> -  stable_regions.resize(regions_.size());
> -  for (size_t i = 0; i < regions_.size(); i++) {
> -    stable_regions[i] = !changed_regions[i] && is_stable(i);
> -  }
> -}
> -
> -void SquashState::RecordHistory(DrmHwcLayer *layers, size_t num_layers,
> -                                const std::vector<bool> &changed_regions) {
> -  if (num_layers != last_handles_.size()) {
> -    ALOGE("SquashState::RecordHistory expected %zu layers but got %zu layers",
> -          last_handles_.size(), num_layers);
> -    return;
> -  }
> -  if (changed_regions.size() != regions_.size()) {
> -    ALOGE("SquashState::RecordHistory expected %zu regions but got %zu regions",
> -          regions_.size(), changed_regions.size());
> -    return;
> -  }
> -
> -  for (size_t i = 0; i < last_handles_.size(); i++) {
> -    DrmHwcLayer *layer = &layers[i];
> -    last_handles_[i] = layer->sf_handle;
> -  }
> -
> -  for (size_t i = 0; i < regions_.size(); i++) {
> -    regions_[i].change_history <<= 1;
> -    regions_[i].change_history.set(/* LSB */ 0, changed_regions[i]);
> -  }
> -
> -  valid_history_++;
> -}
> -
> -bool SquashState::RecordAndCompareSquashed(
> -    const std::vector<bool> &squashed_regions) {
> -  if (squashed_regions.size() != regions_.size()) {
> -    ALOGE(
> -        "SquashState::RecordAndCompareSquashed expected %zu regions but got "
> -        "%zu regions",
> -        regions_.size(), squashed_regions.size());
> -    return false;
> -  }
> -  bool changed = false;
> -  for (size_t i = 0; i < regions_.size(); i++) {
> -    if (regions_[i].squashed != squashed_regions[i]) {
> -      regions_[i].squashed = squashed_regions[i];
> -      changed = true;
> -    }
> -  }
> -  return changed;
> -}
> -
> -void SquashState::Dump(std::ostringstream *out) const {
> -  *out << "----SquashState generation=" << generation_number_
> -       << " history=" << valid_history_ << "\n"
> -       << "    Regions: count=" << regions_.size() << "\n";
> -  for (size_t i = 0; i < regions_.size(); i++) {
> -    const Region &region = regions_[i];
> -    *out << "      [" << i << "]"
> -         << " history=" << region.change_history << " rect";
> -    region.rect.Dump(out);
> -    *out << " layers=(";
> -    bool first = true;
> -    for (size_t layer_index = 0; layer_index < kMaxLayers; layer_index++) {
> -      if ((region.layer_refs &
> -           std::bitset<kMaxLayers>((size_t)1 << layer_index))
> -              .any()) {
> -        if (!first)
> -          *out << " ";
> -        first = false;
> -        *out << layer_index;
> -      }
> -    }
> -    *out << ")";
> -    if (region.squashed)
> -      *out << " squashed";
> -    *out << "\n";
> -  }
> -}
> -
> -static bool UsesSquash(const std::vector<DrmCompositionPlane> &comp_planes) {
> -  return std::any_of(comp_planes.begin(), comp_planes.end(),
> -                     [](const DrmCompositionPlane &plane) {
> -    return plane.type() == DrmCompositionPlane::Type::kSquash;
> -  });
> -}
> -
>  DrmDisplayCompositor::DrmDisplayCompositor()
>      : drm_(NULL),
>        display_(-1),
>        initialized_(false),
>        active_(false),
>        use_hw_overlays_(true),
> -      framebuffer_index_(0),
> -      squash_framebuffer_index_(0),
>        dump_frames_composited_(0),
>        dump_last_timestamp_ns_(0) {
>    struct timespec ts;
> @@ -244,112 +106,6 @@ DrmDisplayCompositor::GetActiveModeResolution() {
>    return std::make_tuple(mode.h_display(), mode.v_display(), 0);
>  }
>  
> -int DrmDisplayCompositor::PrepareFramebuffer(
> -    DrmFramebuffer &fb, DrmDisplayComposition *display_comp) {
> -  int ret = fb.WaitReleased(-1);
> -  if (ret) {
> -    ALOGE("Failed to wait for framebuffer release %d", ret);
> -    return ret;
> -  }
> -  uint32_t width, height;
> -  std::tie(width, height, ret) = GetActiveModeResolution();
> -  if (ret) {
> -    ALOGE(
> -        "Failed to allocate framebuffer because the display resolution could "
> -        "not be determined %d",
> -        ret);
> -    return ret;
> -  }
> -
> -  fb.set_release_fence_fd(-1);
> -  if (!fb.Allocate(width, height)) {
> -    ALOGE("Failed to allocate framebuffer with size %dx%d", width, height);
> -    return -ENOMEM;
> -  }
> -
> -  display_comp->layers().emplace_back();
> -  DrmHwcLayer &pre_comp_layer = display_comp->layers().back();
> -  pre_comp_layer.sf_handle = fb.buffer()->handle;
> -  pre_comp_layer.blending = DrmHwcBlending::kPreMult;
> -  pre_comp_layer.source_crop = DrmHwcRect<float>(0, 0, width, height);
> -  pre_comp_layer.display_frame = DrmHwcRect<int>(0, 0, width, height);
> -  ret = pre_comp_layer.buffer.ImportBuffer(fb.buffer()->handle,
> -                                           display_comp->importer());
> -  if (ret) {
> -    ALOGE("Failed to import framebuffer for display %d", ret);
> -    return ret;
> -  }
> -
> -  return ret;
> -}
> -
> -int DrmDisplayCompositor::ApplySquash(DrmDisplayComposition *display_comp) {
> -  int ret = 0;
> -
> -  DrmFramebuffer &fb = squash_framebuffers_[squash_framebuffer_index_];
> -  ret = PrepareFramebuffer(fb, display_comp);
> -  if (ret) {
> -    ALOGE("Failed to prepare framebuffer for squash %d", ret);
> -    return ret;
> -  }
> -
> -  std::vector<DrmCompositionRegion> &regions = display_comp->squash_regions();
> -  ret = pre_compositor_->Composite(display_comp->layers().data(),
> -                                   regions.data(), regions.size(), fb.buffer(),
> -                                   display_comp->importer());
> -  pre_compositor_->Finish();
> -
> -  if (ret) {
> -    ALOGE("Failed to squash layers");
> -    return ret;
> -  }
> -
> -  ret = display_comp->CreateNextTimelineFence();
> -  if (ret <= 0) {
> -    ALOGE("Failed to create squash framebuffer release fence %d", ret);
> -    return ret;
> -  }
> -
> -  fb.set_release_fence_fd(ret);
> -  display_comp->SignalSquashDone();
> -
> -  return 0;
> -}
> -
> -int DrmDisplayCompositor::ApplyPreComposite(
> -    DrmDisplayComposition *display_comp) {
> -  int ret = 0;
> -
> -  DrmFramebuffer &fb = framebuffers_[framebuffer_index_];
> -  ret = PrepareFramebuffer(fb, display_comp);
> -  if (ret) {
> -    ALOGE("Failed to prepare framebuffer for pre-composite %d", ret);
> -    return ret;
> -  }
> -
> -  std::vector<DrmCompositionRegion> &regions = display_comp->pre_comp_regions();
> -  ret = pre_compositor_->Composite(display_comp->layers().data(),
> -                                   regions.data(), regions.size(), fb.buffer(),
> -                                   display_comp->importer());
> -  pre_compositor_->Finish();
> -
> -  if (ret) {
> -    ALOGE("Failed to pre-composite layers");
> -    return ret;
> -  }
> -
> -  ret = display_comp->CreateNextTimelineFence();
> -  if (ret <= 0) {
> -    ALOGE("Failed to create pre-composite framebuffer release fence %d", ret);
> -    return ret;
> -  }
> -
> -  fb.set_release_fence_fd(ret);
> -  display_comp->SignalPreCompDone();
> -
> -  return 0;
> -}
> -
>  int DrmDisplayCompositor::DisablePlanes(DrmDisplayComposition *display_comp) {
>    drmModeAtomicReqPtr pset = drmModeAtomicAlloc();
>    if (!pset) {
> @@ -384,103 +140,6 @@ int DrmDisplayCompositor::DisablePlanes(DrmDisplayComposition *display_comp) {
>    return 0;
>  }
>  
> -int DrmDisplayCompositor::PrepareFrame(DrmDisplayComposition *display_comp) {
> -  int ret = 0;
> -
> -  std::vector<DrmHwcLayer> &layers = display_comp->layers();
> -  std::vector<DrmCompositionPlane> &comp_planes =
> -      display_comp->composition_planes();
> -  std::vector<DrmCompositionRegion> &squash_regions =
> -      display_comp->squash_regions();
> -  std::vector<DrmCompositionRegion> &pre_comp_regions =
> -      display_comp->pre_comp_regions();
> -
> -  if (!pre_compositor_) {
> -    pre_compositor_.reset(new GLWorkerCompositor());
> -    int ret = pre_compositor_->Init();
> -    if (ret) {
> -      ALOGE("Failed to initialize OpenGL compositor %d", ret);
> -      return ret;
> -    }
> -  }
> -
> -  int squash_layer_index = -1;
> -  if (squash_regions.size() > 0) {
> -    squash_framebuffer_index_ = (squash_framebuffer_index_ + 1) % 2;
> -    ret = ApplySquash(display_comp);
> -    if (ret)
> -      return ret;
> -
> -    squash_layer_index = layers.size() - 1;
> -  } else {
> -    if (UsesSquash(comp_planes)) {
> -      DrmFramebuffer &fb = squash_framebuffers_[squash_framebuffer_index_];
> -      layers.emplace_back();
> -      squash_layer_index = layers.size() - 1;
> -      DrmHwcLayer &squash_layer = layers.back();
> -      ret = squash_layer.buffer.ImportBuffer(fb.buffer()->handle,
> -                                             display_comp->importer());
> -      if (ret) {
> -        ALOGE("Failed to import old squashed framebuffer %d", ret);
> -        return ret;
> -      }
> -      squash_layer.sf_handle = fb.buffer()->handle;
> -      squash_layer.blending = DrmHwcBlending::kPreMult;
> -      squash_layer.source_crop = DrmHwcRect<float>(
> -          0, 0, squash_layer.buffer->width, squash_layer.buffer->height);
> -      squash_layer.display_frame = DrmHwcRect<int>(
> -          0, 0, squash_layer.buffer->width, squash_layer.buffer->height);
> -      ret = display_comp->CreateNextTimelineFence();
> -
> -      if (ret <= 0) {
> -        ALOGE("Failed to create squash framebuffer release fence %d", ret);
> -        return ret;
> -      }
> -
> -      fb.set_release_fence_fd(ret);
> -      ret = 0;
> -    }
> -  }
> -
> -  bool do_pre_comp = pre_comp_regions.size() > 0;
> -  int pre_comp_layer_index = -1;
> -  if (do_pre_comp) {
> -    ret = ApplyPreComposite(display_comp);
> -    if (ret)
> -      return ret;
> -
> -    pre_comp_layer_index = layers.size() - 1;
> -    framebuffer_index_ = (framebuffer_index_ + 1) % DRM_DISPLAY_BUFFERS;
> -  }
> -
> -  for (DrmCompositionPlane &comp_plane : comp_planes) {
> -    std::vector<size_t> &source_layers = comp_plane.source_layers();
> -    switch (comp_plane.type()) {
> -      case DrmCompositionPlane::Type::kSquash:
> -        if (source_layers.size())
> -          ALOGE("Squash source_layers is expected to be empty (%zu/%d)",
> -                source_layers[0], squash_layer_index);
> -        source_layers.push_back(squash_layer_index);
> -        break;
> -      case DrmCompositionPlane::Type::kPrecomp:
> -        if (!do_pre_comp) {
> -          ALOGE(
> -              "Can not use pre composite framebuffer with no pre composite "
> -              "regions");
> -          return -EINVAL;
> -        }
> -        // Replace source_layers with the output of the precomposite
> -        source_layers.clear();
> -        source_layers.push_back(pre_comp_layer_index);
> -        break;
> -      default:
> -        break;
> -    }
> -  }
> -
> -  return ret;
> -}
> -
>  int DrmDisplayCompositor::CommitFrame(DrmDisplayComposition *display_comp,
>                                        bool test_only) {
>    ATRACE_CALL();
> @@ -778,8 +437,6 @@ void DrmDisplayCompositor::ClearDisplay() {
>    if (DisablePlanes(active_composition_.get()))
>      return;
>  
> -  active_composition_->SignalCompositionDone();
> -
>    active_composition_.reset(NULL);
>  }
>  
> @@ -799,9 +456,6 @@ void DrmDisplayCompositor::ApplyFrame(
>    }
>    ++dump_frames_composited_;
>  
> -  if (active_composition_)
> -    active_composition_->SignalCompositionDone();
> -
>    ret = pthread_mutex_lock(&lock_);
>    if (ret)
>      ALOGE("Failed to acquire lock for active_composition swap");
> @@ -819,38 +473,16 @@ int DrmDisplayCompositor::ApplyComposition(
>    int ret = 0;
>    switch (composition->type()) {
>      case DRM_COMPOSITION_TYPE_FRAME:
> -      ret = PrepareFrame(composition.get());
> -      if (ret) {
> -        ALOGE("Failed to prepare frame for display %d", display_);
> -        return ret;
> -      }
>        if (composition->geometry_changed()) {
>          // Send the composition to the kernel to ensure we can commit it. This
> -        // is just a test, it won't actually commit the frame. If rejected,
> -        // squash the frame into one layer and use the squashed composition
> +        // is just a test, it won't actually commit the frame.
>          ret = CommitFrame(composition.get(), true);
> -        if (ret)
> -          ALOGI("Commit test failed, squashing frame for display %d", display_);
> -        use_hw_overlays_ = !ret;
> -      }
> -
> -      // If use_hw_overlays_ is false, we can't use hardware to composite the
> -      // frame. So squash all layers into a single composition and apply that
> -      // instead.
> -      if (!use_hw_overlays_) {
> -        std::unique_ptr<DrmDisplayComposition> squashed = CreateComposition();
> -        ret = SquashFrame(composition.get(), squashed.get());
> -        if (!ret) {
> -          composition = std::move(squashed);
> -        } else {
> -          ALOGE("Failed to squash frame for display %d", display_);
> -          // Disable the hw used by the last active composition. This allows us
> -          // to signal the release fences from that composition to avoid
> -          // hanging.
> -          ClearDisplay();
> +        if (ret) {
> +          ALOGE("Commit test failed for display %d, FIXME", display_);
>            return ret;
>          }
>        }
> +
>        ApplyFrame(std::move(composition), ret);
>        break;
>      case DRM_COMPOSITION_TYPE_DPMS:
> @@ -878,154 +510,6 @@ int DrmDisplayCompositor::ApplyComposition(
>    return ret;
>  }
>  
> -int DrmDisplayCompositor::SquashAll() {
> -  AutoLock lock(&lock_, "compositor");
> -  int ret = lock.Lock();
> -  if (ret)
> -    return ret;
> -
> -  if (!active_composition_)
> -    return 0;
> -
> -  std::unique_ptr<DrmDisplayComposition> comp = CreateComposition();
> -  ret = SquashFrame(active_composition_.get(), comp.get());
> -
> -  // ApplyFrame needs the lock
> -  lock.Unlock();
> -
> -  if (!ret)
> -    ApplyFrame(std::move(comp), 0);
> -
> -  return ret;
> -}
> -
> -// Returns:
> -//   - 0 if src is successfully squashed into dst
> -//   - -EALREADY if the src is already squashed
> -//   - Appropriate error if the squash fails
> -int DrmDisplayCompositor::SquashFrame(DrmDisplayComposition *src,
> -                                      DrmDisplayComposition *dst) {
> -  if (src->type() != DRM_COMPOSITION_TYPE_FRAME)
> -    return -ENOTSUP;
> -
> -  std::vector<DrmCompositionPlane> &src_planes = src->composition_planes();
> -  std::vector<DrmHwcLayer> &src_layers = src->layers();
> -
> -  // Make sure there is more than one layer to squash.
> -  size_t src_planes_with_layer = std::count_if(
> -      src_planes.begin(), src_planes.end(), [](DrmCompositionPlane &p) {
> -        return p.type() != DrmCompositionPlane::Type::kDisable;
> -      });
> -  if (src_planes_with_layer <= 1)
> -    return -EALREADY;
> -
> -  int pre_comp_layer_index;
> -
> -  int ret = dst->Init(drm_, src->crtc(), src->importer(), src->planner(),
> -                      src->frame_no());
> -  if (ret) {
> -    ALOGE("Failed to init squash all composition %d", ret);
> -    return ret;
> -  }
> -
> -  DrmCompositionPlane squashed_comp(DrmCompositionPlane::Type::kPrecomp, NULL,
> -                                    src->crtc());
> -  std::vector<DrmHwcLayer> dst_layers;
> -  for (DrmCompositionPlane &comp_plane : src_planes) {
> -    // Composition planes without DRM planes should never happen
> -    if (comp_plane.plane() == NULL) {
> -      ALOGE("Skipping squash all because of NULL plane");
> -      ret = -EINVAL;
> -      goto move_layers_back;
> -    }
> -
> -    if (comp_plane.plane()->type() == DRM_PLANE_TYPE_PRIMARY)
> -      squashed_comp.set_plane(comp_plane.plane());
> -    else
> -      dst->AddPlaneDisable(comp_plane.plane());
> -
> -    if (comp_plane.type() == DrmCompositionPlane::Type::kDisable)
> -      continue;
> -
> -    for (auto i : comp_plane.source_layers()) {
> -      DrmHwcLayer &layer = src_layers[i];
> -
> -      // Squashing protected layers is impossible.
> -      if (layer.protected_usage()) {
> -        ret = -ENOTSUP;
> -        goto move_layers_back;
> -      }
> -
> -      // The OutputFds point to freed memory after hwc_set returns. They are
> -      // returned to the default to prevent DrmDisplayComposition::Plan from
> -      // filling the OutputFds.
> -      layer.release_fence = OutputFd();
> -      dst_layers.emplace_back(std::move(layer));
> -      squashed_comp.source_layers().push_back(
> -          squashed_comp.source_layers().size());
> -    }
> -  }
> -
> -  if (squashed_comp.plane() == NULL) {
> -    ALOGE("Primary plane not found for squash");
> -    ret = -ENOTSUP;
> -    goto move_layers_back;
> -  }
> -
> -  ret = dst->SetLayers(dst_layers.data(), dst_layers.size(), false);
> -  if (ret) {
> -    ALOGE("Failed to set layers for squash all composition %d", ret);
> -    goto move_layers_back;
> -  }
> -
> -  ret = dst->AddPlaneComposition(std::move(squashed_comp));
> -  if (ret) {
> -    ALOGE("Failed to add squashed plane composition %d", ret);
> -    goto move_layers_back;
> -  }
> -
> -  ret = dst->FinalizeComposition();
> -  if (ret) {
> -    ALOGE("Failed to plan for squash all composition %d", ret);
> -    goto move_layers_back;
> -  }
> -
> -  ret = ApplyPreComposite(dst);
> -  if (ret) {
> -    ALOGE("Failed to pre-composite for squash all composition %d", ret);
> -    goto move_layers_back;
> -  }
> -
> -  pre_comp_layer_index = dst->layers().size() - 1;
> -  framebuffer_index_ = (framebuffer_index_ + 1) % DRM_DISPLAY_BUFFERS;
> -
> -  for (DrmCompositionPlane &plane : dst->composition_planes()) {
> -    if (plane.type() == DrmCompositionPlane::Type::kPrecomp) {
> -      // Replace source_layers with the output of the precomposite
> -      plane.source_layers().clear();
> -      plane.source_layers().push_back(pre_comp_layer_index);
> -      break;
> -    }
> -  }
> -
> -  return 0;
> -
> -// TODO(zachr): think of a better way to transfer ownership back to the active
> -// composition.
> -move_layers_back:
> -  for (size_t plane_index = 0;
> -       plane_index < src_planes.size() && plane_index < dst_layers.size();) {
> -    if (src_planes[plane_index].source_layers().empty()) {
> -      plane_index++;
> -      continue;
> -    }
> -    for (auto i : src_planes[plane_index].source_layers())
> -      src_layers[i] = std::move(dst_layers[plane_index++]);
> -  }
> -
> -  return ret;
> -}
> -
>  void DrmDisplayCompositor::Dump(std::ostringstream *out) const {
>    int ret = pthread_mutex_lock(&lock_);
>    if (ret)
> @@ -1051,11 +535,6 @@ void DrmDisplayCompositor::Dump(std::ostringstream *out) const {
>  
>    dump_last_timestamp_ns_ = cur_ts;
>  
> -  if (active_composition_)
> -    active_composition_->Dump(out);
> -
> -  squash_state_.Dump(out);
> -
>    pthread_mutex_unlock(&lock_);
>  }
>  }
> diff --git a/drmdisplaycompositor.h b/drmdisplaycompositor.h
> index f1965fb0ad7f..eaf82fca989d 100644
> --- a/drmdisplaycompositor.h
> +++ b/drmdisplaycompositor.h
> @@ -36,49 +36,6 @@
>  
>  namespace android {
>  
> -class GLWorkerCompositor;
> -
> -class SquashState {
> - public:
> -  static const unsigned kHistoryLength = 6;  // TODO: make this number not magic
> -  static const unsigned kMaxLayers = 64;
> -
> -  struct Region {
> -    DrmHwcRect<int> rect;
> -    std::bitset<kMaxLayers> layer_refs;
> -    std::bitset<kHistoryLength> change_history;
> -    bool squashed = false;
> -  };
> -
> -  bool is_stable(int region_index) const {
> -    return valid_history_ >= kHistoryLength &&
> -           regions_[region_index].change_history.none();
> -  }
> -
> -  const std::vector<Region> &regions() const {
> -    return regions_;
> -  }
> -
> -  void Init(DrmHwcLayer *layers, size_t num_layers);
> -  void GenerateHistory(DrmHwcLayer *layers, size_t num_layers,
> -                       std::vector<bool> &changed_regions) const;
> -  void StableRegionsWithMarginalHistory(
> -      const std::vector<bool> &changed_regions,
> -      std::vector<bool> &stable_regions) const;
> -  void RecordHistory(DrmHwcLayer *layers, size_t num_layers,
> -                     const std::vector<bool> &changed_regions);
> -  bool RecordAndCompareSquashed(const std::vector<bool> &squashed_regions);
> -
> -  void Dump(std::ostringstream *out) const;
> -
> - private:
> -  size_t generation_number_ = 0;
> -  unsigned valid_history_ = 0;
> -  std::vector<buffer_handle_t> last_handles_;
> -
> -  std::vector<Region> regions_;
> -};
> -
>  class DrmDisplayCompositor {
>   public:
>    DrmDisplayCompositor();
> @@ -89,15 +46,10 @@ class DrmDisplayCompositor {
>    std::unique_ptr<DrmDisplayComposition> CreateComposition() const;
>    int ApplyComposition(std::unique_ptr<DrmDisplayComposition> composition);
>    int Composite();
> -  int SquashAll();
>    void Dump(std::ostringstream *out) const;
>  
>    std::tuple<uint32_t, uint32_t, int> GetActiveModeResolution();
>  
> -  SquashState *squash_state() {
> -    return &squash_state_;
> -  }
> -
>   private:
>    struct ModeState {
>      bool needs_modeset = false;
> @@ -115,11 +67,8 @@ class DrmDisplayCompositor {
>  
>    int PrepareFramebuffer(DrmFramebuffer &fb,
>                           DrmDisplayComposition *display_comp);
> -  int ApplySquash(DrmDisplayComposition *display_comp);
> -  int ApplyPreComposite(DrmDisplayComposition *display_comp);
>    int PrepareFrame(DrmDisplayComposition *display_comp);
>    int CommitFrame(DrmDisplayComposition *display_comp, bool test_only);
> -  int SquashFrame(DrmDisplayComposition *src, DrmDisplayComposition *dst);
>    int ApplyDpms(DrmDisplayComposition *display_comp);
>    int DisablePlanes(DrmDisplayComposition *display_comp);
>  
> @@ -142,11 +91,6 @@ class DrmDisplayCompositor {
>  
>    int framebuffer_index_;
>    DrmFramebuffer framebuffers_[DRM_DISPLAY_BUFFERS];
> -  std::unique_ptr<GLWorkerCompositor> pre_compositor_;
> -
> -  SquashState squash_state_;
> -  int squash_framebuffer_index_;
> -  DrmFramebuffer squash_framebuffers_[2];
>  
>    // mutable since we need to acquire in Dump()
>    mutable pthread_mutex_t lock_;
> diff --git a/drmhwctwo.cpp b/drmhwctwo.cpp
> index 8e00d7150217..60ff384e9a08 100644
> --- a/drmhwctwo.cpp
> +++ b/drmhwctwo.cpp
> @@ -539,7 +539,7 @@ HWC2::Error DrmHwcTwo::HwcDisplay::PresentDisplay(int32_t *retire_fence) {
>  
>    std::vector<DrmPlane *> primary_planes(primary_planes_);
>    std::vector<DrmPlane *> overlay_planes(overlay_planes_);
> -  ret = composition->Plan(compositor_.squash_state(), &primary_planes,
> +  ret = composition->Plan(&primary_planes,
>                           &overlay_planes);
>    if (ret) {
>      ALOGE("Failed to plan the composition ret=%d", ret);
> @@ -692,12 +692,10 @@ HWC2::Error DrmHwcTwo::HwcDisplay::ValidateDisplay(uint32_t *num_types,
>        case HWC2::Composition::SolidColor:
>        case HWC2::Composition::Cursor:
>        case HWC2::Composition::Sideband:
> +      default:
>          layer.set_validated_type(HWC2::Composition::Client);
>          ++*num_types;
>          break;
> -      default:
> -        layer.set_validated_type(layer.sf_type());
> -        break;
>      }
>    }
>    return *num_types ? HWC2::Error::HasChanges : HWC2::Error::None;
> diff --git a/glworker.cpp b/glworker.cpp
> deleted file mode 100644
> index ca726bf573ba..000000000000
> --- a/glworker.cpp
> +++ /dev/null
> @@ -1,840 +0,0 @@
> -/*
> - * Copyright (C) 2015 The Android Open Source Project
> - *
> - * Licensed under the Apache License, Version 2.0 (the "License");
> - * you may not use this file except in compliance with the License.
> - * You may obtain a copy of the License at
> - *
> - *      http://www.apache.org/licenses/LICENSE-2.0
> - *
> - * Unless required by applicable law or agreed to in writing, software
> - * distributed under the License is distributed on an "AS IS" BASIS,
> - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
> - * See the License for the specific language governing permissions and
> - * limitations under the License.
> - */
> -
> -#define ATRACE_TAG ATRACE_TAG_GRAPHICS
> -#define LOG_TAG "hwc-gl-worker"
> -
> -#include <algorithm>
> -#include <string>
> -#include <sstream>
> -#include <unordered_set>
> -
> -#include <sys/resource.h>
> -
> -#include <cutils/properties.h>
> -
> -#include <hardware/hardware.h>
> -#include <hardware/hwcomposer.h>
> -
> -#include <ui/GraphicBuffer.h>
> -#include <ui/PixelFormat.h>
> -
> -#include <utils/Trace.h>
> -
> -#include "drmdisplaycomposition.h"
> -#include "platform.h"
> -
> -#include "glworker.h"
> -
> -#define MAX_OVERLAPPING_LAYERS 64
> -
> -namespace android {
> -
> -// clang-format off
> -// Column-major order:
> -// float mat[4] = { 1, 2, 3, 4 } ===
> -// [ 1 3 ]
> -// [ 2 4 ]
> -float kTextureTransformMatrices[] = {
> -   1.0f,  0.0f,  0.0f,  1.0f, // identity matrix
> -   0.0f,  1.0f,  1.0f,  0.0f, // swap x and y
> -};
> -// clang-format on
> -
> -static const char *GetGLError(void) {
> -  switch (glGetError()) {
> -    case GL_NO_ERROR:
> -      return "GL_NO_ERROR";
> -    case GL_INVALID_ENUM:
> -      return "GL_INVALID_ENUM";
> -    case GL_INVALID_VALUE:
> -      return "GL_INVALID_VALUE";
> -    case GL_INVALID_OPERATION:
> -      return "GL_INVALID_OPERATION";
> -    case GL_INVALID_FRAMEBUFFER_OPERATION:
> -      return "GL_INVALID_FRAMEBUFFER_OPERATION";
> -    case GL_OUT_OF_MEMORY:
> -      return "GL_OUT_OF_MEMORY";
> -    default:
> -      return "Unknown error";
> -  }
> -}
> -
> -static const char *GetGLFramebufferError(void) {
> -  switch (glCheckFramebufferStatus(GL_FRAMEBUFFER)) {
> -    case GL_FRAMEBUFFER_COMPLETE:
> -      return "GL_FRAMEBUFFER_COMPLETE";
> -    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
> -      return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
> -    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
> -      return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
> -    case GL_FRAMEBUFFER_UNSUPPORTED:
> -      return "GL_FRAMEBUFFER_UNSUPPORTED";
> -    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
> -      return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
> -    default:
> -      return "Unknown error";
> -  }
> -}
> -
> -static const char *GetEGLError(void) {
> -  switch (eglGetError()) {
> -    case EGL_SUCCESS:
> -      return "EGL_SUCCESS";
> -    case EGL_NOT_INITIALIZED:
> -      return "EGL_NOT_INITIALIZED";
> -    case EGL_BAD_ACCESS:
> -      return "EGL_BAD_ACCESS";
> -    case EGL_BAD_ALLOC:
> -      return "EGL_BAD_ALLOC";
> -    case EGL_BAD_ATTRIBUTE:
> -      return "EGL_BAD_ATTRIBUTE";
> -    case EGL_BAD_CONTEXT:
> -      return "EGL_BAD_CONTEXT";
> -    case EGL_BAD_CONFIG:
> -      return "EGL_BAD_CONFIG";
> -    case EGL_BAD_CURRENT_SURFACE:
> -      return "EGL_BAD_CURRENT_SURFACE";
> -    case EGL_BAD_DISPLAY:
> -      return "EGL_BAD_DISPLAY";
> -    case EGL_BAD_SURFACE:
> -      return "EGL_BAD_SURFACE";
> -    case EGL_BAD_MATCH:
> -      return "EGL_BAD_MATCH";
> -    case EGL_BAD_PARAMETER:
> -      return "EGL_BAD_PARAMETER";
> -    case EGL_BAD_NATIVE_PIXMAP:
> -      return "EGL_BAD_NATIVE_PIXMAP";
> -    case EGL_BAD_NATIVE_WINDOW:
> -      return "EGL_BAD_NATIVE_WINDOW";
> -    case EGL_CONTEXT_LOST:
> -      return "EGL_CONTEXT_LOST";
> -    default:
> -      return "Unknown error";
> -  }
> -}
> -
> -static bool HasExtension(const char *extension, const char *extensions) {
> -  const char *start, *where, *terminator;
> -  start = extensions;
> -  for (;;) {
> -    where = (char *)strstr((const char *)start, extension);
> -    if (!where)
> -      break;
> -    terminator = where + strlen(extension);
> -    if (where == start || *(where - 1) == ' ')
> -      if (*terminator == ' ' || *terminator == '\0')
> -        return true;
> -    start = terminator;
> -  }
> -  return false;
> -}
> -
> -int GLWorkerCompositor::BeginContext() {
> -  private_.saved_egl_display = eglGetCurrentDisplay();
> -  private_.saved_egl_ctx = eglGetCurrentContext();
> -
> -  if (private_.saved_egl_display != egl_display_ ||
> -      private_.saved_egl_ctx != egl_ctx_) {
> -    private_.saved_egl_read = eglGetCurrentSurface(EGL_READ);
> -    private_.saved_egl_draw = eglGetCurrentSurface(EGL_DRAW);
> -  } else {
> -    return 0;
> -  }
> -
> -  if (!eglMakeCurrent(egl_display_, EGL_NO_SURFACE, EGL_NO_SURFACE, egl_ctx_)) {
> -    ALOGE("BeginContext failed: %s", GetEGLError());
> -    return 1;
> -  }
> -  return 0;
> -}
> -
> -int GLWorkerCompositor::EndContext() {
> -  if (private_.saved_egl_display != eglGetCurrentDisplay() ||
> -      private_.saved_egl_ctx != eglGetCurrentContext()) {
> -    if (!eglMakeCurrent(private_.saved_egl_display, private_.saved_egl_read,
> -                        private_.saved_egl_draw, private_.saved_egl_ctx)) {
> -      ALOGE("EndContext failed: %s", GetEGLError());
> -      return 1;
> -    }
> -  }
> -
> -  return 0;
> -}
> -
> -static AutoGLShader CompileAndCheckShader(GLenum type, unsigned source_count,
> -                                          const GLchar **sources,
> -                                          std::ostringstream *shader_log) {
> -  GLint status;
> -  AutoGLShader shader(glCreateShader(type));
> -  if (shader.get() == 0) {
> -    if (shader_log)
> -      *shader_log << "Failed glCreateShader call";
> -    return 0;
> -  }
> -
> -  glShaderSource(shader.get(), source_count, sources, NULL);
> -  glCompileShader(shader.get());
> -  glGetShaderiv(shader.get(), GL_COMPILE_STATUS, &status);
> -  if (!status) {
> -    if (shader_log) {
> -      GLint log_length;
> -      glGetShaderiv(shader.get(), GL_INFO_LOG_LENGTH, &log_length);
> -      std::string info_log(log_length, ' ');
> -      glGetShaderInfoLog(shader.get(), log_length, NULL, &info_log.front());
> -      *shader_log << "Failed to compile shader:\n" << info_log.c_str()
> -                  << "\nShader Source:\n";
> -      for (unsigned i = 0; i < source_count; i++) {
> -        *shader_log << sources[i];
> -      }
> -      *shader_log << "\n";
> -    }
> -    return 0;
> -  }
> -
> -  return shader;
> -}
> -
> -static std::string GenerateVertexShader(int layer_count) {
> -  std::ostringstream vertex_shader_stream;
> -  vertex_shader_stream
> -      << "#version 300 es\n"
> -      << "#define LAYER_COUNT " << layer_count << "\n"
> -      << "precision mediump int;\n"
> -      << "uniform vec4 uViewport;\n"
> -      << "uniform vec4 uLayerCrop[LAYER_COUNT];\n"
> -      << "uniform mat2 uTexMatrix[LAYER_COUNT];\n"
> -      << "in vec2 vPosition;\n"
> -      << "in vec2 vTexCoords;\n"
> -      << "out vec2 fTexCoords[LAYER_COUNT];\n"
> -      << "void main() {\n"
> -      << "  for (int i = 0; i < LAYER_COUNT; i++) {\n"
> -      << "    vec2 tempCoords = vTexCoords * uTexMatrix[i];\n"
> -      << "    fTexCoords[i] =\n"
> -      << "        uLayerCrop[i].xy + tempCoords * uLayerCrop[i].zw;\n"
> -      << "  }\n"
> -      << "  vec2 scaledPosition = uViewport.xy + vPosition * uViewport.zw;\n"
> -      << "  gl_Position =\n"
> -      << "      vec4(scaledPosition * vec2(2.0) - vec2(1.0), 0.0, 1.0);\n"
> -      << "}\n";
> -  return vertex_shader_stream.str();
> -}
> -
> -static std::string GenerateFragmentShader(int layer_count) {
> -  std::ostringstream fragment_shader_stream;
> -  fragment_shader_stream << "#version 300 es\n"
> -                         << "#define LAYER_COUNT " << layer_count << "\n"
> -                         << "#extension GL_OES_EGL_image_external : require\n"
> -                         << "precision mediump float;\n";
> -  for (int i = 0; i < layer_count; ++i) {
> -    fragment_shader_stream << "uniform samplerExternalOES uLayerTexture" << i
> -                           << ";\n";
> -  }
> -  fragment_shader_stream << "uniform float uLayerAlpha[LAYER_COUNT];\n"
> -                         << "uniform float uLayerPremult[LAYER_COUNT];\n"
> -                         << "in vec2 fTexCoords[LAYER_COUNT];\n"
> -                         << "out vec4 oFragColor;\n"
> -                         << "void main() {\n"
> -                         << "  vec3 color = vec3(0.0, 0.0, 0.0);\n"
> -                         << "  float alphaCover = 1.0;\n"
> -                         << "  vec4 texSample;\n"
> -                         << "  vec3 multRgb;\n";
> -  for (int i = 0; i < layer_count; ++i) {
> -    if (i > 0)
> -      fragment_shader_stream << "  if (alphaCover > 0.5/255.0) {\n";
> -    // clang-format off
> -    fragment_shader_stream
> -        << "  texSample = texture2D(uLayerTexture" << i << ",\n"
> -        << "                        fTexCoords[" << i << "]);\n"
> -        << "  multRgb = texSample.rgb *\n"
> -        << "            max(texSample.a, uLayerPremult[" << i << "]);\n"
> -        << "  color += multRgb * uLayerAlpha[" << i << "] * alphaCover;\n"
> -        << "  alphaCover *= 1.0 - texSample.a * uLayerAlpha[" << i << "];\n";
> -    // clang-format on
> -  }
> -  for (int i = 0; i < layer_count - 1; ++i)
> -    fragment_shader_stream << "  }\n";
> -  fragment_shader_stream << "  oFragColor = vec4(color, 1.0 - alphaCover);\n"
> -                         << "}\n";
> -  return fragment_shader_stream.str();
> -}
> -
> -static AutoGLProgram GenerateProgram(unsigned num_textures,
> -                                     std::ostringstream *shader_log) {
> -  std::string vertex_shader_string = GenerateVertexShader(num_textures);
> -  const GLchar *vertex_shader_source = vertex_shader_string.c_str();
> -  AutoGLShader vertex_shader = CompileAndCheckShader(
> -      GL_VERTEX_SHADER, 1, &vertex_shader_source, shader_log);
> -  if (!vertex_shader.get())
> -    return 0;
> -
> -  std::string fragment_shader_string = GenerateFragmentShader(num_textures);
> -  const GLchar *fragment_shader_source = fragment_shader_string.c_str();
> -  AutoGLShader fragment_shader = CompileAndCheckShader(
> -      GL_FRAGMENT_SHADER, 1, &fragment_shader_source, shader_log);
> -  if (!fragment_shader.get())
> -    return 0;
> -
> -  AutoGLProgram program(glCreateProgram());
> -  if (!program.get()) {
> -    if (shader_log)
> -      *shader_log << "Failed to create program: " << GetGLError() << "\n";
> -    return 0;
> -  }
> -
> -  glAttachShader(program.get(), vertex_shader.get());
> -  glAttachShader(program.get(), fragment_shader.get());
> -  glBindAttribLocation(program.get(), 0, "vPosition");
> -  glBindAttribLocation(program.get(), 1, "vTexCoords");
> -  glLinkProgram(program.get());
> -  glDetachShader(program.get(), vertex_shader.get());
> -  glDetachShader(program.get(), fragment_shader.get());
> -
> -  GLint status;
> -  glGetProgramiv(program.get(), GL_LINK_STATUS, &status);
> -  if (!status) {
> -    if (shader_log) {
> -      GLint log_length;
> -      glGetProgramiv(program.get(), GL_INFO_LOG_LENGTH, &log_length);
> -      std::string program_log(log_length, ' ');
> -      glGetProgramInfoLog(program.get(), log_length, NULL,
> -                          &program_log.front());
> -      *shader_log << "Failed to link program:\n" << program_log.c_str() << "\n";
> -    }
> -    return 0;
> -  }
> -
> -  return program;
> -}
> -
> -struct RenderingCommand {
> -  struct TextureSource {
> -    unsigned texture_index;
> -    float crop_bounds[4];
> -    float alpha;
> -    float premult;
> -    float texture_matrix[4];
> -  };
> -
> -  float bounds[4];
> -  unsigned texture_count = 0;
> -  TextureSource textures[MAX_OVERLAPPING_LAYERS];
> -};
> -
> -static void ConstructCommand(const DrmHwcLayer *layers,
> -                             const DrmCompositionRegion &region,
> -                             RenderingCommand &cmd) {
> -  std::copy_n(region.frame.bounds, 4, cmd.bounds);
> -
> -  for (size_t texture_index : region.source_layers) {
> -    const DrmHwcLayer &layer = layers[texture_index];
> -
> -    DrmHwcRect<float> display_rect(layer.display_frame);
> -    float display_size[2] = {display_rect.bounds[2] - display_rect.bounds[0],
> -                             display_rect.bounds[3] - display_rect.bounds[1]};
> -
> -    float tex_width = layer.buffer->width;
> -    float tex_height = layer.buffer->height;
> -    DrmHwcRect<float> crop_rect(layer.source_crop.left / tex_width,
> -                                layer.source_crop.top / tex_height,
> -                                layer.source_crop.right / tex_width,
> -                                layer.source_crop.bottom / tex_height);
> -
> -    float crop_size[2] = {crop_rect.bounds[2] - crop_rect.bounds[0],
> -                          crop_rect.bounds[3] - crop_rect.bounds[1]};
> -
> -    RenderingCommand::TextureSource &src = cmd.textures[cmd.texture_count];
> -    cmd.texture_count++;
> -    src.texture_index = texture_index;
> -
> -    bool swap_xy = false;
> -    bool flip_xy[2] = { false, false };
> -
> -    if (layer.transform == DrmHwcTransform::kRotate180) {
> -      swap_xy = false;
> -      flip_xy[0] = true;
> -      flip_xy[1] = true;
> -    } else if (layer.transform == DrmHwcTransform::kRotate270) {
> -      swap_xy = true;
> -      flip_xy[0] = true;
> -      flip_xy[1] = false;
> -    } else if (layer.transform & DrmHwcTransform::kRotate90) {
> -      swap_xy = true;
> -      if (layer.transform & DrmHwcTransform::kFlipH) {
> -        flip_xy[0] = true;
> -        flip_xy[1] = true;
> -      } else if (layer.transform & DrmHwcTransform::kFlipV) {
> -        flip_xy[0] = false;
> -        flip_xy[1] = false;
> -      } else {
> -        flip_xy[0] = false;
> -        flip_xy[1] = true;
> -      }
> -    } else {
> -      if (layer.transform & DrmHwcTransform::kFlipH)
> -        flip_xy[0] = true;
> -      if (layer.transform & DrmHwcTransform::kFlipV)
> -        flip_xy[1] = true;
> -    }
> -
> -    if (swap_xy)
> -      std::copy_n(&kTextureTransformMatrices[4], 4, src.texture_matrix);
> -    else
> -      std::copy_n(&kTextureTransformMatrices[0], 4, src.texture_matrix);
> -
> -    for (int j = 0; j < 4; j++) {
> -      int b = j ^ (swap_xy ? 1 : 0);
> -      float bound_percent =
> -          (cmd.bounds[b] - display_rect.bounds[b % 2]) / display_size[b % 2];
> -      if (flip_xy[j % 2]) {
> -        src.crop_bounds[j] =
> -            crop_rect.bounds[j % 2 + 2] - bound_percent * crop_size[j % 2];
> -      } else {
> -        src.crop_bounds[j] =
> -            crop_rect.bounds[j % 2] + bound_percent * crop_size[j % 2];
> -      }
> -    }
> -
> -    if (layer.blending == DrmHwcBlending::kNone) {
> -      src.alpha = src.premult = 1.0f;
> -      // This layer is opaque. There is no point in using layers below this one.
> -      break;
> -    }
> -
> -    src.alpha = layer.alpha / 255.0f;
> -    src.premult = (layer.blending == DrmHwcBlending::kPreMult) ? 1.0f : 0.0f;
> -  }
> -}
> -
> -static int EGLFenceWait(EGLDisplay egl_display, int acquireFenceFd) {
> -  int ret = 0;
> -
> -  EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, acquireFenceFd,
> -                      EGL_NONE};
> -  EGLSyncKHR egl_sync =
> -      eglCreateSyncKHR(egl_display, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
> -  if (egl_sync == EGL_NO_SYNC_KHR) {
> -    ALOGE("Failed to make EGLSyncKHR from acquireFenceFd: %s", GetEGLError());
> -    close(acquireFenceFd);
> -    return 1;
> -  }
> -
> -  EGLint success = eglWaitSyncKHR(egl_display, egl_sync, 0);
> -  if (success == EGL_FALSE) {
> -    ALOGE("Failed to wait for acquire: %s", GetEGLError());
> -    ret = 1;
> -  }
> -  eglDestroySyncKHR(egl_display, egl_sync);
> -
> -  return ret;
> -}
> -
> -static int CreateTextureFromHandle(EGLDisplay egl_display,
> -                                   buffer_handle_t handle,
> -                                   Importer *importer,
> -                                   AutoEGLImageAndGLTexture *out) {
> -  EGLImageKHR image = importer->ImportImage(egl_display, handle);
> -
> -  if (image == EGL_NO_IMAGE_KHR) {
> -    ALOGE("Failed to make image %s %p", GetEGLError(), handle);
> -    return -EINVAL;
> -  }
> -
> -  GLuint texture;
> -  glGenTextures(1, &texture);
> -  glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
> -  glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, (GLeglImageOES)image);
> -  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
> -  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
> -  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_REPEAT);
> -  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_REPEAT);
> -  glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
> -
> -  out->image.reset(egl_display, image);
> -  out->texture.reset(texture);
> -
> -  return 0;
> -}
> -
> -GLWorkerCompositor::GLWorkerCompositor()
> -    : egl_display_(EGL_NO_DISPLAY), egl_ctx_(EGL_NO_CONTEXT) {
> -}
> -
> -int GLWorkerCompositor::Init() {
> -  int ret = 0;
> -  const char *egl_extensions;
> -  const char *gl_extensions;
> -  EGLint num_configs;
> -  EGLConfig egl_config;
> -
> -  // clang-format off
> -  const GLfloat verts[] = {
> -    0.0f,  0.0f,    0.0f, 0.0f,
> -    0.0f,  2.0f,    0.0f, 2.0f,
> -    2.0f,  0.0f,    2.0f, 0.0f
> -  };
> -  // clang-format on
> -
> -  const EGLint config_attribs[] = {EGL_RENDERABLE_TYPE,
> -                                   EGL_OPENGL_ES2_BIT,
> -                                   EGL_RED_SIZE,
> -                                   8,
> -                                   EGL_GREEN_SIZE,
> -                                   8,
> -                                   EGL_BLUE_SIZE,
> -                                   8,
> -                                   EGL_NONE};
> -
> -  const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
> -
> -  egl_display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
> -  if (egl_display_ == EGL_NO_DISPLAY) {
> -    ALOGE("Failed to get egl display");
> -    return 1;
> -  }
> -
> -  if (!eglInitialize(egl_display_, NULL, NULL)) {
> -    ALOGE("Failed to initialize egl: %s", GetEGLError());
> -    return 1;
> -  }
> -
> -  egl_extensions = eglQueryString(egl_display_, EGL_EXTENSIONS);
> -
> -  // These extensions are all technically required but not always reported due
> -  // to meta EGL filtering them out.
> -  if (!HasExtension("EGL_KHR_image_base", egl_extensions))
> -    ALOGW("EGL_KHR_image_base extension not supported");
> -
> -  if (!HasExtension("EGL_ANDROID_image_native_buffer", egl_extensions))
> -    ALOGW("EGL_ANDROID_image_native_buffer extension not supported");
> -
> -  if (!HasExtension("EGL_ANDROID_native_fence_sync", egl_extensions))
> -    ALOGW("EGL_ANDROID_native_fence_sync extension not supported");
> -
> -  if (!eglChooseConfig(egl_display_, config_attribs, &egl_config, 1,
> -                       &num_configs)) {
> -    ALOGE("eglChooseConfig() failed with error: %s", GetEGLError());
> -    return 1;
> -  }
> -
> -  egl_ctx_ =
> -      eglCreateContext(egl_display_, egl_config,
> -                       EGL_NO_CONTEXT /* No shared context */, context_attribs);
> -
> -  if (egl_ctx_ == EGL_NO_CONTEXT) {
> -    ALOGE("Failed to create OpenGL ES Context: %s", GetEGLError());
> -    return 1;
> -  }
> -
> -  ret = BeginContext();
> -  if (ret)
> -    return ret;
> -
> -  gl_extensions = (const char *)glGetString(GL_EXTENSIONS);
> -
> -  if (!HasExtension("GL_OES_EGL_image", gl_extensions))
> -    ALOGW("GL_OES_EGL_image extension not supported");
> -
> -  if (!HasExtension("GL_OES_EGL_image_external", gl_extensions))
> -    ALOGW("GL_OES_EGL_image_external extension not supported");
> -
> -  GLuint vertex_buffer;
> -  glGenBuffers(1, &vertex_buffer);
> -  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
> -  glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
> -  glBindBuffer(GL_ARRAY_BUFFER, 0);
> -  vertex_buffer_.reset(vertex_buffer);
> -
> -  std::ostringstream shader_log;
> -  blend_programs_.emplace_back(GenerateProgram(1, &shader_log));
> -
> -  EndContext();
> -
> -  if (blend_programs_.back().get() == 0) {
> -    ALOGE("%s", shader_log.str().c_str());
> -    return 1;
> -  }
> -
> -  return 0;
> -}
> -
> -GLWorkerCompositor::~GLWorkerCompositor() {
> -  if (egl_display_ != EGL_NO_DISPLAY && egl_ctx_ != EGL_NO_CONTEXT)
> -    if (eglDestroyContext(egl_display_, egl_ctx_) == EGL_FALSE)
> -      ALOGE("Failed to destroy OpenGL ES Context: %s", GetEGLError());
> -}
> -
> -int GLWorkerCompositor::Composite(DrmHwcLayer *layers,
> -                                  DrmCompositionRegion *regions,
> -                                  size_t num_regions,
> -                                  const sp<GraphicBuffer> &framebuffer,
> -                                  Importer *importer) {
> -  ATRACE_CALL();
> -  int ret = 0;
> -  std::vector<AutoEGLImageAndGLTexture> layer_textures;
> -  std::vector<RenderingCommand> commands;
> -
> -  if (num_regions == 0) {
> -    return -EALREADY;
> -  }
> -
> -  ret = BeginContext();
> -  if (ret)
> -    return -1;
> -
> -  GLint frame_width = framebuffer->getWidth();
> -  GLint frame_height = framebuffer->getHeight();
> -  CachedFramebuffer *cached_framebuffer =
> -      PrepareAndCacheFramebuffer(framebuffer);
> -  if (cached_framebuffer == NULL) {
> -    ALOGE("Composite failed because of failed framebuffer");
> -    EndContext();
> -    return -EINVAL;
> -  }
> -
> -  std::unordered_set<size_t> layers_used_indices;
> -  for (size_t region_index = 0; region_index < num_regions; region_index++) {
> -    DrmCompositionRegion &region = regions[region_index];
> -    layers_used_indices.insert(region.source_layers.begin(),
> -                               region.source_layers.end());
> -    commands.emplace_back();
> -    ConstructCommand(layers, region, commands.back());
> -  }
> -
> -  for (size_t layer_index = 0; layer_index < MAX_OVERLAPPING_LAYERS;
> -       layer_index++) {
> -    DrmHwcLayer *layer = &layers[layer_index];
> -
> -    layer_textures.emplace_back();
> -
> -    if (layers_used_indices.count(layer_index) == 0)
> -      continue;
> -
> -    ret = CreateTextureFromHandle(egl_display_, layer->get_usable_handle(),
> -                                  importer, &layer_textures.back());
> -
> -    if (!ret) {
> -      ret = EGLFenceWait(egl_display_, layer->acquire_fence.Release());
> -    }
> -    if (ret) {
> -      layer_textures.pop_back();
> -      ret = -EINVAL;
> -    }
> -  }
> -
> -  if (ret) {
> -    EndContext();
> -    return ret;
> -  }
> -
> -  glViewport(0, 0, frame_width, frame_height);
> -
> -  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
> -  glClear(GL_COLOR_BUFFER_BIT);
> -
> -  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_.get());
> -  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, NULL);
> -  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4,
> -                        (void *)(sizeof(float) * 2));
> -  glEnableVertexAttribArray(0);
> -  glEnableVertexAttribArray(1);
> -  glEnable(GL_SCISSOR_TEST);
> -
> -  for (const RenderingCommand &cmd : commands) {
> -    if (cmd.texture_count == 0)
> -      continue;
> -
> -    // TODO(zachr): handle the case of too many overlapping textures for one
> -    // area by falling back to rendering as many layers as possible using
> -    // multiple blending passes.
> -    GLint program = PrepareAndCacheProgram(cmd.texture_count);
> -    if (program == 0) {
> -      ALOGE("Too many layers to render in one area");
> -      continue;
> -    }
> -
> -    glUseProgram(program);
> -    GLint gl_viewport_loc = glGetUniformLocation(program, "uViewport");
> -    GLint gl_crop_loc = glGetUniformLocation(program, "uLayerCrop");
> -    GLint gl_alpha_loc = glGetUniformLocation(program, "uLayerAlpha");
> -    GLint gl_premult_loc = glGetUniformLocation(program, "uLayerPremult");
> -    GLint gl_tex_matrix_loc = glGetUniformLocation(program, "uTexMatrix");
> -    glUniform4f(gl_viewport_loc, cmd.bounds[0] / (float)frame_width,
> -                cmd.bounds[1] / (float)frame_height,
> -                (cmd.bounds[2] - cmd.bounds[0]) / (float)frame_width,
> -                (cmd.bounds[3] - cmd.bounds[1]) / (float)frame_height);
> -
> -    for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
> -      std::ostringstream texture_name_formatter;
> -      texture_name_formatter << "uLayerTexture" << src_index;
> -      GLint gl_tex_loc =
> -          glGetUniformLocation(program, texture_name_formatter.str().c_str());
> -
> -      const RenderingCommand::TextureSource &src = cmd.textures[src_index];
> -      glUniform1f(gl_alpha_loc + src_index, src.alpha);
> -      glUniform1f(gl_premult_loc + src_index, src.premult);
> -      glUniform4f(gl_crop_loc + src_index, src.crop_bounds[0],
> -                  src.crop_bounds[1], src.crop_bounds[2] - src.crop_bounds[0],
> -                  src.crop_bounds[3] - src.crop_bounds[1]);
> -      glUniform1i(gl_tex_loc, src_index);
> -      glUniformMatrix2fv(gl_tex_matrix_loc + src_index, 1, GL_FALSE,
> -                         src.texture_matrix);
> -      glActiveTexture(GL_TEXTURE0 + src_index);
> -      glBindTexture(GL_TEXTURE_EXTERNAL_OES,
> -                    layer_textures[src.texture_index].texture.get());
> -    }
> -
> -    glScissor(cmd.bounds[0], cmd.bounds[1], cmd.bounds[2] - cmd.bounds[0],
> -              cmd.bounds[3] - cmd.bounds[1]);
> -    glDrawArrays(GL_TRIANGLES, 0, 3);
> -
> -    for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
> -      glActiveTexture(GL_TEXTURE0 + src_index);
> -      glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
> -    }
> -  }
> -
> -  glDisable(GL_SCISSOR_TEST);
> -  glActiveTexture(GL_TEXTURE0);
> -  glDisableVertexAttribArray(0);
> -  glDisableVertexAttribArray(1);
> -  glBindBuffer(GL_ARRAY_BUFFER, 0);
> -  glUseProgram(0);
> -
> -  glBindFramebuffer(GL_FRAMEBUFFER, 0);
> -
> -  EndContext();
> -  return ret;
> -}
> -
> -void GLWorkerCompositor::Finish() {
> -  ATRACE_CALL();
> -  glFinish();
> -
> -  char use_framebuffer_cache_opt[PROPERTY_VALUE_MAX];
> -  property_get("hwc.drm.use_framebuffer_cache", use_framebuffer_cache_opt, "1");
> -  bool use_framebuffer_cache = atoi(use_framebuffer_cache_opt);
> -
> -  if (use_framebuffer_cache) {
> -    for (auto &fb : cached_framebuffers_)
> -      fb.strong_framebuffer.clear();
> -  } else {
> -    cached_framebuffers_.clear();
> -  }
> -}
> -
> -GLWorkerCompositor::CachedFramebuffer::CachedFramebuffer(
> -    const sp<GraphicBuffer> &gb, AutoEGLDisplayImage &&image,
> -    AutoGLTexture &&tex, AutoGLFramebuffer &&fb)
> -    : strong_framebuffer(gb),
> -      weak_framebuffer(gb),
> -      egl_fb_image(std::move(image)),
> -      gl_fb_tex(std::move(tex)),
> -      gl_fb(std::move(fb)) {
> -}
> -
> -bool GLWorkerCompositor::CachedFramebuffer::Promote() {
> -  if (strong_framebuffer.get() != NULL)
> -    return true;
> -  strong_framebuffer = weak_framebuffer.promote();
> -  return strong_framebuffer.get() != NULL;
> -}
> -
> -GLWorkerCompositor::CachedFramebuffer *
> -GLWorkerCompositor::FindCachedFramebuffer(
> -    const sp<GraphicBuffer> &framebuffer) {
> -  for (auto &fb : cached_framebuffers_)
> -    if (fb.weak_framebuffer == framebuffer)
> -      return &fb;
> -  return NULL;
> -}
> -
> -GLWorkerCompositor::CachedFramebuffer *
> -GLWorkerCompositor::PrepareAndCacheFramebuffer(
> -    const sp<GraphicBuffer> &framebuffer) {
> -  CachedFramebuffer *cached_framebuffer = FindCachedFramebuffer(framebuffer);
> -  if (cached_framebuffer != NULL) {
> -    if (cached_framebuffer->Promote()) {
> -      glBindFramebuffer(GL_FRAMEBUFFER, cached_framebuffer->gl_fb.get());
> -      return cached_framebuffer;
> -    }
> -
> -    for (auto it = cached_framebuffers_.begin();
> -         it != cached_framebuffers_.end(); ++it) {
> -      if (it->weak_framebuffer == framebuffer) {
> -        cached_framebuffers_.erase(it);
> -        break;
> -      }
> -    }
> -  }
> -
> -  AutoEGLDisplayImage egl_fb_image(
> -      egl_display_,
> -      eglCreateImageKHR(egl_display_, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
> -                        (EGLClientBuffer)framebuffer->getNativeBuffer(),
> -                        NULL /* no attribs */));
> -
> -  if (egl_fb_image.image() == EGL_NO_IMAGE_KHR) {
> -    ALOGE("Failed to make image from target buffer: %s", GetEGLError());
> -    return NULL;
> -  }
> -
> -  GLuint gl_fb_tex;
> -  glGenTextures(1, &gl_fb_tex);
> -  AutoGLTexture gl_fb_tex_auto(gl_fb_tex);
> -  glBindTexture(GL_TEXTURE_2D, gl_fb_tex);
> -  glEGLImageTargetTexture2DOES(GL_TEXTURE_2D,
> -                               (GLeglImageOES)egl_fb_image.image());
> -  glBindTexture(GL_TEXTURE_2D, 0);
> -
> -  GLuint gl_fb;
> -  glGenFramebuffers(1, &gl_fb);
> -  AutoGLFramebuffer gl_fb_auto(gl_fb);
> -  glBindFramebuffer(GL_FRAMEBUFFER, gl_fb);
> -  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
> -                         gl_fb_tex, 0);
> -
> -  if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
> -    ALOGE("Failed framebuffer check for created target buffer: %s",
> -          GetGLFramebufferError());
> -    return NULL;
> -  }
> -
> -  cached_framebuffers_.emplace_back(framebuffer, std::move(egl_fb_image),
> -                                    std::move(gl_fb_tex_auto),
> -                                    std::move(gl_fb_auto));
> -  return &cached_framebuffers_.back();
> -}
> -
> -GLint GLWorkerCompositor::PrepareAndCacheProgram(unsigned texture_count) {
> -  if (blend_programs_.size() >= texture_count) {
> -    GLint program = blend_programs_[texture_count - 1].get();
> -    if (program != 0)
> -      return program;
> -  }
> -
> -  AutoGLProgram program = GenerateProgram(texture_count, NULL);
> -  if (program.get() != 0) {
> -    if (blend_programs_.size() < texture_count)
> -      blend_programs_.resize(texture_count);
> -    blend_programs_[texture_count - 1] = std::move(program);
> -    return blend_programs_[texture_count - 1].get();
> -  }
> -
> -  return 0;
> -}
> -
> -}  // namespace android
> diff --git a/glworker.h b/glworker.h
> deleted file mode 100644
> index 26de55d725cd..000000000000
> --- a/glworker.h
> +++ /dev/null
> @@ -1,94 +0,0 @@
> -/*
> - * Copyright (C) 2015 The Android Open Source Project
> - *
> - * Licensed under the Apache License, Version 2.0 (the "License");
> - * you may not use this file except in compliance with the License.
> - * You may obtain a copy of the License at
> - *
> - *      http://www.apache.org/licenses/LICENSE-2.0
> - *
> - * Unless required by applicable law or agreed to in writing, software
> - * distributed under the License is distributed on an "AS IS" BASIS,
> - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
> - * See the License for the specific language governing permissions and
> - * limitations under the License.
> - */
> -
> -#ifndef ANDROID_GL_WORKER_H_
> -#define ANDROID_GL_WORKER_H_
> -
> -#include <vector>
> -
> -#define EGL_EGLEXT_PROTOTYPES
> -#define GL_GLEXT_PROTOTYPES
> -
> -#include <EGL/egl.h>
> -#include <EGL/eglext.h>
> -#include <GLES2/gl2.h>
> -#include <GLES2/gl2ext.h>
> -
> -#include <ui/GraphicBuffer.h>
> -
> -#include "autogl.h"
> -
> -namespace android {
> -
> -struct DrmHwcLayer;
> -struct DrmCompositionRegion;
> -
> -class GLWorkerCompositor {
> - public:
> -  GLWorkerCompositor();
> -  ~GLWorkerCompositor();
> -
> -  int Init();
> -  int Composite(DrmHwcLayer *layers, DrmCompositionRegion *regions,
> -                size_t num_regions, const sp<GraphicBuffer> &framebuffer,
> -                Importer *importer);
> -  void Finish();
> -
> - private:
> -  struct CachedFramebuffer {
> -    // If the strong_framebuffer is non-NULL, we are holding a strong reference
> -    // until we are sure rendering is done. The weak reference will be equal in
> -    // that case.
> -    sp<GraphicBuffer> strong_framebuffer;
> -    wp<GraphicBuffer> weak_framebuffer;
> -    AutoEGLDisplayImage egl_fb_image;
> -    AutoGLTexture gl_fb_tex;
> -    AutoGLFramebuffer gl_fb;
> -
> -    CachedFramebuffer(const sp<GraphicBuffer> &gb, AutoEGLDisplayImage &&image,
> -                      AutoGLTexture &&tex, AutoGLFramebuffer &&fb);
> -
> -    bool Promote();
> -  };
> -
> -  struct {
> -    EGLDisplay saved_egl_display = EGL_NO_DISPLAY;
> -    EGLContext saved_egl_ctx = EGL_NO_CONTEXT;
> -    EGLSurface saved_egl_read = EGL_NO_SURFACE;
> -    EGLSurface saved_egl_draw = EGL_NO_SURFACE;
> -  } private_;
> -
> -  int BeginContext();
> -  int EndContext();
> -
> -  CachedFramebuffer *FindCachedFramebuffer(
> -      const sp<GraphicBuffer> &framebuffer);
> -  CachedFramebuffer *PrepareAndCacheFramebuffer(
> -      const sp<GraphicBuffer> &framebuffer);
> -
> -  GLint PrepareAndCacheProgram(unsigned texture_count);
> -
> -  EGLDisplay egl_display_;
> -  EGLContext egl_ctx_;
> -
> -  std::vector<AutoGLProgram> blend_programs_;
> -  AutoGLBuffer vertex_buffer_;
> -
> -  std::vector<CachedFramebuffer> cached_framebuffers_;
> -};
> -}
> -
> -#endif
> diff --git a/hwcomposer.cpp b/hwcomposer.cpp
> deleted file mode 100644
> index 338e042895a9..000000000000
> --- a/hwcomposer.cpp
> +++ /dev/null
> @@ -1,841 +0,0 @@
> -/*
> - * Copyright (C) 2015 The Android Open Source Project
> - *
> - * Licensed under the Apache License, Version 2.0 (the "License");
> - * you may not use this file except in compliance with the License.
> - * You may obtain a copy of the License at
> - *
> - *      http://www.apache.org/licenses/LICENSE-2.0
> - *
> - * Unless required by applicable law or agreed to in writing, software
> - * distributed under the License is distributed on an "AS IS" BASIS,
> - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
> - * See the License for the specific language governing permissions and
> - * limitations under the License.
> - */
> -
> -#define ATRACE_TAG ATRACE_TAG_GRAPHICS
> -#define LOG_TAG "hwcomposer-drm"
> -
> -#include "drmhwcomposer.h"
> -#include "drmeventlistener.h"
> -#include "drmresources.h"
> -#include "platform.h"
> -#include "virtualcompositorworker.h"
> -#include "vsyncworker.h"
> -
> -#include <stdlib.h>
> -
> -#include <cinttypes>
> -#include <map>
> -#include <vector>
> -#include <sstream>
> -
> -#include <errno.h>
> -#include <fcntl.h>
> -#include <pthread.h>
> -#include <sys/param.h>
> -#include <sys/resource.h>
> -#include <xf86drm.h>
> -#include <xf86drmMode.h>
> -
> -#include <log/log.h>
> -#include <cutils/properties.h>
> -#include <hardware/hardware.h>
> -#include <hardware/hwcomposer.h>
> -#include <sw_sync.h>
> -#include <sync/sync.h>
> -#include <utils/Trace.h>
> -
> -#define UM_PER_INCH 25400
> -
> -namespace android {
> -
> -class DummySwSyncTimeline {
> - public:
> -  int Init() {
> -    int ret = timeline_fd_.Set(sw_sync_timeline_create());
> -    if (ret < 0)
> -      return ret;
> -    return 0;
> -  }
> -
> -  UniqueFd CreateDummyFence() {
> -    int ret = sw_sync_fence_create(timeline_fd_.get(), "dummy fence",
> -                                   timeline_pt_ + 1);
> -    if (ret < 0) {
> -      ALOGE("Failed to create dummy fence %d", ret);
> -      return ret;
> -    }
> -
> -    UniqueFd ret_fd(ret);
> -
> -    ret = sw_sync_timeline_inc(timeline_fd_.get(), 1);
> -    if (ret) {
> -      ALOGE("Failed to increment dummy sync timeline %d", ret);
> -      return ret;
> -    }
> -
> -    ++timeline_pt_;
> -    return ret_fd;
> -  }
> -
> - private:
> -  UniqueFd timeline_fd_;
> -  int timeline_pt_ = 0;
> -};
> -
> -struct CheckedOutputFd {
> -  CheckedOutputFd(int *fd, const char *description,
> -                  DummySwSyncTimeline &timeline)
> -      : fd_(fd), description_(description), timeline_(timeline) {
> -  }
> -  CheckedOutputFd(CheckedOutputFd &&rhs)
> -      : description_(rhs.description_), timeline_(rhs.timeline_) {
> -    std::swap(fd_, rhs.fd_);
> -  }
> -
> -  CheckedOutputFd &operator=(const CheckedOutputFd &rhs) = delete;
> -
> -  ~CheckedOutputFd() {
> -    if (fd_ == NULL)
> -      return;
> -
> -    if (*fd_ >= 0)
> -      return;
> -
> -    *fd_ = timeline_.CreateDummyFence().Release();
> -
> -    if (*fd_ < 0)
> -      ALOGE("Failed to fill %s (%p == %d) before destruction",
> -            description_.c_str(), fd_, *fd_);
> -  }
> -
> - private:
> -  int *fd_ = NULL;
> -  std::string description_;
> -  DummySwSyncTimeline &timeline_;
> -};
> -
> -typedef struct hwc_drm_display {
> -  struct hwc_context_t *ctx;
> -  int display;
> -
> -  std::vector<uint32_t> config_ids;
> -
> -  VSyncWorker vsync_worker;
> -} hwc_drm_display_t;
> -
> -class DrmHotplugHandler : public DrmEventHandler {
> - public:
> -  void Init(DrmResources *drm, const struct hwc_procs *procs) {
> -    drm_ = drm;
> -    procs_ = procs;
> -  }
> -
> -  void HandleEvent(uint64_t timestamp_us) {
> -    for (auto &conn : drm_->connectors()) {
> -      drmModeConnection old_state = conn->state();
> -
> -      conn->UpdateModes();
> -
> -      drmModeConnection cur_state = conn->state();
> -
> -      if (cur_state == old_state)
> -        continue;
> -
> -      ALOGI("%s event @%" PRIu64 " for connector %u\n",
> -            cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug", timestamp_us,
> -            conn->id());
> -
> -      if (cur_state == DRM_MODE_CONNECTED) {
> -        // Take the first one, then look for the preferred
> -        DrmMode mode = *(conn->modes().begin());
> -        for (auto &m : conn->modes()) {
> -          if (m.type() & DRM_MODE_TYPE_PREFERRED) {
> -            mode = m;
> -            break;
> -          }
> -        }
> -        ALOGI("Setting mode %dx%d for connector %d\n", mode.h_display(),
> -              mode.v_display(), conn->id());
> -        int ret = drm_->SetDisplayActiveMode(conn->display(), mode);
> -        if (ret) {
> -          ALOGE("Failed to set active config %d", ret);
> -          return;
> -        }
> -      } else {
> -        int ret = drm_->SetDpmsMode(conn->display(), DRM_MODE_DPMS_OFF);
> -        if (ret) {
> -          ALOGE("Failed to set dpms mode off %d", ret);
> -          return;
> -        }
> -      }
> -
> -      procs_->hotplug(procs_, conn->display(),
> -                      cur_state == DRM_MODE_CONNECTED ? 1 : 0);
> -    }
> -  }
> -
> - private:
> -  DrmResources *drm_ = NULL;
> -  const struct hwc_procs *procs_ = NULL;
> -};
> -
> -struct hwc_context_t {
> -  // map of display:hwc_drm_display_t
> -  typedef std::map<int, hwc_drm_display_t> DisplayMap;
> -
> -  ~hwc_context_t() {
> -    virtual_compositor_worker.Exit();
> -  }
> -
> -  hwc_composer_device_1_t device;
> -  hwc_procs_t const *procs = NULL;
> -
> -  DisplayMap displays;
> -  DrmResources drm;
> -  std::unique_ptr<Importer> importer;
> -  const gralloc_module_t *gralloc;
> -  DummySwSyncTimeline dummy_timeline;
> -  VirtualCompositorWorker virtual_compositor_worker;
> -  DrmHotplugHandler hotplug_handler;
> -};
> -
> -class DrmVsyncCallback : public VsyncCallback {
> - public:
> -  DrmVsyncCallback(hwc_procs_t const *procs) : procs_(procs) {
> -  }
> -
> -  void Callback(int display, int64_t timestamp) {
> -    procs_->vsync(procs_, display, timestamp);
> -  }
> - private:
> -  hwc_procs_t const *procs_;
> -};
> -
> -static void hwc_dump(struct hwc_composer_device_1 *dev, char *buff,
> -                     int buff_len) {
> -  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
> -  std::ostringstream out;
> -
> -  ctx->drm.compositor()->Dump(&out);
> -  std::string out_str = out.str();
> -  strncpy(buff, out_str.c_str(),
> -          std::min((size_t)buff_len, out_str.length() + 1));
> -  buff[buff_len - 1] = '\0';
> -}
> -
> -static bool hwc_skip_layer(const std::pair<int, int> &indices, int i) {
> -  return indices.first >= 0 && i >= indices.first && i <= indices.second;
> -}
> -
> -static int hwc_prepare(hwc_composer_device_1_t *dev, size_t num_displays,
> -                       hwc_display_contents_1_t **display_contents) {
> -  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
> -
> -  for (int i = 0; i < (int)num_displays; ++i) {
> -    if (!display_contents[i])
> -      continue;
> -
> -    bool use_framebuffer_target = false;
> -    DrmMode mode;
> -    if (i == HWC_DISPLAY_VIRTUAL) {
> -      use_framebuffer_target = true;
> -    } else {
> -      DrmConnector *c = ctx->drm.GetConnectorForDisplay(i);
> -      if (!c) {
> -        ALOGE("Failed to get DrmConnector for display %d", i);
> -        return -ENODEV;
> -      }
> -      mode = c->active_mode();
> -    }
> -
> -    // Since we can't composite HWC_SKIP_LAYERs by ourselves, we'll let SF
> -    // handle all layers in between the first and last skip layers. So find the
> -    // outer indices and mark everything in between as HWC_FRAMEBUFFER
> -    std::pair<int, int> skip_layer_indices(-1, -1);
> -    int num_layers = display_contents[i]->numHwLayers;
> -    for (int j = 0; !use_framebuffer_target && j < num_layers; ++j) {
> -      hwc_layer_1_t *layer = &display_contents[i]->hwLayers[j];
> -
> -      if (!(layer->flags & HWC_SKIP_LAYER))
> -        continue;
> -
> -      if (skip_layer_indices.first == -1)
> -        skip_layer_indices.first = j;
> -      skip_layer_indices.second = j;
> -    }
> -
> -    for (int j = 0; j < num_layers; ++j) {
> -      hwc_layer_1_t *layer = &display_contents[i]->hwLayers[j];
> -
> -      if (!use_framebuffer_target && !hwc_skip_layer(skip_layer_indices, j)) {
> -        // If the layer is off the screen, don't earmark it for an overlay.
> -        // We'll leave it as-is, which effectively just drops it from the frame
> -        const hwc_rect_t *frame = &layer->displayFrame;
> -        if ((frame->right - frame->left) <= 0 ||
> -            (frame->bottom - frame->top) <= 0 ||
> -            frame->right <= 0 || frame->bottom <= 0 ||
> -            frame->left >= (int)mode.h_display() ||
> -            frame->top >= (int)mode.v_display())
> -            continue;
> -
> -        if (layer->compositionType == HWC_FRAMEBUFFER)
> -          layer->compositionType = HWC_OVERLAY;
> -      } else {
> -        switch (layer->compositionType) {
> -          case HWC_OVERLAY:
> -          case HWC_BACKGROUND:
> -          case HWC_SIDEBAND:
> -          case HWC_CURSOR_OVERLAY:
> -            layer->compositionType = HWC_FRAMEBUFFER;
> -            break;
> -        }
> -      }
> -    }
> -  }
> -
> -  return 0;
> -}
> -
> -static void hwc_add_layer_to_retire_fence(
> -    hwc_layer_1_t *layer, hwc_display_contents_1_t *display_contents) {
> -  if (layer->releaseFenceFd < 0)
> -    return;
> -
> -  if (display_contents->retireFenceFd >= 0) {
> -    int old_retire_fence = display_contents->retireFenceFd;
> -    display_contents->retireFenceFd =
> -        sync_merge("dc_retire", old_retire_fence, layer->releaseFenceFd);
> -    close(old_retire_fence);
> -  } else {
> -    display_contents->retireFenceFd = dup(layer->releaseFenceFd);
> -  }
> -}
> -
> -static int hwc_set(hwc_composer_device_1_t *dev, size_t num_displays,
> -                   hwc_display_contents_1_t **sf_display_contents) {
> -  ATRACE_CALL();
> -  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
> -  int ret = 0;
> -
> -  std::vector<CheckedOutputFd> checked_output_fences;
> -  std::vector<DrmHwcDisplayContents> displays_contents;
> -  std::vector<DrmCompositionDisplayLayersMap> layers_map;
> -  std::vector<std::vector<size_t>> layers_indices;
> -  displays_contents.reserve(num_displays);
> -  // layers_map.reserve(num_displays);
> -  layers_indices.reserve(num_displays);
> -
> -  // Phase one does nothing that would cause errors. Only take ownership of FDs.
> -  for (size_t i = 0; i < num_displays; ++i) {
> -    hwc_display_contents_1_t *dc = sf_display_contents[i];
> -    displays_contents.emplace_back();
> -    DrmHwcDisplayContents &display_contents = displays_contents.back();
> -    layers_indices.emplace_back();
> -    std::vector<size_t> &indices_to_composite = layers_indices.back();
> -
> -    if (!sf_display_contents[i])
> -      continue;
> -
> -    if (i == HWC_DISPLAY_VIRTUAL) {
> -      ctx->virtual_compositor_worker.QueueComposite(dc);
> -      continue;
> -    }
> -
> -    std::ostringstream display_index_formatter;
> -    display_index_formatter << "retire fence for display " << i;
> -    std::string display_fence_description(display_index_formatter.str());
> -    checked_output_fences.emplace_back(&dc->retireFenceFd,
> -                                       display_fence_description.c_str(),
> -                                       ctx->dummy_timeline);
> -    display_contents.retire_fence = OutputFd(&dc->retireFenceFd);
> -
> -    size_t num_dc_layers = dc->numHwLayers;
> -    int framebuffer_target_index = -1;
> -    for (size_t j = 0; j < num_dc_layers; ++j) {
> -      hwc_layer_1_t *sf_layer = &dc->hwLayers[j];
> -      if (sf_layer->compositionType == HWC_FRAMEBUFFER_TARGET) {
> -        framebuffer_target_index = j;
> -        break;
> -      }
> -    }
> -
> -    for (size_t j = 0; j < num_dc_layers; ++j) {
> -      hwc_layer_1_t *sf_layer = &dc->hwLayers[j];
> -
> -      display_contents.layers.emplace_back();
> -      DrmHwcLayer &layer = display_contents.layers.back();
> -
> -      // In prepare() we marked all layers FRAMEBUFFER between SKIP_LAYER's.
> -      // This means we should insert the FB_TARGET layer in the composition
> -      // stack at the location of the first skip layer, and ignore the rest.
> -      if (sf_layer->flags & HWC_SKIP_LAYER) {
> -        if (framebuffer_target_index < 0)
> -          continue;
> -        int idx = framebuffer_target_index;
> -        framebuffer_target_index = -1;
> -        hwc_layer_1_t *fbt_layer = &dc->hwLayers[idx];
> -        if (!fbt_layer->handle || (fbt_layer->flags & HWC_SKIP_LAYER)) {
> -          ALOGE("Invalid HWC_FRAMEBUFFER_TARGET with HWC_SKIP_LAYER present");
> -          continue;
> -        }
> -        indices_to_composite.push_back(idx);
> -        continue;
> -      }
> -
> -      if (sf_layer->compositionType == HWC_OVERLAY)
> -        indices_to_composite.push_back(j);
> -
> -      layer.acquire_fence.Set(sf_layer->acquireFenceFd);
> -      sf_layer->acquireFenceFd = -1;
> -
> -      std::ostringstream layer_fence_formatter;
> -      layer_fence_formatter << "release fence for layer " << j << " of display "
> -                            << i;
> -      std::string layer_fence_description(layer_fence_formatter.str());
> -      checked_output_fences.emplace_back(&sf_layer->releaseFenceFd,
> -                                         layer_fence_description.c_str(),
> -                                         ctx->dummy_timeline);
> -      layer.release_fence = OutputFd(&sf_layer->releaseFenceFd);
> -    }
> -
> -    // This is a catch-all in case we get a frame without any overlay layers, or
> -    // skip layers, but with a value fb_target layer. This _shouldn't_ happen,
> -    // but it's not ruled out by the hwc specification
> -    if (indices_to_composite.empty() && framebuffer_target_index >= 0) {
> -      hwc_layer_1_t *sf_layer = &dc->hwLayers[framebuffer_target_index];
> -      if (!sf_layer->handle || (sf_layer->flags & HWC_SKIP_LAYER)) {
> -        ALOGE(
> -            "Expected valid layer with HWC_FRAMEBUFFER_TARGET when all "
> -            "HWC_OVERLAY layers are skipped.");
> -        ret = -EINVAL;
> -      }
> -      indices_to_composite.push_back(framebuffer_target_index);
> -    }
> -  }
> -
> -  if (ret)
> -    return ret;
> -
> -  for (size_t i = 0; i < num_displays; ++i) {
> -    hwc_display_contents_1_t *dc = sf_display_contents[i];
> -    DrmHwcDisplayContents &display_contents = displays_contents[i];
> -    if (!sf_display_contents[i] || i == HWC_DISPLAY_VIRTUAL)
> -      continue;
> -
> -    layers_map.emplace_back();
> -    DrmCompositionDisplayLayersMap &map = layers_map.back();
> -    map.display = i;
> -    map.geometry_changed =
> -        (dc->flags & HWC_GEOMETRY_CHANGED) == HWC_GEOMETRY_CHANGED;
> -    std::vector<size_t> &indices_to_composite = layers_indices[i];
> -    for (size_t j : indices_to_composite) {
> -      hwc_layer_1_t *sf_layer = &dc->hwLayers[j];
> -
> -      DrmHwcLayer &layer = display_contents.layers[j];
> -
> -      ret = layer.InitFromHwcLayer(sf_layer, ctx->importer.get(), ctx->gralloc);
> -      if (ret) {
> -        ALOGE("Failed to init composition from layer %d", ret);
> -        return ret;
> -      }
> -      map.layers.emplace_back(std::move(layer));
> -    }
> -  }
> -
> -  std::unique_ptr<DrmComposition> composition(
> -      ctx->drm.compositor()->CreateComposition(ctx->importer.get()));
> -  if (!composition) {
> -    ALOGE("Drm composition init failed");
> -    return -EINVAL;
> -  }
> -
> -  ret = composition->SetLayers(layers_map.size(), layers_map.data());
> -  if (ret) {
> -    return -EINVAL;
> -  }
> -
> -  ret = ctx->drm.compositor()->QueueComposition(std::move(composition));
> -  if (ret) {
> -    return -EINVAL;
> -  }
> -
> -  for (size_t i = 0; i < num_displays; ++i) {
> -    hwc_display_contents_1_t *dc = sf_display_contents[i];
> -    if (!dc)
> -      continue;
> -
> -    size_t num_dc_layers = dc->numHwLayers;
> -    for (size_t j = 0; j < num_dc_layers; ++j) {
> -      hwc_layer_1_t *layer = &dc->hwLayers[j];
> -      if (layer->flags & HWC_SKIP_LAYER)
> -        continue;
> -      hwc_add_layer_to_retire_fence(layer, dc);
> -    }
> -  }
> -
> -  composition.reset(NULL);
> -
> -  return ret;
> -}
> -
> -static int hwc_event_control(struct hwc_composer_device_1 *dev, int display,
> -                             int event, int enabled) {
> -  if (event != HWC_EVENT_VSYNC || (enabled != 0 && enabled != 1))
> -    return -EINVAL;
> -
> -  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
> -  hwc_drm_display_t *hd = &ctx->displays[display];
> -  hd->vsync_worker.VSyncControl(enabled);
> -  return 0;
> -}
> -
> -static int hwc_set_power_mode(struct hwc_composer_device_1 *dev, int display,
> -                              int mode) {
> -  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
> -
> -  uint64_t dpmsValue = 0;
> -  switch (mode) {
> -    case HWC_POWER_MODE_OFF:
> -      dpmsValue = DRM_MODE_DPMS_OFF;
> -      break;
> -
> -    /* We can't support dozing right now, so go full on */
> -    case HWC_POWER_MODE_DOZE:
> -    case HWC_POWER_MODE_DOZE_SUSPEND:
> -    case HWC_POWER_MODE_NORMAL:
> -      dpmsValue = DRM_MODE_DPMS_ON;
> -      break;
> -  };
> -  return ctx->drm.SetDpmsMode(display, dpmsValue);
> -}
> -
> -static int hwc_query(struct hwc_composer_device_1 * /* dev */, int what,
> -                     int *value) {
> -  switch (what) {
> -    case HWC_BACKGROUND_LAYER_SUPPORTED:
> -      *value = 0; /* TODO: We should do this */
> -      break;
> -    case HWC_VSYNC_PERIOD:
> -      ALOGW("Query for deprecated vsync value, returning 60Hz");
> -      *value = 1000 * 1000 * 1000 / 60;
> -      break;
> -    case HWC_DISPLAY_TYPES_SUPPORTED:
> -      *value = HWC_DISPLAY_PRIMARY_BIT | HWC_DISPLAY_EXTERNAL_BIT |
> -               HWC_DISPLAY_VIRTUAL_BIT;
> -      break;
> -  }
> -  return 0;
> -}
> -
> -static void hwc_register_procs(struct hwc_composer_device_1 *dev,
> -                               hwc_procs_t const *procs) {
> -  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
> -
> -  ctx->procs = procs;
> -
> -  for (std::pair<const int, hwc_drm_display> &display_entry : ctx->displays) {
> -    auto callback = std::make_shared<DrmVsyncCallback>(procs);
> -    display_entry.second.vsync_worker.RegisterCallback(std::move(callback));
> -  }
> -
> -  ctx->hotplug_handler.Init(&ctx->drm, procs);
> -  ctx->drm.event_listener()->RegisterHotplugHandler(&ctx->hotplug_handler);
> -}
> -
> -static int hwc_get_display_configs(struct hwc_composer_device_1 *dev,
> -                                   int display, uint32_t *configs,
> -                                   size_t *num_configs) {
> -  if (!*num_configs)
> -    return 0;
> -
> -  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
> -  hwc_drm_display_t *hd = &ctx->displays[display];
> -  hd->config_ids.clear();
> -
> -  DrmConnector *connector = ctx->drm.GetConnectorForDisplay(display);
> -  if (!connector) {
> -    ALOGE("Failed to get connector for display %d", display);
> -    return -ENODEV;
> -  }
> -
> -  int ret = connector->UpdateModes();
> -  if (ret) {
> -    ALOGE("Failed to update display modes %d", ret);
> -    return ret;
> -  }
> -
> -  for (const DrmMode &mode : connector->modes()) {
> -    size_t idx = hd->config_ids.size();
> -    if (idx == *num_configs)
> -      break;
> -    hd->config_ids.push_back(mode.id());
> -    configs[idx] = mode.id();
> -  }
> -  *num_configs = hd->config_ids.size();
> -  return *num_configs == 0 ? -1 : 0;
> -}
> -
> -static int hwc_get_display_attributes(struct hwc_composer_device_1 *dev,
> -                                      int display, uint32_t config,
> -                                      const uint32_t *attributes,
> -                                      int32_t *values) {
> -  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
> -  DrmConnector *c = ctx->drm.GetConnectorForDisplay(display);
> -  if (!c) {
> -    ALOGE("Failed to get DrmConnector for display %d", display);
> -    return -ENODEV;
> -  }
> -  DrmMode mode;
> -  for (const DrmMode &conn_mode : c->modes()) {
> -    if (conn_mode.id() == config) {
> -      mode = conn_mode;
> -      break;
> -    }
> -  }
> -  if (mode.id() == 0) {
> -    ALOGE("Failed to find active mode for display %d", display);
> -    return -ENOENT;
> -  }
> -
> -  uint32_t mm_width = c->mm_width();
> -  uint32_t mm_height = c->mm_height();
> -  for (int i = 0; attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; ++i) {
> -    switch (attributes[i]) {
> -      case HWC_DISPLAY_VSYNC_PERIOD:
> -        values[i] = 1000 * 1000 * 1000 / mode.v_refresh();
> -        break;
> -      case HWC_DISPLAY_WIDTH:
> -        values[i] = mode.h_display();
> -        break;
> -      case HWC_DISPLAY_HEIGHT:
> -        values[i] = mode.v_display();
> -        break;
> -      case HWC_DISPLAY_DPI_X:
> -        /* Dots per 1000 inches */
> -        values[i] = mm_width ? (mode.h_display() * UM_PER_INCH) / mm_width : 0;
> -        break;
> -      case HWC_DISPLAY_DPI_Y:
> -        /* Dots per 1000 inches */
> -        values[i] =
> -            mm_height ? (mode.v_display() * UM_PER_INCH) / mm_height : 0;
> -        break;
> -    }
> -  }
> -  return 0;
> -}
> -
> -static int hwc_get_active_config(struct hwc_composer_device_1 *dev,
> -                                 int display) {
> -  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
> -  DrmConnector *c = ctx->drm.GetConnectorForDisplay(display);
> -  if (!c) {
> -    ALOGE("Failed to get DrmConnector for display %d", display);
> -    return -ENODEV;
> -  }
> -
> -  DrmMode mode = c->active_mode();
> -  hwc_drm_display_t *hd = &ctx->displays[display];
> -  for (size_t i = 0; i < hd->config_ids.size(); ++i) {
> -    if (hd->config_ids[i] == mode.id())
> -      return i;
> -  }
> -  return -1;
> -}
> -
> -static int hwc_set_active_config(struct hwc_composer_device_1 *dev, int display,
> -                                 int index) {
> -  struct hwc_context_t *ctx = (struct hwc_context_t *)&dev->common;
> -  hwc_drm_display_t *hd = &ctx->displays[display];
> -  if (index >= (int)hd->config_ids.size()) {
> -    ALOGE("Invalid config index %d passed in", index);
> -    return -EINVAL;
> -  }
> -
> -  DrmConnector *c = ctx->drm.GetConnectorForDisplay(display);
> -  if (!c) {
> -    ALOGE("Failed to get connector for display %d", display);
> -    return -ENODEV;
> -  }
> -
> -  if (c->state() != DRM_MODE_CONNECTED)
> -    return -ENODEV;
> -
> -  DrmMode mode;
> -  for (const DrmMode &conn_mode : c->modes()) {
> -    if (conn_mode.id() == hd->config_ids[index]) {
> -      mode = conn_mode;
> -      break;
> -    }
> -  }
> -  if (mode.id() != hd->config_ids[index]) {
> -    ALOGE("Could not find active mode for %d/%d", index, hd->config_ids[index]);
> -    return -ENOENT;
> -  }
> -  int ret = ctx->drm.SetDisplayActiveMode(display, mode);
> -  if (ret) {
> -    ALOGE("Failed to set active config %d", ret);
> -    return ret;
> -  }
> -  ret = ctx->drm.SetDpmsMode(display, DRM_MODE_DPMS_ON);
> -  if (ret) {
> -    ALOGE("Failed to set dpms mode on %d", ret);
> -    return ret;
> -  }
> -  return ret;
> -}
> -
> -static int hwc_device_close(struct hw_device_t *dev) {
> -  struct hwc_context_t *ctx = (struct hwc_context_t *)dev;
> -  delete ctx;
> -  return 0;
> -}
> -
> -/*
> - * TODO: This function sets the active config to the first one in the list. This
> - * should be fixed such that it selects the preferred mode for the display, or
> - * some other, saner, method of choosing the config.
> - */
> -static int hwc_set_initial_config(hwc_drm_display_t *hd) {
> -  uint32_t config;
> -  size_t num_configs = 1;
> -  int ret = hwc_get_display_configs(&hd->ctx->device, hd->display, &config,
> -                                    &num_configs);
> -  if (ret || !num_configs)
> -    return 0;
> -
> -  ret = hwc_set_active_config(&hd->ctx->device, hd->display, 0);
> -  if (ret) {
> -    ALOGE("Failed to set active config d=%d ret=%d", hd->display, ret);
> -    return ret;
> -  }
> -
> -  return ret;
> -}
> -
> -static int hwc_initialize_display(struct hwc_context_t *ctx, int display) {
> -  hwc_drm_display_t *hd = &ctx->displays[display];
> -  hd->ctx = ctx;
> -  hd->display = display;
> -
> -  int ret = hwc_set_initial_config(hd);
> -  if (ret) {
> -    ALOGE("Failed to set initial config for d=%d ret=%d", display, ret);
> -    return ret;
> -  }
> -
> -  ret = hd->vsync_worker.Init(&ctx->drm, display);
> -  if (ret) {
> -    ALOGE("Failed to create event worker for display %d %d\n", display, ret);
> -    return ret;
> -  }
> -
> -  return 0;
> -}
> -
> -static int hwc_enumerate_displays(struct hwc_context_t *ctx) {
> -  int ret;
> -  for (auto &conn : ctx->drm.connectors()) {
> -    ret = hwc_initialize_display(ctx, conn->display());
> -    if (ret) {
> -      ALOGE("Failed to initialize display %d", conn->display());
> -      return ret;
> -    }
> -  }
> -
> -  ret = ctx->virtual_compositor_worker.Init();
> -  if (ret) {
> -    ALOGE("Failed to initialize virtual compositor worker");
> -    return ret;
> -  }
> -  return 0;
> -}
> -
> -static int hwc_device_open(const struct hw_module_t *module, const char *name,
> -                           struct hw_device_t **dev) {
> -  if (strcmp(name, HWC_HARDWARE_COMPOSER)) {
> -    ALOGE("Invalid module name- %s", name);
> -    return -EINVAL;
> -  }
> -
> -  std::unique_ptr<hwc_context_t> ctx(new hwc_context_t());
> -  if (!ctx) {
> -    ALOGE("Failed to allocate hwc context");
> -    return -ENOMEM;
> -  }
> -
> -  int ret = ctx->drm.Init();
> -  if (ret) {
> -    ALOGE("Can't initialize Drm object %d", ret);
> -    return ret;
> -  }
> -
> -  ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID,
> -                      (const hw_module_t **)&ctx->gralloc);
> -  if (ret) {
> -    ALOGE("Failed to open gralloc module %d", ret);
> -    return ret;
> -  }
> -
> -  ret = ctx->dummy_timeline.Init();
> -  if (ret) {
> -    ALOGE("Failed to create dummy sw sync timeline %d", ret);
> -    return ret;
> -  }
> -
> -  ctx->importer.reset(Importer::CreateInstance(&ctx->drm));
> -  if (!ctx->importer) {
> -    ALOGE("Failed to create importer instance");
> -    return ret;
> -  }
> -
> -  ret = hwc_enumerate_displays(ctx.get());
> -  if (ret) {
> -    ALOGE("Failed to enumerate displays: %s", strerror(ret));
> -    return ret;
> -  }
> -
> -  ctx->device.common.tag = HARDWARE_DEVICE_TAG;
> -  ctx->device.common.version = HWC_DEVICE_API_VERSION_1_4;
> -  ctx->device.common.module = const_cast<hw_module_t *>(module);
> -  ctx->device.common.close = hwc_device_close;
> -
> -  ctx->device.dump = hwc_dump;
> -  ctx->device.prepare = hwc_prepare;
> -  ctx->device.set = hwc_set;
> -  ctx->device.eventControl = hwc_event_control;
> -  ctx->device.setPowerMode = hwc_set_power_mode;
> -  ctx->device.query = hwc_query;
> -  ctx->device.registerProcs = hwc_register_procs;
> -  ctx->device.getDisplayConfigs = hwc_get_display_configs;
> -  ctx->device.getDisplayAttributes = hwc_get_display_attributes;
> -  ctx->device.getActiveConfig = hwc_get_active_config;
> -  ctx->device.setActiveConfig = hwc_set_active_config;
> -  ctx->device.setCursorPositionAsync = NULL; /* TODO: Add cursor */
> -
> -  *dev = &ctx->device.common;
> -  ctx.release();
> -
> -  return 0;
> -}
> -}
> -
> -static struct hw_module_methods_t hwc_module_methods = {
> -  .open = android::hwc_device_open
> -};
> -
> -hwc_module_t HAL_MODULE_INFO_SYM = {
> -  .common = {
> -    .tag = HARDWARE_MODULE_TAG,
> -    .version_major = 1,
> -    .version_minor = 0,
> -    .id = HWC_HARDWARE_MODULE_ID,
> -    .name = "DRM hwcomposer module",
> -    .author = "The Android Open Source Project",
> -    .methods = &hwc_module_methods,
> -    .dso = NULL,
> -    .reserved = {0},
> -  }
> -};
> diff --git a/platform.cpp b/platform.cpp
> index 62b03a881dca..b6c39d05a3a1 100644
> --- a/platform.cpp
> +++ b/platform.cpp
> @@ -37,7 +37,7 @@ std::vector<DrmPlane *> Planner::GetUsablePlanes(
>  }
>  
>  std::tuple<int, std::vector<DrmCompositionPlane>> Planner::ProvisionPlanes(
> -    std::map<size_t, DrmHwcLayer *> &layers, bool use_squash_fb, DrmCrtc *crtc,
> +    std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc *crtc,
>      std::vector<DrmPlane *> *primary_planes,
>      std::vector<DrmPlane *> *overlay_planes) {
>    std::vector<DrmCompositionPlane> composition;
> @@ -48,30 +48,6 @@ std::tuple<int, std::vector<DrmCompositionPlane>> Planner::ProvisionPlanes(
>      return std::make_tuple(-ENODEV, std::vector<DrmCompositionPlane>());
>    }
>  
> -  // If needed, reserve the squash plane at the highest z-order
> -  DrmPlane *squash_plane = NULL;
> -  if (use_squash_fb) {
> -    if (!planes.empty()) {
> -      squash_plane = planes.back();
> -      planes.pop_back();
> -    } else {
> -      ALOGI("Not enough planes to reserve for squash fb");
> -    }
> -  }
> -
> -  // If needed, reserve the precomp plane at the next highest z-order
> -  DrmPlane *precomp_plane = NULL;
> -  if (layers.size() > planes.size()) {
> -    if (!planes.empty()) {
> -      precomp_plane = planes.back();
> -      planes.pop_back();
> -      composition.emplace_back(DrmCompositionPlane::Type::kPrecomp,
> -                               precomp_plane, crtc);
> -    } else {
> -      ALOGE("Not enough planes to reserve for precomp fb");
> -    }
> -  }
> -
>    // Go through the provisioning stages and provision planes
>    for (auto &i : stages_) {
>      int ret = i->ProvisionPlanes(&composition, layers, crtc, &planes);
> @@ -81,10 +57,6 @@ std::tuple<int, std::vector<DrmCompositionPlane>> Planner::ProvisionPlanes(
>      }
>    }
>  
> -  if (squash_plane)
> -    composition.emplace_back(DrmCompositionPlane::Type::kSquash, squash_plane,
> -                             crtc);
> -
>    return std::make_tuple(0, std::move(composition));
>  }
>  
> @@ -109,62 +81,6 @@ int PlanStageProtected::ProvisionPlanes(
>      i = layers.erase(i);
>    }
>  
> -  if (protected_zorder == -1)
> -    return 0;
> -
> -  // Add any layers below the protected content to the precomposition since we
> -  // need to punch a hole through them.
> -  for (auto i = layers.begin(); i != layers.end();) {
> -    // Skip layers above the z-order of the protected content
> -    if (i->first > static_cast<size_t>(protected_zorder)) {
> -      ++i;
> -      continue;
> -    }
> -
> -    // If there's no precomp layer already queued, queue one now.
> -    DrmCompositionPlane *precomp = GetPrecomp(composition);
> -    if (precomp) {
> -      precomp->source_layers().emplace_back(i->first);
> -    } else {
> -      if (!planes->empty()) {
> -        DrmPlane *precomp_plane = planes->back();
> -        planes->pop_back();
> -        composition->emplace_back(DrmCompositionPlane::Type::kPrecomp,
> -                                  precomp_plane, crtc, i->first);
> -      } else {
> -        ALOGE("Not enough planes to reserve for precomp fb");
> -      }
> -    }
> -    i = layers.erase(i);
> -  }
> -  return 0;
> -}
> -
> -int PlanStagePrecomp::ProvisionPlanes(
> -    std::vector<DrmCompositionPlane> *composition,
> -    std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc * /*crtc*/,
> -    std::vector<DrmPlane *> * /*planes*/) {
> -  DrmCompositionPlane *precomp = GetPrecomp(composition);
> -  if (!precomp || precomp->source_layers().empty())
> -    return 0;
> -
> -  // Find lowest zorder out of precomp layers
> -  size_t precomp_zorder = *std::min_element(
> -      precomp->source_layers().begin(), precomp->source_layers().end(),
> -      [](size_t a, size_t b) { return a < b; });
> -
> -  // if there are any remaining layers on top of any of the precomp layers,
> -  // add them to precomp to avoid blending issues since precomp is always at
> -  // highest zorder
> -  for (auto i = layers.begin(); i != layers.end();) {
> -    if (i->first < precomp_zorder) {
> -      i++;
> -      continue;
> -    }
> -    precomp->source_layers().emplace_back(i->first);
> -    i = layers.erase(i);
> -  }
> -
>    return 0;
>  }
>  
> @@ -183,13 +99,6 @@ int PlanStageGreedy::ProvisionPlanes(
>        ALOGE("Failed to emplace layer %zu, dropping it", i->first);
>    }
>  
> -  // Put the rest of the layers in the precomp plane
> -  DrmCompositionPlane *precomp = GetPrecomp(composition);
> -  if (precomp) {
> -    for (auto i = layers.begin(); i != layers.end(); i = layers.erase(i))
> -      precomp->source_layers().emplace_back(i->first);
> -  }
> -
>    return 0;
>  }
>  }
> diff --git a/platform.h b/platform.h
> index e417bf785a2c..639ac884ba3f 100644
> --- a/platform.h
> +++ b/platform.h
> @@ -38,10 +38,6 @@ class Importer {
>    // Creates a platform-specific importer instance
>    static Importer *CreateInstance(DrmResources *drm);
>  
> -  // Imports EGLImage for glcompositor, since NV handles this in non-standard
> -  // way, and fishing out the details is specific to the gralloc used.
> -  virtual EGLImageKHR ImportImage(EGLDisplay egl_display, buffer_handle_t handle) = 0;
> -
>    // Imports the buffer referred to by handle into bo.
>    //
>    // Note: This can be called from a different thread than ReleaseBuffer. The
> @@ -77,17 +73,7 @@ class Planner {
>        return plane;
>      }
>  
> -    // Finds and returns the squash layer from the composition
> -    static DrmCompositionPlane *GetPrecomp(
> -        std::vector<DrmCompositionPlane> *composition) {
> -      auto l = GetPrecompIter(composition);
> -      if (l == composition->end())
> -        return NULL;
> -      return &(*l);
> -    }
> -
> -    // Inserts the given layer:plane in the composition right before the precomp
> -    // layer
> +    // Inserts the given layer:plane in the composition at the back
>      static int Emplace(std::vector<DrmCompositionPlane> *composition,
>                         std::vector<DrmPlane *> *planes,
>                         DrmCompositionPlane::Type type, DrmCrtc *crtc,
> @@ -96,40 +82,25 @@ class Planner {
>        if (!plane)
>          return -ENOENT;
>  
> -      auto precomp = GetPrecompIter(composition);
> -      composition->emplace(precomp, type, plane, crtc, source_layer);
> +      composition->emplace_back(type, plane, crtc, source_layer);
>        return 0;
>      }
> -
> -   private:
> -    static std::vector<DrmCompositionPlane>::iterator GetPrecompIter(
> -        std::vector<DrmCompositionPlane> *composition) {
> -      return std::find_if(composition->begin(), composition->end(),
> -                          [](const DrmCompositionPlane &p) {
> -        return p.type() == DrmCompositionPlane::Type::kPrecomp;
> -      });
> -    }
>    };
>  
>    // Creates a planner instance with platform-specific planning stages
>    static std::unique_ptr<Planner> CreateInstance(DrmResources *drm);
>  
>    // Takes a stack of layers and provisions hardware planes for them. If the
> -  // entire stack can't fit in hardware, the Planner may place the remaining
> -  // layers in a PRECOMP plane. Layers in the PRECOMP plane will be composited
> -  // using GL. PRECOMP planes should be placed above any 1:1 layer:plane
> -  // compositions. If use_squash_fb is true, the Planner should try to reserve a
> -  // plane at the highest z-order with type SQUASH.
> +  // entire stack can't fit in hardware, FIXME
>    //
>    // @layers: a map of index:layer of layers to composite
> -  // @use_squash_fb: reserve a squash framebuffer
>    // @primary_planes: a vector of primary planes available for this frame
>    // @overlay_planes: a vector of overlay planes available for this frame
>    //
>    // Returns: A tuple with the status of the operation (0 for success) and
>    //          a vector of the resulting plan (ie: layer->plane mapping).
>    std::tuple<int, std::vector<DrmCompositionPlane>> ProvisionPlanes(
> -      std::map<size_t, DrmHwcLayer *> &layers, bool use_squash_fb,
> +      std::map<size_t, DrmHwcLayer *> &layers,
>        DrmCrtc *crtc, std::vector<DrmPlane *> *primary_planes,
>        std::vector<DrmPlane *> *overlay_planes);
>  
> @@ -156,18 +127,6 @@ class PlanStageProtected : public Planner::PlanStage {
>                        std::vector<DrmPlane *> *planes);
>  };
>  
> -// This plan stage provisions the precomp plane with any remaining layers that
> -// are on top of the current precomp layers. This stage should be included in
> -// all platforms before loosely allocating layers (i.e. PlanStageGreedy) if
> -// any previous plan could have modified the precomp plane layers
> -// (ex. PlanStageProtected).
> -class PlanStagePrecomp : public Planner::PlanStage {
> - public:
> -  int ProvisionPlanes(std::vector<DrmCompositionPlane> *composition,
> -                      std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc *crtc,
> -                      std::vector<DrmPlane *> *planes);
> -};
> -
>  // This plan stage places as many layers on dedicated planes as possible (first
>  // come first serve), and then sticks the rest in a precomposition plane (if
>  // needed).
> diff --git a/platformdrmgeneric.cpp b/platformdrmgeneric.cpp
> index 82539676b229..5b42c4aed5a4 100644
> --- a/platformdrmgeneric.cpp
> +++ b/platformdrmgeneric.cpp
> @@ -27,7 +27,6 @@
>  #include <log/log.h>
>  #include <gralloc_handle.h>
>  #include <hardware/gralloc.h>
> -#include <EGL/eglext.h>
>  
>  namespace android {
>  
> @@ -84,22 +83,6 @@ uint32_t DrmGenericImporter::ConvertHalFormatToDrm(uint32_t hal_format) {
>    }
>  }
>  
> -EGLImageKHR DrmGenericImporter::ImportImage(EGLDisplay egl_display, buffer_handle_t handle) {
> -  gralloc_handle_t *gr_handle = gralloc_handle(handle);
> -  if (!gr_handle)
> -    return NULL;
> -  EGLint attr[] = {
> -    EGL_WIDTH, (EGLint)gr_handle->width,
> -    EGL_HEIGHT, (EGLint)gr_handle->height,
> -    EGL_LINUX_DRM_FOURCC_EXT, (EGLint)ConvertHalFormatToDrm(gr_handle->format),
> -    EGL_DMA_BUF_PLANE0_FD_EXT, gr_handle->prime_fd,
> -    EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0,
> -    EGL_DMA_BUF_PLANE0_PITCH_EXT, (EGLint)gr_handle->stride,
> -    EGL_NONE,
> -  };
> -  return eglCreateImageKHR(egl_display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL, attr);
> -}
> -
>  int DrmGenericImporter::ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) {
>    gralloc_handle_t *gr_handle = gralloc_handle(handle);
>    if (!gr_handle)
> diff --git a/platformdrmgeneric.h b/platformdrmgeneric.h
> index fbe059b49a92..0339e1e3957e 100644
> --- a/platformdrmgeneric.h
> +++ b/platformdrmgeneric.h
> @@ -31,7 +31,6 @@ class DrmGenericImporter : public Importer {
>  
>    int Init();
>  
> -  EGLImageKHR ImportImage(EGLDisplay egl_display, buffer_handle_t handle) override;
>    int ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) override;
>    int ReleaseBuffer(hwc_drm_bo_t *bo) override;
>  
> diff --git a/platformhisi.cpp b/platformhisi.cpp
> index 3f5c31995c57..1ea1d0776648 100644
> --- a/platformhisi.cpp
> +++ b/platformhisi.cpp
> @@ -69,27 +69,6 @@ int HisiImporter::Init() {
>    return 0;
>  }
>  
> -EGLImageKHR HisiImporter::ImportImage(EGLDisplay egl_display, buffer_handle_t handle) {
> -  private_handle_t const *hnd = reinterpret_cast < private_handle_t const *>(handle);
> -  if (!hnd)
> -    return NULL;
> -
> -  EGLint fmt = ConvertHalFormatToDrm(hnd->req_format);
> -  if (fmt < 0)
> -	return NULL;
> -
> -  EGLint attr[] = {
> -    EGL_WIDTH, hnd->width,
> -    EGL_HEIGHT, hnd->height,
> -    EGL_LINUX_DRM_FOURCC_EXT, fmt,
> -    EGL_DMA_BUF_PLANE0_FD_EXT, hnd->share_fd,
> -    EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0,
> -    EGL_DMA_BUF_PLANE0_PITCH_EXT, hnd->byte_stride,
> -    EGL_NONE,
> -  };
> -  return eglCreateImageKHR(egl_display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL, attr);
> -}
> -
>  int HisiImporter::ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) {
>    private_handle_t const *hnd = reinterpret_cast < private_handle_t const *>(handle);
>    if (!hnd)
> @@ -131,5 +110,3 @@ std::unique_ptr<Planner> Planner::CreateInstance(DrmResources *) {
>    return planner;
>  }
>  }
> -
> -
> diff --git a/platformhisi.h b/platformhisi.h
> index 46f459513dff..a0986923d4d3 100644
> --- a/platformhisi.h
> +++ b/platformhisi.h
> @@ -34,7 +34,6 @@ class HisiImporter : public DrmGenericImporter {
>  
>    int Init();
>  
> -  EGLImageKHR ImportImage(EGLDisplay egl_display, buffer_handle_t handle) override;
>    int ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) override;
>  
>   private:
> diff --git a/platformminigbm.cpp b/platformminigbm.cpp
> index 80e2c0f9f5fd..8e3cc65f0c4c 100644
> --- a/platformminigbm.cpp
> +++ b/platformminigbm.cpp
> @@ -66,22 +66,6 @@ int DrmMinigbmImporter::Init() {
>    return 0;
>  }
>  
> -EGLImageKHR DrmMinigbmImporter::ImportImage(EGLDisplay egl_display, buffer_handle_t handle) {
> -  cros_gralloc_handle *gr_handle = (cros_gralloc_handle *)handle;
> -  if (!gr_handle)
> -    return NULL;
> -  EGLint attr[] = {
> -    EGL_WIDTH, (EGLint)gr_handle->width,
> -    EGL_HEIGHT, (EGLint)gr_handle->height,
> -    EGL_LINUX_DRM_FOURCC_EXT, (EGLint)gr_handle->format,
> -    EGL_DMA_BUF_PLANE0_FD_EXT, gr_handle->fds[0],
> -    EGL_DMA_BUF_PLANE0_PITCH_EXT, (EGLint)gr_handle->strides[0],
> -    EGL_DMA_BUF_PLANE0_OFFSET_EXT, (EGLint)gr_handle->offsets[0],
> -    EGL_NONE,
> -  };
> -  return eglCreateImageKHR(egl_display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL, attr);
> -}
> -
>  int DrmMinigbmImporter::ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) {
>    cros_gralloc_handle *gr_handle = (cros_gralloc_handle *)handle;
>    if (!gr_handle)
> diff --git a/platformminigbm.h b/platformminigbm.h
> index ded4c077e178..f25bf7bc2d19 100644
> --- a/platformminigbm.h
> +++ b/platformminigbm.h
> @@ -32,7 +32,6 @@ class DrmMinigbmImporter : public DrmGenericImporter {
>  
>    int Init();
>  
> -  EGLImageKHR ImportImage(EGLDisplay egl_display, buffer_handle_t handle) override;
>    int ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) override;
>  
>   private:
> diff --git a/virtualcompositorworker.cpp b/virtualcompositorworker.cpp
> deleted file mode 100644
> index b64b4148ee50..000000000000
> --- a/virtualcompositorworker.cpp
> +++ /dev/null
> @@ -1,168 +0,0 @@
> -/*
> - * Copyright (C) 2015 The Android Open Source Project
> - *
> - * Licensed under the Apache License, Version 2.0 (the "License");
> - * you may not use this file except in compliance with the License.
> - * You may obtain a copy of the License at
> - *
> - *      http://www.apache.org/licenses/LICENSE-2.0
> - *
> - * Unless required by applicable law or agreed to in writing, software
> - * distributed under the License is distributed on an "AS IS" BASIS,
> - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
> - * See the License for the specific language governing permissions and
> - * limitations under the License.
> - */
> -
> -#define LOG_TAG "hwc-virtual-compositor-worker"
> -
> -#include "virtualcompositorworker.h"
> -#include "worker.h"
> -
> -#include <errno.h>
> -#include <stdlib.h>
> -
> -#include <log/log.h>
> -#include <hardware/hardware.h>
> -#include <hardware/hwcomposer.h>
> -#include <sched.h>
> -#include <sw_sync.h>
> -#include <sync/sync.h>
> -
> -namespace android {
> -
> -static const int kMaxQueueDepth = 3;
> -static const int kAcquireWaitTimeoutMs = 3000;
> -
> -VirtualCompositorWorker::VirtualCompositorWorker()
> -    : Worker("virtual-compositor", HAL_PRIORITY_URGENT_DISPLAY),
> -      timeline_fd_(-1),
> -      timeline_(0),
> -      timeline_current_(0) {
> -}
> -
> -VirtualCompositorWorker::~VirtualCompositorWorker() {
> -  if (timeline_fd_ >= 0) {
> -    FinishComposition(timeline_);
> -    close(timeline_fd_);
> -    timeline_fd_ = -1;
> -  }
> -}
> -
> -int VirtualCompositorWorker::Init() {
> -  int ret = sw_sync_timeline_create();
> -  if (ret < 0) {
> -    ALOGE("Failed to create sw sync timeline %d", ret);
> -    return ret;
> -  }
> -  timeline_fd_ = ret;
> -  return InitWorker();
> -}
> -
> -void VirtualCompositorWorker::QueueComposite(hwc_display_contents_1_t *dc) {
> -  std::unique_ptr<VirtualComposition> composition(new VirtualComposition);
> -
> -  composition->outbuf_acquire_fence.Set(dc->outbufAcquireFenceFd);
> -  dc->outbufAcquireFenceFd = -1;
> -  if (dc->retireFenceFd >= 0)
> -    close(dc->retireFenceFd);
> -  dc->retireFenceFd = CreateNextTimelineFence();
> -
> -  for (size_t i = 0; i < dc->numHwLayers; ++i) {
> -    hwc_layer_1_t *layer = &dc->hwLayers[i];
> -    if (layer->flags & HWC_SKIP_LAYER)
> -      continue;
> -    composition->layer_acquire_fences.emplace_back(layer->acquireFenceFd);
> -    layer->acquireFenceFd = -1;
> -    if (layer->releaseFenceFd >= 0)
> -      close(layer->releaseFenceFd);
> -    layer->releaseFenceFd = CreateNextTimelineFence();
> -  }
> -
> -  composition->release_timeline = timeline_;
> -
> -  Lock();
> -  while (composite_queue_.size() >= kMaxQueueDepth) {
> -    Unlock();
> -    sched_yield();
> -    Lock();
> -  }
> -
> -  composite_queue_.push(std::move(composition));
> -  Unlock();
> -  Signal();
> -}
> -
> -void VirtualCompositorWorker::Routine() {
> -  int wait_ret = 0;
> -
> -  Lock();
> -  if (composite_queue_.empty()) {
> -    wait_ret = WaitForSignalOrExitLocked();
> -  }
> -
> -  std::unique_ptr<VirtualComposition> composition;
> -  if (!composite_queue_.empty()) {
> -    composition = std::move(composite_queue_.front());
> -    composite_queue_.pop();
> -  }
> -  Unlock();
> -
> -  if (wait_ret == -EINTR) {
> -    return;
> -  } else if (wait_ret) {
> -    ALOGE("Failed to wait for signal, %d", wait_ret);
> -    return;
> -  }
> -
> -  Compose(std::move(composition));
> -}
> -
> -int VirtualCompositorWorker::CreateNextTimelineFence() {
> -  ++timeline_;
> -  return sw_sync_fence_create(timeline_fd_, "drm_fence", timeline_);
> -}
> -
> -int VirtualCompositorWorker::FinishComposition(int point) {
> -  int timeline_increase = point - timeline_current_;
> -  if (timeline_increase <= 0)
> -    return 0;
> -  int ret = sw_sync_timeline_inc(timeline_fd_, timeline_increase);
> -  if (ret)
> -    ALOGE("Failed to increment sync timeline %d", ret);
> -  else
> -    timeline_current_ = point;
> -  return ret;
> -}
> -
> -void VirtualCompositorWorker::Compose(
> -    std::unique_ptr<VirtualComposition> composition) {
> -  if (!composition.get())
> -    return;
> -
> -  int ret;
> -  int outbuf_acquire_fence = composition->outbuf_acquire_fence.get();
> -  if (outbuf_acquire_fence >= 0) {
> -    ret = sync_wait(outbuf_acquire_fence, kAcquireWaitTimeoutMs);
> -    if (ret) {
> -      ALOGE("Failed to wait for outbuf acquire %d/%d", outbuf_acquire_fence,
> -            ret);
> -      return;
> -    }
> -    composition->outbuf_acquire_fence.Close();
> -  }
> -  for (size_t i = 0; i < composition->layer_acquire_fences.size(); ++i) {
> -    int layer_acquire_fence = composition->layer_acquire_fences[i].get();
> -    if (layer_acquire_fence >= 0) {
> -      ret = sync_wait(layer_acquire_fence, kAcquireWaitTimeoutMs);
> -      if (ret) {
> -        ALOGE("Failed to wait for layer acquire %d/%d", layer_acquire_fence,
> -              ret);
> -        return;
> -      }
> -      composition->layer_acquire_fences[i].Close();
> -    }
> -  }
> -  FinishComposition(composition->release_timeline);
> -}
> -}
> diff --git a/virtualcompositorworker.h b/virtualcompositorworker.h
> deleted file mode 100644
> index 1fc5e435eaac..000000000000
> --- a/virtualcompositorworker.h
> +++ /dev/null
> @@ -1,56 +0,0 @@
> -/*
> - * Copyright (C) 2015 The Android Open Source Project
> - *
> - * Licensed under the Apache License, Version 2.0 (the "License");
> - * you may not use this file except in compliance with the License.
> - * You may obtain a copy of the License at
> - *
> - *      http://www.apache.org/licenses/LICENSE-2.0
> - *
> - * Unless required by applicable law or agreed to in writing, software
> - * distributed under the License is distributed on an "AS IS" BASIS,
> - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
> - * See the License for the specific language governing permissions and
> - * limitations under the License.
> - */
> -
> -#ifndef ANDROID_VIRTUAL_COMPOSITOR_WORKER_H_
> -#define ANDROID_VIRTUAL_COMPOSITOR_WORKER_H_
> -
> -#include "drmhwcomposer.h"
> -#include "worker.h"
> -
> -#include <queue>
> -
> -namespace android {
> -
> -class VirtualCompositorWorker : public Worker {
> - public:
> -  VirtualCompositorWorker();
> -  ~VirtualCompositorWorker() override;
> -
> -  int Init();
> -  void QueueComposite(hwc_display_contents_1_t *dc);
> -
> - protected:
> -  void Routine() override;
> -
> - private:
> -  struct VirtualComposition {
> -    UniqueFd outbuf_acquire_fence;
> -    std::vector<UniqueFd> layer_acquire_fences;
> -    int release_timeline;
> -  };
> -
> -  int CreateNextTimelineFence();
> -  int FinishComposition(int timeline);
> -  void Compose(std::unique_ptr<VirtualComposition> composition);
> -
> -  std::queue<std::unique_ptr<VirtualComposition>> composite_queue_;
> -  int timeline_fd_;
> -  int timeline_;
> -  int timeline_current_;
> -};
> -}
> -
> -#endif
> -- 
> 2.17.0
>