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

Unified Diff: cc/resources/resource_provider.cc

Issue 2046033002: Revert of cc: Add mailbox support to ResourceProvider write locks. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@worker_context_stream
Patch Set: 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 side-by-side diff with in-line comments
Download patch
« no previous file with comments | « cc/resources/resource_provider.h ('k') | cc/resources/resource_provider_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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)) {
« no previous file with comments | « cc/resources/resource_provider.h ('k') | cc/resources/resource_provider_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698