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"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "cc/platform_color.h"
 #include "cc/rendering_stats.h"
 #include "cc/resource_pool.h"
 #include "cc/switches.h"
 #include "cc/tile.h"
+#include "skia/ext/lazy_pixel_ref.h"
 #include "third_party/skia/include/core/SkDevice.h"
 
 namespace {
 
 const char* kRasterThreadNamePrefix = "CompositorRaster";
 
 const int kMaxRasterThreads = 64;
 const int kDefaultNumberOfRasterThreads = 1;
 
 // Allow two pending raster tasks per thread. This keeps resource usage
@@ skipping 29 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,
+                                     SkPixelRef* pixel_ref,
+                                     const base::Closure& reply) {
+    ++num_pending_tasks_;
+    message_loop_proxy()->PostTaskAndReply(
+        from_here,
+        base::Bind(&skia::LazyPixelRef::Decode, base::Unretained(
+            static_cast<skia::LazyPixelRef*>(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 152 matching lines @@
       mts.bin = NOW_BIN;
       continue;
     }
 
     if (prio.time_to_needed_in_seconds() < prepainting_window_time_seconds) {
       mts.bin = SOON_BIN;
       continue;
     }
 
     mts.bin = EVENTUALLY_BIN;
+
+    // Update all the SkPixelRefs this tile intersects.
+    mts.pending_pixel_refs.clear();
+    mts.has_image_decoding_info = false;
   }
 
   // Memory limit policy works by mapping some bin states to the NEVER bin.
   TileManagerBin bin_map[NUM_BINS];
   if (global_state_.memory_limit_policy == ALLOW_NOTHING) {
     bin_map[NOW_BIN] = NEVER_BIN;
     bin_map[SOON_BIN] = NEVER_BIN;
     bin_map[EVENTUALLY_BIN] = NEVER_BIN;
     bin_map[NEVER_BIN] = NEVER_BIN;
   } else if (global_state_.memory_limit_policy == ALLOW_ABSOLUTE_MINIMUM) {
@@ skipping 17 matching lines @@
     TileManagerBin bin = bin_map[tile->managed_state().bin];
     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();
 
+  // Initialize image information for tiles in the NOW_BIN. For other tiles,
+  // we will get the information later when decoding is about to start.
+  for (TileVector::reverse_iterator it =
+      tiles_that_need_to_be_rasterized_.rbegin();
+      it != tiles_that_need_to_be_rasterized_.rend(); ++it) {
+    if ((*it)->managed_state().bin == NOW_BIN)
+      GetImageInformationForTile(*it);
+    else
+      break;
+  }
+
   // Finally, kick the rasterizer.
   DispatchMoreRasterTasks();
 }
 
 void TileManager::renderingStats(RenderingStats* stats) {
   stats->totalRasterizeTimeInSeconds =
     rendering_stats_.totalRasterizeTimeInSeconds;
   stats->totalPixelsRasterized = rendering_stats_.totalPixelsRasterized;
 }
 
@@ skipping 37 matching lines @@
       tiles_that_need_to_be_rasterized_.push_back(tile);
   }
 
   // Reverse two tiles_that_need_* vectors such that pop_back gets
   // the highest priority tile.
   std::reverse(
       tiles_that_need_to_be_rasterized_.begin(),
       tiles_that_need_to_be_rasterized_.end());
 }
 
+void TileManager::GetImageInformationForTile(Tile* tile) {
+  ManagedTileState& managed_state = tile->managed_state();
+  if (!managed_state.has_image_decoding_info) {
+    const_cast<PicturePileImpl *>(tile->picture_pile())->GatherPixelRefs(
+        tile->rect_inside_picture_, managed_state.pending_pixel_refs);
+    managed_state.has_image_decoding_info = true;
+  }
+}
+
 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());
 }
 
+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::DispatchMoreRasterTasks() {
   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;
-    }
-
+    RasterThread* thread = GetFreeRasterThread();
     // Stop dispatching tasks when all threads are busy.
     if (!thread)
         return;
 
-    DispatchOneRasterTask(thread, tiles_that_need_to_be_rasterized_.back());
+    Tile* tile = tiles_that_need_to_be_rasterized_.back();
+    if (!HasDispatchedImageDecodingTasks(tile))
+      DispatchOneRasterTask(thread, tile);
     tiles_that_need_to_be_rasterized_.pop_back();
   }
 }
 
+bool TileManager::HasDispatchedImageDecodingTasks(Tile* tile) {
+  bool has_dispatched_task = false;
+  if (!tile->managed_state().has_image_decoding_info)
+    GetImageInformationForTile(tile);
+
+  std::vector<int> index_to_be_removed;
+  RasterThread* thread = 0;
+  std::vector<SkPixelRef*>& pending_pixel_refs =
+      tile->managed_state().pending_pixel_refs;
+  for (int i = 0; i <  pending_pixel_refs.size(); ++i) {
+    SkPixelRef* pixel_ref = pending_pixel_refs[i];
+    if (pending_decode_tasks_.end() != pending_decode_tasks_.find(
+        pixel_ref->getGenerationID()))
+      continue;

[reveman, 2012/12/10 17:58:12]

I'm confused. Doesn't this function have to return true if one of the pixel refs
have a pending decode task?

[qinmin, 2012/12/10 22:52:51]

it should return false in that case, suppose the particular rect of this image
hasn't been decoded.

On 2012/12/10 17:58:12, David Reveman wrote:

+    if (static_cast<skia::LazyPixelRef*>(pixel_ref)->PrepareToDecode(
+        skia::LazyPixelRef::PrepareParams())) {
+      index_to_be_removed.push_back(i);
+    } else {
+      thread = GetFreeRasterThread();
+      if (thread) {
+        has_dispatched_task = true;
+        DispatchOneImageDecodingTask(thread, tile, pixel_ref);
+      }
+    }
+  }
+
+  for (std::vector<int>::reverse_iterator it = index_to_be_removed.rbegin();
+      it != index_to_be_removed.rend(); ++it) {
+    pending_pixel_refs.erase(pending_pixel_refs.begin() + (*it));

[reveman, 2012/12/10 17:58:12]

removing elements from the middle vector is not very efficient. if we need to be
able to remove elements, should we be using a different data structure?

[qinmin, 2012/12/10 22:52:51]

Switched to list instead

On 2012/12/10 17:58:12, David Reveman wrote:

+  }
+
+  if (has_dispatched_task)
+    tiles_waiting_for_image_decoding_.push_back(tile);
+
+  return has_dispatched_task;
+}
+
+void TileManager::DispatchOneImageDecodingTask(RasterThread* thread,
+                                               scoped_refptr<Tile> tile,
+                                               SkPixelRef* 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);
+
+  std::vector<int> tile_index_to_be_removed;
+  for (int i = 0; i <  tiles_waiting_for_image_decoding_.size(); ++i) {
+    std::vector<SkPixelRef*>& pixel_refs =
+        tiles_waiting_for_image_decoding_[i]->
+            managed_state().pending_pixel_refs;
+    for (std::vector<SkPixelRef*>::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);
+        tile_index_to_be_removed.push_back(i);
+        break;
+      }
+    }
+  }
+
+  // Tiles are in increasing priority in the image decoding queue. But since
+  // we are appending tiles to the back of the rasterize queue, we need to
+  // iterate through tiles reversely.
+  for (std::vector<int>::reverse_iterator it =
+      tile_index_to_be_removed.rbegin();
+      it != tile_index_to_be_removed.rend(); ++it) {
+    tiles_that_need_to_be_rasterized_.push_back(
+        tiles_waiting_for_image_decoding_[*it]);
+    tiles_waiting_for_image_decoding_.erase(
+        tiles_waiting_for_image_decoding_.begin() + (*it));

[reveman, 2012/12/10 17:58:12]

again removing elements from the middle of vector. can we avoid this somehow?

[qinmin, 2012/12/10 22:52:51]

using list instead

On 2012/12/10 17:58:12, David Reveman wrote:

+  }
+
+  DispatchMoreRasterTasks();
+}
+
 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 69 matching lines @@
     Tile* tile, scoped_ptr<ResourcePool::Resource> resource) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(!managed_tile_state.resource);
   managed_tile_state.resource = resource.Pass();
   managed_tile_state.resource_is_being_initialized = false;
   // TODO(qinmin): Make this conditional on managed_tile_state.bin == NOW_BIN.
   client_->ScheduleRedraw();
 }
 
 }