cc: Prevent recursion in *TileTaskWorkerPool methods.

cc/resources/tile_manager.cc

 // Copyright 2012 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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 212 matching lines @@
       all_tiles_that_need_to_be_rasterized_are_scheduled_(true),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
       did_oom_on_last_assign_(false),
       ready_to_activate_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToActivate,
                      base::Unretained(this))),
       ready_to_draw_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToDraw, base::Unretained(this))),
+      more_tiles_need_prepare_check_notifier_(
+          task_runner_.get(),
+          base::Bind(&TileManager::CheckIfMoreTilesNeedPrepare,
+                     base::Unretained(this))),
       did_notify_ready_to_activate_(false),
       did_notify_ready_to_draw_(false) {
   tile_task_runner_->SetClient(this);
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
 
@@ skipping 60 matching lines @@
 void TileManager::DidFinishRunningTileTasks(TaskSet task_set) {
   TRACE_EVENT1("cc", "TileManager::DidFinishRunningTileTasks", "task_set",
                TaskSetName(task_set));
 
   switch (task_set) {
     case ALL: {
       bool memory_usage_above_limit =
           resource_pool_->total_memory_usage_bytes() >
           global_state_.soft_memory_limit_in_bytes;
 
-      // When OOM, keep re-assigning memory until we reach a steady state
-      // where top-priority tiles are initialized.
       if (all_tiles_that_need_to_be_rasterized_are_scheduled_ &&
           !memory_usage_above_limit)
         return;
 
-      tile_task_runner_->CheckForCompletedTasks();
-      did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
-
-      TileVector tiles_that_need_to_be_rasterized;
-      AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
-
-      // |tiles_that_need_to_be_rasterized| will be empty when we reach a
-      // steady memory state. Keep scheduling tasks until we reach this state.
-      if (!tiles_that_need_to_be_rasterized.empty()) {
-        ScheduleTasks(tiles_that_need_to_be_rasterized);
-        return;
-      }
-
-      FreeResourcesForReleasedTiles();
-
-      resource_pool_->ReduceResourceUsage();
-
-      // We don't reserve memory for required-for-activation tiles during
-      // accelerated gestures, so we just postpone activation when we don't
-      // have these tiles, and activate after the accelerated gesture.
-      // Likewise if we don't allow any tiles (as is the case when we're
-      // invisible), if we have tiles that aren't ready, then we shouldn't
-      // activate as activation can cause checkerboards.
-      bool allow_rasterize_on_demand =
-          global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY &&
-          global_state_.memory_limit_policy != ALLOW_NOTHING;
-
-      // Use on-demand raster for any required-for-activation tiles that have
-      // not
-      // been been assigned memory after reaching a steady memory state. This
-      // ensures that we activate even when OOM. Note that we have to rebuilt
-      // the
-      // queue in case the last AssignGpuMemoryToTiles evicted some tiles that
-      // would otherwise not be picked up by the old raster queue.
-      client_->BuildRasterQueue(&raster_priority_queue_,
-                                global_state_.tree_priority);
-      bool ready_to_activate = true;
-      while (!raster_priority_queue_.IsEmpty()) {
-        Tile* tile = raster_priority_queue_.Top();
-        ManagedTileState& mts = tile->managed_state();
-
-        if (tile->required_for_activation() && !mts.draw_info.IsReadyToDraw()) {
-          // If we can't raster on demand, give up early (and don't activate).
-          if (!allow_rasterize_on_demand) {
-            ready_to_activate = false;
-            break;
-          }
-
-          mts.draw_info.set_rasterize_on_demand();
-          client_->NotifyTileStateChanged(tile);
-        }
-        raster_priority_queue_.Pop();
-      }
-
-      if (ready_to_activate) {
-        DCHECK(IsReadyToActivate());
-        ready_to_activate_check_notifier_.Schedule();
-      }
-      raster_priority_queue_.Reset();
+      more_tiles_need_prepare_check_notifier_.Schedule();
       return;
     }
     case REQUIRED_FOR_ACTIVATION:
       ready_to_activate_check_notifier_.Schedule();
       return;
     case REQUIRED_FOR_DRAW:
       ready_to_draw_check_notifier_.Schedule();
       return;
   }
 
@@ skipping 501 matching lines @@
 
   if (did_notify_ready_to_draw_)
     return;
   if (!IsReadyToDraw())
     return;
 
   client_->NotifyReadyToDraw();
   did_notify_ready_to_draw_ = true;
 }
 
+void TileManager::CheckIfMoreTilesNeedPrepare() {
+  tile_task_runner_->CheckForCompletedTasks();
+  did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+
+  // When OOM, keep re-assigning memory until we reach a steady state
+  // where top-priority tiles are initialized.
+  TileVector tiles_that_need_to_be_rasterized;
+  AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
+
+  // |tiles_that_need_to_be_rasterized| will be empty when we reach a
+  // steady memory state. Keep scheduling tasks until we reach this state.
+  if (!tiles_that_need_to_be_rasterized.empty()) {
+    ScheduleTasks(tiles_that_need_to_be_rasterized);
+    return;
+  }
+
+  FreeResourcesForReleasedTiles();
+
+  resource_pool_->ReduceResourceUsage();
+
+  // We don't reserve memory for required-for-activation tiles during
+  // accelerated gestures, so we just postpone activation when we don't
+  // have these tiles, and activate after the accelerated gesture.
+  // Likewise if we don't allow any tiles (as is the case when we're
+  // invisible), if we have tiles that aren't ready, then we shouldn't
+  // activate as activation can cause checkerboards.
+  bool allow_rasterize_on_demand =
+      global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY &&
+      global_state_.memory_limit_policy != ALLOW_NOTHING;
+
+  // Use on-demand raster for any required-for-activation tiles that have
+  // not
+  // been been assigned memory after reaching a steady memory state. This
+  // ensures that we activate even when OOM. Note that we have to rebuilt
+  // the
+  // queue in case the last AssignGpuMemoryToTiles evicted some tiles that
+  // would otherwise not be picked up by the old raster queue.
+  client_->BuildRasterQueue(&raster_priority_queue_,
+                            global_state_.tree_priority);
+  bool ready_to_activate = true;
+  while (!raster_priority_queue_.IsEmpty()) {
+    Tile* tile = raster_priority_queue_.Top();
+    ManagedTileState& mts = tile->managed_state();
+
+    if (tile->required_for_activation() && !mts.draw_info.IsReadyToDraw()) {
+      // If we can't raster on demand, give up early (and don't activate).
+      if (!allow_rasterize_on_demand) {
+        ready_to_activate = false;
+        break;
+      }
+
+      mts.draw_info.set_rasterize_on_demand();
+      client_->NotifyTileStateChanged(tile);
+    }
+    raster_priority_queue_.Pop();
+  }
+
+  if (ready_to_activate) {
+    DCHECK(IsReadyToActivate());
+    ready_to_activate_check_notifier_.Schedule();
+  }
+  raster_priority_queue_.Reset();
+}
+
 TileManager::MemoryUsage::MemoryUsage() : memory_bytes_(0), resource_count_(0) {
 }
 
 TileManager::MemoryUsage::MemoryUsage(int64 memory_bytes, int resource_count)
     : memory_bytes_(memory_bytes), resource_count_(resource_count) {
 }
 
 // static
 TileManager::MemoryUsage TileManager::MemoryUsage::FromConfig(
     const gfx::Size& size,
@@ skipping 31 matching lines @@
   result -= other;
   return result;
 }
 
 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
   return memory_bytes_ > limit.memory_bytes_ ||
          resource_count_ > limit.resource_count_;
 }
 
 }  // namespace cc