Implement the logic to kick off image decoding jobs for TileManager

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/command_line.h"
@@ skipping 48 matching lines @@
         from_here,
         base::Bind(&RunRasterTask,
                    base::Unretained(picture_pile),
                    mapped_buffer,
                    rect,
                    contents_scale,
                    stats),
         base::Bind(&RasterThread::RunReply, base::Unretained(this), reply));
   }
 
+  void PostImageDecodingTaskAndReply(const tracked_objects::Location& from_here,
+                                     skia::LazyPixelRef* pixel_ref,
+                                     const base::Closure& reply) {
+    ++num_pending_tasks_;
+    message_loop_proxy()->PostTaskAndReply(
+        from_here,
+        base::Bind(&skia::LazyPixelRef::Decode, base::Unretained(pixel_ref)),
+        base::Bind(&RasterThread::RunReply, base::Unretained(this), reply));
+  }
+
  private:
   static void RunRasterTask(PicturePileImpl* picture_pile,
                             uint8_t* mapped_buffer,
                             const gfx::Rect& rect,
                             float contents_scale,
                             RenderingStats* stats) {
     TRACE_EVENT0("cc", "RasterThread::RunRasterTask");
     DCHECK(picture_pile);
     DCHECK(mapped_buffer);
     SkBitmap bitmap;
@@ skipping 15 matching lines @@
 
   int num_pending_tasks_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterThread);
 };
 
 ManagedTileState::ManagedTileState()
     : can_use_gpu_memory(false),
       can_be_freed(true),
       resource_is_being_initialized(false),
-      contents_swizzled(false) {
+      contents_swizzled(false),
+      need_to_gather_pixel_refs(true) {
 }
 
 ManagedTileState::~ManagedTileState() {
   DCHECK(!resource);
   DCHECK(!resource_is_being_initialized);
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
@@ skipping 162 matching lines @@
     tile->managed_state().bin = bin;
   }
 
   // Sort by bin.
   std::sort(tiles_.begin(), tiles_.end(), BinComparator());
 
   // Assign gpu memory and determine what tiles need to be rasterized.
   AssignGpuMemoryToTiles();
 
   // Finally, kick the rasterizer.
-  DispatchMoreRasterTasks();
+  DispatchMoreTasks();
 }
 
 void TileManager::CheckForCompletedSetPixels() {
   check_for_completed_set_pixels_pending_ = false;
 
   while (!tiles_with_pending_set_pixels_.empty()) {
     Tile* tile = tiles_with_pending_set_pixels_.front();
     DCHECK(tile->managed_state().resource);
 
     // Set pixel tasks complete in the order they are posted.
@@ skipping 65 matching lines @@
       tiles_that_need_to_be_rasterized_.end());
 }
 
 void TileManager::FreeResourcesForTile(Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.can_be_freed);
   if (managed_tile_state.resource)
     resource_pool_->ReleaseResource(managed_tile_state.resource.Pass());
 }
 
