[go: nahoru, domu]
Google Git
Sign in
chromium / chromium / src / 7499629e5db5df76176f12b94dd4dffa69fbe668 / . / cc / raster / gpu_raster_buffer_provider.cc
blob: 208068a8103ecc6d0c9e91e588501945aeb0b1da [file] [log] [blame]
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]1// Copyright 2014 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
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]5#include "cc/raster/gpu_raster_buffer_provider.h"
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]6
avi02a4d172015-12-21 06:14:36[diff] [blame]7#include <stdint.h>
8
ernstm69fedbd2014-09-18 01:23:41[diff] [blame]9#include <algorithm>
10
avi02a4d172015-12-21 06:14:36[diff] [blame]11#include "base/macros.h"
danakj60bc3bc2016-04-09 00:24:48[diff] [blame]12#include "base/memory/ptr_util.h"
ericrke4027312016-06-30 00:12:42[diff] [blame]13#include "base/metrics/histogram_macros.h"
ssid904ce3b2015-01-27 15:20:16[diff] [blame]14#include "base/trace_event/trace_event.h"
ericrkc7c9e3f2016-07-01 17:30:16[diff] [blame]15#include "cc/base/histograms.h"
enne5a9630362017-02-24 23:41:03[diff] [blame]16#include "cc/paint/paint_canvas.h"
ericrk1259d6e72016-07-15 00:47:32[diff] [blame]17#include "cc/playback/image_hijack_canvas.h"
vmpstr41d68f82016-03-30 01:20:23[diff] [blame]18#include "cc/playback/raster_source.h"
danakj920156852015-05-18 20:22:29[diff] [blame]19#include "cc/raster/scoped_gpu_raster.h"
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]20#include "cc/resources/resource.h"
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]21#include "gpu/command_buffer/client/context_support.h"
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]22#include "gpu/command_buffer/client/gles2_interface.h"
hendrikw04cea972014-09-23 20:50:53[diff] [blame]23#include "third_party/skia/include/core/SkMultiPictureDraw.h"
24#include "third_party/skia/include/core/SkPictureRecorder.h"
reveman47560ab2014-09-18 19:39:21[diff] [blame]25#include "third_party/skia/include/core/SkSurface.h"
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]26#include "third_party/skia/include/gpu/GrContext.h"
27
28namespace cc {
reveman47560ab2014-09-18 19:39:21[diff] [blame]29namespace {
30
vmiuraf7c765c2016-12-03 21:02:32[diff] [blame]31static void RasterizeSource(
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]32 const RasterSource* raster_source,
33 bool resource_has_previous_content,
34 const gfx::Size& resource_size,
35 const gfx::Rect& raster_full_rect,
36 const gfx::Rect& raster_dirty_rect,
vmpstr69c12082017-01-13 01:52:43[diff] [blame]37 float scale,
vmiuraf7c765c2016-12-03 21:02:32[diff] [blame]38 const RasterSource::PlaybackSettings& playback_settings,
39 ContextProvider* context_provider,
40 ResourceProvider::ScopedWriteLockGL* resource_lock,
41 bool async_worker_context_enabled,
42 bool use_distance_field_text,
43 int msaa_sample_count) {
44 ScopedGpuRaster gpu_raster(context_provider);
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]45
vmiuraf7c765c2016-12-03 21:02:32[diff] [blame]46 ResourceProvider::ScopedSkSurfaceProvider scoped_surface(
47 context_provider, resource_lock, async_worker_context_enabled,
48 use_distance_field_text, raster_source->CanUseLCDText(),
ccameron76f24f02017-02-23 05:24:44[diff] [blame]49 msaa_sample_count);
vmiuraf7c765c2016-12-03 21:02:32[diff] [blame]50 SkSurface* sk_surface = scoped_surface.sk_surface();
51 // Allocating an SkSurface will fail after a lost context. Pretend we
52 // rasterized, as the contents of the resource don't matter anymore.
ccameron220942362017-02-06 20:29:19[diff] [blame]53 if (!sk_surface) {
54 DLOG(ERROR) << "Failed to allocate raster surface";
vmiuraf7c765c2016-12-03 21:02:32[diff] [blame]55 return;
ccameron220942362017-02-06 20:29:19[diff] [blame]56 }
vmiuraf7c765c2016-12-03 21:02:32[diff] [blame]57
58 // Playback
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]59 gfx::Rect playback_rect = raster_full_rect;
60 if (resource_has_previous_content) {
61 playback_rect.Intersect(raster_dirty_rect);
danakj05d69002015-06-02 01:42:20[diff] [blame]62 }
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]63 DCHECK(!playback_rect.IsEmpty())
64 << "Why are we rastering a tile that's not dirty?";
reveman47560ab2014-09-18 19:39:21[diff] [blame]65
ericrke4027312016-06-30 00:12:42[diff] [blame]66 // Log a histogram of the percentage of pixels that were saved due to
67 // partial raster.
ericrkc7c9e3f2016-07-01 17:30:16[diff] [blame]68 const char* client_name = GetClientNameForMetrics();
ericrke4027312016-06-30 00:12:42[diff] [blame]69 float full_rect_size = raster_full_rect.size().GetArea();
ericrkc7c9e3f2016-07-01 17:30:16[diff] [blame]70 if (full_rect_size > 0 && client_name) {
ericrke4027312016-06-30 00:12:42[diff] [blame]71 float fraction_partial_rastered =
72 static_cast<float>(playback_rect.size().GetArea()) / full_rect_size;
73 float fraction_saved = 1.0f - fraction_partial_rastered;
ericrkc7c9e3f2016-07-01 17:30:16[diff] [blame]74 UMA_HISTOGRAM_PERCENTAGE(
75 base::StringPrintf("Renderer4.%s.PartialRasterPercentageSaved.Gpu",
76 client_name),
77 100.0f * fraction_saved);
ericrke4027312016-06-30 00:12:42[diff] [blame]78 }
79
vmiuraf7c765c2016-12-03 21:02:32[diff] [blame]80 raster_source->PlaybackToCanvas(sk_surface->getCanvas(), raster_full_rect,
vmpstr69c12082017-01-13 01:52:43[diff] [blame]81 playback_rect, scale, playback_settings);
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]82}
reveman47560ab2014-09-18 19:39:21[diff] [blame]83
84} // namespace
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]85
86GpuRasterBufferProvider::RasterBufferImpl::RasterBufferImpl(
87 GpuRasterBufferProvider* client,
88 ResourceProvider* resource_provider,
89 ResourceId resource_id,
90 bool async_worker_context_enabled,
91 bool resource_has_previous_content)
92 : client_(client),
93 lock_(resource_provider, resource_id, async_worker_context_enabled),
94 resource_has_previous_content_(resource_has_previous_content) {
95 client_->pending_raster_buffers_.insert(this);
96}
97
98GpuRasterBufferProvider::RasterBufferImpl::~RasterBufferImpl() {
99 client_->pending_raster_buffers_.erase(this);
100}
101
102void GpuRasterBufferProvider::RasterBufferImpl::Playback(
103 const RasterSource* raster_source,
104 const gfx::Rect& raster_full_rect,
105 const gfx::Rect& raster_dirty_rect,
106 uint64_t new_content_id,
vmpstr69c12082017-01-13 01:52:43[diff] [blame]107 float scale,
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]108 const RasterSource::PlaybackSettings& playback_settings) {
109 TRACE_EVENT0("cc", "GpuRasterBuffer::Playback");
110 client_->PlaybackOnWorkerThread(&lock_, sync_token_,
111 resource_has_previous_content_, raster_source,
112 raster_full_rect, raster_dirty_rect,
vmpstr69c12082017-01-13 01:52:43[diff] [blame]113 new_content_id, scale, playback_settings);
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]114}
vmiura78b69282015-02-14 00:01:17[diff] [blame]115
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]116GpuRasterBufferProvider::GpuRasterBufferProvider(
danakj0de0c95a2016-05-25 01:42:49[diff] [blame]117 ContextProvider* compositor_context_provider,
118 ContextProvider* worker_context_provider,
hendrikw59d449482015-04-04 00:44:32[diff] [blame]119 ResourceProvider* resource_provider,
120 bool use_distance_field_text,
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]121 int gpu_rasterization_msaa_sample_count,
122 bool async_worker_context_enabled)
danakj0de0c95a2016-05-25 01:42:49[diff] [blame]123 : compositor_context_provider_(compositor_context_provider),
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]124 worker_context_provider_(worker_context_provider),
125 resource_provider_(resource_provider),
126 use_distance_field_text_(use_distance_field_text),
127 msaa_sample_count_(gpu_rasterization_msaa_sample_count),
128 async_worker_context_enabled_(async_worker_context_enabled) {
129 DCHECK(compositor_context_provider);
130 DCHECK(worker_context_provider);
danakj0de0c95a2016-05-25 01:42:49[diff] [blame]131}
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]132
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]133GpuRasterBufferProvider::~GpuRasterBufferProvider() {
134 DCHECK(pending_raster_buffers_.empty());
135}
reveman@chromium.orgec7541d2014-04-09 01:23:53[diff] [blame]136
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]137std::unique_ptr<RasterBuffer> GpuRasterBufferProvider::AcquireBufferForRaster(
danakje0b54782015-05-29 22:47:52[diff] [blame]138 const Resource* resource,
danakj510822aa2015-06-01 20:23:02[diff] [blame]139 uint64_t resource_content_id,
danakje0b54782015-05-29 22:47:52[diff] [blame]140 uint64_t previous_content_id) {
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]141 bool resource_has_previous_content =
142 resource_content_id && resource_content_id == previous_content_id;
riceada4bffb6e2016-08-22 05:28:17[diff] [blame]143 return base::MakeUnique<RasterBufferImpl>(
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]144 this, resource_provider_, resource->id(), async_worker_context_enabled_,
riceada4bffb6e2016-08-22 05:28:17[diff] [blame]145 resource_has_previous_content);
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]146}
147
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]148void GpuRasterBufferProvider::ReleaseBufferForRaster(
danakj60bc3bc2016-04-09 00:24:48[diff] [blame]149 std::unique_ptr<RasterBuffer> buffer) {
reveman47560ab2014-09-18 19:39:21[diff] [blame]150 // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]151}
152
sunnyps12074d3d2016-06-21 01:57:48[diff] [blame]153void GpuRasterBufferProvider::OrderingBarrier() {
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]154 TRACE_EVENT0("cc", "GpuRasterBufferProvider::OrderingBarrier");
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]155
156 gpu::gles2::GLES2Interface* gl = compositor_context_provider_->ContextGL();
157 if (async_worker_context_enabled_) {
158 GLuint64 fence = gl->InsertFenceSyncCHROMIUM();
159 gl->OrderingBarrierCHROMIUM();
160
161 gpu::SyncToken sync_token;
162 gl->GenUnverifiedSyncTokenCHROMIUM(fence, sync_token.GetData());
163
164 DCHECK(sync_token.HasData() ||
165 gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR);
166
167 for (RasterBufferImpl* buffer : pending_raster_buffers_)
168 buffer->set_sync_token(sync_token);
169 } else {
170 gl->OrderingBarrierCHROMIUM();
171 }
172 pending_raster_buffers_.clear();
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]173}
174
175ResourceFormat GpuRasterBufferProvider::GetResourceFormat(
176 bool must_support_alpha) const {
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]177 return resource_provider_->best_render_buffer_format();
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]178}
179
ericrkeeda58992016-07-07 02:34:27[diff] [blame]180bool GpuRasterBufferProvider::IsResourceSwizzleRequired(
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]181 bool must_support_alpha) const {
182 // This doesn't require a swizzle because we rasterize to the correct format.
183 return false;
184}
185
ericrk5ac42f322016-07-14 01:06:51[diff] [blame]186bool GpuRasterBufferProvider::CanPartialRasterIntoProvidedResource() const {
ericrkc9ed0832016-07-20 19:42:50[diff] [blame]187 // Partial raster doesn't support MSAA, as the MSAA resolve is unaware of clip
188 // rects.
189 // TODO(crbug.com/629683): See if we can work around this limitation.
190 return msaa_sample_count_ == 0;
ericrkeeda58992016-07-07 02:34:27[diff] [blame]191}
192
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]193bool GpuRasterBufferProvider::IsResourceReadyToDraw(
194 ResourceId resource_id) const {
195 if (!async_worker_context_enabled_)
196 return true;
197
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]198 gpu::SyncToken sync_token =
ericrk6d7564a2017-02-02 23:55:58[diff] [blame]199 resource_provider_->GetSyncTokenForResources({resource_id});
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]200 if (!sync_token.HasData())
201 return true;
202
sunnyps74996292017-03-15 02:35:48[diff] [blame^]203 // IsSyncTokenSignaled is thread-safe, no need for worker context lock.
204 return worker_context_provider_->ContextSupport()->IsSyncTokenSignaled(
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]205 sync_token);
206}
207
208uint64_t GpuRasterBufferProvider::SetReadyToDrawCallback(
209 const ResourceProvider::ResourceIdArray& resource_ids,
210 const base::Closure& callback,
211 uint64_t pending_callback_id) const {
212 if (!async_worker_context_enabled_)
213 return 0;
214
215 gpu::SyncToken sync_token =
216 resource_provider_->GetSyncTokenForResources(resource_ids);
217 uint64_t callback_id = sync_token.release_count();
218 DCHECK_NE(callback_id, 0u);
219
220 // If the callback is different from the one the caller is already waiting on,
sunnyps31c92fe2017-02-10 23:46:55[diff] [blame]221 // pass the callback through to SignalSyncToken. Otherwise the request is
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]222 // redundant.
223 if (callback_id != pending_callback_id) {
sunnyps31c92fe2017-02-10 23:46:55[diff] [blame]224 // Use the compositor context because we want this callback on the impl
225 // thread.
226 compositor_context_provider_->ContextSupport()->SignalSyncToken(sync_token,
227 callback);
ericrk7f6a27f2017-01-31 22:34:32[diff] [blame]228 }
229
230 return callback_id;
231}
232
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]233void GpuRasterBufferProvider::Shutdown() {
234 pending_raster_buffers_.clear();
235}
236
237void GpuRasterBufferProvider::PlaybackOnWorkerThread(
238 ResourceProvider::ScopedWriteLockGL* resource_lock,
239 const gpu::SyncToken& sync_token,
240 bool resource_has_previous_content,
241 const RasterSource* raster_source,
242 const gfx::Rect& raster_full_rect,
243 const gfx::Rect& raster_dirty_rect,
244 uint64_t new_content_id,
vmpstr69c12082017-01-13 01:52:43[diff] [blame]245 float scale,
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]246 const RasterSource::PlaybackSettings& playback_settings) {
247 ContextProvider::ScopedContextLock scoped_context(worker_context_provider_);
248 gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
249 DCHECK(gl);
250
251 if (async_worker_context_enabled_) {
252 // Early out if sync token is invalid. This happens if the compositor
253 // context was lost before ScheduleTasks was called.
254 if (!sync_token.HasData())
255 return;
256 // Synchronize with compositor.
257 gl->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
258 }
259
vmiuraf7c765c2016-12-03 21:02:32[diff] [blame]260 RasterizeSource(raster_source, resource_has_previous_content,
261 resource_lock->size(), raster_full_rect, raster_dirty_rect,
vmpstr69c12082017-01-13 01:52:43[diff] [blame]262 scale, playback_settings, worker_context_provider_,
vmiuraf7c765c2016-12-03 21:02:32[diff] [blame]263 resource_lock, async_worker_context_enabled_,
ericrkb04a4a62017-01-03 20:48:08[diff] [blame]264 use_distance_field_text_, msaa_sample_count_);
sunnyps5d6ff0d02016-06-28 00:40:11[diff] [blame]265
266 const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
267
268 // Barrier to sync worker context output to cc context.
269 gl->OrderingBarrierCHROMIUM();
270
271 // Generate sync token after the barrier for cross context synchronization.
272 gpu::SyncToken resource_sync_token;
273 gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, resource_sync_token.GetData());
274 resource_lock->set_sync_token(resource_sync_token);
275 resource_lock->set_synchronized(!async_worker_context_enabled_);
276}
prashant.nb4d4f492016-04-29 12:51:28[diff] [blame]277
reveman@chromium.orgb5641b92014-02-15 14:21:58[diff] [blame]278} // namespace cc