cc : Push layer lists instead of layer tree at commit and activation

cc/trees/layer_tree_impl.cc

 // Copyright 2011 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.
 
 #include "cc/trees/layer_tree_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 243 matching lines @@
 
 void LayerTreeImpl::SetRootLayer(std::unique_ptr<LayerImpl> layer) {
   if (root_layer_ && layer.get() != root_layer_)
     RemoveLayer(root_layer_->id());
   root_layer_ = layer.get();
   if (layer)
     AddLayer(std::move(layer));
   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
 
+void LayerTreeImpl::SetRootLayerFromLayerList() {
+  root_layer_ = layer_list_.empty() ? nullptr : layer_list_[0];
+  layer_tree_host_impl_->OnCanDrawStateChangedForTree();
+}
+
+void LayerTreeImpl::AddToLayerList(LayerImpl* layer) {
+  layer_list_.push_back(layer);
+}
+
+void LayerTreeImpl::ClearLayerList() {
+  layer_list_.clear();
+}
+
 void LayerTreeImpl::BuildLayerListForTesting() {
-  layer_list_.clear();
+  ClearLayerList();
   LayerListIterator<LayerImpl> it(root_layer_);
   for (; it != LayerListIterator<LayerImpl>(nullptr); ++it) {
-    layer_list_.push_back(*it);
+    AddToLayerList(*it);
   }
 }
 
 bool LayerTreeImpl::IsRootLayer(const LayerImpl* layer) const {
   return root_layer_ == layer;
 }
 
 LayerImpl* LayerTreeImpl::InnerViewportScrollLayer() const {
   return LayerById(inner_viewport_scroll_layer_id_);
 }
@@ skipping 21 matching lines @@
     offset += InnerViewportScrollLayer()->MaxScrollOffset();
 
   if (OuterViewportScrollLayer())
     offset += OuterViewportScrollLayer()->MaxScrollOffset();
 
   return offset;
 }
 
 std::unique_ptr<OwnedLayerImplList> LayerTreeImpl::DetachLayers() {
   root_layer_ = nullptr;
+  layer_list_.clear();
   render_surface_layer_list_.clear();
   set_needs_update_draw_properties();
   std::unique_ptr<OwnedLayerImplList> ret = std::move(layers_);
   layers_.reset(new OwnedLayerImplList);
   return ret;
 }
 
 static void UpdateClipTreeForBoundsDeltaOnLayer(LayerImpl* layer,
                                                 ClipTree* clip_tree) {
   if (layer && layer->masks_to_bounds()) {
@@ skipping 117 matching lines @@
 void LayerTreeImpl::MoveChangeTrackingToLayers() {
   // We need to update the change tracking on property trees before we move it
   // onto the layers.
   property_trees_.UpdateChangeTracking();
   for (auto* layer : *this) {
     if (layer->LayerPropertyChanged())
       layer->NoteLayerPropertyChanged();
   }
 }
 
-LayerListIterator<LayerImpl> LayerTreeImpl::begin() const {
-  return LayerListIterator<LayerImpl>(root_layer_);
+LayerImplList::const_iterator LayerTreeImpl::begin() const {
+  return layer_list_.cbegin();
 }
 
-LayerListIterator<LayerImpl> LayerTreeImpl::end() const {
-  return LayerListIterator<LayerImpl>(nullptr);
+LayerImplList::const_iterator LayerTreeImpl::end() const {
+  return layer_list_.cend();
 }
 
-LayerListReverseIterator<LayerImpl> LayerTreeImpl::rbegin() {
-  return LayerListReverseIterator<LayerImpl>(root_layer_);
+LayerImplList::reverse_iterator LayerTreeImpl::rbegin() {
+  return layer_list_.rbegin();
 }
 
-LayerListReverseIterator<LayerImpl> LayerTreeImpl::rend() {
-  return LayerListReverseIterator<LayerImpl>(nullptr);
+LayerImplList::reverse_iterator LayerTreeImpl::rend() {
+  return layer_list_.rend();
 }
 
 void LayerTreeImpl::AddToElementMap(LayerImpl* layer) {
   if (!layer->element_id() || !layer->mutable_properties())
     return;
 
   TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "LayerTreeImpl::AddToElementMap", "element_id",
                layer->element_id(), "layer_id", layer->id());
 
@@ skipping 1029 matching lines @@
   clip_scroll_map_.erase(layer->scroll_clip_layer_id());
 }
 
 void LayerTreeImpl::AddSurfaceLayer(LayerImpl* layer) {
   DCHECK(std::find(surface_layers_.begin(), surface_layers_.end(), layer) ==
          surface_layers_.end());
   surface_layers_.push_back(layer);
 }
 
 void LayerTreeImpl::RemoveSurfaceLayer(LayerImpl* layer) {
-  std::vector<LayerImpl*>::iterator it =
+  LayerImplList::iterator it =
       std::find(surface_layers_.begin(), surface_layers_.end(), layer);
   DCHECK(it != surface_layers_.end());
   surface_layers_.erase(it);
 }
 
 template <typename LayerType>
 static inline bool LayerClipsSubtree(LayerType* layer) {
   return layer->masks_to_bounds() || layer->mask_layer();
 }
 
@@ skipping 540 matching lines @@
 }
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   for (auto* layer : *this)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc