Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(94)

Side by Side Diff: cc/raster/one_copy_raster_buffer_provider.cc

Issue 2081883002: Reland of cc: Add mailbox support to ResourceProvider write locks. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@worker_context_sync_tokens_revert
Patch Set: rebase Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « cc/raster/one_copy_raster_buffer_provider.h ('k') | cc/raster/raster_buffer_provider.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "cc/raster/one_copy_raster_buffer_provider.h" 5 #include "cc/raster/one_copy_raster_buffer_provider.h"
6 6
7 #include <stdint.h> 7 #include <stdint.h>
8 8
9 #include <algorithm> 9 #include <algorithm>
10 #include <limits> 10 #include <limits>
11 #include <utility> 11 #include <utility>
12 12
13 #include "base/macros.h" 13 #include "base/macros.h"
14 #include "cc/base/math_util.h" 14 #include "cc/base/math_util.h"
15 #include "cc/resources/platform_color.h" 15 #include "cc/resources/platform_color.h"
16 #include "cc/resources/resource_format.h" 16 #include "cc/resources/resource_format.h"
17 #include "cc/resources/resource_util.h" 17 #include "cc/resources/resource_util.h"
18 #include "cc/resources/scoped_resource.h" 18 #include "cc/resources/scoped_resource.h"
19 #include "gpu/GLES2/gl2extchromium.h" 19 #include "gpu/GLES2/gl2extchromium.h"
20 #include "gpu/command_buffer/client/gles2_interface.h" 20 #include "gpu/command_buffer/client/gles2_interface.h"
21 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h" 21 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
22 #include "ui/gfx/buffer_format_util.h" 22 #include "ui/gfx/buffer_format_util.h"
23 23
24 namespace cc { 24 namespace cc {
25 namespace { 25 namespace {
26 26
27 class RasterBufferImpl : public RasterBuffer {
28 public:
29 RasterBufferImpl(OneCopyRasterBufferProvider* worker_pool,
30 ResourceProvider* resource_provider,
31 ResourceFormat resource_format,
32 const Resource* resource,
33 uint64_t previous_content_id)
34 : worker_pool_(worker_pool),
35 resource_(resource),
36 lock_(resource_provider, resource->id()),
37 previous_content_id_(previous_content_id) {}
38
39 ~RasterBufferImpl() override {}
40
41 // Overridden from RasterBuffer:
42 void Playback(
43 const RasterSource* raster_source,
44 const gfx::Rect& raster_full_rect,
45 const gfx::Rect& raster_dirty_rect,
46 uint64_t new_content_id,
47 float scale,
48 const RasterSource::PlaybackSettings& playback_settings) override {
49 TRACE_EVENT0("cc", "OneCopyRasterBuffer::Playback");
50 worker_pool_->PlaybackAndCopyOnWorkerThread(
51 resource_, &lock_, raster_source, raster_full_rect, raster_dirty_rect,
52 scale, playback_settings, previous_content_id_, new_content_id);
53 }
54
55 private:
56 OneCopyRasterBufferProvider* worker_pool_;
57 const Resource* resource_;
58 ResourceProvider::ScopedWriteLockGL lock_;
59 uint64_t previous_content_id_;
60
61 DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
62 };
63
64 // 4MiB is the size of 4 512x512 tiles, which has proven to be a good 27 // 4MiB is the size of 4 512x512 tiles, which has proven to be a good
65 // default batch size for copy operations. 28 // default batch size for copy operations.
66 const int kMaxBytesPerCopyOperation = 1024 * 1024 * 4; 29 const int kMaxBytesPerCopyOperation = 1024 * 1024 * 4;
67 30
68 } // namespace 31 } // namespace
69 32
33 OneCopyRasterBufferProvider::RasterBufferImpl::RasterBufferImpl(
34 OneCopyRasterBufferProvider* client,
35 ResourceProvider* resource_provider,
36 const Resource* resource,
37 uint64_t previous_content_id,
38 bool async_worker_context_enabled)
39 : client_(client),
40 resource_(resource),
41 lock_(resource_provider, resource->id(), async_worker_context_enabled),
42 previous_content_id_(previous_content_id) {
43 client_->pending_raster_buffers_.insert(this);
44 }
45
46 OneCopyRasterBufferProvider::RasterBufferImpl::~RasterBufferImpl() {
47 client_->pending_raster_buffers_.erase(this);
48 }
49
50 void OneCopyRasterBufferProvider::RasterBufferImpl::Playback(
51 const RasterSource* raster_source,
52 const gfx::Rect& raster_full_rect,
53 const gfx::Rect& raster_dirty_rect,
54 uint64_t new_content_id,
55 float scale,
56 const RasterSource::PlaybackSettings& playback_settings) {
57 TRACE_EVENT0("cc", "OneCopyRasterBuffer::Playback");
58 client_->PlaybackAndCopyOnWorkerThread(
59 resource_, &lock_, sync_token_, raster_source, raster_full_rect,
60 raster_dirty_rect, scale, playback_settings, previous_content_id_,
61 new_content_id);
62 }
63
70 OneCopyRasterBufferProvider::OneCopyRasterBufferProvider( 64 OneCopyRasterBufferProvider::OneCopyRasterBufferProvider(
71 base::SequencedTaskRunner* task_runner, 65 base::SequencedTaskRunner* task_runner,
72 ContextProvider* compositor_context_provider, 66 ContextProvider* compositor_context_provider,
73 ContextProvider* worker_context_provider, 67 ContextProvider* worker_context_provider,
74 ResourceProvider* resource_provider, 68 ResourceProvider* resource_provider,
75 int max_copy_texture_chromium_size, 69 int max_copy_texture_chromium_size,
76 bool use_partial_raster, 70 bool use_partial_raster,
77 int max_staging_buffer_usage_in_bytes, 71 int max_staging_buffer_usage_in_bytes,
78 ResourceFormat preferred_tile_format) 72 ResourceFormat preferred_tile_format,
73 bool async_worker_context_enabled)
79 : compositor_context_provider_(compositor_context_provider), 74 : compositor_context_provider_(compositor_context_provider),
80 worker_context_provider_(worker_context_provider), 75 worker_context_provider_(worker_context_provider),
81 resource_provider_(resource_provider), 76 resource_provider_(resource_provider),
82 max_bytes_per_copy_operation_( 77 max_bytes_per_copy_operation_(
83 max_copy_texture_chromium_size 78 max_copy_texture_chromium_size
84 ? std::min(kMaxBytesPerCopyOperation, 79 ? std::min(kMaxBytesPerCopyOperation,
85 max_copy_texture_chromium_size) 80 max_copy_texture_chromium_size)
86 : kMaxBytesPerCopyOperation), 81 : kMaxBytesPerCopyOperation),
87 use_partial_raster_(use_partial_raster), 82 use_partial_raster_(use_partial_raster),
88 bytes_scheduled_since_last_flush_(0), 83 bytes_scheduled_since_last_flush_(0),
89 preferred_tile_format_(preferred_tile_format), 84 preferred_tile_format_(preferred_tile_format),
90 staging_pool_(task_runner, 85 staging_pool_(task_runner,
91 worker_context_provider, 86 worker_context_provider,
92 resource_provider, 87 resource_provider,
93 use_partial_raster, 88 use_partial_raster,
94 max_staging_buffer_usage_in_bytes) { 89 max_staging_buffer_usage_in_bytes),
95 DCHECK(compositor_context_provider_); 90 async_worker_context_enabled_(async_worker_context_enabled) {
91 DCHECK(compositor_context_provider);
96 DCHECK(worker_context_provider); 92 DCHECK(worker_context_provider);
97 } 93 }
98 94
99 OneCopyRasterBufferProvider::~OneCopyRasterBufferProvider() {} 95 OneCopyRasterBufferProvider::~OneCopyRasterBufferProvider() {
96 DCHECK(pending_raster_buffers_.empty());
97 }
100 98
101 std::unique_ptr<RasterBuffer> 99 std::unique_ptr<RasterBuffer>
102 OneCopyRasterBufferProvider::AcquireBufferForRaster( 100 OneCopyRasterBufferProvider::AcquireBufferForRaster(
103 const Resource* resource, 101 const Resource* resource,
104 uint64_t resource_content_id, 102 uint64_t resource_content_id,
105 uint64_t previous_content_id) { 103 uint64_t previous_content_id) {
106 // TODO(danakj): If resource_content_id != 0, we only need to copy/upload 104 // TODO(danakj): If resource_content_id != 0, we only need to copy/upload
107 // the dirty rect. 105 // the dirty rect.
108 return base::WrapUnique<RasterBuffer>( 106 return base::WrapUnique(new RasterBufferImpl(this, resource_provider_,
109 new RasterBufferImpl(this, resource_provider_, resource->format(), 107 resource, previous_content_id,
110 resource, previous_content_id)); 108 async_worker_context_enabled_));
111 } 109 }
112 110
113 void OneCopyRasterBufferProvider::ReleaseBufferForRaster( 111 void OneCopyRasterBufferProvider::ReleaseBufferForRaster(
114 std::unique_ptr<RasterBuffer> buffer) { 112 std::unique_ptr<RasterBuffer> buffer) {
115 // Nothing to do here. RasterBufferImpl destructor cleans up after itself. 113 // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
116 } 114 }
117 115
118 void OneCopyRasterBufferProvider::OrderingBarrier() { 116 void OneCopyRasterBufferProvider::OrderingBarrier() {
119 TRACE_EVENT0("cc", "OneCopyRasterBufferProvider::OrderingBarrier"); 117 TRACE_EVENT0("cc", "OneCopyRasterBufferProvider::OrderingBarrier");
120 compositor_context_provider_->ContextGL()->OrderingBarrierCHROMIUM(); 118
119 gpu::gles2::GLES2Interface* gl = compositor_context_provider_->ContextGL();
120 if (async_worker_context_enabled_) {
121 GLuint64 fence = gl->InsertFenceSyncCHROMIUM();
122 gl->OrderingBarrierCHROMIUM();
123
124 gpu::SyncToken sync_token;
125 gl->GenUnverifiedSyncTokenCHROMIUM(fence, sync_token.GetData());
126
127 DCHECK(sync_token.HasData() ||
128 gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR);
129
130 for (RasterBufferImpl* buffer : pending_raster_buffers_)
131 buffer->set_sync_token(sync_token);
132 } else {
133 gl->OrderingBarrierCHROMIUM();
134 }
135 pending_raster_buffers_.clear();
121 } 136 }
122 137
123 ResourceFormat OneCopyRasterBufferProvider::GetResourceFormat( 138 ResourceFormat OneCopyRasterBufferProvider::GetResourceFormat(
124 bool must_support_alpha) const { 139 bool must_support_alpha) const {
125 if (resource_provider_->IsResourceFormatSupported(preferred_tile_format_) && 140 if (resource_provider_->IsResourceFormatSupported(preferred_tile_format_) &&
126 (DoesResourceFormatSupportAlpha(preferred_tile_format_) || 141 (DoesResourceFormatSupportAlpha(preferred_tile_format_) ||
127 !must_support_alpha)) { 142 !must_support_alpha)) {
128 return preferred_tile_format_; 143 return preferred_tile_format_;
129 } 144 }
130 145
131 return resource_provider_->best_texture_format(); 146 return resource_provider_->best_texture_format();
132 } 147 }
133 148
134 bool OneCopyRasterBufferProvider::GetResourceRequiresSwizzle( 149 bool OneCopyRasterBufferProvider::GetResourceRequiresSwizzle(
135 bool must_support_alpha) const { 150 bool must_support_alpha) const {
136 return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha)); 151 return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
137 } 152 }
138 153
139 void OneCopyRasterBufferProvider::Shutdown() { 154 void OneCopyRasterBufferProvider::Shutdown() {
140 staging_pool_.Shutdown(); 155 staging_pool_.Shutdown();
156 pending_raster_buffers_.clear();
141 } 157 }
142 158
143 void OneCopyRasterBufferProvider::PlaybackAndCopyOnWorkerThread( 159 void OneCopyRasterBufferProvider::PlaybackAndCopyOnWorkerThread(
144 const Resource* resource, 160 const Resource* resource,
145 ResourceProvider::ScopedWriteLockGL* resource_lock, 161 ResourceProvider::ScopedWriteLockGL* resource_lock,
162 const gpu::SyncToken& sync_token,
146 const RasterSource* raster_source, 163 const RasterSource* raster_source,
147 const gfx::Rect& raster_full_rect, 164 const gfx::Rect& raster_full_rect,
148 const gfx::Rect& raster_dirty_rect, 165 const gfx::Rect& raster_dirty_rect,
149 float scale, 166 float scale,
150 const RasterSource::PlaybackSettings& playback_settings, 167 const RasterSource::PlaybackSettings& playback_settings,
151 uint64_t previous_content_id, 168 uint64_t previous_content_id,
152 uint64_t new_content_id) { 169 uint64_t new_content_id) {
170 if (async_worker_context_enabled_) {
171 // Early out if sync token is invalid. This happens if the compositor
172 // context was lost before ScheduleTasks was called.
173 if (!sync_token.HasData())
174 return;
175 ContextProvider::ScopedContextLock scoped_context(worker_context_provider_);
176 gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
177 DCHECK(gl);
178 // Synchronize with compositor.
179 gl->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
180 }
181
153 std::unique_ptr<StagingBuffer> staging_buffer = 182 std::unique_ptr<StagingBuffer> staging_buffer =
154 staging_pool_.AcquireStagingBuffer(resource, previous_content_id); 183 staging_pool_.AcquireStagingBuffer(resource, previous_content_id);
155 184
156 PlaybackToStagingBuffer(staging_buffer.get(), resource, raster_source, 185 PlaybackToStagingBuffer(staging_buffer.get(), resource, raster_source,
157 raster_full_rect, raster_dirty_rect, scale, 186 raster_full_rect, raster_dirty_rect, scale,
158 playback_settings, previous_content_id, 187 playback_settings, previous_content_id,
159 new_content_id); 188 new_content_id);
160 189
161 CopyOnWorkerThread(staging_buffer.get(), resource, resource_lock, 190 CopyOnWorkerThread(staging_buffer.get(), resource_lock, sync_token,
162 raster_source, previous_content_id, new_content_id); 191 raster_source, previous_content_id, new_content_id);
163 192
164 staging_pool_.ReleaseStagingBuffer(std::move(staging_buffer)); 193 staging_pool_.ReleaseStagingBuffer(std::move(staging_buffer));
165 } 194 }
166 195
167 void OneCopyRasterBufferProvider::PlaybackToStagingBuffer( 196 void OneCopyRasterBufferProvider::PlaybackToStagingBuffer(
168 StagingBuffer* staging_buffer, 197 StagingBuffer* staging_buffer,
169 const Resource* resource, 198 const Resource* resource,
170 const RasterSource* raster_source, 199 const RasterSource* raster_source,
171 const gfx::Rect& raster_full_rect, 200 const gfx::Rect& raster_full_rect,
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
210 buffer->memory(0), resource->format(), staging_buffer->size, 239 buffer->memory(0), resource->format(), staging_buffer->size,
211 buffer->stride(0), raster_source, raster_full_rect, playback_rect, 240 buffer->stride(0), raster_source, raster_full_rect, playback_rect,
212 scale, playback_settings); 241 scale, playback_settings);
213 buffer->Unmap(); 242 buffer->Unmap();
214 staging_buffer->content_id = new_content_id; 243 staging_buffer->content_id = new_content_id;
215 } 244 }
216 } 245 }
217 246
218 void OneCopyRasterBufferProvider::CopyOnWorkerThread( 247 void OneCopyRasterBufferProvider::CopyOnWorkerThread(
219 StagingBuffer* staging_buffer, 248 StagingBuffer* staging_buffer,
220 const Resource* resource,
221 ResourceProvider::ScopedWriteLockGL* resource_lock, 249 ResourceProvider::ScopedWriteLockGL* resource_lock,
250 const gpu::SyncToken& sync_token,
222 const RasterSource* raster_source, 251 const RasterSource* raster_source,
223 uint64_t previous_content_id, 252 uint64_t previous_content_id,
224 uint64_t new_content_id) { 253 uint64_t new_content_id) {
225 { 254 ContextProvider::ScopedContextLock scoped_context(worker_context_provider_);
226 ContextProvider::ScopedContextLock scoped_context(worker_context_provider_); 255 gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
256 DCHECK(gl);
227 257
228 gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL(); 258 // Create texture after synchronizing with compositor.
229 DCHECK(gl); 259 ResourceProvider::ScopedTextureProvider scoped_texture(
260 gl, resource_lock, async_worker_context_enabled_);
230 261
231 unsigned image_target = 262 unsigned resource_texture_id = scoped_texture.texture_id();
232 resource_provider_->GetImageTextureTarget(resource->format()); 263 unsigned image_target =
264 resource_provider_->GetImageTextureTarget(resource_lock->format());
233 265
234 // Create and bind staging texture. 266 // Create and bind staging texture.
235 if (!staging_buffer->texture_id) { 267 if (!staging_buffer->texture_id) {
236 gl->GenTextures(1, &staging_buffer->texture_id); 268 gl->GenTextures(1, &staging_buffer->texture_id);
237 gl->BindTexture(image_target, staging_buffer->texture_id); 269 gl->BindTexture(image_target, staging_buffer->texture_id);
238 gl->TexParameteri(image_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 270 gl->TexParameteri(image_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
239 gl->TexParameteri(image_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 271 gl->TexParameteri(image_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
240 gl->TexParameteri(image_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 272 gl->TexParameteri(image_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
241 gl->TexParameteri(image_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 273 gl->TexParameteri(image_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
242 } else { 274 } else {
243 gl->BindTexture(image_target, staging_buffer->texture_id); 275 gl->BindTexture(image_target, staging_buffer->texture_id);
244 } 276 }
245 277
246 // Create and bind image. 278 // Create and bind image.
247 if (!staging_buffer->image_id) { 279 if (!staging_buffer->image_id) {
248 if (staging_buffer->gpu_memory_buffer) { 280 if (staging_buffer->gpu_memory_buffer) {
249 staging_buffer->image_id = gl->CreateImageCHROMIUM( 281 staging_buffer->image_id = gl->CreateImageCHROMIUM(
250 staging_buffer->gpu_memory_buffer->AsClientBuffer(), 282 staging_buffer->gpu_memory_buffer->AsClientBuffer(),
251 staging_buffer->size.width(), staging_buffer->size.height(), 283 staging_buffer->size.width(), staging_buffer->size.height(),
252 GLInternalFormat(resource->format())); 284 GLInternalFormat(resource_lock->format()));
253 gl->BindTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
254 }
255 } else {
256 gl->ReleaseTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
257 gl->BindTexImage2DCHROMIUM(image_target, staging_buffer->image_id); 285 gl->BindTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
258 } 286 }
287 } else {
288 gl->ReleaseTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
289 gl->BindTexImage2DCHROMIUM(image_target, staging_buffer->image_id);
290 }
259 291
260 // Unbind staging texture. 292 // Unbind staging texture.
261 gl->BindTexture(image_target, 0); 293 gl->BindTexture(image_target, 0);
262 294
263 if (resource_provider_->use_sync_query()) { 295 if (resource_provider_->use_sync_query()) {
264 if (!staging_buffer->query_id) 296 if (!staging_buffer->query_id)
265 gl->GenQueriesEXT(1, &staging_buffer->query_id); 297 gl->GenQueriesEXT(1, &staging_buffer->query_id);
266 298
267 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY) 299 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
268 // TODO(reveman): This avoids a performance problem on ARM ChromeOS 300 // TODO(reveman): This avoids a performance problem on ARM ChromeOS
269 // devices. crbug.com/580166 301 // devices. crbug.com/580166
270 gl->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM, staging_buffer->query_id); 302 gl->BeginQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM, staging_buffer->query_id);
271 #else 303 #else
272 gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM, 304 gl->BeginQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM, staging_buffer->query_id);
273 staging_buffer->query_id);
274 #endif 305 #endif
275 } 306 }
276 307
277 // Since compressed texture's cannot be pre-allocated we might have an 308 // Since compressed texture's cannot be pre-allocated we might have an
278 // unallocated resource in which case we need to perform a full size copy. 309 // unallocated resource in which case we need to perform a full size copy.
279 if (IsResourceFormatCompressed(resource->format())) { 310 if (IsResourceFormatCompressed(resource_lock->format())) {
280 gl->CompressedCopyTextureCHROMIUM(staging_buffer->texture_id, 311 gl->CompressedCopyTextureCHROMIUM(staging_buffer->texture_id,
281 resource_lock->texture_id()); 312 resource_texture_id);
282 } else { 313 } else {
283 int bytes_per_row = ResourceUtil::UncheckedWidthInBytes<int>( 314 int bytes_per_row = ResourceUtil::UncheckedWidthInBytes<int>(
284 resource->size().width(), resource->format()); 315 resource_lock->size().width(), resource_lock->format());
285 int chunk_size_in_rows = 316 int chunk_size_in_rows =
286 std::max(1, max_bytes_per_copy_operation_ / bytes_per_row); 317 std::max(1, max_bytes_per_copy_operation_ / bytes_per_row);
287 // Align chunk size to 4. Required to support compressed texture formats. 318 // Align chunk size to 4. Required to support compressed texture formats.
288 chunk_size_in_rows = MathUtil::UncheckedRoundUp(chunk_size_in_rows, 4); 319 chunk_size_in_rows = MathUtil::UncheckedRoundUp(chunk_size_in_rows, 4);
289 int y = 0; 320 int y = 0;
290 int height = resource->size().height(); 321 int height = resource_lock->size().height();
291 while (y < height) { 322 while (y < height) {
292 // Copy at most |chunk_size_in_rows|. 323 // Copy at most |chunk_size_in_rows|.
293 int rows_to_copy = std::min(chunk_size_in_rows, height - y); 324 int rows_to_copy = std::min(chunk_size_in_rows, height - y);
294 DCHECK_GT(rows_to_copy, 0); 325 DCHECK_GT(rows_to_copy, 0);
295 326
296 gl->CopySubTextureCHROMIUM( 327 gl->CopySubTextureCHROMIUM(
297 staging_buffer->texture_id, resource_lock->texture_id(), 0, y, 0, y, 328 staging_buffer->texture_id, resource_texture_id, 0, y, 0, y,
298 resource->size().width(), rows_to_copy, false, false, false); 329 resource_lock->size().width(), rows_to_copy, false, false, false);
299 y += rows_to_copy; 330 y += rows_to_copy;
300 331
301 // Increment |bytes_scheduled_since_last_flush_| by the amount of memory 332 // Increment |bytes_scheduled_since_last_flush_| by the amount of memory
302 // used for this copy operation. 333 // used for this copy operation.
303 bytes_scheduled_since_last_flush_ += rows_to_copy * bytes_per_row; 334 bytes_scheduled_since_last_flush_ += rows_to_copy * bytes_per_row;
304 335
305 if (bytes_scheduled_since_last_flush_ >= 336 if (bytes_scheduled_since_last_flush_ >= max_bytes_per_copy_operation_) {
306 max_bytes_per_copy_operation_) { 337 gl->ShallowFlushCHROMIUM();
307 gl->ShallowFlushCHROMIUM(); 338 bytes_scheduled_since_last_flush_ = 0;
308 bytes_scheduled_since_last_flush_ = 0;
309 }
310 } 339 }
311 } 340 }
341 }
312 342
313 if (resource_provider_->use_sync_query()) { 343 if (resource_provider_->use_sync_query()) {
314 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY) 344 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
315 gl->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM); 345 gl->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
316 #else 346 #else
317 gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM); 347 gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);
318 #endif 348 #endif
319 } 349 }
320 350
321 const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM(); 351 const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
322 352
323 // Barrier to sync worker context output to cc context. 353 // Barrier to sync worker context output to cc context.
324 gl->OrderingBarrierCHROMIUM(); 354 gl->OrderingBarrierCHROMIUM();
325 355
326 // Generate sync token after the barrier for cross context synchronization. 356 // Generate sync token after the barrier for cross context synchronization.
327 gpu::SyncToken sync_token; 357 gpu::SyncToken resource_sync_token;
328 gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData()); 358 gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, resource_sync_token.GetData());
329 resource_lock->UpdateResourceSyncToken(sync_token); 359 resource_lock->set_sync_token(resource_sync_token);
330 } 360 resource_lock->set_synchronized(!async_worker_context_enabled_);
331 } 361 }
332 362
333 } // namespace cc 363 } // namespace cc
OLDNEW
« no previous file with comments | « cc/raster/one_copy_raster_buffer_provider.h ('k') | cc/raster/raster_buffer_provider.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698