cc: Remove LayerTreeImpl::root_layer usage outside tests

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 72 matching lines @@
       top_controls_shown_ratio_(top_controls_shown_ratio) {
   property_trees()->is_main_thread = false;
 }
 
 LayerTreeImpl::~LayerTreeImpl() {
   BreakSwapPromises(IsActiveTree() ? SwapPromise::SWAP_FAILS
                                    : SwapPromise::ACTIVATION_FAILS);
 
   // Need to explicitly clear the tree prior to destroying this so that
   // the LayerTreeImpl pointer is still valid in the LayerImpl dtor.
-  DCHECK(!root_layer_);
+  DCHECK(LayerListIsEmpty());
   DCHECK(layers_->empty());
 }
 
 void LayerTreeImpl::Shutdown() {
   DetachLayers();
-  DCHECK(!root_layer_);
+  DCHECK(LayerListIsEmpty());
 }
 
 void LayerTreeImpl::ReleaseResources() {
-  if (root_layer_) {
+  if (!LayerListIsEmpty()) {
     LayerTreeHostCommon::CallFunctionForEveryLayer(
         this, [](LayerImpl* layer) { layer->ReleaseResources(); });
   }
 }
 
 void LayerTreeImpl::RecreateResources() {
-  if (root_layer_) {
+  if (!LayerListIsEmpty()) {
     LayerTreeHostCommon::CallFunctionForEveryLayer(
         this, [](LayerImpl* layer) { layer->RecreateResources(); });
   }
 }
 
 bool LayerTreeImpl::IsViewportLayerId(int id) const {
   if (id == inner_viewport_scroll_layer_id_ ||
       id == outer_viewport_scroll_layer_id_)
     return true;
   if (InnerViewportContainerLayer() &&
@@ skipping 125 matching lines @@
 
   if (scrollbar_needs_animation) {
     ScrollbarAnimationController* controller =
         layer_tree_host_impl_->ScrollbarAnimationControllerForId(
             scroll_layer_id);
     if (controller)
       controller->DidScrollUpdate(scroll_layer_size_did_change);
   }
 }
 
+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();
   if (layer)
     AddLayer(std::move(layer));
   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
 
 void LayerTreeImpl::SetRootLayerFromLayerList() {
@@ skipping 11 matching lines @@
 
 void LayerTreeImpl::BuildLayerListForTesting() {
   ClearLayerList();
   LayerListIterator<LayerImpl> it(root_layer_);
   for (; it != LayerListIterator<LayerImpl>(nullptr); ++it) {
     AddToLayerList(*it);
   }
 }
 
 bool LayerTreeImpl::IsRootLayer(const LayerImpl* layer) const {
-  return root_layer_ == layer;
+  return layer_list_.empty() ? false : layer_list_[0] == layer;
 }
 
 LayerImpl* LayerTreeImpl::InnerViewportScrollLayer() const {
   return LayerById(inner_viewport_scroll_layer_id_);
 }
 
 LayerImpl* LayerTreeImpl::OuterViewportScrollLayer() const {
   return LayerById(outer_viewport_scroll_layer_id_);
 }
 
@@ skipping 291 matching lines @@
   return page_scale_factor;
 }
 
 void LayerTreeImpl::UpdatePropertyTreeScrollingAndAnimationFromMainThread() {
   // TODO(enne): This should get replaced by pulling out scrolling and
   // animations into their own trees.  Then scrolls and animations would have
   // their own ways of synchronizing across commits.  This occurs to push
   // updates from scrolling deltas on the compositor thread that have occurred
   // after begin frame and updates from animations that have ticked since begin
   // frame to a newly-committed property tree.
-  if (!root_layer())
+  if (layer_list_.empty())
     return;
   for (auto& layer_id_to_opacity : opacity_animations_map_) {
     const int id = layer_id_to_opacity.first;
     if (property_trees_.IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id)) {
       EffectNode* node = property_trees_.effect_tree.Node(
           property_trees_.effect_id_to_index_map[id]);
       if (!node->data.is_currently_animating_opacity ||
           node->data.opacity == layer_id_to_opacity.second)
         continue;
       node->data.opacity = layer_id_to_opacity.second;
@@ skipping 26 matching lines @@
 void LayerTreeImpl::SetPageScaleOnActiveTree(float active_page_scale) {
   DCHECK(IsActiveTree());
   if (page_scale_factor()->SetCurrent(
           ClampPageScaleFactorToLimits(active_page_scale))) {
     DidUpdatePageScale();
     if (PageScaleLayer()) {
       draw_property_utils::UpdatePageScaleFactor(
           property_trees(), PageScaleLayer(), current_page_scale_factor(),
           device_scale_factor(), layer_tree_host_impl_->DrawTransform());
     } else {
-      DCHECK(!root_layer_ || active_page_scale == 1);
+      DCHECK(layer_list_.empty() || active_page_scale == 1);
     }
   }
 }
 
 void LayerTreeImpl::PushPageScaleFromMainThread(float page_scale_factor,
                                                 float min_page_scale_factor,
                                                 float max_page_scale_factor) {
   PushPageScaleFactorAndLimits(&page_scale_factor, min_page_scale_factor,
                                max_page_scale_factor);
 }
@@ skipping 27 matching lines @@
 
   if (changed_page_scale)
     DidUpdatePageScale();
 
   if (page_scale_factor) {
     if (PageScaleLayer()) {
       draw_property_utils::UpdatePageScaleFactor(
           property_trees(), PageScaleLayer(), current_page_scale_factor(),
           device_scale_factor(), layer_tree_host_impl_->DrawTransform());
     } else {
-      DCHECK(!root_layer_ || *page_scale_factor == 1);
+      DCHECK(layer_list_.empty() || *page_scale_factor == 1);
     }
   }
 }
 
 void LayerTreeImpl::set_top_controls_shrink_blink_size(bool shrink) {
   if (top_controls_shrink_blink_size_ == shrink)
     return;
 
   top_controls_shrink_blink_size_ = shrink;
   if (IsActiveTree())
@@ skipping 91 matching lines @@
       gfx::Rect(root_scroll_layer->bounds()));
 }
 
 void LayerTreeImpl::ApplySentScrollAndScaleDeltasFromAbortedCommit() {
   DCHECK(IsActiveTree());
 
   page_scale_factor()->AbortCommit();
   top_controls_shown_ratio()->AbortCommit();
   elastic_overscroll()->AbortCommit();
 
-  if (!root_layer())
+  if (layer_list_.empty())
     return;
 
   property_trees()->scroll_tree.ApplySentScrollDeltasFromAbortedCommit();
 }
 
 void LayerTreeImpl::SetViewportLayersFromIds(
     int overscroll_elasticity_layer_id,
     int page_scale_layer_id,
     int inner_viewport_scroll_layer_id,
     int outer_viewport_scroll_layer_id) {
@@ skipping 21 matching lines @@
   // For max_texture_size.  When the renderer is re-created in
   // CreateAndSetRenderer, the needs update draw properties flag is set
   // again.
   if (!layer_tree_host_impl_->renderer())
     return false;
 
   // Clear this after the renderer early out, as it should still be
   // possible to hit test even without a renderer.
   render_surface_layer_list_.clear();
 
-  if (!root_layer())
+  if (layer_list_.empty())
     return false;
 
   {
     base::ElapsedTimer timer;
     TRACE_EVENT2(
         "cc", "LayerTreeImpl::UpdateDrawProperties::CalculateDrawProperties",
         "IsActive", IsActiveTree(), "SourceFrameNumber", source_frame_number_);
     bool can_render_to_separate_surface =
         (!is_in_resourceless_software_draw_mode());
 
     LayerTreeHostCommon::CalcDrawPropsImplInputs inputs(
-        root_layer(), DrawViewportSize(),
+        layer_list_[0], DrawViewportSize(),
         layer_tree_host_impl_->DrawTransform(), device_scale_factor(),
         current_page_scale_factor(), PageScaleLayer(),
         InnerViewportScrollLayer(), OuterViewportScrollLayer(),
         elastic_overscroll()->Current(IsActiveTree()),
         OverscrollElasticityLayer(), resource_provider()->max_texture_size(),
         can_render_to_separate_surface,
         settings().layer_transforms_should_scale_layer_contents,
         settings().verify_clip_tree_calculations, &render_surface_layer_list_,
         &property_trees_);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     if (const char* client_name = GetClientNameForMetrics()) {
       UMA_HISTOGRAM_COUNTS(
           base::StringPrintf(
               "Compositing.%s.LayerTreeImpl.CalculateDrawPropertiesUs",
               client_name),
           timer.Elapsed().InMicroseconds());
       UMA_HISTOGRAM_COUNTS_100(
           base::StringPrintf("Compositing.%s.NumRenderSurfaces", client_name),
           base::saturated_cast<int>(render_surface_layer_list_.size()));
     }
   }
 
   {
     TRACE_EVENT2("cc", "LayerTreeImpl::UpdateDrawProperties::Occlusion",
                  "IsActive", IsActiveTree(), "SourceFrameNumber",
                  source_frame_number_);
     OcclusionTracker occlusion_tracker(
-        root_layer()->render_surface()->content_rect());
+        layer_list_[0]->render_surface()->content_rect());
     occlusion_tracker.set_minimum_tracking_size(
         settings().minimum_occlusion_tracking_size);
 
     // LayerIterator is used here instead of CallFunctionForEveryLayer to only
     // UpdateTilePriorities on layers that will be visible (and thus have valid
     // draw properties) and not because any ordering is required.
     LayerIterator end = LayerIterator::End(&render_surface_layer_list_);
     for (LayerIterator it = LayerIterator::Begin(&render_surface_layer_list_);
          it != end; ++it) {
       occlusion_tracker.EnterLayer(it);
@@ skipping 165 matching lines @@
       layer->id(),
       IsActiveTree() ? ElementListType::ACTIVE : ElementListType::PENDING);
 }
 
 void LayerTreeImpl::UnregisterLayer(LayerImpl* layer) {
   DCHECK(LayerById(layer->id()));
   layer_tree_host_impl_->animation_host()->UnregisterElement(
       layer->id(),
       IsActiveTree() ? ElementListType::ACTIVE : ElementListType::PENDING);
   layer_id_map_.erase(layer->id());
-  DCHECK_NE(root_layer_, layer);
 }
 
 // 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) {
@@ skipping 17 matching lines @@
 void LayerTreeImpl::DidBecomeActive() {
   if (next_activation_forces_redraw_) {
     layer_tree_host_impl_->SetFullRootLayerDamage();
     next_activation_forces_redraw_ = false;
   }
 
   // Always reset this flag on activation, as we would only have activated
   // if we were in a good state.
   layer_tree_host_impl_->ResetRequiresHighResToDraw();
 
-  if (root_layer()) {
+  if (!layer_list_.empty()) {
     LayerTreeHostCommon::CallFunctionForEveryLayer(
         this, [](LayerImpl* layer) { layer->DidBecomeActive(); });
   }
 
   for (const auto& swap_promise : swap_promise_list_)
     swap_promise->DidActivate();
   devtools_instrumentation::DidActivateLayerTree(layer_tree_host_impl_->id(),
                                                  source_frame_number_);
 }
 
@@ skipping 638 matching lines @@
 struct FindScrollingLayerOrScrollbarLayerFunctor {
   bool operator()(LayerImpl* layer) const {
     return ScrollsOrScrollbarAnyDrawnRenderSurfaceLayerListMember(layer);
   }
 };
 
 LayerImpl*
 LayerTreeImpl::FindFirstScrollingLayerOrScrollbarLayerThatIsHitByPoint(
     const gfx::PointF& screen_space_point) {
   FindClosestMatchingLayerState state;
-  FindClosestMatchingLayer(screen_space_point, root_layer(),
+  LayerImpl* root_layer = layer_list_.empty() ? nullptr : layer_list_[0];
+  FindClosestMatchingLayer(screen_space_point, root_layer,
                            FindScrollingLayerOrScrollbarLayerFunctor(),
                            property_trees_.transform_tree,
                            property_trees_.clip_tree, &state);
   return state.closest_match;
 }
 
 struct HitTestVisibleScrollableOrTouchableFunctor {
   bool operator()(LayerImpl* layer) const {
     return layer->is_drawn_render_surface_layer_list_member() ||
            ScrollsOrScrollbarAnyDrawnRenderSurfaceLayerListMember(layer) ||
            !layer->touch_event_handler_region().IsEmpty();
   }
 };
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPoint(
     const gfx::PointF& screen_space_point) {
-  if (!root_layer())
+  if (layer_list_.empty())
     return NULL;
   bool update_lcd_text = false;
   if (!UpdateDrawProperties(update_lcd_text))
     return NULL;
   FindClosestMatchingLayerState state;
-  FindClosestMatchingLayer(screen_space_point, root_layer(),
+  FindClosestMatchingLayer(screen_space_point, layer_list_[0],
                            HitTestVisibleScrollableOrTouchableFunctor(),
                            property_trees_.transform_tree,
                            property_trees_.clip_tree, &state);
   return state.closest_match;
 }
 
 static bool LayerHasTouchEventHandlersAt(const gfx::PointF& screen_space_point,
                                          LayerImpl* layer_impl,
                                          const TransformTree& transform_tree,
                                          const ClipTree& clip_tree) {
@@ skipping 20 matching lines @@
     return LayerHasTouchEventHandlersAt(screen_space_point, layer,
                                         transform_tree, clip_tree);
   }
   const gfx::PointF screen_space_point;
   const TransformTree& transform_tree;
   const ClipTree& clip_tree;
 };
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPointInTouchHandlerRegion(
     const gfx::PointF& screen_space_point) {
-  if (!root_layer())
+  if (layer_list_.empty())
     return NULL;
   bool update_lcd_text = false;
   if (!UpdateDrawProperties(update_lcd_text))
     return NULL;
   FindTouchEventLayerFunctor func = {screen_space_point,
                                      property_trees_.transform_tree,
                                      property_trees_.clip_tree};
   FindClosestMatchingLayerState state;
-  FindClosestMatchingLayer(screen_space_point, root_layer(), func,
+  FindClosestMatchingLayer(screen_space_point, layer_list_[0], func,
                            property_trees_.transform_tree,
                            property_trees_.clip_tree, &state);
   return state.closest_match;
 }
 
 void LayerTreeImpl::RegisterSelection(const LayerSelection& selection) {
   selection_ = selection;
 }
 
 static gfx::SelectionBound ComputeViewportSelectionBound(
@@ skipping 223 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