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.
5 #include "cc/raster/tile_task_worker_pool.h"
9 #include "base/trace_event/trace_event.h"
10 #include "cc/playback/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/SkDrawFilter.h"
14 #include "third_party/skia/include/core/SkSurface.h"
19 class TaskSetFinishedTaskImpl
: public TileTask
{
21 explicit TaskSetFinishedTaskImpl(
22 base::SequencedTaskRunner
* task_runner
,
23 const base::Closure
& on_task_set_finished_callback
)
24 : task_runner_(task_runner
),
25 on_task_set_finished_callback_(on_task_set_finished_callback
) {}
27 // Overridden from Task:
28 void RunOnWorkerThread() override
{
29 TRACE_EVENT0("cc", "TaskSetFinishedTaskImpl::RunOnWorkerThread");
33 // Overridden from TileTask:
34 void ScheduleOnOriginThread(TileTaskClient
* client
) override
{}
35 void CompleteOnOriginThread(TileTaskClient
* client
) override
{}
38 ~TaskSetFinishedTaskImpl() override
{}
40 void TaskSetFinished() {
41 task_runner_
->PostTask(FROM_HERE
, on_task_set_finished_callback_
);
45 scoped_refptr
<base::SequencedTaskRunner
> task_runner_
;
46 const base::Closure on_task_set_finished_callback_
;
48 DISALLOW_COPY_AND_ASSIGN(TaskSetFinishedTaskImpl
);
53 // This allows a micro benchmark system to run tasks with highest priority,
54 // since it should finish as quickly as possible.
55 size_t 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 size_t TileTaskWorkerPool::kTaskSetFinishedTaskPriorityBase
= 1u;
60 // For correctness, |kTileTaskPriorityBase| must be greater than
61 // |kTaskSetFinishedTaskPriorityBase + kNumberOfTaskSets|.
62 size_t TileTaskWorkerPool::kTileTaskPriorityBase
= 10u;
64 TileTaskWorkerPool::TileTaskWorkerPool() {
67 TileTaskWorkerPool::~TileTaskWorkerPool() {
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
));
79 void TileTaskWorkerPool::ScheduleTasksOnOriginThread(TileTaskClient
* client
,
81 TRACE_EVENT0("cc", "TileTaskWorkerPool::ScheduleTasksOnOriginThread");
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
);
88 if (!task
->HasBeenScheduled()) {
90 task
->ScheduleOnOriginThread(client
);
97 void TileTaskWorkerPool::InsertNodeForTask(TaskGraph
* graph
,
100 size_t dependencies
) {
101 DCHECK(std::find_if(graph
->nodes
.begin(), graph
->nodes
.end(),
102 TaskGraph::Node::TaskComparator(task
)) ==
104 graph
->nodes
.push_back(TaskGraph::Node(task
, priority
, dependencies
));
108 void TileTaskWorkerPool::InsertNodesForRasterTask(
110 RasterTask
* raster_task
,
111 const ImageDecodeTask::Vector
& decode_tasks
,
113 size_t dependencies
= 0u;
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();
120 // Skip if already decoded.
121 if (decode_task
->HasCompleted())
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);
133 graph
->edges
.push_back(TaskGraph::Edge(decode_task
, raster_task
));
136 InsertNodeForTask(graph
, raster_task
, priority
, dependencies
);
139 static bool IsSupportedPlaybackToMemoryFormat(ResourceFormat format
) {
156 class SkipImageFilter
: public SkDrawFilter
{
158 bool filter(SkPaint
* paint
, Type type
) override
{
159 if (type
== kBitmap_Type
)
162 SkShader
* shader
= paint
->getShader();
163 return !shader
|| !shader
->isABitmap();
168 void TileTaskWorkerPool::PlaybackToMemory(void* memory
,
169 ResourceFormat format
,
170 const gfx::Size
& size
,
172 const RasterSource
* raster_source
,
173 const gfx::Rect
& canvas_bitmap_rect
,
174 const gfx::Rect
& canvas_playback_rect
,
176 bool include_images
) {
177 TRACE_EVENT0("cc", "TileTaskWorkerPool::PlaybackToMemory");
179 DCHECK(IsSupportedPlaybackToMemoryFormat(format
)) << format
;
181 // Uses kPremul_SkAlphaType since the result is not known to be opaque.
183 SkImageInfo::MakeN32(size
.width(), size
.height(), kPremul_SkAlphaType
);
184 SkColorType buffer_color_type
= ResourceFormatToSkColorType(format
);
185 bool needs_copy
= buffer_color_type
!= info
.colorType();
187 // Use unknown pixel geometry to disable LCD text.
188 SkSurfaceProps
surface_props(0, kUnknown_SkPixelGeometry
);
189 if (raster_source
->CanUseLCDText()) {
190 // LegacyFontHost will get LCD text and skia figures out what type to use.
191 surface_props
= SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType
);
195 stride
= info
.minRowBytes();
196 DCHECK_GT(stride
, 0u);
198 skia::RefPtr
<SkDrawFilter
> image_filter
;
200 image_filter
= skia::AdoptRef(new SkipImageFilter
);
203 skia::RefPtr
<SkSurface
> surface
= skia::AdoptRef(
204 SkSurface::NewRasterDirect(info
, memory
, stride
, &surface_props
));
205 skia::RefPtr
<SkCanvas
> canvas
= skia::SharePtr(surface
->getCanvas());
206 canvas
->setDrawFilter(image_filter
.get());
207 raster_source
->PlaybackToCanvas(canvas
.get(), canvas_bitmap_rect
,
208 canvas_playback_rect
, scale
);
212 skia::RefPtr
<SkSurface
> surface
=
213 skia::AdoptRef(SkSurface::NewRaster(info
, &surface_props
));
214 skia::RefPtr
<SkCanvas
> canvas
= skia::SharePtr(surface
->getCanvas());
215 canvas
->setDrawFilter(image_filter
.get());
216 // TODO(reveman): Improve partial raster support by reducing the size of
217 // playback rect passed to PlaybackToCanvas. crbug.com/519070
218 raster_source
->PlaybackToCanvas(canvas
.get(), canvas_bitmap_rect
,
219 canvas_bitmap_rect
, scale
);
222 TRACE_EVENT0("cc", "TileTaskWorkerPool::PlaybackToMemory::ConvertPixels");
224 SkImageInfo dst_info
=
225 SkImageInfo::Make(info
.width(), info
.height(), buffer_color_type
,
226 info
.alphaType(), info
.profileType());
227 // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
228 // bitmap data. There will be no need to call SkAlign4 once crbug.com/293728
230 const size_t dst_row_bytes
= SkAlign4(dst_info
.minRowBytes());
231 DCHECK_EQ(0u, dst_row_bytes
% 4);
232 bool success
= canvas
->readPixels(dst_info
, memory
, dst_row_bytes
, 0, 0);
233 DCHECK_EQ(true, success
);