Update from https://crrev.com/304121

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 157 matching lines @@
 
  private:
   skia::RefPtr<SkPixelRef> pixel_ref_;
   int layer_id_;
   RenderingStatsInstrumentation* rendering_stats_;
   const base::Callback<void(bool was_canceled)> reply_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
+const char* TaskSetName(TaskSet task_set) {
+  switch (task_set) {
+    case TileManager::ALL:
+      return "ALL";
+    case TileManager::REQUIRED_FOR_ACTIVATION:
+      return "REQUIRED_FOR_ACTIVATION";
+    case TileManager::REQUIRED_FOR_DRAW:
+      return "REQUIRED_FOR_DRAW";
+  }
+
+  NOTREACHED();
+  return "Invalid TaskSet";
+}
+
 }  // namespace
 
 RasterTaskCompletionStats::RasterTaskCompletionStats()
     : completed_count(0u), canceled_count(0u) {}
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>
 RasterTaskCompletionStatsAsValue(const RasterTaskCompletionStats& stats) {
   scoped_refptr<base::debug::TracedValue> state =
       new base::debug::TracedValue();
   state->SetInteger("completed_count", stats.completed_count);
@@ skipping 30 matching lines @@
       rasterizer_(rasterizer),
       scheduled_raster_task_limit_(scheduled_raster_task_limit),
       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 49 matching lines @@
       used_layer_counts_.erase(layer_it);
       image_decode_tasks_.erase(tile->layer_id());
     }
 
     delete tile;
     it = released_tiles_.erase(it);
   }
 }
 
 void TileManager::DidFinishRunningTasks(TaskSet task_set) {
-  if (task_set == ALL) {
-    TRACE_EVENT1("cc", "TileManager::DidFinishRunningTasks", "task_set", "ALL");
+  TRACE_EVENT1("cc", "TileManager::DidFinishRunningTasks", "task_set",
+               TaskSetName(task_set));
 
-    bool memory_usage_above_limit = resource_pool_->total_memory_usage_bytes() >
-                                    global_state_.soft_memory_limit_in_bytes;
+  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;
+      // 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;
 
-    rasterizer_->CheckForCompletedTasks();
-    did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+      rasterizer_->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);
+      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);
+      // |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();
       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());
+    case REQUIRED_FOR_ACTIVATION:
       ready_to_activate_check_notifier_.Schedule();
-    }
-    raster_priority_queue_.Reset();
-    return;
+      return;
+    case 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();
-  }
+  NOTREACHED();
 }
 
 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
   TRACE_EVENT0("cc", "TileManager::ManageTiles");
 
   global_state_ = state;
 
   // We need to call CheckForCompletedTasks() once in-between each call
   // to ScheduleTasks() to prevent canceled tasks from being scheduled.
   if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
@@ skipping 277 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 149 matching lines @@
 
 void TileManager::SetRasterizerForTesting(Rasterizer* rasterizer) {
   rasterizer_ = rasterizer;
   rasterizer_->SetClient(this);
 }
 
 bool TileManager::IsReadyToActivate() const {
   TRACE_EVENT0("cc", "TileManager::IsReadyToActivate");
   const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
 
-  for (std::vector<PictureLayerImpl*>::const_iterator it = layers.begin();
-       it != layers.end();
-       ++it) {
-    if (!(*it)->AllTilesRequiredForActivationAreReadyToDraw())
+  for (const auto& layer : layers) {
+    if (!layer->AllTilesRequiredForActivationAreReadyToDraw())
       return false;
   }
 
+  return true;
+}
+
+bool TileManager::IsReadyToDraw() const {
+  const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
+
+  for (const auto& layer : layers) {
+    if (!layer->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