1 files changed, 37 insertions, 76 deletions

diff --git a/compositor/Planner.h b/compositor/Planner.h
index 09034ff..7802d0c 100644
--- a/compositor/Planner.h
+++ b/compositor/Planner.h
@@ -21,6 +21,7 @@
 #include <hardware/hwcomposer.h>
 
 #include <map>
+#include <memory>
 #include <vector>
 
 #include "compositor/DrmDisplayComposition.h"
@@ -31,59 +32,46 @@ namespace android {
 class DrmDevice;
 
 class Planner {
- public:
-  class PlanStage {
-   public:
-    virtual ~PlanStage() {
-    }
-
-    virtual int ProvisionPlanes(std::vector<DrmCompositionPlane> *composition,
-                                std::map<size_t, DrmHwcLayer *> &layers,
-                                DrmCrtc *crtc,
-                                std::vector<DrmPlane *> *planes) = 0;
+ private:
+  // Removes and returns the next available plane from planes
+  static DrmPlane *PopPlane(std::vector<DrmPlane *> *planes) {
+    if (planes->empty())
+      return nullptr;
+    DrmPlane *plane = planes->front();
+    planes->erase(planes->begin());
+    return plane;
+  }
 
-   protected:
-    // Removes and returns the next available plane from planes
-    static DrmPlane *PopPlane(std::vector<DrmPlane *> *planes) {
-      if (planes->empty())
-        return NULL;
-      DrmPlane *plane = planes->front();
-      planes->erase(planes->begin());
-      return plane;
+  // Inserts the given layer:plane in the composition at the back
+  static int Emplace(std::vector<DrmCompositionPlane> *composition,
+                     std::vector<DrmPlane *> *planes,
+                     std::pair<size_t, DrmHwcLayer *> layer) {
+    DrmPlane *plane = PopPlane(planes);
+    std::vector<DrmPlane *> unused_planes;
+    int ret = -ENOENT;
+    while (plane != nullptr) {
+      ret = plane->IsValidForLayer(layer.second) ? 0 : -EINVAL;
+      if (ret == 0)
+        break;
+      if (!plane->GetZPosProperty().is_immutable())
+        unused_planes.push_back(plane);
+      plane = PopPlane(planes);
     }
 
-    static int ValidatePlane(DrmPlane *plane, DrmHwcLayer *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,
-                       std::pair<size_t, DrmHwcLayer *> layer) {
-      DrmPlane *plane = PopPlane(planes);
-      std::vector<DrmPlane *> unused_planes;
-      int ret = -ENOENT;
-      while (plane) {
-        ret = ValidatePlane(plane, layer.second);
-        if (!ret)
-          break;
-        if (!plane->zpos_property().is_immutable())
-          unused_planes.push_back(plane);
-        plane = PopPlane(planes);
-      }
-
-      if (!ret) {
-        composition->emplace_back(type, plane, crtc, layer.first);
-        planes->insert(planes->begin(), unused_planes.begin(),
-                       unused_planes.end());
-      }
-
-      return ret;
+    if (ret == 0) {
+      composition->emplace_back(plane, layer.first);
+      planes->insert(planes->begin(), unused_planes.begin(),
+                     unused_planes.end());
     }
-  };
 
-  // Creates a planner instance with platform-specific planning stages
-  static std::unique_ptr<Planner> CreateInstance(DrmDevice *drm);
+    return ret;
+  }
+
+  static int ProvisionPlanesInternal(
+      std::vector<DrmCompositionPlane> *composition,
+      std::map<size_t, DrmHwcLayer *> &layers, std::vector<DrmPlane *> *planes);
 
+ public:
   // Takes a stack of layers and provisions hardware planes for them. If the
   // entire stack can't fit in hardware, FIXME
   //
@@ -93,42 +81,15 @@ class Planner {
   //
   // 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(
+  static std::tuple<int, std::vector<DrmCompositionPlane>> ProvisionPlanes(
       std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc *crtc,
       std::vector<DrmPlane *> *primary_planes,
       std::vector<DrmPlane *> *overlay_planes);
 
-  template <typename T, typename... A>
-  void AddStage(A &&... args) {
-    stages_.emplace_back(
-        std::unique_ptr<PlanStage>(new T(std::forward(args)...)));
-  }
-
  private:
-  std::vector<DrmPlane *> GetUsablePlanes(
+  static std::vector<DrmPlane *> GetUsablePlanes(
       DrmCrtc *crtc, std::vector<DrmPlane *> *primary_planes,
       std::vector<DrmPlane *> *overlay_planes);
-
-  std::vector<std::unique_ptr<PlanStage>> stages_;
-};
-
-// This plan stage extracts all protected layers and places them on dedicated
-// planes.
-class PlanStageProtected : 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).
-class PlanStageGreedy : public Planner::PlanStage {
- public:
-  int ProvisionPlanes(std::vector<DrmCompositionPlane> *composition,
-                      std::map<size_t, DrmHwcLayer *> &layers, DrmCrtc *crtc,
-                      std::vector<DrmPlane *> *planes);
 };
 }  // namespace android
 #endif