cc: ReadyToDraw notifications.

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 225 matching lines @@
       resource_pool_(resource_pool),
       rasterizer_(rasterizer),
       all_tiles_that_need_to_be_rasterized_are_scheduled_(true),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       did_initialize_visible_tile_(false),
       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))) {
+                     base::Unretained(this))),
+      ready_to_draw_check_notifier_(task_runner_.get(),
+                                    base::Bind(&TileManager::CheckIfReadyToDraw,
+                                               base::Unretained(this))) {
   rasterizer_->SetClient(this);
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
 
   RasterTaskQueue empty;
   rasterizer_->ScheduleTasks(&empty);
@@ skipping 121 matching lines @@
     }
 
     if (ready_to_activate) {
       DCHECK(IsReadyToActivate());
       ready_to_activate_check_notifier_.Schedule();
     }
     raster_priority_queue_.Reset();
     return;
   }
 
+  if (task_set == REQUIRED_FOR_DRAW) {

[brianderson, 2014/10/24 01:34:04]

Can a task_set be both required for draw and required for activation? How does
this make sure we get both notifications if the pending tree has no new tiles
compared to the active tree?

[ernstm, 2014/10/24 04:54:20]

We get separate DidFinishRunningTasks notifications for each set that finishes. 
They are sent when all tasks in a set finished. If a set is empty (e.g. no tiles
required for activation), we still get a notification for it.

+    TRACE_EVENT1("cc",
+                 "TileManager::DidFinishRunningTasks",
+                 "task_set",
+                 "REQUIRED_FOR_DRAW");
+    ready_to_draw_check_notifier_.Schedule();
+    return;
+  }
+
   if (task_set == REQUIRED_FOR_ACTIVATION) {
     TRACE_EVENT1("cc",
                  "TileManager::DidFinishRunningTasks",
                  "task_set",
                  "REQUIRED_FOR_ACTIVATION");
     ready_to_activate_check_notifier_.Schedule();
   }
 }
 
 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
@@ skipping 283 matching lines @@
 
     DCHECK(mts.draw_info.requires_resource());
     DCHECK(!mts.draw_info.resource_);
 
     if (!mts.raster_task.get())
       mts.raster_task = CreateRasterTask(tile);
 
     TaskSetCollection task_sets;
     if (tile->required_for_activation())
       task_sets.set(REQUIRED_FOR_ACTIVATION);
+    if (tile->required_for_draw())
+      task_sets.set(REQUIRED_FOR_DRAW);
     task_sets.set(ALL);
     raster_queue_.items.push_back(
         RasterTaskQueue::Item(mts.raster_task.get(), task_sets));
   }
 
   // We must reduce the amount of unused resoruces before calling
   // ScheduleTasks to prevent usage from rising above limits.
   resource_pool_->ReduceResourceUsage();
 
   // Schedule running of |raster_queue_|. This replaces any previously
@@ skipping 159 matching lines @@
   for (std::vector<PictureLayerImpl*>::const_iterator it = layers.begin();
        it != layers.end();
        ++it) {
     if (!(*it)->AllTilesRequiredForActivationAreReadyToDraw())
       return false;
   }
 
   return true;
 }
 
+bool TileManager::IsReadyToDraw() const {
+  const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
+
+  for (std::vector<PictureLayerImpl*>::const_iterator it = layers.begin();
+       it != layers.end();
+       ++it) {
+    if (!(*it)->AllTilesRequiredForDrawAreReadyToDraw())
+      return false;
+  }
+
+  return true;
+}
+
 void TileManager::CheckIfReadyToActivate() {
   TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate");
 
   rasterizer_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   if (IsReadyToActivate())
     client_->NotifyReadyToActivate();
 }
 
+void TileManager::CheckIfReadyToDraw() {
+  TRACE_EVENT0("cc", "TileManager::CheckIfReadyToDraw");
+
+  rasterizer_->CheckForCompletedTasks();
+  did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+
+  if (IsReadyToDraw())
+    client_->NotifyReadyToDraw();
+}
+
 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