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 <limits>
 
 #include "base/basictypes.h"
@@ skipping 179 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 61 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();
   } 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();
@@ skipping 57 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;
+
   tile_manager_->SetGlobalState(new_state);
-  manage_tiles_needed_ = true;
+  DidModifyTilePriorities();
+}
+
+void LayerTreeHostImpl::DidModifyTilePriorities() {
+  DCHECK(settings_.impl_side_painting);
+  // 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 1391 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;
   tile_manager_->SetGlobalState(new_state);
-  manage_tiles_needed_ = true;
+  DidModifyTilePriorities();
 }
 
 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 131 matching lines @@
   std::set<UIResourceId>::iterator found_in_evicted =
       evicted_ui_resources_.find(uid);
   if (found_in_evicted == evicted_ui_resources_.end())
     return;
   evicted_ui_resources_.erase(found_in_evicted);
   if (evicted_ui_resources_.empty())
     client_->OnCanDrawStateChanged(CanDraw());
 }
 
 }  // namespace cc