Re-land: cc: Examine layers to determine if we're ready to activate.

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 347 matching lines @@
     const RasterTaskCompletionStats& stats) {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->SetInteger("completed_count", stats.completed_count);
   state->SetInteger("canceled_count", stats.canceled_count);
   return state.PassAs<base::Value>();
 }
 
 // static
 scoped_ptr<TileManager> TileManager::Create(
     TileManagerClient* client,
+    base::SequencedTaskRunner* task_runner,
     ResourcePool* resource_pool,
     Rasterizer* rasterizer,
     Rasterizer* gpu_rasterizer,
-    bool use_rasterize_on_demand,
     RenderingStatsInstrumentation* rendering_stats_instrumentation) {
   return make_scoped_ptr(new TileManager(client,
+                                         task_runner,
                                          resource_pool,
                                          rasterizer,
                                          gpu_rasterizer,
-                                         use_rasterize_on_demand,
                                          rendering_stats_instrumentation));
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
+    base::SequencedTaskRunner* task_runner,
     ResourcePool* resource_pool,
     Rasterizer* rasterizer,
     Rasterizer* gpu_rasterizer,
-    bool use_rasterize_on_demand,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
     : client_(client),
+      task_runner_(task_runner),
       resource_pool_(resource_pool),
       prioritized_tiles_dirty_(false),
       all_tiles_that_need_to_be_rasterized_have_memory_(true),
       all_tiles_required_for_activation_have_memory_(true),
       memory_required_bytes_(0),
       memory_nice_to_have_bytes_(0),
       bytes_releasable_(0),
       resources_releasable_(0),
       ever_exceeded_memory_budget_(false),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       did_initialize_visible_tile_(false),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
-      use_rasterize_on_demand_(use_rasterize_on_demand) {
+      check_if_ready_to_activate_pending_(false),
+      weak_ptr_factory_(this) {
   Rasterizer* rasterizers[NUM_RASTERIZER_TYPES] = {
       rasterizer,      // RASTERIZER_TYPE_DEFAULT
       gpu_rasterizer,  // RASTERIZER_TYPE_GPU
   };
   rasterizer_delegate_ =
       RasterizerDelegate::Create(this, rasterizers, arraysize(rasterizers));
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
@@ skipping 116 matching lines @@
   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 we can't raster on demand, give up early (and don't activate).
       if (!allow_rasterize_on_demand)
         return;
-      if (use_rasterize_on_demand_)
-        tile_version.set_rasterize_on_demand();
+
+      tile_version.set_rasterize_on_demand();
+      client_->NotifyTileStateChanged(tile);
     }
   }
 
-  client_->NotifyReadyToActivate();
+  DCHECK(IsReadyToActivate());
+  ScheduleCheckIfReadyToActivate();
 }
 
 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
   // required for activation are OOM.
   if (!all_tiles_required_for_activation_have_memory_)
     return;
 
-  client_->NotifyReadyToActivate();
+  ScheduleCheckIfReadyToActivate();
 }
 
 void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet* tiles) {
   TRACE_EVENT0("cc", "TileManager::GetTilesWithAssignedBins");
 
   // Compute new stats to be return by GetMemoryStats().
   memory_required_bytes_ = 0;
   memory_nice_to_have_bytes_ = 0;
 
   const TileMemoryLimitPolicy memory_policy = global_state_.memory_limit_policy;
@@ skipping 95 matching lines @@
 
     mts.visible_and_ready_to_draw =
         tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN;
 
     // If the tile is in NEVER_BIN and it does not have an active task, then we
     // can release the resources early. If it does have the task however, we
     // should keep it in the prioritized tile set to ensure that AssignGpuMemory
     // can visit it.
     if (mts.bin == NEVER_BIN &&
         !mts.tile_versions[mts.raster_mode].raster_task_) {
-      FreeResourcesForTile(tile);
+      FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);

[vmpstr, 2014/05/16 17:09:06]

yay 56 character function names :P

       continue;
     }
 
     // Insert the tile into a priority set.
     tiles->InsertTile(tile, mts.bin);
   }
 }
 
 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
   TRACE_EVENT0("cc", "TileManager::ManageTiles");
@@ skipping 153 matching lines @@
 
     ManagedTileState::TileVersion& tile_version =
         mts.tile_versions[mts.raster_mode];
 
     // If this tile doesn't need a resource, then nothing to do.
     if (!tile_version.requires_resource())
       continue;
 
     // If the tile is not needed, free it up.
     if (mts.bin == NEVER_BIN) {
-      FreeResourcesForTile(tile);
+      FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
       continue;
     }
 
     const bool tile_uses_hard_limit = mts.bin <= NOW_BIN;
     const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile);
     const size_t tile_bytes_left =
         (tile_uses_hard_limit) ? hard_bytes_left : soft_bytes_left;
 
     // Hard-limit is reserved for tiles that would cause a calamity
     // if they were to go away, so by definition they are the highest
@@ skipping 21 matching lines @@
       // If we don't have the required version, and it's not in flight
       // then we'll have to pay to create a new task.
       if (!tile_version.resource_ && !tile_version.raster_task_) {
         tile_bytes += bytes_if_allocated;
         tile_resources++;
       }
     }
 
     // Tile is OOM.
     if (tile_bytes > tile_bytes_left || tile_resources > resources_left) {
+      bool was_ready_to_draw = tile->IsReadyToDraw();
+
       FreeResourcesForTile(tile);
 
       // This tile was already on screen and now its resources have been
       // released. In order to prevent checkerboarding, set this tile as
       // rasterize on demand immediately.
-      if (mts.visible_and_ready_to_draw && use_rasterize_on_demand_)
+      if (mts.visible_and_ready_to_draw)
         tile_version.set_rasterize_on_demand();
 
+      if (was_ready_to_draw)
+        client_->NotifyTileStateChanged(tile);
+
       oomed_soft = true;
       if (tile_uses_hard_limit) {
         oomed_hard = true;
         bytes_that_exceeded_memory_budget += tile_bytes;
       }
     } else {
       resources_left -= tile_resources;
       hard_bytes_left -= tile_bytes;
       soft_bytes_left =
           (soft_bytes_left > tile_bytes) ? soft_bytes_left - tile_bytes : 0;
@@ skipping 74 matching lines @@
       break;
     }
   }
 
   for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
     if (mode != used_mode)
       FreeResourceForTile(tile, static_cast<RasterMode>(mode));
   }
 }
 
+void TileManager::FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(
+    Tile* tile) {
+  bool was_ready_to_draw = tile->IsReadyToDraw();
+  FreeResourcesForTile(tile);
+  if (was_ready_to_draw)
+    client_->NotifyTileStateChanged(tile);
+}
+
 void TileManager::ScheduleTasks(
     const TileVector& tiles_that_need_to_be_rasterized) {
   TRACE_EVENT1("cc",
                "TileManager::ScheduleTasks",
                "count",
                tiles_that_need_to_be_rasterized.size());
 
   DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
 
   for (size_t i = 0; i < NUM_RASTERIZER_TYPES; ++i)
@@ skipping 176 matching lines @@
     tile_version.set_solid_color(analysis.solid_color);
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
     tile_version.set_use_resource();
     tile_version.resource_ = resource.Pass();
 
     bytes_releasable_ += BytesConsumedIfAllocated(tile);
     ++resources_releasable_;
   }
 
-  client_->NotifyTileInitialized(tile);
-
   FreeUnusedResourcesForTile(tile);
   if (tile->priority(ACTIVE_TREE).distance_to_visible == 0.f)
     did_initialize_visible_tile_ = true;
+
+  client_->NotifyTileStateChanged(tile);
 }
 
 scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
                                             const gfx::Size& tile_size,
                                             const gfx::Rect& content_rect,
                                             const gfx::Rect& opaque_rect,
                                             float contents_scale,
                                             int layer_id,
                                             int source_frame_number,
                                             int flags) {
@@ skipping 415 matching lines @@
   return a_priority.IsHigherPriorityThan(b_priority);
 }
 
 void TileManager::SetRasterizersForTesting(Rasterizer* rasterizer,
                                            Rasterizer* gpu_rasterizer) {
   Rasterizer* rasterizers[2] = {rasterizer, gpu_rasterizer};
   rasterizer_delegate_ =
       RasterizerDelegate::Create(this, rasterizers, arraysize(rasterizers));
 }
 
+bool TileManager::IsReadyToActivate() const {
+  for (std::vector<PictureLayerImpl*>::const_iterator it = layers_.begin();
+       it != layers_.end();
+       ++it) {
+    if (!(*it)->AllTilesRequiredForActivationAreReadyToDraw())
+      return false;
+  }
+
+  return true;
+}
+
+void TileManager::ScheduleCheckIfReadyToActivate() {
+  if (check_if_ready_to_activate_pending_)
+    return;
+
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&TileManager::CheckIfReadyToActivate,
+                                    weak_ptr_factory_.GetWeakPtr()));
+  check_if_ready_to_activate_pending_ = true;
+}
+
+void TileManager::CheckIfReadyToActivate() {
+  DCHECK(check_if_ready_to_activate_pending_);
+  check_if_ready_to_activate_pending_ = false;
+
+  rasterizer_delegate_->CheckForCompletedTasks();
+  did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+
+  if (IsReadyToActivate())
+    client_->NotifyReadyToActivate();
+}
+
 }  // namespace cc