cc: Refactor additional code from BuildRasterQueue.

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 <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 211 matching lines @@
       device_scale_factor_(1.f),
       resourceless_software_draw_(false),
       begin_impl_frame_interval_(BeginFrameArgs::DefaultInterval()),
       animation_registrar_(AnimationRegistrar::Create()),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       micro_benchmark_controller_(this),
       shared_bitmap_manager_(shared_bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       id_(id),
       requires_high_res_to_draw_(false),
-      required_for_draw_tile_is_top_of_raster_queue_(false) {
+      is_likely_to_require_a_draw_(false) {
   DCHECK(proxy_->IsImplThread());
   DidVisibilityChange(this, visible_);
   animation_registrar_->set_supports_scroll_animations(
       proxy_->SupportsImplScrolling());
 
   SetDebugState(settings.initial_debug_state);
 
   // LTHI always has an active tree.
   active_tree_ = LayerTreeImpl::create(this, new SyncedProperty<ScaleGroup>(),
                                        new SyncedElasticOverscroll);
@@ skipping 950 matching lines @@
     }
   }
 }
 
 scoped_ptr<RasterTilePriorityQueue> LayerTreeHostImpl::BuildRasterQueue(
     TreePriority tree_priority,
     RasterTilePriorityQueue::Type type) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::BuildRasterQueue");
   picture_layer_pairs_.clear();
   GetPictureLayerImplPairs(&picture_layer_pairs_, true);
-  scoped_ptr<RasterTilePriorityQueue> queue(RasterTilePriorityQueue::Create(
-      picture_layer_pairs_, tree_priority, type));
-
-  if (!queue->IsEmpty()) {
-    // Only checking the Top() tile here isn't a definite answer that there is
-    // or isn't something required for draw in this raster queue. It's just a
-    // heuristic to let us hit the common case and proactively tell the
-    // scheduler that we expect to draw within each vsync until we get all the
-    // tiles ready to draw. If we happen to miss a required for draw tile here,
-    // then we will miss telling the scheduler each frame that we intend to draw
-    // so it may make worse scheduling decisions.
-    required_for_draw_tile_is_top_of_raster_queue_ =
-        queue->Top()->required_for_draw();
-  } else {
-    required_for_draw_tile_is_top_of_raster_queue_ = false;
-  }
-  return queue;
+  return RasterTilePriorityQueue::Create(picture_layer_pairs_, tree_priority,
+                                         type);
 }
 
 scoped_ptr<EvictionTilePriorityQueue> LayerTreeHostImpl::BuildEvictionQueue(
     TreePriority tree_priority) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::BuildEvictionQueue");
   scoped_ptr<EvictionTilePriorityQueue> queue(new EvictionTilePriorityQueue);
   picture_layer_pairs_.clear();
   GetPictureLayerImplPairs(&picture_layer_pairs_, false);
   queue->Build(picture_layer_pairs_, tree_priority);
   return queue;
 }
 
+void LayerTreeHostImpl::SetIsLikelyToRequireADraw(
+    bool is_likely_to_require_a_draw) {

[vmpstr, 2015/01/26 22:08:35]

Since we're updating this only in certain cases, does it make sense for this to
be SetIsLikelyToRequireADraw() { is_likely_to_require_a_draw_ = true; } and have
the caller have if(...) SetIsLikelyToRequireADraw? Wdyt?

+  // Proactively tell the scheduler that we expect to draw within each vsync
+  // until we get all the tiles ready to draw. If we happen to miss a required
+  // for draw tile here, then we will miss telling the scheduler each frame that
+  // we intend to draw so it may make worse scheduling decisions.
+  is_likely_to_require_a_draw_ = is_likely_to_require_a_draw;
+}
+
 const std::vector<PictureLayerImpl*>& LayerTreeHostImpl::GetPictureLayers()
     const {
   return picture_layers_;
 }
 
 void LayerTreeHostImpl::NotifyReadyToActivate() {
   client_->NotifyReadyToActivate();
 }
 
 void LayerTreeHostImpl::NotifyReadyToDraw() {
   // Tiles that are ready will cause NotifyTileStateChanged() to be called so we
   // don't need to schedule a draw here. Just stop WillBeginImplFrame() from
   // causing optimistic requests to draw a frame.
-  required_for_draw_tile_is_top_of_raster_queue_ = false;
+  is_likely_to_require_a_draw_ = false;
 
   client_->NotifyReadyToDraw();
 }
 
 void LayerTreeHostImpl::NotifyTileStateChanged(const Tile* tile) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::NotifyTileStateChanged");
 
   if (active_tree_) {
     LayerImpl* layer_impl =
         active_tree_->FindActiveTreeLayerById(tile->layer_id());
@@ skipping 349 matching lines @@
   return true;
 }
 
 void LayerTreeHostImpl::WillBeginImplFrame(const BeginFrameArgs& args) {
   // Sample the frame time now. This time will be used for updating animations
   // when we draw.
   UpdateCurrentBeginFrameArgs(args);
   // Cache the begin impl frame interval
   begin_impl_frame_interval_ = args.interval;
 
-  if (required_for_draw_tile_is_top_of_raster_queue_) {
+  if (is_likely_to_require_a_draw_) {
     // Optimistically schedule a draw, as a tile required for draw is at the top
     // of the current raster queue. This will let us expect the tile to complete
     // and draw it within the impl frame we are beginning now.
     SetNeedsRedraw();
   }
 }
 
 void LayerTreeHostImpl::UpdateViewportContainerSizes() {
   LayerImpl* inner_container = active_tree_->InnerViewportContainerLayer();
   LayerImpl* outer_container = active_tree_->OuterViewportContainerLayer();
@@ skipping 1834 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc