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 348 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_->NotifyTileInitialized(tile);

[vmpstr, 2014/05/15 17:46:23]

This means that we might end up calling NotifyTileInitialized multiple times
right? I mean it's a somewhat awkward state to deal with (rasterize_on_demand).
It causes us to be able to draw, but it also will need rasterization. I'm not
sure if it's correct to say it's been initialized or not, tbh.

[reveman, 2014/05/15 19:01:43]

That's already the case as we have multiple tile versions but we might want to
change the name of this function to make this less confusing.
NotifyReadyToDrawStateChanged? The important part is that we can track damage
correctly.

[vmpstr, 2014/05/16 00:38:45]

Fair enough. I agree that with versions it should probably be a different name.
Also tile versions make the counts hard to maintain, so I'm glad that we won't
need them.

     }
   }
 
-  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 316 matching lines @@
       }
     }
 
     // Tile is OOM.
     if (tile_bytes > tile_bytes_left || tile_resources > resources_left) {
       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_)

[vmpstr, 2014/05/15 17:46:23]

Why this change?

[reveman, 2014/05/15 19:01:43]

We can't handle situations where the renderer doesn't support on-demand in the
tile manager anymore as this not where we decide if tiles are ready.

[vmpstr, 2014/05/16 00:38:45]

I don't follow. This part was there to prevent us from releasing active tree
visible tiles (or at least to immediatly replace them with rasterize on demand
content. I think the same applies if we don't support rasterize on demand,
except that we would flash/display checkerboard.

Besides, if rasterize on demand doesn't work, then how will this behave? Also,
should we call client_->NotifyReadyToDrawStateChanged? (we should probably name
this something entirely different since in the case of versions, we didn't
change the draw state, we just changed which resource we're using to draw)

[reveman, 2014/05/16 16:50:13]

This patch just moves the awareness of support for raster-on-demand to the
layer. As far as the tile manager knows. Raster-on-demand is now always
supported. The layer will simply avoid to generate on-demand quads if not
supported by the Renderer. The critical part is that the layer knows the
difference between a "real" checkboard tile and an on-demand tile that just
happens to be checkboard because the renderer doesn't support anything else.
That's needed for the layer to be able to determine if it's in a state where
it's ready to be activated.
The result will be the same as before. The tile will be marked as on-demand but
the layer will produce a checkerboard quad for it as on-demand is not supported.

Also,
Yes, calling NotifyTileStateChanged here makes sense. I changed this a bit in
latest patch to make sure this client callback is now issued whenever the tile
state changes in a way that might affect output.

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

Oh, I missed the bit where it's handled in AppendQuads. Thanks for the
explanation.

+      if (mts.visible_and_ready_to_draw)
         tile_version.set_rasterize_on_demand();
 
       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;
@@ skipping 705 matching lines @@
   bool prioritize_low_res = tree_priority_ != SMOOTHNESS_TAKES_PRIORITY;
 
   if (b_priority.resolution != a_priority.resolution) {
     return (prioritize_low_res && b_priority.resolution == LOW_RESOLUTION) ||
            (!prioritize_low_res && b_priority.resolution == HIGH_RESOLUTION) ||
            (a_priority.resolution == NON_IDEAL_RESOLUTION);
   }
   return a_priority.IsHigherPriorityThan(b_priority);
 }
 
+bool TileManager::IsReadyToActivate() const {
+  for (std::vector<PictureLayerImpl*>::const_iterator it = layers_.begin();

[vmpstr, 2014/05/16 00:38:45]

This is probably dependent on my patch that clears layers that are not in RSLL.
That patch in part depends on another part, so it might be a couple of days
before that lands.

[reveman, 2014/05/16 16:50:13]

Yes, we should hold off on this until that lands.

+       it != layers_.end();
+       ++it) {
+    if (!(*it)->AllTilesRequiredForActivationAreReadyToDraw())
+      return false;
+  }
+
+  return true;
+}
+
+void TileManager::ScheduleCheckIfReadyToActivate() {
+  if (check_if_ready_to_activate_pending_)

[vmpstr, 2014/05/16 00:38:45]

As an aside, this pattern seems to be in a few places:

ScheduleCheck
  if already_scheduled:
    return
  schedule and post
  already_scheduled = true

Is it worth it to extract that into UniqueNotification or something like that,
where it would take a task as a constructor/setting and then you just have to do
UniqueNotification un(task); un.Schedule(); or something?

[reveman, 2014/05/16 16:50:13]

Yes, that would be nice and we can probably bake the weak ptr stuff into that
too. This would be a separate patch though.

+    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