cc: Replace LayerIterator with iterator that walks layer list and effect tree

cc/layers/layer_iterator.h

Index: cc/layers/layer_iterator.h
diff --git a/cc/layers/layer_iterator.h b/cc/layers/layer_iterator.h
deleted file mode 100644
index 4a6cbb3a397583de6baa8edd2b92fbfcca9600e4..0000000000000000000000000000000000000000
--- a/cc/layers/layer_iterator.h
+++ /dev/null
@@ -1,291 +0,0 @@
-// 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 <stddef.h>
-
-#include "cc/cc_export.h"
-#include "cc/layers/layer_impl.h"
-#include "cc/trees/layer_tree_host_common.h"
-
-namespace cc {
-
-// These classes provide means to iterate over the
-// RenderSurfaceImpl-LayerImpl tree.
-
-// Example code follows, for a tree of LayerImpl/RenderSurfaceImpl objects.
-// See below for details.
-//
-// void DoStuffOnLayers(
-//     const LayerImplList& render_surface_layer_list) {
-//
-//   LayerIterator end =
-//       LayerIterator::End(&render_surface_layer_list);
-//   for (LayerIterator
-//            it = LayerIterator::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
-//     if (it.represents_contributing_render_surface())
-//       bar(*it);  // *it is a layer representing a RenderSurface that
-//                  // contributes to the layer's target RenderSurface
-//     if (it.represents_itself())
-//       baz(*it);  // *it is a layer representing itself,
-//                  // as it contributes to its own target RenderSurface
-//   }
-// }
-
-// A RenderSurface R may be referred to in one of two different contexts.
-// One RenderSurface is "current" at any time, for whatever operation
-// is being performed. This current surface is referred to as a target surface.
-// For example, when R is being painted it would be the target surface.
-// Once R has been painted, its contents may be included into another
-// surface S. While S is considered the target surface when it is being
-// painted, R is called a contributing surface in this context as it
-// contributes to the content of the target surface S.
-//
-// The iterator's current position in the tree always points to some layer.
-// The state of the iterator indicates the role of the layer,
-// and will be one of the following three states.
-// A single layer L will appear in the iteration process in at least one,
-// and possibly all, of these states.
-// 1. Representing the target surface: The iterator in this state,
-// pointing at layer L, indicates that the target RenderSurface
-// is now the surface owned by L. This will occur exactly once for each
-// RenderSurface in the tree.
-// 2. Representing a contributing surface: The iterator in this state,
-// pointing at layer L, refers to the RenderSurface owned
-// by L as a contributing surface, without changing the current
-// target RenderSurface.
-// 3. Representing itself: The iterator in this state, pointing at layer L,
-// refers to the layer itself, as a child of the
-// current target RenderSurface.
-//
-// The FrontToBack iterator will iterate over children layers of a surface
-// before the layer representing the surface as a target surface.
-//
-// To use the iterators:
-//
-// Create a stepping iterator and end iterator by calling
-// LayerIterator::Begin() and LayerIterator::End() and passing in the
-// list of layers owning target RenderSurfaces. Step through the tree
-// by incrementing the stepping iterator while it is != to
-// the end iterator. At each step the iterator knows what the layer
-// is representing, and you can query the iterator to decide
-// what actions to perform with the layer given what it represents.
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct LayerIteratorValue {
-  static const int kInvalidTargetRenderSurfaceLayerIndex = -1;
-  // This must be (size_t)-1 since the iterator action code assumes that this
-  // value can be reached by subtracting one from the position of the first
-  // layer in the current target surface's child layer list, which is 0.
-  static const size_t kLayerIndexRepresentingTargetRenderSurface =
-      static_cast<size_t>(-1);
-};
-
-// The position of a layer iterator that is independent
-// of its many template types.
-struct LayerIteratorPosition {
-  bool represents_target_render_surface;
-  bool represents_contributing_render_surface;
-  bool represents_itself;
-  LayerImpl* target_render_surface_layer;
-  LayerImpl* current_layer;
-};
-
-// An iterator class for walking over layers in the
-// RenderSurface-Layer tree.
-// TODO(enne): This class probably shouldn't be entirely inline and
-// should get moved to a .cc file where it makes sense.
-class LayerIterator {
- public:
-  LayerIterator() : render_surface_layer_list_(nullptr) {}
-
-  static LayerIterator Begin(const LayerImplList* render_surface_layer_list) {
-    return LayerIterator(render_surface_layer_list, true);
-  }
-  static LayerIterator End(const LayerImplList* render_surface_layer_list) {
-    return LayerIterator(render_surface_layer_list, false);
-  }
-
-  LayerIterator& operator++() {
-    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 LayerIterator& other) const {
-    return !(*this == other);
-  }
-
-  LayerImpl* operator->() const { return current_layer(); }
-  LayerImpl* operator*() const { return current_layer(); }
-
-  bool represents_target_render_surface() const {
-    return current_layer_represents_target_render_surface();
-  }
-  bool represents_contributing_render_surface() const {
-    return !represents_target_render_surface() &&
-           current_layer_represents_contributing_render_surface();
-  }
-  bool represents_itself() const {
-    return !represents_target_render_surface() &&
-           !represents_contributing_render_surface();
-  }
-
-  LayerImpl* target_render_surface_layer() const {
-    return render_surface_layer_list_->at(target_render_surface_layer_index_);
-  }
-
-  operator const LayerIteratorPosition() const {
-    LayerIteratorPosition position;
-    position.represents_target_render_surface =
-        represents_target_render_surface();
-    position.represents_contributing_render_surface =
-        represents_contributing_render_surface();
-    position.represents_itself = represents_itself();
-    position.target_render_surface_layer = target_render_surface_layer();
-    position.current_layer = current_layer();
-    return position;
-  }
-
- private:
-  LayerIterator(const LayerImplList* 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)->GetRenderSurface()) {
-        NOTREACHED();
-        MoveToEnd();
-        return;
-      }
-    }
-
-    if (start && !render_surface_layer_list->empty())
-      MoveToBegin();
-    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 (LayerImpl* 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 LayerImpl* 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 {
-    RenderSurfaceImpl* render_surface = current_layer()->GetRenderSurface();
-    return render_surface && render_surface != target_render_surface();
-  }
-  inline bool current_layer_represents_target_render_surface() const {
-    return current_layer_index_ ==
-           LayerIteratorValue::kLayerIndexRepresentingTargetRenderSurface;
-  }
-
-  inline RenderSurfaceImpl* target_render_surface() const {
-    return target_render_surface_layer()->GetRenderSurface();
-  }
-  inline const LayerImplList& target_render_surface_children() const {
-    return target_render_surface()->layer_list();
-  }
-
-  const LayerImplList* 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_layer_index
-  // to a value of
-  // LayerIteratorValue::kLayerIndexRepresentingTargetRenderSurface.
-  size_t current_layer_index_;
-};
-
-}  // namespace cc
-
-#endif  // CC_LAYERS_LAYER_ITERATOR_H_