Index: cc/resources/resource_provider.cc |
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc |
index ba448a363f6f7aa145f85e39842af6142ea7c28e..8d7fb6428ba375b8a2425417a83921fdcd3a2995 100644 |
--- a/cc/resources/resource_provider.cc |
+++ b/cc/resources/resource_provider.cc |
@@ -816,12 +816,11 @@ |
SkCanvas dest(lock.sk_bitmap()); |
dest.writePixels(source_info, image, image_stride, 0, 0); |
} else { |
- ScopedWriteLockGL lock(this, id, false); |
- unsigned resource_texture_id = lock.texture_id(); |
- DCHECK(resource_texture_id); |
+ ScopedWriteLockGL lock(this, id); |
+ DCHECK(lock.texture_id()); |
GLES2Interface* gl = ContextGL(); |
DCHECK(gl); |
- gl->BindTexture(resource->target, resource_texture_id); |
+ gl->BindTexture(resource->target, lock.texture_id()); |
if (resource->format == ETC1) { |
DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D)); |
int image_bytes = ResourceUtil::CheckedSizeInBytes<int>(image_size, ETC1); |
@@ -837,7 +836,7 @@ |
gl->OrderingBarrierCHROMIUM(); |
gpu::SyncToken sync_token; |
gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData()); |
- lock.set_sync_token(sync_token); |
+ lock.UpdateResourceSyncToken(sync_token); |
} |
} |
@@ -1001,7 +1000,7 @@ |
return resource->is_overlay_candidate; |
} |
-void ResourceProvider::UnlockForWrite(Resource* resource) { |
+void ResourceProvider::UnlockForWrite(ResourceProvider::Resource* resource) { |
DCHECK(resource->locked_for_write); |
DCHECK_EQ(resource->exported_count, 0); |
DCHECK(resource->origin == Resource::INTERNAL); |
@@ -1018,11 +1017,10 @@ |
ResourceProvider::ScopedReadLockGL::ScopedReadLockGL( |
ResourceProvider* resource_provider, |
ResourceId resource_id) |
- : resource_provider_(resource_provider), resource_id_(resource_id) { |
- const Resource* resource = resource_provider->LockForRead(resource_id, false); |
- texture_id_ = resource->gl_id; |
- target_ = resource->target; |
- size_ = resource->size; |
+ : resource_provider_(resource_provider), |
+ resource_id_(resource_id), |
+ resource_(resource_provider->LockForRead(resource_id, false)) { |
+ DCHECK(resource_); |
} |
ResourceProvider::ScopedReadLockGL::~ScopedReadLockGL() { |
@@ -1033,89 +1031,186 @@ |
ResourceProvider* resource_provider, |
ResourceId resource_id, |
GLenum filter) |
- : resource_lock_(resource_provider, resource_id), |
+ : ScopedReadLockGL(resource_provider, resource_id), |
unit_(GL_TEXTURE0), |
- target_(resource_provider->BindForSampling(resource_id, unit_, filter)) {} |
+ target_(resource_provider->BindForSampling(resource_id, unit_, filter)) { |
+} |
ResourceProvider::ScopedSamplerGL::ScopedSamplerGL( |
ResourceProvider* resource_provider, |
ResourceId resource_id, |
GLenum unit, |
GLenum filter) |
- : resource_lock_(resource_provider, resource_id), |
+ : ScopedReadLockGL(resource_provider, resource_id), |
unit_(unit), |
- target_(resource_provider->BindForSampling(resource_id, unit_, filter)) {} |
+ target_(resource_provider->BindForSampling(resource_id, unit_, filter)) { |
+} |
ResourceProvider::ScopedSamplerGL::~ScopedSamplerGL() { |
} |
ResourceProvider::ScopedWriteLockGL::ScopedWriteLockGL( |
ResourceProvider* resource_provider, |
- ResourceId resource_id, |
- bool create_mailbox) |
+ ResourceId resource_id) |
+ : resource_provider_(resource_provider), |
+ resource_(resource_provider->LockForWrite(resource_id)), |
+ texture_id_(0), |
+ set_sync_token_(false) { |
+ resource_provider_->LazyAllocate(resource_); |
+ texture_id_ = resource_->gl_id; |
+ DCHECK(texture_id_); |
+ if (resource_->image_id && resource_->dirty_image) |
+ resource_provider_->BindImageForSampling(resource_); |
+} |
+ |
+ResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL() { |
+ if (set_sync_token_) |
+ resource_->UpdateSyncToken(sync_token_); |
+ resource_provider_->UnlockForWrite(resource_); |
+} |
+ |
+void ResourceProvider::PopulateSkBitmapWithResource( |
+ SkBitmap* sk_bitmap, const Resource* resource) { |
+ DCHECK_EQ(RGBA_8888, resource->format); |
+ SkImageInfo info = SkImageInfo::MakeN32Premul(resource->size.width(), |
+ resource->size.height()); |
+ sk_bitmap->installPixels(info, resource->pixels, info.minRowBytes()); |
+} |
+ |
+ResourceProvider::ScopedReadLockSoftware::ScopedReadLockSoftware( |
+ ResourceProvider* resource_provider, |
+ ResourceId resource_id) |
: resource_provider_(resource_provider), resource_id_(resource_id) { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- Resource* resource = resource_provider->LockForWrite(resource_id); |
- resource_provider_->LazyAllocate(resource); |
- if (resource->image_id && resource->dirty_image) |
- resource_provider_->BindImageForSampling(resource); |
- if (create_mailbox) { |
- resource_provider_->CreateMailboxAndBindResource( |
- resource_provider_->ContextGL(), resource); |
- } |
- texture_id_ = resource->gl_id; |
- target_ = resource->target; |
- format_ = resource->format; |
- size_ = resource->size; |
- mailbox_ = resource->mailbox(); |
-} |
- |
-ResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL() { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- Resource* resource = resource_provider_->GetResource(resource_id_); |
- DCHECK(resource->locked_for_write); |
- if (sync_token_.HasData()) |
- resource->UpdateSyncToken(sync_token_); |
- resource_provider_->UnlockForWrite(resource); |
-} |
- |
-ResourceProvider::ScopedTextureProvider::ScopedTextureProvider( |
- gpu::gles2::GLES2Interface* gl, |
- ScopedWriteLockGL* resource_lock, |
- bool use_mailbox) |
- : gl_(gl), use_mailbox_(use_mailbox) { |
- if (use_mailbox_) { |
- texture_id_ = gl_->CreateAndConsumeTextureCHROMIUM( |
- resource_lock->target(), resource_lock->mailbox().name()); |
- } else { |
- texture_id_ = resource_lock->texture_id(); |
- } |
- DCHECK(texture_id_); |
-} |
- |
-ResourceProvider::ScopedTextureProvider::~ScopedTextureProvider() { |
- if (use_mailbox_) |
- gl_->DeleteTextures(1, &texture_id_); |
-} |
- |
-ResourceProvider::ScopedSkSurfaceProvider::ScopedSkSurfaceProvider( |
- ContextProvider* context_provider, |
- ScopedWriteLockGL* resource_lock, |
- bool use_mailbox, |
+ const Resource* resource = resource_provider->LockForRead(resource_id, false); |
+ ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource); |
+} |
+ |
+ResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware() { |
+ resource_provider_->UnlockForRead(resource_id_); |
+} |
+ |
+ResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware( |
+ ResourceProvider* resource_provider, |
+ ResourceId resource_id) |
+ : resource_provider_(resource_provider), |
+ resource_(resource_provider->LockForWrite(resource_id)) { |
+ ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource_); |
+ DCHECK(valid()); |
+} |
+ |
+ResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware() { |
+ DCHECK(thread_checker_.CalledOnValidThread()); |
+ resource_provider_->UnlockForWrite(resource_); |
+} |
+ |
+ResourceProvider::ScopedWriteLockGpuMemoryBuffer:: |
+ ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider, |
+ ResourceId resource_id) |
+ : resource_provider_(resource_provider), |
+ resource_(resource_provider->LockForWrite(resource_id)) { |
+ DCHECK(IsGpuResourceType(resource_->type)); |
+ gpu_memory_buffer_ = std::move(resource_->gpu_memory_buffer); |
+ resource_->gpu_memory_buffer = nullptr; |
+} |
+ |
+ResourceProvider::ScopedWriteLockGpuMemoryBuffer:: |
+ ~ScopedWriteLockGpuMemoryBuffer() { |
+ DCHECK(thread_checker_.CalledOnValidThread()); |
+ resource_provider_->UnlockForWrite(resource_); |
+ if (!gpu_memory_buffer_) |
+ return; |
+ |
+ DCHECK(!resource_->gpu_memory_buffer); |
+ resource_provider_->LazyCreate(resource_); |
+ resource_->gpu_memory_buffer = std::move(gpu_memory_buffer_); |
+ if (resource_->gpu_memory_buffer) |
+ resource_->gpu_memory_buffer_id = resource_->gpu_memory_buffer->GetId(); |
+ resource_->allocated = true; |
+ resource_provider_->LazyCreateImage(resource_); |
+ resource_->dirty_image = true; |
+ resource_->is_overlay_candidate = true; |
+ resource_->SetSynchronized(); |
+ |
+ // GpuMemoryBuffer provides direct access to the memory used by the GPU. |
+ // Read lock fences are required to ensure that we're not trying to map a |
+ // buffer that is currently in-use by the GPU. |
+ resource_->read_lock_fences_enabled = true; |
+} |
+ |
+gfx::GpuMemoryBuffer* |
+ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() { |
+ if (!gpu_memory_buffer_) { |
+ gpu_memory_buffer_ = |
+ resource_provider_->gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer( |
+ resource_->size, BufferFormat(resource_->format), |
+ gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, gpu::kNullSurfaceHandle); |
+ } |
+ return gpu_memory_buffer_.get(); |
+} |
+ |
+ResourceProvider::ScopedReadLockGpuMemoryBuffer::ScopedReadLockGpuMemoryBuffer( |
+ ResourceProvider* resource_provider, |
+ ResourceId resource_id) |
+ : resource_provider_(resource_provider), |
+ resource_id_(resource_id), |
+ resource_(resource_provider->LockForRead(resource_id, true)) {} |
+ |
+ResourceProvider::ScopedReadLockGpuMemoryBuffer:: |
+ ~ScopedReadLockGpuMemoryBuffer() { |
+ DCHECK(thread_checker_.CalledOnValidThread()); |
+ resource_provider_->UnlockForRead(resource_id_); |
+} |
+ |
+gfx::GpuMemoryBuffer* |
+ResourceProvider::ScopedReadLockGpuMemoryBuffer::GetGpuMemoryBuffer() const { |
+ return resource_->gpu_memory_buffer.get(); |
+} |
+ |
+unsigned ResourceProvider::ScopedReadLockGpuMemoryBuffer::GetTextureId() const { |
+ return resource_->gl_id; |
+} |
+ |
+ResourceId ResourceProvider::ScopedReadLockGpuMemoryBuffer::GetResourceId() |
+ const { |
+ return resource_id_; |
+} |
+ |
+ResourceProvider::ScopedWriteLockGr::ScopedWriteLockGr( |
+ ResourceProvider* resource_provider, |
+ ResourceId resource_id) |
+ : resource_provider_(resource_provider), |
+ resource_(resource_provider->LockForWrite(resource_id)), |
+ set_sync_token_(false) { |
+ DCHECK(thread_checker_.CalledOnValidThread()); |
+ resource_provider_->LazyAllocate(resource_); |
+ if (resource_->image_id && resource_->dirty_image) |
+ resource_provider_->BindImageForSampling(resource_); |
+} |
+ |
+ResourceProvider::ScopedWriteLockGr::~ScopedWriteLockGr() { |
+ DCHECK(thread_checker_.CalledOnValidThread()); |
+ DCHECK(resource_->locked_for_write); |
+ if (set_sync_token_) |
+ resource_->UpdateSyncToken(sync_token_); |
+ |
+ resource_provider_->UnlockForWrite(resource_); |
+} |
+ |
+void ResourceProvider::ScopedWriteLockGr::InitSkSurface( |
+ GrContext* gr_context, |
bool use_distance_field_text, |
bool can_use_lcd_text, |
- int msaa_sample_count) |
- : texture_provider_(context_provider->ContextGL(), |
- resource_lock, |
- use_mailbox) { |
+ int msaa_sample_count) { |
+ DCHECK(resource_->locked_for_write); |
+ |
GrGLTextureInfo texture_info; |
- texture_info.fID = texture_provider_.texture_id(); |
- texture_info.fTarget = resource_lock->target(); |
+ texture_info.fID = resource_->gl_id; |
+ texture_info.fTarget = resource_->target; |
GrBackendTextureDesc desc; |
desc.fFlags = kRenderTarget_GrBackendTextureFlag; |
- desc.fWidth = resource_lock->size().width(); |
- desc.fHeight = resource_lock->size().height(); |
- desc.fConfig = ToGrPixelConfig(resource_lock->format()); |
+ desc.fWidth = resource_->size.width(); |
+ desc.fHeight = resource_->size.height(); |
+ desc.fConfig = ToGrPixelConfig(resource_->format); |
desc.fOrigin = kTopLeft_GrSurfaceOrigin; |
desc.fTextureHandle = skia::GrGLTextureInfoToGrBackendObject(texture_info); |
desc.fSampleCnt = msaa_sample_count; |
@@ -1130,109 +1225,13 @@ |
SkSurfaceProps(flags, SkSurfaceProps::kLegacyFontHost_InitType); |
} |
sk_surface_ = SkSurface::MakeFromBackendTextureAsRenderTarget( |
- context_provider->GrContext(), desc, &surface_props); |
-} |
- |
-ResourceProvider::ScopedSkSurfaceProvider::~ScopedSkSurfaceProvider() { |
- if (sk_surface_.get()) { |
- sk_surface_->prepareForExternalIO(); |
- sk_surface_.reset(); |
- } |
-} |
- |
-void ResourceProvider::PopulateSkBitmapWithResource( |
- SkBitmap* sk_bitmap, const Resource* resource) { |
- DCHECK_EQ(RGBA_8888, resource->format); |
- SkImageInfo info = SkImageInfo::MakeN32Premul(resource->size.width(), |
- resource->size.height()); |
- sk_bitmap->installPixels(info, resource->pixels, info.minRowBytes()); |
-} |
- |
-ResourceProvider::ScopedReadLockSoftware::ScopedReadLockSoftware( |
- ResourceProvider* resource_provider, |
- ResourceId resource_id) |
- : resource_provider_(resource_provider), resource_id_(resource_id) { |
- const Resource* resource = resource_provider->LockForRead(resource_id, false); |
- ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource); |
-} |
- |
-ResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware() { |
- resource_provider_->UnlockForRead(resource_id_); |
-} |
- |
-ResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware( |
- ResourceProvider* resource_provider, |
- ResourceId resource_id) |
- : resource_provider_(resource_provider), resource_id_(resource_id) { |
- ResourceProvider::PopulateSkBitmapWithResource( |
- &sk_bitmap_, resource_provider->LockForWrite(resource_id)); |
- DCHECK(valid()); |
-} |
- |
-ResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware() { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- resource_provider_->UnlockForWrite( |
- resource_provider_->GetResource(resource_id_)); |
-} |
- |
-ResourceProvider::ScopedWriteLockGpuMemoryBuffer:: |
- ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider, |
- ResourceId resource_id) |
- : resource_provider_(resource_provider), resource_id_(resource_id) { |
- Resource* resource = resource_provider->LockForWrite(resource_id); |
- DCHECK(IsGpuResourceType(resource->type)); |
- format_ = resource->format; |
- size_ = resource->size; |
- gpu_memory_buffer_ = std::move(resource->gpu_memory_buffer); |
- resource->gpu_memory_buffer = nullptr; |
-} |
- |
-ResourceProvider::ScopedWriteLockGpuMemoryBuffer:: |
- ~ScopedWriteLockGpuMemoryBuffer() { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- Resource* resource = resource_provider_->GetResource(resource_id_); |
- if (gpu_memory_buffer_) { |
- DCHECK(!resource->gpu_memory_buffer); |
- resource_provider_->LazyCreate(resource); |
- resource->gpu_memory_buffer = std::move(gpu_memory_buffer_); |
- if (resource->gpu_memory_buffer) |
- resource->gpu_memory_buffer_id = resource->gpu_memory_buffer->GetId(); |
- resource->allocated = true; |
- resource_provider_->LazyCreateImage(resource); |
- resource->dirty_image = true; |
- resource->is_overlay_candidate = true; |
- // GpuMemoryBuffer provides direct access to the memory used by the GPU. |
- // Read lock fences are required to ensure that we're not trying to map a |
- // buffer that is currently in-use by the GPU. |
- resource->read_lock_fences_enabled = true; |
- } |
- resource_provider_->UnlockForWrite(resource); |
-} |
- |
-gfx::GpuMemoryBuffer* |
-ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() { |
- if (!gpu_memory_buffer_) { |
- gpu_memory_buffer_ = |
- resource_provider_->gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer( |
- size_, BufferFormat(format_), |
- gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, gpu::kNullSurfaceHandle); |
- } |
- return gpu_memory_buffer_.get(); |
-} |
- |
-ResourceProvider::ScopedReadLockGpuMemoryBuffer::ScopedReadLockGpuMemoryBuffer( |
- ResourceProvider* resource_provider, |
- ResourceId resource_id) |
- : resource_provider_(resource_provider), resource_id_(resource_id) { |
- const Resource* resource = resource_provider->LockForRead(resource_id, true); |
- gpu_memory_buffer_ = resource->gpu_memory_buffer.get(); |
- texture_id_ = resource->gl_id; |
-} |
- |
-ResourceProvider::ScopedReadLockGpuMemoryBuffer:: |
- ~ScopedReadLockGpuMemoryBuffer() { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- resource_provider_->UnlockForRead(resource_id_); |
+ gr_context, desc, &surface_props); |
+} |
+ |
+void ResourceProvider::ScopedWriteLockGr::ReleaseSkSurface() { |
+ DCHECK(sk_surface_); |
+ sk_surface_->prepareForExternalIO(); |
+ sk_surface_.reset(); |
} |
ResourceProvider::SynchronousFence::SynchronousFence( |
@@ -1791,10 +1790,6 @@ |
LazyCreateImage(resource); |
resource->dirty_image = true; |
resource->is_overlay_candidate = true; |
- // GpuMemoryBuffer provides direct access to the memory used by the GPU. |
- // Read lock fences are required to ensure that we're not trying to map a |
- // buffer that is currently in-use by the GPU. |
- resource->read_lock_fences_enabled = true; |
} else if (use_texture_storage_ext_ && |
IsFormatSupportedForStorage(format, use_texture_format_bgra_) && |
(resource->hint & TEXTURE_HINT_IMMUTABLE)) { |