Revert "Revert 253606 "Revert 251238 "cc: Clean up iterator template to ...""

cc/layers/layer_iterator.h

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CC_LAYERS_LAYER_ITERATOR_H_
 #define CC_LAYERS_LAYER_ITERATOR_H_
 
+#include "base/memory/ref_counted.h"
 #include "cc/base/cc_export.h"
 #include "cc/trees/layer_tree_host_common.h"
 
 namespace cc {
 
 // These classes provide means to iterate over the
 // RenderSurface-Layer tree.
 
 // Example code follows, for a tree of Layer/RenderSurface objects.
 // See below for details.
 //
 // void DoStuffOnLayers(
 //     const RenderSurfaceLayerList& render_surface_layer_list) {
-//   typedef LayerIterator<Layer> LayerIteratorType;
+//   typedef LayerIterator<Layer,
+//                         RenderSurfaceLayerList,
+//                         RenderSurface,
+//                         LayerIteratorActions::FrontToBack>
+//       LayerIteratorType;
 //
 //   LayerIteratorType end =
 //       LayerIteratorType::End(&render_surface_layer_list);
 //   for (LayerIteratorType
 //            it = LayerIteratorType::Begin(&render_surface_layer_list);
 //        it != end;
 //        ++it) {
 //     // Only one of these will be true
 //     if (it.represents_target_render_surface())
 //       foo(*it);  // *it is a layer representing a target RenderSurface
@@ skipping 61 matching lines @@
 template <typename LayerType> struct LayerIteratorPosition {
   bool represents_target_render_surface;
   bool represents_contributing_render_surface;
   bool represents_itself;
   LayerType* target_render_surface_layer;
   LayerType* current_layer;
 };
 
 // An iterator class for walking over layers in the
 // RenderSurface-Layer tree.
-template <typename LayerType>
+template <typename LayerType,
+          typename LayerList,
+          typename RenderSurfaceType,
+          typename IteratorActionType>
 class LayerIterator {
-  typedef LayerIterator<LayerType> LayerIteratorType;
-  typedef typename LayerType::RenderSurfaceListType LayerList;
-  typedef typename LayerType::RenderSurfaceType RenderSurfaceType;
+  typedef LayerIterator<LayerType,
+                        LayerList,
+                        RenderSurfaceType,
+                        IteratorActionType> LayerIteratorType;
 
  public:
   LayerIterator() : render_surface_layer_list_(NULL) {}
 
   static LayerIteratorType Begin(const LayerList* render_surface_layer_list) {
     return LayerIteratorType(render_surface_layer_list, true);
   }
   static LayerIteratorType End(const LayerList* render_surface_layer_list) {
     return LayerIteratorType(render_surface_layer_list, false);
   }
 
   LayerIteratorType& operator++() {
-    MoveToNext();
+    actions_.Next(this);
     return *this;
   }
   bool operator==(const LayerIterator& other) const {
     return target_render_surface_layer_index_ ==
            other.target_render_surface_layer_index_ &&
            current_layer_index_ == other.current_layer_index_;
   }
   bool operator!=(const LayerIteratorType& other) const {
     return !(*this == other);
   }
@@ skipping 29 matching lines @@
     return position;
   }
 
  private:
   LayerIterator(const LayerList* render_surface_layer_list, bool start)
       : render_surface_layer_list_(render_surface_layer_list),
         target_render_surface_layer_index_(0) {
     for (size_t i = 0; i < render_surface_layer_list->size(); ++i) {
       if (!render_surface_layer_list->at(i)->render_surface()) {
         NOTREACHED();
-        MoveToEnd();
+        actions_.End(this);
         return;
       }
     }
 
     if (start && !render_surface_layer_list->empty())
-      MoveToBegin();
+      actions_.Begin(this);
     else
-      MoveToEnd();
-  }
-
-  void MoveToBegin() {
-    target_render_surface_layer_index_ = 0;
-    current_layer_index_ = target_render_surface_children().size() - 1;
-    MoveToHighestInSubtree();
-  }
-
-  void MoveToEnd() {
-    target_render_surface_layer_index_ =
-        LayerIteratorValue::kInvalidTargetRenderSurfaceLayerIndex;
-    current_layer_index_ = 0;
-  }
-
-  void MoveToNext() {
-    // Moves to the previous layer in the current RS layer list.
-    // Then we check if the new current layer has its own RS,
-    // in which case there are things in that RS layer list that are higher,
-    // so we find the highest layer in that subtree.
-    // If we move back past the front of the list,
-    // we jump up to the previous RS layer list, picking up again where we
-    // had previously recursed into the current RS layer list.
-
-    if (!current_layer_represents_target_render_surface()) {
-      // Subtracting one here will eventually cause the current layer
-      // to become that layer representing the target render surface.
-      --current_layer_index_;
-      MoveToHighestInSubtree();
-    } else {
-      while (current_layer_represents_target_render_surface()) {
-        if (!target_render_surface_layer_index_) {
-          // End of the list.
-          target_render_surface_layer_index_ =
-              LayerIteratorValue::kInvalidTargetRenderSurfaceLayerIndex;
-          current_layer_index_ = 0;
-          return;
-        }
-        target_render_surface_layer_index_ =
-            target_render_surface()->target_render_surface_layer_index_history_;
-        current_layer_index_ =
-            target_render_surface()->current_layer_index_history_;
-      }
-    }
-  }
-
-  void MoveToHighestInSubtree() {
-    if (current_layer_represents_target_render_surface())
-      return;
-    while (current_layer_represents_contributing_render_surface()) {
-      // Save where we were in the current target surface, move to the next one,
-      // and save the target surface that we came from there
-      // so we can go back to it.
-      target_render_surface()->current_layer_index_history_ =
-          current_layer_index_;
-      int previous_target_render_surface_layer =
-          target_render_surface_layer_index_;
-
-      for (LayerType* layer = current_layer();
-           target_render_surface_layer() != layer;
-           ++target_render_surface_layer_index_) {
-      }
-      current_layer_index_ = target_render_surface_children().size() - 1;
-
-      target_render_surface()->target_render_surface_layer_index_history_ =
-          previous_target_render_surface_layer;
-    }
+      actions_.End(this);
   }
 
   inline LayerType* current_layer() const {
     return current_layer_represents_target_render_surface()
            ? target_render_surface_layer()
            : target_render_surface_children().at(current_layer_index_);
   }
 
   inline bool current_layer_represents_contributing_render_surface() const {
     return LayerTreeHostCommon::RenderSurfaceContributesToTarget<LayerType>(
         current_layer(), target_render_surface_layer()->id());
   }
   inline bool current_layer_represents_target_render_surface() const {
     return current_layer_index_ ==
            LayerIteratorValue::kLayerIndexRepresentingTargetRenderSurface;
   }
 
   inline RenderSurfaceType* target_render_surface() const {
     return target_render_surface_layer()->render_surface();
   }
   inline const LayerList& target_render_surface_children() const {
     return target_render_surface()->layer_list();
   }
 
+  IteratorActionType actions_;
   const LayerList* render_surface_layer_list_;
 
   // The iterator's current position.
 
   // A position in the render_surface_layer_list. This points to a layer which
   // owns the current target surface. This is a value from 0 to n-1
   // (n = size of render_surface_layer_list = number of surfaces).
   // A value outside of this range
   // (for example, LayerIteratorValue::kInvalidTargetRenderSurfaceLayerIndex)
   // is used to indicate a position outside the bounds of the tree.
   int target_render_surface_layer_index_;
   // A position in the list of layers that are children of the
   // current target surface. When pointing to one of these layers,
   // this is a value from 0 to n-1 (n = number of children).
   // Since the iterator must also stop at the layers representing
   // the target surface, this is done by setting the current_layerIndex
   // to a value of LayerIteratorValue::LayerRepresentingTargetRenderSurface.
   int current_layer_index_;
+
+  friend struct LayerIteratorActions;
+};
+
+// Orderings for iterating over the RenderSurface-Layer tree.
+struct CC_EXPORT LayerIteratorActions {
+  // Walks layers sorted by z-order from front to back
+  class CC_EXPORT FrontToBack {
+   public:
+    template <typename LayerType,
+              typename LayerList,
+              typename RenderSurfaceType,
+              typename ActionType>
+    void Begin(
+        LayerIterator<LayerType, LayerList, RenderSurfaceType, ActionType>* it);
+
+    template <typename LayerType,
+              typename LayerList,
+              typename RenderSurfaceType,
+              typename ActionType>
+    void End(
+        LayerIterator<LayerType, LayerList, RenderSurfaceType, ActionType>* it);
+
+    template <typename LayerType,
+              typename LayerList,
+              typename RenderSurfaceType,
+              typename ActionType>
+    void Next(
+        LayerIterator<LayerType, LayerList, RenderSurfaceType, ActionType>* it);
+
+   private:
+    template <typename LayerType,
+              typename LayerList,
+              typename RenderSurfaceType,
+              typename ActionType>
+    void GoToHighestInSubtree(
+        LayerIterator<LayerType, LayerList, RenderSurfaceType, ActionType>* it);
+  };
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_ITERATOR_H_