diff --git a/compositor/Planner.cpp b/compositor/Planner.cpp
index fd9678c..6c0785a 100644
--- a/compositor/Planner.cpp
+++ b/compositor/Planner.cpp
@@ -27,7 +27,6 @@
 
 std::unique_ptr<Planner> Planner::CreateInstance(DrmDevice * /*device*/) {
   std::unique_ptr<Planner> planner(new Planner);
-  planner->AddStage<PlanStageGreedy>();
   return planner;
 }
 
@@ -57,40 +56,16 @@
   }
 
   // Go through the provisioning stages and provision planes
-  for (auto &i : stages_) {
-    int ret = i->ProvisionPlanes(&composition, layers, &planes);
-    if (ret) {
-      ALOGV("Failed provision stage with ret %d", ret);
-      return std::make_tuple(ret, std::vector<DrmCompositionPlane>());
-    }
+  int ret = ProvisionPlanesInternal(&composition, layers, &planes);
+  if (ret) {
+    ALOGV("Failed provision stage with ret %d", ret);
+    return std::make_tuple(ret, std::vector<DrmCompositionPlane>());
   }
 
   return std::make_tuple(0, std::move(composition));
 }
 
-int PlanStageProtected::ProvisionPlanes(
-    std::vector<DrmCompositionPlane> *composition,
-    std::map<size_t, DrmHwcLayer *> &layers, std::vector<DrmPlane *> *planes) {
-  int ret = 0;
-  for (auto i = layers.begin(); i != layers.end();) {
-    if (!i->second->protected_usage()) {
-      ++i;
-      continue;
-    }
-
-    ret = Emplace(composition, planes, std::make_pair(i->first, i->second));
-    if (ret) {
-      ALOGE("Failed to dedicate protected layer! Dropping it.");
-      return ret;
-    }
-
-    i = layers.erase(i);
-  }
-
-  return 0;
-}
-
-int PlanStageGreedy::ProvisionPlanes(
+int Planner::ProvisionPlanesInternal(
     std::vector<DrmCompositionPlane> *composition,
     std::map<size_t, DrmHwcLayer *> &layers, std::vector<DrmPlane *> *planes) {
   // Fill up the remaining planes
diff --git a/compositor/Planner.h b/compositor/Planner.h
index b54a9be..ff059f5 100644
--- a/compositor/Planner.h
+++ b/compositor/Planner.h
@@ -32,53 +32,47 @@
 class DrmDevice;
 
 class Planner {
+ private:
+  // 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) {
+      ret = plane->IsValidForLayer(layer.second) ? 0 : -EINVAL;
+      if (!ret)
+        break;
+      if (!plane->zpos_property().is_immutable())
+        unused_planes.push_back(plane);
+      plane = PopPlane(planes);
+    }
+
+    if (!ret) {
+      composition->emplace_back(plane, layer.first);
+      planes->insert(planes->begin(), unused_planes.begin(),
+                     unused_planes.end());
+    }
+
+    return ret;
+  }
+
+  int ProvisionPlanesInternal(std::vector<DrmCompositionPlane> *composition,
+                              std::map<size_t, DrmHwcLayer *> &layers,
+                              std::vector<DrmPlane *> *planes);
+
  public:
-  class PlanStage {
-   public:
-    virtual ~PlanStage() {
-    }
-
-    virtual int ProvisionPlanes(std::vector<DrmCompositionPlane> *composition,
-                                std::map<size_t, DrmHwcLayer *> &layers,
-                                std::vector<DrmPlane *> *planes) = 0;
-
-   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) {
-        ret = plane->IsValidForLayer(layer.second) ? 0 : -EINVAL;
-        if (!ret)
-          break;
-        if (!plane->zpos_property().is_immutable())
-          unused_planes.push_back(plane);
-        plane = PopPlane(planes);
-      }
-
-      if (!ret) {
-        composition->emplace_back(plane, layer.first);
-        planes->insert(planes->begin(), unused_planes.begin(),
-                       unused_planes.end());
-      }
-
-      return ret;
-    }
-  };
-
-  // Creates a planner instance with platform-specific planning stages
+  // Creates a planner instance
   static std::unique_ptr<Planner> CreateInstance(DrmDevice *drm);
 
   // Takes a stack of layers and provisions hardware planes for them. If the
@@ -95,37 +89,10 @@
       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(
       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,
-                      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,
-                      std::vector<DrmPlane *> *planes);
 };
 }  // namespace android
 #endif