-void TileManager::DispatchMoreRasterTasks() {
+RasterThread* TileManager::GetFreeRasterThread() {
+  RasterThread* thread = 0;
+  for (RasterThreadVector::iterator it = raster_threads_.begin();
+       it != raster_threads_.end(); ++it) {
+    if ((*it)->num_pending_tasks() == kNumPendingRasterTasksPerThread)
+      continue;
+    // Check if this is the best thread we've found so far.
+    if (!thread || (*it)->num_pending_tasks() < thread->num_pending_tasks())
+      thread = *it;
+  }
+  return thread;
+}
+
+void TileManager::DispatchMoreTasks() {
+  // Because tiles in the image decoding list have higher priorities, we
+  // need to process those tiles first before we start to handle the tiles
+  // in the need_to_be_rasterized queue.
+  std::list<Tile*>::iterator it = tiles_with_image_decoding_tasks_.begin();
+  while (it != tiles_with_image_decoding_tasks_.end()) {
+    DispatchImageDecodingTasksForTile(*it);
+    ManagedTileState& managed_state = (*it)->managed_state();
+    if (managed_state.pending_pixel_refs.empty()) {
+      RasterThread* thread = GetFreeRasterThread();
+      if (!thread)
+        return;
+      DispatchOneRasterTask(thread, *it);
+      tiles_with_image_decoding_tasks_.erase(it++);
+    } else {
+      ++it;
+    }
+  }
+
+  // Process all tiles in the need_to_be_rasterized queue. If a tile has
+  // image decoding tasks, put it to the back of the image decoding list.
   while (!tiles_that_need_to_be_rasterized_.empty()) {
-    RasterThread* thread = 0;
-
-    for (RasterThreadVector::iterator it = raster_threads_.begin();
-         it != raster_threads_.end(); ++it) {
-      if ((*it)->num_pending_tasks() == kNumPendingRasterTasksPerThread)
-        continue;
-      // Check if this is the best thread we've found so far.
-      if (!thread || (*it)->num_pending_tasks() < thread->num_pending_tasks())
-        thread = *it;
+    Tile* tile = tiles_that_need_to_be_rasterized_.back();
+    DispatchImageDecodingTasksForTile(tile);
+    ManagedTileState& managed_state = tile->managed_state();
+    if (!managed_state.pending_pixel_refs.empty())
+      tiles_with_image_decoding_tasks_.push_back(tile);
+    else {

[reveman, 2012/12/11 05:07:18]

nit: curly braces around both IF and ELSE required

[qinmin, 2012/12/11 05:36:20]

Done.

+      RasterThread* thread = GetFreeRasterThread();
+      if (!thread)
+        return;
+      DispatchOneRasterTask(thread, tile);
     }
-
-    // Stop dispatching tasks when all threads are busy.
-    if (!thread)
-        return;
-
-    DispatchOneRasterTask(thread, tiles_that_need_to_be_rasterized_.back());
     tiles_that_need_to_be_rasterized_.pop_back();
   }
 }
 
+void TileManager::DispatchImageDecodingTasksForTile(Tile* tile) {
+  ManagedTileState& managed_state = tile->managed_state();
+  if (!managed_state.need_to_gather_pixel_refs) {
+    const_cast<PicturePileImpl *>(tile->picture_pile())->GatherPixelRefs(
+        tile->content_rect_, managed_state.pending_pixel_refs);
+    managed_state.need_to_gather_pixel_refs = false;
+  }
+
+  RasterThread* thread = 0;

[reveman, 2012/12/11 05:07:18]

nit: |thread| is not needed in this scope. please move it to the scope below
where it's used.

[qinmin, 2012/12/11 05:36:20]

Done.

+  std::list<skia::LazyPixelRef*>& pending_pixel_refs =
+      tile->managed_state().pending_pixel_refs;
+  std::list<skia::LazyPixelRef*>::iterator it = pending_pixel_refs.begin();
+  while (it != pending_pixel_refs.end()) {
+    if (pending_decode_tasks_.end() != pending_decode_tasks_.find(
+        (*it)->getGenerationID())) {
+      ++it;
+      continue;
+    }
+    if ((*it)->PrepareToDecode(skia::LazyPixelRef::PrepareParams()))
+      pending_pixel_refs.erase(it++);
+    else {

[reveman, 2012/12/11 05:07:18]

nit: curly braces around both IF and ELSE required

[qinmin, 2012/12/11 05:36:20]

Done.

+      thread = GetFreeRasterThread();
+      if (thread)
+        DispatchOneImageDecodingTask(thread, tile, *it);
+      ++it;
+    }
+  }
+}
+
+void TileManager::DispatchOneImageDecodingTask(RasterThread* thread,
+                                               scoped_refptr<Tile> tile,
+                                               skia::LazyPixelRef* pixel_ref) {
+  TRACE_EVENT0("cc", "TileManager::DispatchOneImageDecodingTask");
+  uint32_t pixel_ref_id = pixel_ref->getGenerationID();
+  DCHECK(pending_decode_tasks_.end() ==
+      pending_decode_tasks_.find(pixel_ref_id));
+  pending_decode_tasks_[pixel_ref_id] = pixel_ref;
+
+  thread->PostImageDecodingTaskAndReply(
+          FROM_HERE,
+          pixel_ref,
+          base::Bind(&TileManager::OnImageDecodingTaskCompleted,
+                     base::Unretained(this),
+                     tile,
+                     pixel_ref_id));
+}
+
+void TileManager::OnImageDecodingTaskCompleted(scoped_refptr<Tile> tile,
+                                               uint32_t pixel_ref_id) {
+  TRACE_EVENT0("cc", "TileManager::OnImageDecoded");
+  pending_decode_tasks_.erase(pixel_ref_id);
+
+  for (TileList::iterator it = tiles_with_image_decoding_tasks_.begin();
+      it != tiles_with_image_decoding_tasks_.end(); ++it) {
+    std::list<skia::LazyPixelRef*>& pixel_refs =
+        (*it)->managed_state().pending_pixel_refs;
+    for (std::list<skia::LazyPixelRef*>::iterator pixel_it =
+        pixel_refs.begin(); pixel_it != pixel_refs.end(); ++pixel_it) {
+      if (pixel_ref_id == (*pixel_it)->getGenerationID()) {
+        pixel_refs.erase(pixel_it);
+        break;
+      }
+    }
+  }
+  DispatchMoreTasks();
+}
+
 void TileManager::DispatchOneRasterTask(
     RasterThread* thread, scoped_refptr<Tile> tile) {
   TRACE_EVENT0("cc", "TileManager::DispatchOneRasterTask");
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.can_use_gpu_memory);
   scoped_ptr<ResourcePool::Resource> resource =
       resource_pool_->AcquireResource(tile->tile_size_.size(), tile->format_);
   resource_pool_->resource_provider()->acquirePixelBuffer(resource->id());
 
   managed_tile_state.resource_is_being_initialized = true;
@@ skipping 34 matching lines @@
   resource_pool_->resource_provider()->unmapPixelBuffer(resource->id());
 
   ManagedTileState& managed_tile_state = tile->managed_state();
   managed_tile_state.can_be_freed = true;
 
   // Tile can be freed after the completion of the raster task. Call
   // AssignGpuMemoryToTiles() to re-assign gpu memory to highest priority
   // tiles. The result of this could be that this tile is no longer
   // allowed to use gpu memory and in that case we need to abort
   // initialization and free all associated resources before calling
-  // DispatchMoreRasterTasks().
+  // DispatchMoreTasks().
   AssignGpuMemoryToTiles();
 
   // Finish resource initialization if |can_use_gpu_memory| is true.
   if (managed_tile_state.can_use_gpu_memory) {
     // The component order may be bgra if we're uploading bgra pixels to rgba
     // texture. Mark contents as swizzled if image component order is
     // different than texture format.
     managed_tile_state.contents_swizzled =
         !PlatformColor::sameComponentOrder(tile->format_);
 
     // Tile resources can't be freed until upload has completed.
     managed_tile_state.can_be_freed = false;
 
     resource_pool_->resource_provider()->beginSetPixels(resource->id());
     managed_tile_state.resource = resource.Pass();
     tiles_with_pending_set_pixels_.push(tile);
 
     ScheduleCheckForCompletedSetPixels();
   } else {
     resource_pool_->resource_provider()->releasePixelBuffer(resource->id());
     resource_pool_->ReleaseResource(resource.Pass());
     managed_tile_state.resource_is_being_initialized = false;
   }
-
-  DispatchMoreRasterTasks();
+  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;
 }
 
 }