cc: Fix memory limit edge cases for SetIsLikelyToRequireADraw.

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 408 matching lines @@
 
   scoped_ptr<RasterTilePriorityQueue> required_for_draw_queue(
       client_->BuildRasterQueue(
           global_state_.tree_priority,
           RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW));
   TileVector tiles_that_need_to_be_rasterized;
   AssignGpuMemoryToTiles(required_for_draw_queue.get(),
                          std::numeric_limits<size_t>::max(),
                          &tiles_that_need_to_be_rasterized);
 
+  // Since we are synchronously rasterizing all tiles, we don't require further
+  // draws for that. Set the flag to false so that we can clear it if it was set
+  // earlier by PrepareTiles.
+  client_->SetIsLikelyToRequireADraw(false);

[vmpstr, 2015/03/27 17:23:28]

Just FYI, this function is kind of slated for removal. crbug.com/457860

[sunnyps, 2015/03/27 18:38:04]

Yeah, would be nice to keep the test while it's alive.

+
   // We must reduce the amount of unused resources before calling
   // RunTasks to prevent usage from rising above limits.
   resource_pool_->ReduceResourceUsage();
 
   // Run and complete all raster task synchronously.
   rasterizer_->RasterizeTiles(
       tiles_that_need_to_be_rasterized, resource_pool_,
       tile_task_runner_->GetResourceFormat(),
       base::Bind(&TileManager::UpdateTileDrawInfo, base::Unretained(this)));
 
@@ skipping 430 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);
 }
 
+void TileManager::CheckIfMoreTilesNeedToBePreparedForTesting() {
+  CheckIfMoreTilesNeedToBePrepared();

[vmpstr, 2015/03/27 17:23:28]

Feel free to inline this. (We don't typically implement ForTesting functionality
in .cc)

[sunnyps, 2015/03/27 18:38:04]

Done.

+}
+
 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()) {
@@ skipping 51 matching lines @@
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   if (did_notify_ready_to_draw_)
     return;
   if (!IsReadyToDraw())
     return;
 
   NotifyReadyToDraw();
 }
 
 void TileManager::CheckIfMoreTilesNeedToBePrepared() {

[vmpstr, 2015/03/27 17:23:28]

Kind of thinking out loud, but this function and PrepareTiles function share
quite a bit of code, and it would probably be nice to refactor at some point :)

[sunnyps, 2015/03/27 18:38:04]

Acknowledged.

   tile_task_runner_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   // When OOM, keep re-assigning memory until we reach a steady state
   // where top-priority tiles are initialized.
   TileVector tiles_that_need_to_be_rasterized;
   scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
       client_->BuildRasterQueue(global_state_.tree_priority,
                                 RasterTilePriorityQueue::Type::ALL));
   AssignGpuMemoryToTiles(raster_priority_queue.get(),
                          scheduled_raster_task_limit_,
                          &tiles_that_need_to_be_rasterized);
 
+  // Inform the client that will likely require a draw if the highest priority
+  // tile that will be rasterized is required for draw.
+  client_->SetIsLikelyToRequireADraw(
+      !tiles_that_need_to_be_rasterized.empty() &&
+      (*tiles_that_need_to_be_rasterized.begin())->required_for_draw());
+
   // |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();
@@ skipping 79 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