CC: Add a scheduled action for ManageTiles

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 231 matching lines @@
   AssignGpuMemoryToTiles(GetPrioritizedTileSet(),
                          &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;
   }
 
+  // We don't reserve memory for required-for-activation tiles during
+  // smoothness mode, so it is very likely these tiles will not get memory.
+  // This prevents raster-on-demand and simply delays activation in this case.
+  bool allow_rasterize_on_demand = global_state_.tree_priority
+                                   != SMOOTHNESS_TAKES_PRIORITY;
+
   // 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.
   for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     Tile* tile = it->second;
     ManagedTileState& mts = tile->managed_state();
     ManagedTileState::TileVersion& tile_version =
         mts.tile_versions[mts.raster_mode];
 
-    if (tile->required_for_activation() && !tile_version.IsReadyToDraw())
+    if (tile->required_for_activation() && !tile_version.IsReadyToDraw()) {
+      // If we can't raster on demand, give up early (and don't activate).
+      if (!allow_rasterize_on_demand)

[brianderson, 2013/09/10 02:35:19]

Instead of calling ManageTiles again, would it work to set a flag here
indicating that you should call NotifyReadyToActivate when you exit
SMOOTHNESS_TAKES_PRIORITY?

[epenner, 2013/09/10 18:13:39]

The trouble is we are not ready to activate. Potentially we need to do all of
the following:
- ManageTiles() to prioritize visible pending tiles
- Paint those visible pending tiles.
- Finally, Activate.

Hmm, we could however store a flag indicating we blocked raster-on-demand, and
only trigger ManageTiles in that case. It's very common on Android, but that's
partially due to the URL bar causing invalidations.

[reveman, 2013/09/10 19:21:20]

We should be calling ManageTiles as a result of changing tree priority mode
independent of raster-on-demand. Avoiding that seems like a bad idea.

+        return;
       tile_version.set_rasterize_on_demand();
+    }
   }
 
   client_->NotifyReadyToActivate();
 }
 
 void TileManager::DidFinishRunningTasksRequiredForActivation() {
   // This is only a true indication that all tiles required for
   // activation are initialized when no tiles are OOM. We need to
   // wait for DidFinishRunningTasks() to be called, try to re-assign
   // memory and in worst case use on-demand raster when tiles
@@ skipping 554 matching lines @@
     bytes_releasable_ += tile->bytes_consumed_if_allocated();
     ++resources_releasable_;
   }
 
   FreeUnusedResourcesForTile(tile);
   if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     did_initialize_visible_tile_ = true;
 }
 
 }  // namespace cc