cc: Call ManageTiles explicitly

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/json/json_writer.h"
@@ skipping 145 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),
       root_layer_scroll_offset_delegate_(NULL),
       settings_(settings),
       visible_(true),
       managed_memory_policy_(
           PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
           ManagedMemoryPolicy::CUTOFF_ALLOW_EVERYTHING,
           0,
           ManagedMemoryPolicy::CUTOFF_ALLOW_NOTHING),
       pinch_gesture_active_(false),
       fps_counter_(FrameRateCounter::Create(proxy_->HasImplThread())),
@@ skipping 55 matching lines @@
 
 void LayerTreeHostImpl::CommitComplete() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
 
   // 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.
   if (settings_.impl_side_painting) {
     pending_tree_->set_needs_update_draw_properties();
     pending_tree_->UpdateDrawProperties();
+    // Start working on newly created tiles immediately if needed.
+    ManageTiles();
   } else {
     active_tree_->set_needs_update_draw_properties();
   }
 
   client_->SendManagedMemoryStats();
 }
 
 bool LayerTreeHostImpl::CanDraw() {
   // Note: If you are changing this function or any other function that might
   // affect the result of CanDraw, make sure to call
@@ skipping 34 matching lines @@
                                 base::Time wall_clock_time) {
   if (input_handler_client_)
     input_handler_client_->Animate(monotonic_time);
   AnimatePageScale(monotonic_time);
   AnimateLayers(monotonic_time, wall_clock_time);
   AnimateScrollbars(monotonic_time);
   AnimateTopControls(monotonic_time);
 }
 
 void LayerTreeHostImpl::ManageTiles() {
-  DCHECK(tile_manager_);
+  if (!tile_manager_)
+    return;
+  if (!manage_tiles_needed_)
+    return;
+  manage_tiles_needed_ = false;
   tile_manager_->ManageTiles();
 
   size_t memory_required_bytes;
   size_t memory_nice_to_have_bytes;
   size_t memory_used_bytes;
   tile_manager_->GetMemoryStats(&memory_required_bytes,
                                 &memory_nice_to_have_bytes,
                                 &memory_used_bytes);
   SendManagedMemoryStats(memory_required_bytes,
                          memory_nice_to_have_bytes,
@@ skipping 657 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);
   tile_manager_->SetGlobalState(new_state);
+  manage_tiles_needed_ = true;
 }
 
 bool LayerTreeHostImpl::HasImplThread() const {
   return proxy_->HasImplThread();
 }
 
-void LayerTreeHostImpl::ScheduleManageTiles() {
-  if (client_)
-    client_->SetNeedsManageTilesOnImplThread();
-}
-
 void LayerTreeHostImpl::DidInitializeVisibleTile() {
   // TODO(reveman): Determine tiles that changed and only damage
   // what's necessary.
   SetFullRootLayerDamage();
   if (client_)
     client_->DidInitializeVisibleTileOnImplThread();
 }
 
 bool LayerTreeHostImpl::
     ShouldForceTileUploadsRequiredForActivationToComplete() const {
@@ skipping 337 matching lines @@
 }
 
 bool LayerTreeHostImpl::ActivatePendingTreeIfNeeded() {
   if (!pending_tree_)
     return false;
 
   CHECK(settings_.impl_side_painting);
 
   // TODO(enne): This needs to be moved somewhere else (post-animate?)
   pending_tree_->UpdateDrawProperties();
+  // Note: This will likely cause ManageTiles to be needed.  However,
+  // it is only out of date as far as the last commit or the last draw.
+  // For performance reasons, don't call ManageTiles again here.
 
   TRACE_EVENT_ASYNC_STEP1(
     "cc",
     "PendingTree", pending_tree_.get(), "activate",
     "state", TracedValue::FromValue(ActivationStateAsValue().release()));
 
   if (tile_manager_) {
     tile_manager_->CheckForCompletedTileUploads();
     if (!tile_manager_->AreTilesRequiredForActivationReady())
       return false;
@@ skipping 873 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;
 }
 
 void LayerTreeHostImpl::ResetCurrentFrameTimeForNextFrame() {
   current_frame_timeticks_ = base::TimeTicks();
   current_frame_time_ = base::Time();
 }
 
 static void UpdateCurrentFrameTime(base::TimeTicks* ticks, base::Time* now) {
   if (ticks->is_null()) {
     DCHECK(now->is_null());
@@ skipping 61 matching lines @@
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
 }  // namespace cc