cc: Remove LayerTreeImpl::root_layer usage outside tests

cc/trees/layer_tree_host_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_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 380 matching lines @@
 
   if (!renderer_) {
     TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no renderer",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   // Must have an OutputSurface if |renderer_| is not NULL.
   DCHECK(output_surface_);
 
-  // TODO(boliu): Make draws without root_layer work and move this below
+  // TODO(boliu): Make draws without layers work and move this below
   // |resourceless_software_draw_| check. Tracked in crbug.com/264967.
-  if (!active_tree_->root_layer()) {
+  if (active_tree_->LayerListIsEmpty()) {
     TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no root layer",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   if (resourceless_software_draw_)
     return true;
 
   if (DrawViewportSize().IsEmpty()) {
     TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw empty viewport",
@@ skipping 211 matching lines @@
   return scroll_elasticity_helper_.get();
 }
 
 void LayerTreeHostImpl::QueueSwapPromiseForMainThreadScrollUpdate(
     std::unique_ptr<SwapPromise> swap_promise) {
   swap_promises_for_main_thread_scroll_update_.push_back(
       std::move(swap_promise));
 }
 
 void LayerTreeHostImpl::TrackDamageForAllSurfaces(
-    LayerImpl* root_draw_layer,
     const LayerImplList& render_surface_layer_list) {
   // For now, we use damage tracking to compute a global scissor. To do this, we
   // must compute all damage tracking before drawing anything, so that we know
   // the root damage rect. The root damage rect is then used to scissor each
   // surface.
   size_t render_surface_layer_list_size = render_surface_layer_list.size();
   for (size_t i = 0; i < render_surface_layer_list_size; ++i) {
     size_t surface_index = render_surface_layer_list_size - 1 - i;
     LayerImpl* render_surface_layer = render_surface_layer_list[surface_index];
     RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
@@ skipping 77 matching lines @@
 
     surface->AppendQuads(target_render_pass, replica_draw_transform,
                          replica_occlusion, replica_debug_border_color,
                          replica_debug_border_width, replica_mask_layer,
                          append_quads_data, contributing_render_pass->id);
   }
 }
 
 static void AppendQuadsToFillScreen(const gfx::Rect& root_scroll_layer_rect,
                                     RenderPass* target_render_pass,
-                                    LayerImpl* root_layer,
+                                    RenderSurfaceImpl* root_render_surface,
                                     SkColor screen_background_color,
                                     const Region& fill_region) {
-  if (!root_layer || !SkColorGetA(screen_background_color))
+  if (!root_render_surface || !SkColorGetA(screen_background_color))
     return;
   if (fill_region.IsEmpty())
     return;
 
   // Manually create the quad state for the gutter quads, as the root layer
   // doesn't have any bounds and so can't generate this itself.
   // TODO(danakj): Make the gutter quads generated by the solid color layer
   // (make it smarter about generating quads to fill unoccluded areas).
 
-  gfx::Rect root_target_rect = root_layer->render_surface()->content_rect();
+  gfx::Rect root_target_rect = root_render_surface->content_rect();
   float opacity = 1.f;
   int sorting_context_id = 0;
   SharedQuadState* shared_quad_state =
       target_render_pass->CreateAndAppendSharedQuadState();
   shared_quad_state->SetAll(gfx::Transform(),
                             root_target_rect.size(),
                             root_target_rect,
                             root_target_rect,
                             false,
                             opacity,
@@ skipping 21 matching lines @@
   auto it = std::find_if(
       list.begin(), list.end(),
       [id](const std::unique_ptr<RenderPass>& p) { return p->id == id; });
   return it == list.end() ? nullptr : it->get();
 }
 
 DrawResult LayerTreeHostImpl::CalculateRenderPasses(
     FrameData* frame) {
   DCHECK(frame->render_passes.empty());
   DCHECK(CanDraw());
-  DCHECK(active_tree_->root_layer());
+  DCHECK(!active_tree_->LayerListIsEmpty());
 
-  TrackDamageForAllSurfaces(active_tree_->root_layer(),
-                            *frame->render_surface_layer_list);
+  TrackDamageForAllSurfaces(*frame->render_surface_layer_list);
 
   // If the root render surface has no visible damage, then don't generate a
   // frame at all.
-  RenderSurfaceImpl* root_surface =
-      active_tree_->root_layer()->render_surface();
+  RenderSurfaceImpl* root_surface = active_tree_->RootRenderSurface();
   bool root_surface_has_no_visible_damage =
       !root_surface->damage_tracker()->current_damage_rect().Intersects(
           root_surface->content_rect());
   bool root_surface_has_contributing_layers =
       !root_surface->layer_list().empty();
   bool hud_wants_to_draw_ = active_tree_->hud_layer() &&
                             active_tree_->hud_layer()->IsAnimatingHUDContents();
   if (root_surface_has_contributing_layers &&
       root_surface_has_no_visible_damage &&
       !active_tree_->property_trees()->effect_tree.HasCopyRequests() &&
@@ skipping 172 matching lines @@
     for (const auto& quad : render_pass->quad_list)
       DCHECK(quad->shared_quad_state);
   }
   DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
 #endif
 
   if (!active_tree_->has_transparent_background()) {
     frame->render_passes.back()->has_transparent_background = false;
     AppendQuadsToFillScreen(
         active_tree_->RootScrollLayerDeviceViewportBounds(),
-        frame->render_passes.back().get(), active_tree_->root_layer(),
+        frame->render_passes.back().get(), active_tree_->RootRenderSurface(),
         active_tree_->background_color(), unoccluded_screen_space_region);
   }
 
   RemoveRenderPasses(frame);
   renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
 
   if (have_copy_request) {
     // Any copy requests left in the tree are not going to get serviced, and
     // should be aborted.
     active_tree()->property_trees()->effect_tree.ClearCopyRequests();
@@ skipping 100 matching lines @@
   // This will cause NotifyTileStateChanged() to be called for any tiles that
   // completed, which will add damage for visible tiles to the frame for them so
   // they appear as part of the current frame being drawn.
   tile_manager_.Flush();
 
   frame->render_surface_layer_list = &active_tree_->RenderSurfaceLayerList();
   frame->render_passes.clear();
   frame->will_draw_layers.clear();
   frame->has_no_damage = false;
 
-  if (active_tree_->root_layer()) {
+  if (active_tree_->RootRenderSurface()) {
     gfx::Rect device_viewport_damage_rect = viewport_damage_rect_;
     viewport_damage_rect_ = gfx::Rect();
 
-    active_tree_->root_layer()->render_surface()->damage_tracker()->
-        AddDamageNextUpdate(device_viewport_damage_rect);
+    active_tree_->RootRenderSurface()->damage_tracker()->AddDamageNextUpdate(
+        device_viewport_damage_rect);
   }
 
   DrawResult draw_result = CalculateRenderPasses(frame);
   if (draw_result != DRAW_SUCCESS) {
     DCHECK(!resourceless_software_draw_);
     return draw_result;
   }
 
   // If we return DRAW_SUCCESS, then we expect DrawLayers() to be called before
   // this function is called again.
@@ skipping 513 matching lines @@
   DCHECK(!frame->render_passes.empty());
 
   fps_counter_->SaveTimeStamp(frame_begin_time,
                               !output_surface_->context_provider());
   rendering_stats_instrumentation_->IncrementFrameCount(1);
 
   memory_history_->SaveEntry(tile_manager_.memory_stats_from_last_assign());
 
   if (debug_state_.ShowHudRects()) {
     debug_rect_history_->SaveDebugRectsForCurrentFrame(
-        active_tree_->root_layer(),
-        active_tree_->hud_layer(),
-        *frame->render_surface_layer_list,
-        debug_state_);
+        active_tree(), active_tree_->hud_layer(),
+        *frame->render_surface_layer_list, debug_state_);
   }
 
   bool is_new_trace;
   TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
   if (is_new_trace) {
     if (pending_tree_) {
       LayerTreeHostCommon::CallFunctionForEveryLayer(
           pending_tree(), [](LayerImpl* layer) { layer->DidBeginTracing(); });
     }
     LayerTreeHostCommon::CallFunctionForEveryLayer(
@@ skipping 272 matching lines @@
 void LayerTreeHostImpl::DidLoseOutputSurface() {
   if (resource_provider_)
     resource_provider_->DidLoseOutputSurface();
   client_->DidLoseOutputSurfaceOnImplThread();
 }
 
 bool LayerTreeHostImpl::HaveRootScrollLayer() const {
   return !!InnerViewportScrollLayer();
 }
 
-LayerImpl* LayerTreeHostImpl::RootLayer() const {
-  return active_tree_->root_layer();
-}
-
 LayerImpl* LayerTreeHostImpl::InnerViewportScrollLayer() const {
   return active_tree_->InnerViewportScrollLayer();
 }
 
 LayerImpl* LayerTreeHostImpl::OuterViewportScrollLayer() const {
   return active_tree_->OuterViewportScrollLayer();
 }
 
 LayerImpl* LayerTreeHostImpl::CurrentlyScrollingLayer() const {
   return active_tree_->CurrentlyScrollingLayer();
@@ skipping 34 matching lines @@
     DCHECK(pending_tree_duration_timer_);
     // Reset will call the destructor and log the timer histogram.
     pending_tree_duration_timer_.reset();
 
     // Process any requests in the UI resource queue.  The request queue is
     // given in LayerTreeHost::FinishCommitOnImplThread.  This must take place
     // before the swap.
     pending_tree_->ProcessUIResourceRequestQueue();
 
     if (pending_tree_->needs_full_tree_sync()) {
-      TreeSynchronizer::SynchronizeTrees(pending_tree_->root_layer(),
+      TreeSynchronizer::SynchronizeTrees(pending_tree_.get(),
                                          active_tree_.get());
     }
 
     // Property trees may store damage status. We preserve the active tree
     // damage status by pushing the damage status from active tree property
     // trees to pending tree property trees or by moving it onto the layers.
     if (active_tree_->property_trees()->changed) {
       if (pending_tree_->property_trees()->sequence_number ==
           active_tree_->property_trees()->sequence_number)
         active_tree_->property_trees()->PushChangeTrackingTo(
             pending_tree_->property_trees());
       else
         active_tree_->MoveChangeTrackingToLayers();
     }
     active_tree_->property_trees()->PushOpacityIfNeeded(
         pending_tree_->property_trees());
 
     TreeSynchronizer::PushLayerProperties(pending_tree(), active_tree());
     pending_tree_->PushPropertiesTo(active_tree_.get());
-    if (pending_tree_->root_layer())
+    if (!pending_tree_->LayerListIsEmpty())
       pending_tree_->property_trees()->ResetAllChangeTracking();
 
     // Now that we've synced everything from the pending tree to the active
     // tree, rename the pending tree the recycle tree so we can reuse it on the
     // next sync.
     DCHECK(!recycle_tree_);
     pending_tree_.swap(recycle_tree_);
 
     // If we commit to the active tree directly, this is already done during
     // commit.
@@ skipping 1327 matching lines @@
   std::unique_ptr<BeginFrameCallbackList> callbacks(new BeginFrameCallbackList);
   if (mutator_) {
     const base::Closure& callback = mutator_->TakeMutations();
     if (!callback.is_null())
       callbacks->push_back(callback);
   }
   return callbacks;
 }
 
 static void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
-                                LayerImpl* root_layer) {
-  if (!root_layer)
+                                LayerTreeImpl* tree_impl) {
+  if (tree_impl->LayerListIsEmpty())
     return;
 
-  return root_layer->layer_tree_impl()
-      ->property_trees()
-      ->scroll_tree.CollectScrollDeltas(scroll_info);
+  return tree_impl->property_trees()->scroll_tree.CollectScrollDeltas(
+      scroll_info);
 }
 
 std::unique_ptr<ScrollAndScaleSet> LayerTreeHostImpl::ProcessScrollDeltas() {
   std::unique_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
 
-  CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
+  CollectScrollDeltas(scroll_info.get(), active_tree_.get());
   scroll_info->page_scale_delta =
       active_tree_->page_scale_factor()->PullDeltaForMainThread();
   scroll_info->top_controls_delta =
       active_tree()->top_controls_shown_ratio()->PullDeltaForMainThread();
   scroll_info->elastic_overscroll_delta =
       active_tree_->elastic_overscroll()->PullDeltaForMainThread();
   scroll_info->swap_promises.swap(swap_promises_for_main_thread_scroll_update_);
 
   return scroll_info;
 }
@@ skipping 640 matching lines @@
     const {
   return fixed_raster_scale_attempted_scale_change_history_.count() >=
          kFixedRasterScaleAttemptedScaleChangeThreshold;
 }
 
 void LayerTreeHostImpl::SetFixedRasterScaleAttemptedToChangeScale() {
   fixed_raster_scale_attempted_scale_change_history_.set(0);
 }
 
 }  // namespace cc