cc: Gather and lock/unlock SkDiscardablePixelRefs instead of skia::LazyPixelRefs.

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 840 matching lines @@
 
   // Schedule running of |tasks|. This replaces any previously
   // scheduled tasks and effectively cancels all tasks not present
   // in |tasks|.
   raster_worker_pool_->ScheduleTasks(&tasks);
 
   did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
 }
 
 RasterWorkerPool::Task TileManager::CreateImageDecodeTask(
-    Tile* tile, skia::LazyPixelRef* pixel_ref) {
+    Tile* tile, SkPixelRef* pixel_ref) {
   return RasterWorkerPool::CreateImageDecodeTask(
       pixel_ref,
       tile->layer_id(),
       rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
                  tile->layer_id(),
                  base::Unretained(pixel_ref)));
 }
 
 RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
 
   scoped_ptr<ScopedResource> resource =
       resource_pool_->AcquireResource(tile->tile_size_.size());
   const ScopedResource* const_resource = resource.get();
 
   // Create and queue all image decode tasks that this tile depends on.
   RasterWorkerPool::Task::Set decode_tasks;
   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];
   for (PicturePileImpl::PixelRefIterator iter(tile->content_rect(),
                                               tile->contents_scale(),
                                               tile->picture_pile());
        iter; ++iter) {
-    skia::LazyPixelRef* pixel_ref = *iter;
+    SkPixelRef* pixel_ref = *iter;
     uint32_t id = pixel_ref->getGenerationID();
 
     // Append existing image decode task if available.
     PixelRefTaskMap::iterator decode_task_it = existing_pixel_refs.find(id);
     if (decode_task_it != existing_pixel_refs.end()) {
       decode_tasks.Insert(decode_task_it->second);
       continue;
     }
 
     // Create and append new image decode task for this pixel ref.
@@ skipping 17 matching lines @@
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  tile->id(),
                  base::Passed(&resource),
                  mts.raster_mode),
       &decode_tasks);
 }
 
 void TileManager::OnImageDecodeTaskCompleted(
     int layer_id,
-    skia::LazyPixelRef* pixel_ref,
+    SkPixelRef* pixel_ref,
     bool was_canceled) {
   // If the task was canceled, we need to clean it up
   // from |image_decode_tasks_|.
   if (!was_canceled)
     return;
 
   LayerPixelRefTaskMap::iterator layer_it =
       image_decode_tasks_.find(layer_id);

[vmpstr, 2013/12/20 17:41:06]

I assume we'll also be removing this decode-once thing when we lock/unlock in
separate tasks?

[reveman, 2013/12/20 18:22:19]

Yes, correct.

 
   if (layer_it == image_decode_tasks_.end())
     return;
 
   PixelRefTaskMap& pixel_ref_tasks = layer_it->second;
   PixelRefTaskMap::iterator task_it =
       pixel_ref_tasks.find(pixel_ref->getGenerationID());
 
   if (task_it != pixel_ref_tasks.end())
     pixel_ref_tasks.erase(task_it);
@@ skipping 73 matching lines @@
                                                         int offset_y,
                                                         int width,
                                                         int height) {
   scoped_refptr<TileBundle> bundle = make_scoped_refptr(
       new TileBundle(this, offset_x, offset_y, width, height));
   bundles_[bundle->id()] = bundle;
   return bundle;
 }
 
 }  // namespace cc