cc: Add new RasterWorkerPool interface.

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 <string>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
-#include "cc/resources/raster_worker_pool.h"
-#include "cc/resources/resource_pool.h"
+#include "cc/resources/image_raster_worker_pool.h"
+#include "cc/resources/pixel_buffer_raster_worker_pool.h"
 #include "cc/resources/tile.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 
 namespace {
 
-// If we raster too fast we become upload bound, and pending
-// uploads consume memory. For maximum upload throughput, we would
-// want to allow for upload_throughput * pipeline_time of pending
-// uploads, after which we are just wasting memory. Since we don't
-// know our upload throughput yet, this just caps our memory usage.
-#if defined(OS_ANDROID)
-// For reference, the Nexus10 can upload 1MB in about 2.5ms.
-// Assuming a three frame deep pipeline this implies ~20MB.
-const size_t kMaxPendingUploadBytes = 20 * 1024 * 1024;
-// TODO(epenner): We should remove this upload limit (crbug.com/176197)
-const size_t kMaxPendingUploads = 72;
-#else
-const size_t kMaxPendingUploadBytes = 100 * 1024 * 1024;
-const size_t kMaxPendingUploads = 1000;
-#endif
-
-#if defined(OS_ANDROID)
-const int kMaxNumPendingTasksPerThread = 8;
-#else
-const int kMaxNumPendingTasksPerThread = 40;
-#endif
-
 // Determine bin based on three categories of tiles: things we need now,
 // things we need soon, and eventually.
 inline TileManagerBin BinFromTilePriority(const TilePriority& prio) {
   // The amount of time for which we want to have prepainting coverage.
   const float kPrepaintingWindowTimeSeconds = 1.0f;
   const float kBackflingGuardDistancePixels = 314.0f;
 
   if (prio.time_to_visible_in_seconds == 0)
     return NOW_BIN;
 
@@ skipping 47 matching lines @@
 }
 
 // static
 scoped_ptr<TileManager> TileManager::Create(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads,
     bool use_color_estimator,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     bool use_map_image) {
-  scoped_ptr<RasterWorkerPool> raster_worker_pool =
-      RasterWorkerPool::Create(num_raster_threads);
-  return make_scoped_ptr(new TileManager(client,
-                                         resource_provider,
-                                         raster_worker_pool.Pass(),
-                                         num_raster_threads,
-                                         use_color_estimator,
-                                         rendering_stats_instrumentation,
-                                         use_map_image));
+  return make_scoped_ptr(
+      new TileManager(client,
+                      resource_provider,
+                      use_map_image ?
+                      ImageRasterWorkerPool::Create(
+                          resource_provider, num_raster_threads) :
+                      PixelBufferRasterWorkerPool::Create(
+                          resource_provider, num_raster_threads),
+                      num_raster_threads,
+                      use_color_estimator,
+                      rendering_stats_instrumentation,
+                      use_map_image));
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     scoped_ptr<RasterWorkerPool> raster_worker_pool,
     size_t num_raster_threads,
     bool use_color_estimator,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     bool use_map_image)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(raster_worker_pool.Pass()),
       manage_tiles_pending_(false),
-      bytes_pending_upload_(0),
-      has_performed_uploads_since_last_flush_(false),
       ever_exceeded_memory_budget_(false),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       use_color_estimator_(use_color_estimator),
-      did_initialize_visible_tile_(false),
-      max_pending_tasks_(kMaxNumPendingTasksPerThread * num_raster_threads) {
+      did_initialize_visible_tile_(false) {
   raster_worker_pool_->SetClient(this);
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
   AssignGpuMemoryToTiles();
   // This should finish all pending tasks and release any uninitialized
   // resources.
   raster_worker_pool_->Shutdown();
-  AbortPendingTileUploads();
-  DCHECK_EQ(0u, tiles_with_pending_upload_.size());
   DCHECK_EQ(0u, tiles_.size());
 }
 
 void TileManager::SetGlobalState(
     const GlobalStateThatImpactsTilePriority& global_state) {
   global_state_ = global_state;
   resource_pool_->SetMaxMemoryUsageBytes(
       global_state_.memory_limit_in_bytes,
       global_state_.unused_memory_limit_in_bytes);
   ScheduleManageTiles();
@@ skipping 146 matching lines @@
 
   TRACE_EVENT_INSTANT1(
       "cc", "DidManage", TRACE_EVENT_SCOPE_THREAD,
       "state", TracedValue::FromValue(BasicStateAsValue().release()));
 
   // Finally, schedule rasterizer tasks.
   ScheduleTasks();
 }
 
 void TileManager::CheckForCompletedTileUploads() {
-  while (!tiles_with_pending_upload_.empty()) {
-    Tile* tile = tiles_with_pending_upload_.front();
-    DCHECK(tile->tile_version().resource_);
-
-    // Set pixel tasks complete in the order they are posted.
-    if (!resource_pool_->resource_provider()->DidSetPixelsComplete(
-          tile->tile_version().resource_->id())) {
-      break;
-    }
-
-    // It's now safe to release the pixel buffer.
-    resource_pool_->resource_provider()->ReleasePixelBuffer(
-        tile->tile_version().resource_->id());
-
-    bytes_pending_upload_ -= tile->bytes_consumed_if_allocated();
-    bool was_forced = tile->tile_version().forced_upload_;
-    // Reset forced_upload_ since we now got the upload completed notification.
-    tile->tile_version().forced_upload_ = false;
-    tile->tile_version().memory_state_ = USING_RELEASABLE_MEMORY;
-    if (!was_forced)
-      DidFinishTileInitialization(tile);
-
-    tiles_with_pending_upload_.pop();
-  }
-
-  ScheduleTasks();
-}
-
-void TileManager::AbortPendingTileUploads() {
-  while (!tiles_with_pending_upload_.empty()) {
-    Tile* tile = tiles_with_pending_upload_.front();
-    DCHECK(tile->tile_version().resource_);
-
-    resource_pool_->resource_provider()->AbortSetPixels(
-        tile->tile_version().resource_->id());
-    resource_pool_->resource_provider()->ReleasePixelBuffer(
-        tile->tile_version().resource_->id());
-    tile->tile_version().memory_state_ = USING_RELEASABLE_MEMORY;
-
-    FreeResourcesForTile(tile);
-
-    bytes_pending_upload_ -= tile->bytes_consumed_if_allocated();
-    tiles_with_pending_upload_.pop();
-  }
+  raster_worker_pool_->CheckForCompletedTasks();
 }
 
 void TileManager::ForceTileUploadToComplete(Tile* tile) {
   DCHECK(tile);
-  if (tile->tile_version().resource_ &&
+  if (tile->tile_version().resource_id_ &&
       tile->tile_version().memory_state_ == USING_UNRELEASABLE_MEMORY &&
       !tile->tile_version().forced_upload_) {
-    resource_pool_->resource_provider()->
-        ForceSetPixelsToComplete(tile->tile_version().resource_->id());
+    if (!raster_worker_pool_->ForceUploadToComplete(
+            tile->tile_version().resource_id_))
+      return;
 
-    // We have to set the memory state to be unreleasable, to ensure
-    // that the tile will not be freed until we get the upload finished
-    // notification. However, setting |forced_upload_| to true makes
-    // this tile ready to draw.
-    tile->tile_version().memory_state_ = USING_UNRELEASABLE_MEMORY;
+    // Setting |forced_upload_| to true makes this tile ready to draw.
     tile->tile_version().forced_upload_ = true;
     DidFinishTileInitialization(tile);
     DCHECK(tile->tile_version().IsReadyToDraw());
   }
 
   if (did_initialize_visible_tile_) {
     did_initialize_visible_tile_ = false;
     client_->DidInitializeVisibleTile();
   }
 }
@@ skipping 59 matching lines @@
 }
 
 void TileManager::AddRequiredTileForActivation(Tile* tile) {
   DCHECK(std::find(tiles_that_need_to_be_initialized_for_activation_.begin(),
                    tiles_that_need_to_be_initialized_for_activation_.end(),
                    tile) ==
          tiles_that_need_to_be_initialized_for_activation_.end());
   tiles_that_need_to_be_initialized_for_activation_.insert(tile);
 }
 
-void TileManager::DidFinishDispatchingWorkerPoolCompletionCallbacks() {
-  // If a flush is needed, do it now before starting to dispatch more tasks.
-  if (has_performed_uploads_since_last_flush_) {
-    resource_pool_->resource_provider()->ShallowFlushIfSupported();
-    has_performed_uploads_since_last_flush_ = false;
+void TileManager::DidFinishDispatchingRasterWorkerPoolCompletionCallbacks() {
+  if (did_initialize_visible_tile_) {

[vmpstr, 2013/05/29 16:55:03]

This block of code repeats in at least one other spot. Maybe it's worth making
something like "NotifyClientOfVisibleTileInitialization" and call that here and
wherever the code appears

[reveman, 2013/05/29 19:39:12]

I'm planning to remove this function and the RasterWorkerPoolClient interface
completely before this patch is ready to land. I think that will clean it up
nicely.

[vmpstr, 2013/05/29 20:45:06]

Sounds good.

[reveman, 2013/05/30 01:46:10]

Please take a look at latest patch.

+    did_initialize_visible_tile_ = false;
+    client_->DidInitializeVisibleTile();
   }
-
-  ScheduleTasks();
 }
 
 void TileManager::AssignGpuMemoryToTiles() {
   TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
   size_t unreleasable_bytes = 0;
 
   // Now give memory out to the tiles until we're out, and build
   // the needs-to-be-rasterized queue.
   tiles_that_need_to_be_rasterized_.clear();
   tiles_that_need_to_be_initialized_for_activation_.clear();
@@ skipping 151 matching lines @@
   DCHECK_NE(USING_UNRELEASABLE_MEMORY, tile->tile_version().memory_state_);
   if (tile->tile_version().resource_) {
     resource_pool_->ReleaseResource(
         tile->tile_version().resource_.Pass());
   }
   tile->tile_version().memory_state_ = NOT_ALLOWED_TO_USE_MEMORY;
 }
 
 void TileManager::ScheduleTasks() {
   TRACE_EVENT0("cc", "TileManager::ScheduleTasks");
-  RasterWorkerPool::Task::Queue tasks;
-
-  size_t bytes_pending_upload = bytes_pending_upload_;
-  unsigned pending_tasks = 0;
+  RasterWorkerPool::RasterTask::Queue tasks;
 
   // Build a new task queue containing all task currently needed. Tasks
   // are added in order of priority, highest priority task first.
   for (TileVector::iterator it = tiles_that_need_to_be_rasterized_.begin();
        it != tiles_that_need_to_be_rasterized_.end();
        ++it) {
     Tile* tile = *it;
     ManagedTileState& mts = tile->managed_state();
 
-    // Skip tile if determined to not require resource.
-    if (!tile->tile_version().requires_resource())
-      continue;
-
-    // Skip tile if already rasterized.
-    if (tile->tile_version().resource_)
-      continue;
-
-    // TODO(reveman): Remove throttling based on max pending tasks.
-    if (pending_tasks >= max_pending_tasks_)
-      break;
-
-    // TODO(reveman): Remove throttling based on max pending uploads.
-    if (tiles_with_pending_upload_.size() >= kMaxPendingUploads)
-      break;
-
-    // TODO(reveman): Throttle based on shared memory usage rather
-    // than bytes pending upload.
-    size_t new_bytes_pending = bytes_pending_upload;
-    new_bytes_pending += tile->bytes_consumed_if_allocated();
-    if (new_bytes_pending > kMaxPendingUploadBytes)
-      break;
-    bytes_pending_upload = new_bytes_pending;
+    DCHECK(tile->tile_version().requires_resource());
+    DCHECK(!tile->tile_version().resource_);
 
     // Create raster task for this tile if necessary.
     if (mts.raster_task.is_null())
       mts.raster_task = CreateRasterTask(tile);
 
     // Finally append raster task.
     tasks.Append(mts.raster_task);
-    pending_tasks++;
   }
 
-  if (!tasks.empty()) {
-    RasterWorkerPool::Task root(&tasks);
-
-    // Schedule running of |tasks|. This replaces any previously
-    // scheduled tasks and effectively cancels all tasks not present
-    // in |tasks|.
-    raster_worker_pool_->ScheduleTasks(&root);
-  } else {
-    raster_worker_pool_->ScheduleTasks(NULL);
-  }
-
-  if (did_initialize_visible_tile_) {
-    did_initialize_visible_tile_ = false;
-    client_->DidInitializeVisibleTile();
-  }
+  // Schedule running of |tasks|. This replaces any previously
+  // scheduled tasks and effectively cancels all tasks not present
+  // in |tasks|.
+  raster_worker_pool_->ScheduleTasks(&tasks);
 }
 
 RasterWorkerPool::Task TileManager::CreateImageDecodeTask(
     Tile* tile, skia::LazyPixelRef* pixel_ref) {
   TRACE_EVENT0("cc", "TileManager::CreateImageDecodeTask");
 
   return RasterWorkerPool::Task(
       base::Bind(&TileManager::RunImageDecodeTask,
                  pixel_ref,
                  tile->layer_id(),
                  rendering_stats_instrumentation_),
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
                  make_scoped_refptr(tile),
                  pixel_ref->getGenerationID()));
 }
 
 void TileManager::OnImageDecodeTaskCompleted(scoped_refptr<Tile> tile,
-                                             uint32_t pixel_ref_id,
-                                             bool was_canceled) {
+                                             uint32_t pixel_ref_id) {
   TRACE_EVENT0("cc", "TileManager::OnImageDecodeTaskCompleted");
   DCHECK(pending_decode_tasks_.find(pixel_ref_id) !=
          pending_decode_tasks_.end());
   pending_decode_tasks_.erase(pixel_ref_id);
 }
 
 TileManager::RasterTaskMetadata TileManager::GetRasterTaskMetadata(
     const Tile& tile) const {
   RasterTaskMetadata metadata;
   const ManagedTileState& mts = tile.managed_state();
   metadata.is_tile_in_pending_tree_now_bin =
       mts.tree_bin[PENDING_TREE] == NOW_BIN;
   metadata.tile_resolution = mts.resolution;
   metadata.layer_id = tile.layer_id();
   metadata.tile_id = &tile;
   metadata.source_frame_number = tile.source_frame_number();
   return metadata;
 }
 
-RasterWorkerPool::Task TileManager::CreateRasterTask(Tile* tile) {
+RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
   TRACE_EVENT0("cc", "TileManager::CreateRasterTask");
 
   scoped_ptr<ResourcePool::Resource> resource =
       resource_pool_->AcquireResource(
           tile->tile_size_.size(),
           tile->tile_version().resource_format_);
-  resource_pool_->resource_provider()->AcquirePixelBuffer(resource->id());
+  const Resource* const_resource = resource.get();
 
   DCHECK_EQ(CAN_USE_MEMORY, tile->tile_version().memory_state_);
   tile->tile_version().memory_state_ = USING_UNRELEASABLE_MEMORY;
 
   PicturePileImpl::Analysis* analysis = new PicturePileImpl::Analysis;
 
-  // MapPixelBuffer() returns NULL if context was lost at the time
-  // AcquirePixelBuffer() was called. For simplicity we still create
-  // a raster task that is essentially a noop in these situations.
-  uint8* buffer = resource_pool_->resource_provider()->MapPixelBuffer(
-      resource->id());
-
   // Create and queue all image decode tasks that this tile depends on.
-  RasterWorkerPool::Task::Queue decode_tasks;
+  RasterWorkerPool::Task::Set decode_tasks;
   for (PicturePileImpl::PixelRefIterator iter(tile->content_rect(),
                                               tile->contents_scale(),
                                               tile->picture_pile());
        iter; ++iter) {
     skia::LazyPixelRef* pixel_ref = *iter;
     uint32_t id = pixel_ref->getGenerationID();
 
     // Append existing image decode task if available.
     PixelRefMap::iterator decode_task_it = pending_decode_tasks_.find(id);
     if (decode_task_it != pending_decode_tasks_.end()) {
-      decode_tasks.Append(decode_task_it->second);
+      decode_tasks.Insert(decode_task_it->second);
       continue;
     }
 
     // TODO(qinmin): passing correct image size to PrepareToDecode().
     if (pixel_ref->PrepareToDecode(skia::LazyPixelRef::PrepareParams())) {
       rendering_stats_instrumentation_->IncrementDeferredImageCacheHitCount();
       continue;
     }
 
     // Create and append new image decode task for this pixel ref.
     RasterWorkerPool::Task decode_task = CreateImageDecodeTask(
         tile, pixel_ref);
-    decode_tasks.Append(decode_task);
+    decode_tasks.Insert(decode_task);
     pending_decode_tasks_[id] = decode_task;
   }
 
-  return RasterWorkerPool::PictureTask(
+  return RasterWorkerPool::RasterTask(
       tile->picture_pile(),
+      const_resource,
       base::Bind(&TileManager::RunAnalyzeAndRasterTask,
                  base::Bind(&TileManager::RunAnalyzeTask,
                             analysis,
                             tile->content_rect(),
                             tile->contents_scale(),
                             use_color_estimator_,
                             GetRasterTaskMetadata(*tile),
                             rendering_stats_instrumentation_),
                  base::Bind(&TileManager::RunRasterTask,
-                            buffer,
                             analysis,
                             tile->content_rect(),
                             tile->contents_scale(),
                             GetRasterTaskMetadata(*tile),
                             rendering_stats_instrumentation_)),
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  make_scoped_refptr(tile),
                  base::Passed(&resource),
                  base::Owned(analysis)),
       &decode_tasks);
 }
 
 void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
     PicturePileImpl::Analysis* analysis,
     bool was_canceled) {
   TRACE_EVENT0("cc", "TileManager::OnRasterTaskCompleted");
 
   ManagedTileState& mts = tile->managed_state();
   DCHECK(!mts.raster_task.is_null());
   mts.raster_task.Reset();
 
   // Tile resources can't be freed until upload has completed.
   DCHECK_EQ(USING_UNRELEASABLE_MEMORY, tile->tile_version().memory_state_);
 
-  // Release raster resources.
-  resource_pool_->resource_provider()->UnmapPixelBuffer(resource->id());
-
   if (was_canceled) {
     tile->tile_version().memory_state_ = CAN_USE_MEMORY;
-    resource_pool_->resource_provider()->ReleasePixelBuffer(resource->id());
     resource_pool_->ReleaseResource(resource.Pass());
     return;
   }
 
   mts.picture_pile_analysis = *analysis;
   mts.picture_pile_analyzed = true;
 
   if (analysis->is_solid_color) {
     tile->tile_version().set_solid_color(analysis->solid_color);
-    resource_pool_->resource_provider()->ReleasePixelBuffer(resource->id());
+    tile->tile_version().memory_state_ = CAN_USE_MEMORY;

[vmpstr, 2013/05/29 16:55:03]

Why CAN_USE_MEMORY? set_solid_color sets it to NOT_ALLOWED_TO_USE_MEMORY. 

[reveman, 2013/05/29 19:39:12]

Oh, this is not needed in that case. I still have a hard time reasoning with
this memory state thing. We should be able to remove it completely once this
patch lands as there's no longer such a thing as a TileVersion with unreleasable
memory. It either owns a resource that can be released or it doesn't.

[vmpstr, 2013/05/29 20:45:06]

Agreed. CAN_USE_MEMORY right now means "this version has memory allocated to
it", which means that solid color tiles shouldn't be in that state

     resource_pool_->ReleaseResource(resource.Pass());
-    DidFinishTileInitialization(tile);
-    return;
+  } else {
+    tile->tile_version().memory_state_ = USING_RELEASABLE_MEMORY;
+    tile->tile_version().resource_ = resource.Pass();

[vmpstr, 2013/05/29 16:55:03]

Do you have to set the resource_id_ as well? I can't really find where that's
set. Also, what's the reasoning for separating the two? It seems that you now
have to maintain two items that should(?) be related

[reveman, 2013/05/29 19:39:12]

resource_id_ is needed for ForceUpload. Maybe we should change that API a bit.
How about RasterWorkerPool::ForceUploadToComplete take a raster task as
identifier instead and return a temporary ResourceId that can be used for
drawing until we have the real resource. And we store that temporary id in
something like TileVersion::forced_upload_resource_id_. Wdyt?

[vmpstr, 2013/05/29 20:45:06]

I like ForceUpload taking a task, since it makes it a bit more clear (to me)
what it's operating on. I don't know about forced_upload_resource_id_. It kinda
makes managed tile state cluttered with different resources and/or resource ids.
This temporary id would be the same id as the final one, right? Except the
ownership of the resource is still in the upload queue. 

Ideally we can hand off the ownership of the resource (ie eliminate the concept
of forced or not forced from the managed tile state's perspective), and just
deal with the fact that we might get an upload completed notifications for
resources that are no longer owned by the upload queue. However, we have to be
careful not to free the resource until we get that notification.

[reveman, 2013/05/30 01:46:10]

ForceUpload takes a task in latest patch. It's out of the scope for this patch
but we should move towards being able to always pass the resource ownership back
at completion. This requires detaching the pixel buffer and the shared memory
from the resource somehow and I'm not sure yet how to best do that.

I'd like to eliminate the idea of a forced upload completely. Doing this
requires adding information about what tiles are required for activation to the
RasterWorkerPool::ScheduleTasks API. ie. ScheduleTasks(const RasterTaskQueue&
tasks_required_for_activation, const RasterTaskQueue& other_tasks).

   }
 
-  resource_pool_->resource_provider()->BeginSetPixels(resource->id());
-  has_performed_uploads_since_last_flush_ = true;
-
-  tile->tile_version().resource_ = resource.Pass();
-
-  bytes_pending_upload_ += tile->bytes_consumed_if_allocated();
-  tiles_with_pending_upload_.push(tile);
-
-  if (tile->required_for_activation() &&
-      client_->ShouldForceTileUploadsRequiredForActivationToComplete())
-    ForceTileUploadToComplete(tile);
+  DidFinishTileInitialization(tile);
 }
 
 void TileManager::DidFinishTileInitialization(Tile* tile) {
   if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     did_initialize_visible_tile_ = true;
   if (tile->required_for_activation()) {
     // It's possible that a tile required for activation is not in this list
     // if it was marked as being required after being dispatched for
     // rasterization but before AssignGPUMemory was called again.
     tiles_that_need_to_be_initialized_for_activation_.erase(tile);
@@ skipping 15 matching lines @@
   TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
   devtools_instrumentation::ScopedLayerTask image_decode_task(
       devtools_instrumentation::kImageDecodeTask, layer_id);
   base::TimeTicks start_time = stats_instrumentation->StartRecording();
   pixel_ref->Decode();
   base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
   stats_instrumentation->AddDeferredImageDecode(duration);
 }
 
 // static
-void TileManager::RunAnalyzeAndRasterTask(
-    const RasterWorkerPool::PictureTask::Callback& analyze_task,
-    const RasterWorkerPool::PictureTask::Callback& raster_task,
+bool TileManager::RunAnalyzeAndRasterTask(
+    const base::Callback<void(PicturePileImpl*)>& analyze_task,
+    const RasterWorkerPool::RasterTask::Callback& raster_task,
+    uint8* buffer,
     PicturePileImpl* picture_pile) {
   analyze_task.Run(picture_pile);
-  raster_task.Run(picture_pile);
+  return raster_task.Run(buffer, picture_pile);
 }
 
 // static
 void TileManager::RunAnalyzeTask(
     PicturePileImpl::Analysis* analysis,
     gfx::Rect rect,
     float contents_scale,
     bool use_color_estimator,
     const RasterTaskMetadata& metadata,
     RenderingStatsInstrumentation* stats_instrumentation,
@@ skipping 22 matching lines @@
   scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
   res->Set("tile_id", TracedValue::CreateIDRef(tile_id).release());
   res->SetBoolean("is_tile_in_pending_tree_now_bin",
                   is_tile_in_pending_tree_now_bin);
   res->Set("resolution", TileResolutionAsValue(tile_resolution).release());
   res->SetInteger("source_frame_number", source_frame_number);
   return res.PassAs<base::Value>();
 }
 
 // static
-void TileManager::RunRasterTask(
-    uint8* buffer,
+bool TileManager::RunRasterTask(
     PicturePileImpl::Analysis* analysis,
     gfx::Rect rect,
     float contents_scale,
     const RasterTaskMetadata& metadata,
     RenderingStatsInstrumentation* stats_instrumentation,
+    uint8* buffer,
     PicturePileImpl* picture_pile) {
   TRACE_EVENT1(
       "cc", "TileManager::RunRasterTask",
       "metadata", TracedValue::FromValue(metadata.AsValue().release()));
   devtools_instrumentation::ScopedLayerTask raster_task(
       devtools_instrumentation::kRasterTask, metadata.layer_id);
 
   DCHECK(picture_pile);
   DCHECK(analysis);
 
   // |buffer| can be NULL in lost context situations.
   if (!buffer)
-    return;
+    return false;
 
   if (analysis->is_solid_color)
-    return;
+    return false;
 
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height());
   bitmap.setPixels(buffer);
   SkDevice device(bitmap);
   SkCanvas canvas(&device);
 
   if (stats_instrumentation->record_rendering_stats()) {
     PicturePileImpl::RasterStats raster_stats;
     picture_pile->RasterToBitmap(&canvas, rect, contents_scale, &raster_stats);
     stats_instrumentation->AddRaster(
         raster_stats.total_rasterize_time,
         raster_stats.best_rasterize_time,
         raster_stats.total_pixels_rasterized,
         metadata.is_tile_in_pending_tree_now_bin);
 
     HISTOGRAM_CUSTOM_COUNTS(
         "Renderer4.PictureRasterTimeUS",
         raster_stats.total_rasterize_time.InMicroseconds(),
         0,
         100000,
         100);
   } else {
     picture_pile->RasterToBitmap(&canvas, rect, contents_scale, NULL);
   }
+
+  return true;
 }
 
 }  // namespace cc