CC: Add a scheduled action for ManageTiles

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 "base/basictypes.h"
 #include "base/containers/hash_tables.h"
@@ skipping 156 matching lines @@
     const LayerTreeSettings& settings,
     LayerTreeHostImplClient* client,
     Proxy* proxy,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
     : client_(client),
       proxy_(proxy),
       input_handler_client_(NULL),
       did_lock_scrolling_layer_(false),
       should_bubble_scrolls_(false),
       wheel_scrolling_(false),
-      manage_tiles_needed_(false),
+      tile_priorities_dirty_(false),
       root_layer_scroll_offset_delegate_(NULL),
       settings_(settings),
       visible_(true),
       cached_managed_memory_policy_(
           PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
           ManagedMemoryPolicy::CUTOFF_ALLOW_EVERYTHING,
           0,
           ManagedMemoryPolicy::CUTOFF_ALLOW_NOTHING,
           ManagedMemoryPolicy::kDefaultNumResourcesLimit),
       pinch_gesture_active_(false),
@@ skipping 60 matching lines @@
   TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
 
   if (settings_.impl_side_painting) {
     // Impl-side painting needs an update immediately post-commit to have the
     // opportunity to create tilings.  Other paths can call UpdateDrawProperties
     // more lazily when needed prior to drawing.
     pending_tree()->ApplyScrollDeltasSinceBeginFrame();
     pending_tree_->set_needs_update_draw_properties();
     pending_tree_->UpdateDrawProperties();
     // Start working on newly created tiles immediately if needed.
-    if (!tile_manager_ || !manage_tiles_needed_)
+    if (!tile_manager_ || !tile_priorities_dirty_)
       NotifyReadyToActivate();
     else
       ManageTiles();

[brianderson, 2013/09/11 17:10:30]

Will this ManageTiles() be a redundant call now that the Scheduler initiates
ManageTiles?  It was very confusing and error prone when both the Scheduler and
LTHI were activating the pending tree. If the Scheduler is going to be calling
ManageTiles, I think it would be a good idea to make it the only class that
initiates them.

[epennerAtGoogle, 2013/09/11 18:43:00]

This isn't redundant unless we replicate this behavior in the Scheduler.
Currently I don't do that. I do think it should move to the Scheduler but I
don't know if that should be in this first patch.

In terms of replicating it, I _think_ we could get away doing only this
ManageTiles (somewhere in the scheduler) and skipping any other ManageTiles
within the same frame... But I'm a bit hesitant to conclude that's always okay.

   } else {
     active_tree_->set_needs_update_draw_properties();
     if (time_source_client_adapter_ && time_source_client_adapter_->Active())
       DCHECK(active_tree_->root_layer());
   }
 
   client_->SendManagedMemoryStats();
 }
 
 bool LayerTreeHostImpl::CanDraw() const {
@@ skipping 48 matching lines @@
     input_handler_client_->Animate(monotonic_time);
   AnimatePageScale(monotonic_time);
   AnimateLayers(monotonic_time, wall_clock_time);
   AnimateScrollbars(monotonic_time);
   AnimateTopControls(monotonic_time);
 }
 
 void LayerTreeHostImpl::ManageTiles() {
   if (!tile_manager_)
     return;
-  if (!manage_tiles_needed_)
+  if (!tile_priorities_dirty_)
     return;
   if (!device_viewport_valid_for_tile_management_)
     return;
 
-  manage_tiles_needed_ = false;
+  tile_priorities_dirty_ = false;
   tile_manager_->ManageTiles();
 
   size_t memory_required_bytes;
   size_t memory_nice_to_have_bytes;
   size_t memory_allocated_bytes;
   size_t memory_used_bytes;
   tile_manager_->GetMemoryStats(&memory_required_bytes,
                                 &memory_nice_to_have_bytes,
                                 &memory_allocated_bytes,
                                 &memory_used_bytes);
@@ skipping 755 matching lines @@
   // possible. crbug.com/224475
   new_state.unused_memory_limit_in_bytes = static_cast<size_t>(
       (static_cast<int64>(new_state.memory_limit_in_bytes) *
        settings_.max_unused_resource_memory_percentage) / 100);
   new_state.memory_limit_policy =
       ManagedMemoryPolicy::PriorityCutoffToTileMemoryLimitPolicy(
           visible_ ?
           policy.priority_cutoff_when_visible :
           policy.priority_cutoff_when_not_visible);
   new_state.num_resources_limit = policy.num_resources_limit;
+
+  WillModifyTilePriorities();
   tile_manager_->SetGlobalState(new_state);
-  manage_tiles_needed_ = true;
+}
+
+void LayerTreeHostImpl::WillModifyTilePriorities() {
+  // Mark priorities as dirty and schedule a ManageTiles().
+  tile_priorities_dirty_ = true;
+  client_->SetNeedsManageTilesOnImplThread();
 }
 
 void LayerTreeHostImpl::DidInitializeVisibleTile() {
   // TODO(reveman): Determine tiles that changed and only damage
   // what's necessary.
   SetFullRootLayerDamage();
   if (client_)
     client_->DidInitializeVisibleTileOnImplThread();
 }
 
@@ skipping 1379 matching lines @@
 
 void LayerTreeHostImpl::SetTreePriority(TreePriority priority) {
   if (!tile_manager_)
     return;
 
   GlobalStateThatImpactsTilePriority new_state(tile_manager_->GlobalState());
   if (new_state.tree_priority == priority)
     return;
 
   new_state.tree_priority = priority;
+
+  WillModifyTilePriorities();
   tile_manager_->SetGlobalState(new_state);
-  manage_tiles_needed_ = true;
 }
 
 void LayerTreeHostImpl::ResetCurrentFrameTimeForNextFrame() {
   current_frame_timeticks_ = base::TimeTicks();
   current_frame_time_ = base::Time();
 }
 
 void LayerTreeHostImpl::UpdateCurrentFrameTime(base::TimeTicks* ticks,
                                                base::Time* now) const {
   if (ticks->is_null()) {
@@ skipping 107 matching lines @@
 
 ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
     UIResourceId uid) const {
   UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
   if (iter != ui_resource_map_.end())
     return iter->second;
   return 0;
 }
 
 }  // namespace cc