Update from https://crrev.com/314320

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 344 matching lines @@
       did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
     }
 
     FreeResourcesForReleasedTiles();
     CleanUpReleasedTiles();
 
     TileVector tiles_that_need_to_be_rasterized;
     scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
         client_->BuildRasterQueue(global_state_.tree_priority,
                                   RasterTilePriorityQueue::Type::ALL));
+    // Inform the client that will likely require a draw if the top tile is
+    // required for draw.
+    client_->SetIsLikelyToRequireADraw(
+        !raster_priority_queue->IsEmpty() &&
+        raster_priority_queue->Top()->required_for_draw());
     AssignGpuMemoryToTiles(raster_priority_queue.get(),
                            scheduled_raster_task_limit_,
                            &tiles_that_need_to_be_rasterized);
 
     // Schedule tile tasks.
     ScheduleTasks(tiles_that_need_to_be_rasterized);
 
     did_notify_ready_to_activate_ = false;
     did_notify_ready_to_draw_ = false;
   } else {
@@ skipping 448 matching lines @@
 void TileManager::UpdateTileDrawInfo(
     Tile* tile,
     scoped_ptr<ScopedResource> resource,
     const RasterSource::SolidColorAnalysis& analysis) {
   TileDrawInfo& draw_info = tile->draw_info();
 
   ++update_visible_tiles_stats_.completed_count;
 
   if (analysis.is_solid_color) {
     draw_info.set_solid_color(analysis.solid_color);
-    resource_pool_->ReleaseResource(resource.Pass());
+    if (resource)
+      resource_pool_->ReleaseResource(resource.Pass());
   } else {
+    DCHECK(resource);
     draw_info.set_use_resource();
     draw_info.resource_ = resource.Pass();
   }
 
   client_->NotifyTileStateChanged(tile);
 }
 
 scoped_refptr<Tile> TileManager::CreateTile(
     RasterSource* raster_source,
     const gfx::Size& desired_texture_size,
@@ skipping 11 matching lines @@
   used_layer_counts_[tile->layer_id()]++;
   return tile;
 }
 
 void TileManager::SetTileTaskRunnerForTesting(
     TileTaskRunner* tile_task_runner) {
   tile_task_runner_ = tile_task_runner;
   tile_task_runner_->SetClient(this);
 }
 
+bool TileManager::AreRequiredTilesReadyToDraw(
+    RasterTilePriorityQueue::Type type) const {
+  scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
+      client_->BuildRasterQueue(global_state_.tree_priority, type));
+  // It is insufficient to check whether the raster queue we constructed is
+  // empty. The reason for this is that there are situations (rasterize on
+  // demand) when the tile both needs raster and it's ready to draw. Hence, we
+  // have to iterate the queue to check whether the required tiles are ready to
+  // draw.
+  for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
+    if (!raster_priority_queue->Top()->IsReadyToDraw())
+      return false;
+  }
+  return true;
+}
 bool TileManager::IsReadyToActivate() const {
   TRACE_EVENT0("cc", "TileManager::IsReadyToActivate");
-  const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
-
-  // TODO(vmpstr): Replace this with building a REQUIRED_TO_ACTIVATE raster
-  // queue and checking if the tiles it contains are all ready to draw.
-  for (const auto& layer : layers) {
-    if (!layer->AllTilesRequiredForActivationAreReadyToDraw())
-      return false;
-  }
-
-  return true;
+  return AreRequiredTilesReadyToDraw(
+      RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
 }
 
 bool TileManager::IsReadyToDraw() const {
-  const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
-
-  // TODO(vmpstr): Replace this with building a REQUIRED_TO_DRAW raster queue
-  // and checking if the tiles it contains are all ready to draw.
-  for (const auto& layer : layers) {
-    if (!layer->AllTilesRequiredForDrawAreReadyToDraw())
-      return false;
-  }
-
-  return true;
+  TRACE_EVENT0("cc", "TileManager::IsReadyToDraw");
+  return AreRequiredTilesReadyToDraw(
+      RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
 }
 
 void TileManager::NotifyReadyToActivate() {
   TRACE_EVENT0("cc", "TileManager::NotifyReadyToActivate");
   if (did_notify_ready_to_activate_)
     return;
   client_->NotifyReadyToActivate();
   did_notify_ready_to_activate_ = true;
 }
 
@@ skipping 140 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