cc: Rasterize cheap tiles immediately

cc/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/tile_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 97 matching lines @@
 
 ManagedTileState::~ManagedTileState() {
   DCHECK(!resource);
   DCHECK(!resource_is_being_initialized);
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads,
-    bool record_rendering_stats)
+    bool record_rendering_stats,
+    bool use_cheapness_estimator)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(RasterWorkerPool::Create(num_raster_threads, record_rendering_stats)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
       bytes_pending_set_pixels_(0),
       ever_exceeded_memory_budget_(false),
-      record_rendering_stats_(record_rendering_stats) {
+      record_rendering_stats_(record_rendering_stats),
+      use_cheapness_estimator_(use_cheapness_estimator) {
   for (int i = 0; i < NUM_STATES; ++i) {
     for (int j = 0; j < NUM_TREES; ++j) {
       for (int k = 0; k < NUM_BINS; ++k)
         raster_state_count_[i][j][k] = 0;
     }
   }
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
@@ skipping 503 matching lines @@
       resource_pool_->AcquireResource(tile->tile_size_.size(), tile->format_);
   resource_pool_->resource_provider()->acquirePixelBuffer(resource->id());
 
   managed_tile_state.resource_is_being_initialized = true;
   managed_tile_state.can_be_freed = false;
 
   DidTileRasterStateChange(tile, RASTER_STATE);
 
   ResourceProvider::ResourceId resource_id = resource->id();
 
+  if (use_cheapness_estimator_ &&
+      tile->picture_pile()->IsCheapInRect(tile->content_rect_,
+                                          tile->contents_scale())) {
+    RunRasterTask(resource_pool_->resource_provider()->mapPixelBuffer(

[Sami, 2013/02/04 13:37:48]

Just checking: do I need to clone the picture for the impl thread here?

[vangelis, 2013/02/04 22:33:50]

You're already on the impl thread here. It doesn't seem like cloning will be
needed.

[reveman, 2013/02/04 22:53:24]

You shouldn't need that. All other threads possibly using the picture will have
a clone and those clones are created on this thread.

+                      resource_id),
+                  tile->content_rect_,
+                  tile->contents_scale(),
+                  tile->picture_pile(),
+                  &rendering_stats_);
+    TileManager::OnRasterTaskCompleted(tile, resource.Pass(),

[reveman, 2013/02/04 22:53:24]

nit: TileManager:: is unnecessary.

[Sami, 2013/02/05 12:26:23]

Done.

+                                       manage_tiles_call_count_);
+    return;
+  }

[reveman, 2013/02/04 22:53:24]

I don't think all this belongs in DispatchOneRasterTask. DispatchMoreTasks()
might be better. In this case you're not really dispatching a task so this
running immediately when DispatchOneRasterTask is called seems a bit misleading
unless we change the function name. Also the CanDispatchRasterTask() check
shouldn't prevent us from running a cheap raster job, right?

[Sami, 2013/02/05 12:26:23]

Agreed, it is a little misleading. I've now split this into
DispatchOneRasterTask() and PerformOneRasterTask() -- hopefully that's clearer.

You're right that CanDispatchRasterTask() shouldn't prevent cheap rasters, but
only once we use sync uploads. With this patch we still need to avoid scheduling
too many async uploads.

+
   raster_worker_pool_->PostRasterTaskAndReply(
       tile->picture_pile(),
       base::Bind(&TileManager::RunRasterTask,
                  resource_pool_->resource_provider()->mapPixelBuffer(
                      resource_id),
                  tile->content_rect_,
                  tile->contents_scale()),
-      base::Bind(&TileManager::OnRasterTaskCompleted,
+      base::Bind(&TileManager::OnRasterTaskCompletedByWorker,
                  base::Unretained(this),
                  tile,
                  base::Passed(&resource),
                  manage_tiles_call_count_));
 }
 
 void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
     int manage_tiles_call_count_when_dispatched) {
@@ skipping 31 matching lines @@
 
     bytes_pending_set_pixels_ += tile->bytes_consumed_if_allocated();
     DidTileRasterStateChange(tile, SET_PIXELS_STATE);
     tiles_with_pending_set_pixels_.push(tile);
   } else {
     resource_pool_->resource_provider()->releasePixelBuffer(resource->id());
     resource_pool_->ReleaseResource(resource.Pass());
     managed_tile_state.resource_is_being_initialized = false;
     DidTileRasterStateChange(tile, IDLE_STATE);
   }
+}
 
+void TileManager::OnRasterTaskCompletedByWorker(
+    scoped_refptr<Tile> tile,
+    scoped_ptr<ResourcePool::Resource> resource,
+    int manage_tiles_call_count_when_dispatched) {
+  OnRasterTaskCompleted(tile, resource.Pass(),

[vangelis, 2013/02/04 22:33:50]

In the "cheap tile" case, don't you still need to dispatch more raster tasks
after you're done with one of them?  It looks like DispatchMoreTasks() only gets
called at completion of a threaded raster. 

+                        manage_tiles_call_count_when_dispatched);
   DispatchMoreTasks();
 }
 
 void TileManager::DidFinishTileInitialization(Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.resource);
   managed_tile_state.resource_is_being_initialized = false;
   managed_tile_state.can_be_freed = true;
 }
 
@@ skipping 54 matching lines @@
     decode_begin_time = base::TimeTicks::Now();
   pixel_ref->Decode();
   if (stats) {
     stats->totalDeferredImageDecodeCount++;
     stats->totalDeferredImageDecodeTime +=
         base::TimeTicks::Now() - decode_begin_time;
   }
 }
 
 }  // namespace cc