cc: Add a main thread LayerListIterator

cc/layers/layer_list_iterator.cc

Index: cc/layers/layer_list_iterator.cc
diff --git a/cc/layers/layer_list_iterator.cc b/cc/layers/layer_list_iterator.cc
index e71238d602092766301981cd246d4f1d18a8f633..ec7289937777037fe6053e2710c8732f1ff422c5 100644
--- a/cc/layers/layer_list_iterator.cc
+++ b/cc/layers/layer_list_iterator.cc
@@ -4,42 +4,45 @@
 
 #include "cc/layers/layer_list_iterator.h"
 
+#include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 
 namespace cc {
 
-LayerListIterator::LayerListIterator(LayerImpl* root_layer)
+template <typename LayerType>
+LayerListIterator<LayerType>::LayerListIterator(LayerType* root_layer)
     : current_layer_(root_layer) {
   DCHECK(!root_layer || !root_layer->parent());
   list_indices_.push_back(0);
 }
 
-LayerListIterator::LayerListIterator(const LayerListIterator& other) = default;
+template <typename LayerType>
+LayerListIterator<LayerType>::LayerListIterator(
+    const LayerListIterator<LayerType>& other) = default;
 
-LayerListIterator::~LayerListIterator() {}
+template <typename LayerType>
+LayerListIterator<LayerType>::~LayerListIterator() {}
 
-LayerListIterator& LayerListIterator::operator++() {
+template <typename LayerType>
+LayerListIterator<LayerType>& LayerListIterator<LayerType>::operator++() {
   // case 0: done
   if (!current_layer_)
     return *this;
 
   // case 1: descend.
-  const LayerImplList& current_list = current_layer_->children();
-  if (!current_list.empty()) {
-    current_layer_ = current_list[0];
+  if (!current_layer_->children().empty()) {
+    current_layer_ = current_layer_->child_at(0);
     list_indices_.push_back(0);
     return *this;
   }
 
-  for (LayerImpl* parent = current_layer_->parent(); parent;
+  for (LayerType* parent = current_layer_->parent(); parent;
        parent = parent->parent()) {
     // We now try and advance in some list of siblings.
-    const LayerImplList& sibling_list = parent->children();
-
     // case 2: Advance to a sibling.
-    if (list_indices_.back() + 1 < sibling_list.size()) {
+    if (list_indices_.back() + 1 < parent->children().size()) {
       ++list_indices_.back();
-      current_layer_ = sibling_list[list_indices_.back()];
+      current_layer_ = parent->child_at(list_indices_.back());
       return *this;
     }
 
@@ -51,48 +54,58 @@ LayerListIterator& LayerListIterator::operator++() {
   return *this;
 }
 
-LayerListReverseIterator::LayerListReverseIterator(LayerImpl* root_layer)
-    : LayerListIterator(root_layer) {
+template <typename LayerType>
+LayerListReverseIterator<LayerType>::LayerListReverseIterator(
+    LayerType* root_layer)
+    : LayerListIterator<LayerType>(root_layer) {
   DescendToRightmostInSubtree();
 }
 
-LayerListReverseIterator::~LayerListReverseIterator() {}
+template <typename LayerType>
+LayerListReverseIterator<LayerType>::~LayerListReverseIterator() {}
 
 // We will only support prefix increment.
-LayerListIterator& LayerListReverseIterator::operator++() {
+template <typename LayerType>
+LayerListIterator<LayerType>& LayerListReverseIterator<LayerType>::
+operator++() {
   // case 0: done
-  if (!current_layer_)
+  if (!current_layer())
     return *this;
 
   // case 1: we're the leftmost sibling.
-  if (!list_indices_.back()) {
-    list_indices_.pop_back();
-    current_layer_ = current_layer_->parent();
+  if (!list_indices().back()) {
+    list_indices().pop_back();
+    this->current_layer_ = current_layer()->parent();
     return *this;
   }
 
   // case 2: we're not the leftmost sibling. In this case, we want to move one
   // sibling over, and then descend to the rightmost descendant in that subtree.
-  CHECK(current_layer_->parent());
-  --list_indices_.back();
-  const LayerImplList& parent_list = current_layer_->parent()->children();
-  current_layer_ = parent_list[list_indices_.back()];
+  CHECK(current_layer()->parent());
+  --list_indices().back();
+  this->current_layer_ =
+      current_layer()->parent()->child_at(list_indices().back());
   DescendToRightmostInSubtree();
   return *this;
 }
 
-void LayerListReverseIterator::DescendToRightmostInSubtree() {
-  if (!current_layer_)
+template <typename LayerType>
+void LayerListReverseIterator<LayerType>::DescendToRightmostInSubtree() {
+  if (!current_layer())
     return;
 
-  const LayerImplList& current_list = current_layer_->children();
-  if (current_list.empty())
+  if (current_layer()->children().empty())
     return;
 
-  size_t last_index = current_list.size() - 1;
-  current_layer_ = current_list[last_index];
-  list_indices_.push_back(last_index);
+  size_t last_index = current_layer()->children().size() - 1;
+  this->current_layer_ = current_layer()->child_at(last_index);
+  list_indices().push_back(last_index);
   DescendToRightmostInSubtree();
 }
 
+template class LayerListIterator<Layer>;
+template class LayerListIterator<LayerImpl>;
+template class LayerListReverseIterator<Layer>;
+template class LayerListReverseIterator<LayerImpl>;
+
 }  // namespace cc