Index: cc/resources/resource_provider.cc |
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc |
index 18e2f222a36a1fdc4c6860573a8b7cbf455f065d..a9e8e8552b4d96e462a7fda7b566bb29a43c1d77 100644 |
--- a/cc/resources/resource_provider.cc |
+++ b/cc/resources/resource_provider.cc |
@@ -694,11 +694,25 @@ |
DeleteStyle style) { |
TRACE_EVENT0("cc", "ResourceProvider::DeleteResourceInternal"); |
Resource* resource = &it->second; |
- bool lost_resource = resource->lost; |
- |
DCHECK(resource->exported_count == 0 || style != NORMAL); |
- if (style == FOR_SHUTDOWN && resource->exported_count > 0) |
- lost_resource = true; |
+ |
+ // Exported resources are lost on shutdown. |
+ bool exported_resource_lost = |
+ style == FOR_SHUTDOWN && resource->exported_count > 0; |
+ // GPU resources are lost when output surface is lost. |
+ bool gpu_resource_lost = |
+ IsGpuResourceType(resource->type) && lost_output_surface_; |
+ bool lost_resource = |
+ resource->lost || exported_resource_lost || gpu_resource_lost; |
+ |
+ if (!lost_resource && |
+ resource->synchronization_state() == Resource::NEEDS_WAIT) { |
+ DCHECK(resource->allocated); |
+ DCHECK(IsGpuResourceType(resource->type)); |
+ GLES2Interface* gl = ContextGL(); |
+ DCHECK(gl); |
+ resource->WaitSyncToken(gl); |
+ } |
if (resource->image_id) { |
DCHECK(resource->origin == Resource::INTERNAL); |
@@ -729,7 +743,6 @@ |
gpu::SyncToken sync_token = resource->mailbox().sync_token(); |
if (IsGpuResourceType(resource->type)) { |
DCHECK(resource->mailbox().IsTexture()); |
- lost_resource |= lost_output_surface_; |
GLES2Interface* gl = ContextGL(); |
DCHECK(gl); |
if (resource->gl_id) { |
@@ -815,11 +828,12 @@ |
SkCanvas dest(lock.sk_bitmap()); |
dest.writePixels(source_info, image, image_stride, 0, 0); |
} else { |
- ScopedWriteLockGL lock(this, id); |
- DCHECK(lock.texture_id()); |
+ ScopedWriteLockGL lock(this, id, false); |
+ unsigned resource_texture_id = lock.texture_id(); |
+ DCHECK(resource_texture_id); |
GLES2Interface* gl = ContextGL(); |
DCHECK(gl); |
- gl->BindTexture(resource->target, lock.texture_id()); |
+ gl->BindTexture(resource->target, resource_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); |
@@ -835,7 +849,8 @@ |
gl->OrderingBarrierCHROMIUM(); |
gpu::SyncToken sync_token; |
gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData()); |
- lock.UpdateResourceSyncToken(sync_token); |
+ lock.set_sync_token(sync_token); |
+ lock.set_synchronized(true); |
} |
} |
@@ -853,6 +868,7 @@ |
gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData()); |
resource->UpdateSyncToken(sync_token); |
+ resource->SetSynchronized(); |
} |
void ResourceProvider::GenerateSyncTokenForResources( |
@@ -873,6 +889,7 @@ |
} |
resource->UpdateSyncToken(sync_token); |
+ resource->SetSynchronized(); |
} |
} |
} |
@@ -965,7 +982,8 @@ |
ResourceProvider::Resource* ResourceProvider::LockForWrite(ResourceId id) { |
Resource* resource = GetResource(id); |
DCHECK(CanLockForWrite(id)); |
- DCHECK_NE(Resource::NEEDS_WAIT, resource->synchronization_state()); |
+ if (resource->allocated) |
+ WaitSyncTokenIfNeeded(id); |
resource->locked_for_write = true; |
resource->SetLocallyUsed(); |
return resource; |
@@ -983,12 +1001,11 @@ |
return resource->is_overlay_candidate; |
} |
-void ResourceProvider::UnlockForWrite(ResourceProvider::Resource* resource) { |
+void ResourceProvider::UnlockForWrite(Resource* resource) { |
DCHECK(resource->locked_for_write); |
DCHECK_EQ(resource->exported_count, 0); |
DCHECK(resource->origin == Resource::INTERNAL); |
resource->locked_for_write = false; |
- resource->SetSynchronized(); |
} |
void ResourceProvider::EnableReadLockFencesForTesting(ResourceId id) { |
@@ -1000,10 +1017,11 @@ |
ResourceProvider::ScopedReadLockGL::ScopedReadLockGL( |
ResourceProvider* resource_provider, |
ResourceId resource_id) |
- : resource_provider_(resource_provider), |
- resource_id_(resource_id), |
- resource_(resource_provider->LockForRead(resource_id)) { |
- DCHECK(resource_); |
+ : resource_provider_(resource_provider), resource_id_(resource_id) { |
+ const Resource* resource = resource_provider->LockForRead(resource_id); |
+ texture_id_ = resource->gl_id; |
+ target_ = resource->target; |
+ size_ = resource->size; |
} |
ResourceProvider::ScopedReadLockGL::~ScopedReadLockGL() { |
@@ -1014,7 +1032,7 @@ |
ResourceProvider* resource_provider, |
ResourceId resource_id, |
GLenum filter) |
- : ScopedReadLockGL(resource_provider, resource_id), |
+ : resource_lock_(resource_provider, resource_id), |
unit_(GL_TEXTURE0), |
target_(resource_provider->BindForSampling(resource_id, unit_, filter)) {} |
@@ -1023,7 +1041,7 @@ |
ResourceId resource_id, |
GLenum unit, |
GLenum filter) |
- : ScopedReadLockGL(resource_provider, resource_id), |
+ : resource_lock_(resource_provider, resource_id), |
unit_(unit), |
target_(resource_provider->BindForSampling(resource_id, unit_, filter)) {} |
@@ -1031,137 +1049,75 @@ |
ResourceProvider::ScopedWriteLockGL::ScopedWriteLockGL( |
ResourceProvider* resource_provider, |
- ResourceId resource_id) |
+ ResourceId resource_id, |
+ bool create_mailbox) |
: 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; |
+ resource_id_(resource_id), |
+ synchronized_(false) { |
+ 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_); |
+ if (synchronized_) |
+ resource->SetSynchronized(); |
+ 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_); |
- 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) { |
- const Resource* resource = resource_provider->LockForRead(resource_id); |
- 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_); |
- 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::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, |
+} |
+ |
+ResourceProvider::ScopedTextureProvider::~ScopedTextureProvider() { |
+ if (use_mailbox_) |
+ gl_->DeleteTextures(1, &texture_id_); |
+} |
+ |
+ResourceProvider::ScopedSkSurfaceProvider::ScopedSkSurfaceProvider( |
+ ContextProvider* context_provider, |
+ ScopedWriteLockGL* resource_lock, |
+ bool use_mailbox, |
bool use_distance_field_text, |
bool can_use_lcd_text, |
- int msaa_sample_count) { |
- DCHECK(resource_->locked_for_write); |
- |
+ int msaa_sample_count) |
+ : texture_provider_(context_provider->ContextGL(), |
+ resource_lock, |
+ use_mailbox) { |
GrGLTextureInfo texture_info; |
- texture_info.fID = resource_->gl_id; |
- texture_info.fTarget = resource_->target; |
+ texture_info.fID = texture_provider_.texture_id(); |
+ texture_info.fTarget = resource_lock->target(); |
GrBackendTextureDesc desc; |
desc.fFlags = kRenderTarget_GrBackendTextureFlag; |
- desc.fWidth = resource_->size.width(); |
- desc.fHeight = resource_->size.height(); |
- desc.fConfig = ToGrPixelConfig(resource_->format); |
+ desc.fWidth = resource_lock->size().width(); |
+ desc.fHeight = resource_lock->size().height(); |
+ desc.fConfig = ToGrPixelConfig(resource_lock->format()); |
desc.fOrigin = kTopLeft_GrSurfaceOrigin; |
desc.fTextureHandle = skia::GrGLTextureInfoToGrBackendObject(texture_info); |
desc.fSampleCnt = msaa_sample_count; |
@@ -1176,13 +1132,96 @@ |
SkSurfaceProps(flags, SkSurfaceProps::kLegacyFontHost_InitType); |
} |
sk_surface_ = SkSurface::MakeFromBackendTextureAsRenderTarget( |
- gr_context, desc, &surface_props); |
-} |
- |
-void ResourceProvider::ScopedWriteLockGr::ReleaseSkSurface() { |
- DCHECK(sk_surface_); |
- sk_surface_->prepareForExternalIO(); |
- sk_surface_.reset(); |
+ 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); |
+ 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* resource = resource_provider_->GetResource(resource_id_); |
+ DCHECK(resource); |
+ resource->SetSynchronized(); |
+ resource_provider_->UnlockForWrite(resource); |
+} |
+ |
+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_); |
+ DCHECK(resource); |
+ if (gpu_memory_buffer_) { |
+ DCHECK(!resource->gpu_memory_buffer); |
+ resource_provider_->LazyCreate(resource); |
+ resource->gpu_memory_buffer = std::move(gpu_memory_buffer_); |
+ 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->SetSynchronized(); |
+ 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::SynchronousFence::SynchronousFence( |
@@ -1733,6 +1772,10 @@ |
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)) { |