cc: Clean up root_layer code in LTI

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 37 matching lines @@
 namespace cc {
 
 LayerTreeImpl::LayerTreeImpl(
     LayerTreeHostImpl* layer_tree_host_impl,
     scoped_refptr<SyncedProperty<ScaleGroup>> page_scale_factor,
     scoped_refptr<SyncedTopControls> top_controls_shown_ratio,
     scoped_refptr<SyncedElasticOverscroll> elastic_overscroll)
     : layer_tree_host_impl_(layer_tree_host_impl),
       source_frame_number_(-1),
       is_first_frame_after_commit_tracker_(-1),
-      root_layer_(nullptr),
+      root_layer_for_testing_(nullptr),
       hud_layer_(nullptr),
       background_color_(0),
       has_transparent_background_(false),
       last_scrolled_layer_id_(Layer::INVALID_ID),
       overscroll_elasticity_layer_id_(Layer::INVALID_ID),
       page_scale_layer_id_(Layer::INVALID_ID),
       inner_viewport_scroll_layer_id_(Layer::INVALID_ID),
       outer_viewport_scroll_layer_id_(Layer::INVALID_ID),
       page_scale_factor_(page_scale_factor),
       min_page_scale_factor_(0),
@@ skipping 185 matching lines @@
 }
 
 RenderSurfaceImpl* LayerTreeImpl::RootRenderSurface() const {
   return layer_list_.empty() ? nullptr : layer_list_[0]->render_surface();
 }
 
 bool LayerTreeImpl::LayerListIsEmpty() const {
   return layer_list_.empty();
 }
 
-void LayerTreeImpl::SetRootLayer(std::unique_ptr<LayerImpl> layer) {
-  if (root_layer_ && layer.get() != root_layer_)
-    RemoveLayer(root_layer_->id());
-  root_layer_ = layer.get();
+void LayerTreeImpl::SetRootLayerForTesting(std::unique_ptr<LayerImpl> layer) {
+  if (root_layer_for_testing_ && layer.get() != root_layer_for_testing_)
+    RemoveLayer(root_layer_for_testing_->id());
+  root_layer_for_testing_ = layer.get();
   if (layer)
     AddLayer(std::move(layer));
+  BuildLayerListForTesting();
   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
 
-void LayerTreeImpl::SetRootLayerFromLayerList() {
-  root_layer_ = layer_list_.empty() ? nullptr : layer_list_[0];
+void LayerTreeImpl::SetRootLayerFromLayerListForTesting() {
+  root_layer_for_testing_ = layer_list_.empty() ? nullptr : layer_list_[0];
+}
+
+void LayerTreeImpl::OnCanDrawStateChangedForTree() {
   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
 
 void LayerTreeImpl::AddToLayerList(LayerImpl* layer) {
   layer_list_.push_back(layer);
 }
 
 void LayerTreeImpl::ClearLayerList() {
   layer_list_.clear();
 }
 
 void LayerTreeImpl::BuildLayerListForTesting() {
   ClearLayerList();
-  LayerListIterator<LayerImpl> it(root_layer_);
+  LayerListIterator<LayerImpl> it(root_layer_for_testing_);
   for (; it != LayerListIterator<LayerImpl>(nullptr); ++it) {
     AddToLayerList(*it);
   }
 }
 
 bool LayerTreeImpl::IsRootLayer(const LayerImpl* layer) const {
   return layer_list_.empty() ? false : layer_list_[0] == layer;
 }
 
 LayerImpl* LayerTreeImpl::InnerViewportScrollLayer() const {
@@ skipping 22 matching lines @@
   if (InnerViewportScrollLayer())
     offset += InnerViewportScrollLayer()->MaxScrollOffset();
 
   if (OuterViewportScrollLayer())
     offset += OuterViewportScrollLayer()->MaxScrollOffset();
 
   return offset;
 }
 
 std::unique_ptr<OwnedLayerImplList> LayerTreeImpl::DetachLayers() {
-  root_layer_ = nullptr;
+  root_layer_for_testing_ = 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) {
@@ skipping 662 matching lines @@
                      "layers_updated_count", layers_updated_count);
   }
 
   DCHECK(!needs_update_draw_properties_)
       << "CalcDrawProperties should not set_needs_update_draw_properties()";
   return true;
 }
 
 void LayerTreeImpl::BuildLayerListAndPropertyTreesForTesting() {
   BuildLayerListForTesting();
-  PropertyTreeBuilder::PreCalculateMetaInformationForTesting(root_layer_);
+  PropertyTreeBuilder::PreCalculateMetaInformationForTesting(
+      root_layer_for_testing_);
   property_trees_.transform_tree.set_source_to_parent_updates_allowed(true);
   PropertyTreeBuilder::BuildPropertyTrees(
-      root_layer_, PageScaleLayer(), InnerViewportScrollLayer(),
+      root_layer_for_testing_, PageScaleLayer(), InnerViewportScrollLayer(),
       OuterViewportScrollLayer(), OverscrollElasticityLayer(),
       elastic_overscroll()->Current(IsActiveTree()),
       current_page_scale_factor(), device_scale_factor(),
       gfx::Rect(DrawViewportSize()), layer_tree_host_impl_->DrawTransform(),
       &property_trees_);
   property_trees_.transform_tree.set_source_to_parent_updates_allowed(false);
 }
 
 const LayerImplList& LayerTreeImpl::RenderSurfaceLayerList() const {
   // If this assert triggers, then the list is dirty.
@@ skipping 63 matching lines @@
 }
 
 // These manage ownership of the LayerImpl.
 void LayerTreeImpl::AddLayer(std::unique_ptr<LayerImpl> layer) {
   DCHECK(std::find(layers_->begin(), layers_->end(), layer) == layers_->end());
   layers_->push_back(std::move(layer));
   set_needs_update_draw_properties();
 }
 
 std::unique_ptr<LayerImpl> LayerTreeImpl::RemoveLayer(int id) {
-  if (root_layer_ && root_layer_->id() == id)
-    root_layer_ = nullptr;
   for (auto it = layers_->begin(); it != layers_->end(); ++it) {
     if ((*it) && (*it)->id() != id)
       continue;
     std::unique_ptr<LayerImpl> ret = std::move(*it);
     set_needs_update_draw_properties();
     layers_->erase(it);
     return ret;
   }
   return nullptr;
 }
@@ skipping 974 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks and replicas.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc