cc/resources/tile_task_worker_pool.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/resources/tile_task_worker_pool.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/trace_event/trace_event.h"
  10 #include "cc/resources/raster_source.h"
  11 #include "skia/ext/refptr.h"
  12 #include "third_party/skia/include/core/SkCanvas.h"
  13 #include "third_party/skia/include/core/SkSurface.h"
  14
  15 namespace cc {
  16 namespace {
  17
  18 class TaskSetFinishedTaskImpl : public TileTask {
  19  public:
  20   explicit TaskSetFinishedTaskImpl(
  21       base::SequencedTaskRunner* task_runner,
  22       const base::Closure& on_task_set_finished_callback)
  23       : task_runner_(task_runner),
  24         on_task_set_finished_callback_(on_task_set_finished_callback) {}
  25
  26   // Overridden from Task:
  27   void RunOnWorkerThread() override {
  28     TRACE_EVENT0("cc", "TaskSetFinishedTaskImpl::RunOnWorkerThread");
  29     TaskSetFinished();
  30   }
  31
  32   // Overridden from TileTask:
  33   void ScheduleOnOriginThread(TileTaskClient* client) override {}
  34   void CompleteOnOriginThread(TileTaskClient* client) override {}
  35   void RunReplyOnOriginThread() override {}
  36
  37  protected:
  38   ~TaskSetFinishedTaskImpl() override {}
  39
  40   void TaskSetFinished() {
  41     task_runner_->PostTask(FROM_HERE, on_task_set_finished_callback_);
  42   }
  43
  44  private:
  45   scoped_refptr<base::SequencedTaskRunner> task_runner_;
  46   const base::Closure on_task_set_finished_callback_;
  47
  48   DISALLOW_COPY_AND_ASSIGN(TaskSetFinishedTaskImpl);
  49 };
  50
  51 }  // namespace
  52
  53 // This allows a micro benchmark system to run tasks with highest priority,
  54 // since it should finish as quickly as possible.
  55 unsigned TileTaskWorkerPool::kBenchmarkTaskPriority = 0u;
  56 // Task priorities that make sure task set finished tasks run before any
  57 // other remaining tasks. This is combined with the task set type to ensure
  58 // proper prioritization ordering between task set types.
  59 unsigned TileTaskWorkerPool::kTaskSetFinishedTaskPriorityBase = 1u;
  60 // For correctness, |kTileTaskPriorityBase| must be greater than
  61 // |kTaskSetFinishedTaskPriorityBase + kNumberOfTaskSets|.
  62 unsigned TileTaskWorkerPool::kTileTaskPriorityBase = 10u;
  63
  64 TileTaskWorkerPool::TileTaskWorkerPool() {
  65 }
  66
  67 TileTaskWorkerPool::~TileTaskWorkerPool() {
  68 }
  69
  70 // static
  71 scoped_refptr<TileTask> TileTaskWorkerPool::CreateTaskSetFinishedTask(
  72     base::SequencedTaskRunner* task_runner,
  73     const base::Closure& on_task_set_finished_callback) {
  74   return make_scoped_refptr(
  75       new TaskSetFinishedTaskImpl(task_runner, on_task_set_finished_callback));
  76 }
  77
  78 // static
  79 void TileTaskWorkerPool::ScheduleTasksOnOriginThread(TileTaskClient* client,
  80                                                      TaskGraph* graph) {
  81   TRACE_EVENT0("cc", "TileTaskWorkerPool::ScheduleTasksOnOriginThread");
  82
  83   for (TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
  84        it != graph->nodes.end(); ++it) {
  85     TaskGraph::Node& node = *it;
  86     TileTask* task = static_cast<TileTask*>(node.task);
  87
  88     if (!task->HasBeenScheduled()) {
  89       task->WillSchedule();
  90       task->ScheduleOnOriginThread(client);
  91       task->DidSchedule();
  92     }
  93   }
  94 }
  95
  96 // static
  97 void TileTaskWorkerPool::InsertNodeForTask(TaskGraph* graph,
  98                                            TileTask* task,
  99                                            unsigned priority,
 100                                            size_t dependencies) {
 101   DCHECK(std::find_if(graph->nodes.begin(), graph->nodes.end(),
 102                       TaskGraph::Node::TaskComparator(task)) ==
 103          graph->nodes.end());
 104   graph->nodes.push_back(TaskGraph::Node(task, priority, dependencies));
 105 }
 106
 107 // static
 108 void TileTaskWorkerPool::InsertNodesForRasterTask(
 109     TaskGraph* graph,
 110     RasterTask* raster_task,
 111     const ImageDecodeTask::Vector& decode_tasks,
 112     unsigned priority) {
 113   size_t dependencies = 0u;
 114
 115   // Insert image decode tasks.
 116   for (ImageDecodeTask::Vector::const_iterator it = decode_tasks.begin();
 117        it != decode_tasks.end(); ++it) {
 118     ImageDecodeTask* decode_task = it->get();
 119
 120     // Skip if already decoded.
 121     if (decode_task->HasCompleted())
 122       continue;
 123
 124     dependencies++;
 125
 126     // Add decode task if it doesn't already exists in graph.
 127     TaskGraph::Node::Vector::iterator decode_it =
 128         std::find_if(graph->nodes.begin(), graph->nodes.end(),
 129                      TaskGraph::Node::TaskComparator(decode_task));
 130     if (decode_it == graph->nodes.end())
 131       InsertNodeForTask(graph, decode_task, priority, 0u);
 132
 133     graph->edges.push_back(TaskGraph::Edge(decode_task, raster_task));
 134   }
 135
 136   InsertNodeForTask(graph, raster_task, priority, dependencies);
 137 }
 138
 139 static bool IsSupportedPlaybackToMemoryFormat(ResourceFormat format) {
 140   switch (format) {
 141     case RGBA_4444:
 142     case RGBA_8888:
 143     case BGRA_8888:
 144       return true;
 145     case ALPHA_8:
 146     case LUMINANCE_8:
 147     case RGB_565:
 148     case ETC1:
 149     case RED_8:
 150       return false;
 151   }
 152   NOTREACHED();
 153   return false;
 154 }
 155
 156 // static
 157 void TileTaskWorkerPool::PlaybackToMemory(void* memory,
 158                                           ResourceFormat format,
 159                                           const gfx::Size& size,
 160                                           int stride,
 161                                           const RasterSource* raster_source,
 162                                           const gfx::Rect& rect,
 163                                           float scale) {
 164   DCHECK(IsSupportedPlaybackToMemoryFormat(format)) << format;
 165
 166   // Uses kPremul_SkAlphaType since the result is not known to be opaque.
 167   SkImageInfo info =
 168       SkImageInfo::MakeN32(size.width(), size.height(), kPremul_SkAlphaType);
 169   SkColorType buffer_color_type = ResourceFormatToSkColorType(format);
 170   bool needs_copy = buffer_color_type != info.colorType();
 171
 172   // Use unknown pixel geometry to disable LCD text.
 173   SkSurfaceProps surface_props(0, kUnknown_SkPixelGeometry);
 174   if (raster_source->CanUseLCDText()) {
 175     // LegacyFontHost will get LCD text and skia figures out what type to use.
 176     surface_props = SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
 177   }
 178
 179   if (!stride)
 180     stride = info.minRowBytes();
 181   DCHECK_GT(stride, 0);
 182
 183   if (!needs_copy) {
 184     skia::RefPtr<SkSurface> surface = skia::AdoptRef(
 185         SkSurface::NewRasterDirect(info, memory, stride, &surface_props));
 186     skia::RefPtr<SkCanvas> canvas = skia::SharePtr(surface->getCanvas());
 187     raster_source->PlaybackToCanvas(canvas.get(), rect, scale);
 188     return;
 189   }
 190
 191   skia::RefPtr<SkSurface> surface =
 192       skia::AdoptRef(SkSurface::NewRaster(info, &surface_props));
 193   skia::RefPtr<SkCanvas> canvas = skia::SharePtr(surface->getCanvas());
 194   raster_source->PlaybackToCanvas(canvas.get(), rect, scale);
 195
 196   SkImageInfo dst_info = info;
 197   dst_info.fColorType = buffer_color_type;
 198   // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
 199   // bitmap data. There will be no need to call SkAlign4 once crbug.com/293728
 200   // is fixed.
 201   const size_t dst_row_bytes = SkAlign4(dst_info.minRowBytes());
 202   DCHECK_EQ(0u, dst_row_bytes % 4);
 203   bool success = canvas->readPixels(dst_info, memory, dst_row_bytes, 0, 0);
 204   DCHECK_EQ(true, success);
 205 }
 206
 207 }  // namespace cc