cc: Clean up iterator template to only take 1 parameter.

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,
-//                         RenderSurfaceLayerList,
-//                         RenderSurface,
-//                         LayerIteratorActions::FrontToBack>
-//       LayerIteratorType;
+//   typedef LayerIterator<Layer> 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,
-          typename LayerList,
-          typename RenderSurfaceType,
-          typename IteratorActionType>
+template <typename LayerType>
 class LayerIterator {
-  typedef LayerIterator<LayerType,
-                        LayerList,
-                        RenderSurfaceType,
-                        IteratorActionType> LayerIteratorType;
+  typedef LayerIterator<LayerType> LayerIteratorType;
+  typedef typename LayerType::RenderSurfaceListType LayerList;
+  typedef typename LayerType::RenderSurfaceType RenderSurfaceType;
 
  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++() {
-    actions_.Next(this);
+    MoveToNext();
     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();
-        actions_.End(this);
+        MoveToEnd();
         return;
       }
     }
 
     if (start && !render_surface_layer_list->empty())
-      actions_.Begin(this);
+      MoveToBegin();
     else
-      actions_.End(this);
+      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;
+    }
   }
 
   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_