cc: Rasterize cheap tiles immediately

cc/tile_manager.cc

Index: cc/tile_manager.cc
diff --git a/cc/tile_manager.cc b/cc/tile_manager.cc
index 3dd12b2ce35077cf5d2d8c8f453e2a6c1e40997f..fa51665fabc9107bd2ddf7cad2af7eedcff70499 100644
--- a/cc/tile_manager.cc
+++ b/cc/tile_manager.cc
@@ -194,7 +194,9 @@ TileManager::TileManager(
       has_performed_uploads_since_last_flush_(false),
       ever_exceeded_memory_budget_(false),
       record_rendering_stats_(false),
-      use_cheapness_estimator_(use_cheapness_estimator) {
+      use_cheapness_estimator_(use_cheapness_estimator),
+      allow_cheap_tasks_(true),
+      did_schedule_cheap_tasks_(false) {
   for (int i = 0; i < NUM_STATES; ++i) {
     for (int j = 0; j < NUM_TREES; ++j) {
       for (int k = 0; k < NUM_BINS; ++k)
@@ -454,6 +456,11 @@ void TileManager::AbortPendingTileUploads() {
   }
 }
 
+void TileManager::DidCompleteFrame() {
+  allow_cheap_tasks_ = true;
+  did_schedule_cheap_tasks_ = false;
+}
+
 void TileManager::GetMemoryStats(
     size_t* memoryRequiredBytes,
     size_t* memoryNiceToHaveBytes,
@@ -651,7 +658,7 @@ void TileManager::FreeResourcesForTile(Tile* tile) {
     resource_pool_->ReleaseResource(managed_tile_state.resource.Pass());
 }
 
-bool TileManager::CanDispatchRasterTask(Tile* tile) {
+bool TileManager::CanDispatchRasterTask(Tile* tile) const {
   if (raster_worker_pool_->IsBusy())
     return false;
   size_t new_bytes_pending = bytes_pending_set_pixels_;
@@ -670,7 +677,7 @@ void TileManager::DispatchMoreTasks() {
     ManagedTileState& managed_state = (*it)->managed_state();
     if (managed_state.pending_pixel_refs.empty()) {
       if (!CanDispatchRasterTask(*it))
-        return;
+        break;

[reveman, 2013/02/19 18:05:23]

hm, this makes us enter the loop below in cases where we didn't before. is that
ok? I think we should probably avoid that in this patch unless there's a good
reason for it.

[Sami, 2013/02/19 22:24:38]

You're right. We only need to make sure the allow_cheap_tasks_ flag is properly
reset and we can do it in a simpler way.

       DispatchOneRasterTask(*it);
       tiles_with_image_decoding_tasks_.erase(it++);
     } else {
@@ -688,11 +695,14 @@ void TileManager::DispatchMoreTasks() {
       tiles_with_image_decoding_tasks_.push_back(tile);
     } else {
       if (!CanDispatchRasterTask(tile))
-        return;
+        break;
       DispatchOneRasterTask(tile);
     }
     tiles_that_need_to_be_rasterized_.pop_back();
   }
+
+  if (did_schedule_cheap_tasks_)
+    allow_cheap_tasks_ = false;
 }
 
 void TileManager::GatherPixelRefsForTile(Tile* tile) {
@@ -748,7 +758,7 @@ void TileManager::DispatchOneImageDecodeTask(
   pending_decode_tasks_[pixel_ref_id] = pixel_ref;
 
   raster_worker_pool_->PostTaskAndReply(
-      base::Bind(&TileManager::RunImageDecodeTask, pixel_ref),
+      base::Bind(&TileManager::PerformImageDecode, pixel_ref),
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
                  tile,
@@ -794,8 +804,12 @@ void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
   scoped_ptr<ResourcePool::Resource> resource = PrepareTileForRaster(tile);
   ResourceProvider::ResourceId resource_id = resource->id();
 
+  bool is_cheap = use_cheapness_estimator_ && allow_cheap_tasks_ &&
+      tile->picture_pile()->IsCheapInRect(tile->content_rect_,
+                                          tile->contents_scale());
   raster_worker_pool_->PostRasterTaskAndReply(
       tile->picture_pile(),
+      is_cheap,
       base::Bind(&TileManager::PerformRaster,
                  resource_pool_->resource_provider()->mapPixelBuffer(
                      resource_id),
@@ -808,22 +822,7 @@ void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
                  tile,
                  base::Passed(&resource),
                  manage_tiles_call_count_));
-}
-
-void TileManager::PerformOneRaster(Tile* tile) {
-  scoped_ptr<ResourcePool::Resource> resource = PrepareTileForRaster(tile);
-  ResourceProvider::ResourceId resource_id = resource->id();
-
-  PerformRaster(resource_pool_->resource_provider()->mapPixelBuffer(
-                    resource_id),
-                tile->content_rect_,
-                tile->contents_scale(),
-                use_cheapness_estimator_,
-                GetRasterTaskMetadata(tile->managed_state()),
-                tile->picture_pile(),
-                &rendering_stats_);
-
-  OnRasterCompleted(tile, resource.Pass(), manage_tiles_call_count_);
+  did_schedule_cheap_tasks_ |= is_cheap;
 }
 
 void TileManager::OnRasterCompleted(
@@ -967,7 +966,7 @@ void TileManager::PerformRaster(uint8* buffer,
                                 10);
 
     if (use_cheapness_estimator) {
-      bool is_predicted_cheap = picture_pile->IsCheapInRect (rect, contents_scale);
+      bool is_predicted_cheap = picture_pile->IsCheapInRect(rect, contents_scale);

[reveman, 2013/02/19 18:05:23]

nit: make this line <= 80 characters long

[Sami, 2013/02/19 22:24:38]

Whoops, done.

       bool is_actually_cheap = duration.InMillisecondsF() <= 1.0f;
       RecordCheapnessPredictorResults(is_predicted_cheap, is_actually_cheap);
     }
@@ -987,9 +986,9 @@ void TileManager::RecordCheapnessPredictorResults(bool is_predicted_cheap,
 }
 
 // static
-void TileManager::RunImageDecodeTask(skia::LazyPixelRef* pixel_ref,
+void TileManager::PerformImageDecode(skia::LazyPixelRef* pixel_ref,
                                      RenderingStats* stats) {
-  TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
+  TRACE_EVENT0("cc", "TileManager::PerformImageDecode");
   base::TimeTicks decode_begin_time;
   if (stats)
     decode_begin_time = base::TimeTicks::HighResNow();