cc: Add mailbox support to ResourceProvider write locks.

cc/resources/resource_provider.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/resource_provider.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 745 matching lines @@
     DCHECK(resource->allocated);
     DCHECK_EQ(RGBA_8888, resource->format);
     SkImageInfo source_info =
         SkImageInfo::MakeN32Premul(image_size.width(), image_size.height());
     size_t image_stride = image_size.width() * 4;
 
     ScopedWriteLockSoftware lock(this, id);
     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.ProduceTextureId();
+    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);
       gl->CompressedTexImage2D(resource->target, 0, GLInternalFormat(ETC1),
                                image_size.width(), image_size.height(), 0,
                                image_bytes, image);
     } else {
       gl->TexSubImage2D(resource->target, 0, 0, 0, image_size.width(),
                         image_size.height(), GLDataFormat(resource->format),
                         GLDataType(resource->format), image);
     }
+    lock.ReleaseTextureId();
   }
 }
 
 void ResourceProvider::GenerateSyncTokenForResource(ResourceId resource_id) {
   Resource* resource = GetResource(resource_id);
   if (!resource->needs_sync_token())
     return;
 
   gpu::SyncToken sync_token;
   GLES2Interface* gl = ContextGL();
@@ skipping 189 matching lines @@
     : ScopedReadLockGL(resource_provider, resource_id),
       unit_(unit),
       target_(resource_provider->BindForSampling(resource_id, unit_, filter)) {
 }
 
 ResourceProvider::ScopedSamplerGL::~ScopedSamplerGL() {
 }
 
 ResourceProvider::ScopedWriteLockGL::ScopedWriteLockGL(
     ResourceProvider* resource_provider,
-    ResourceId resource_id)
+    ResourceId resource_id,
+    bool use_mailbox)
     : resource_provider_(resource_provider),
       resource_(resource_provider->LockForWrite(resource_id)),
+      use_mailbox_(use_mailbox),
       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_);
+  if (use_mailbox_) {
+    resource_provider_->CreateMailboxAndBindResource(
+        resource_provider_->ContextGL(), resource_);
+  }
 }
 
 ResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL() {
+  DCHECK_EQ(texture_id_, 0u);
   if (set_sync_token_)
     resource_->UpdateSyncToken(sync_token_);
   resource_provider_->UnlockForWrite(resource_);
 }
 
+unsigned ResourceProvider::ScopedWriteLockGL::ProduceTextureId() {
+  if (use_mailbox_) {
+    if (!texture_id_) {
+      gpu::gles2::GLES2Interface* gl = resource_provider_->output_surface()
+                                           ->worker_context_provider()
+                                           ->ContextGL();

[piman, 2016/05/06 01:55:30]

This path is taken in ResourceProvider::CopyToResource, which is called on the
compositor thread, so in that case we can't use the worker context (doubly so
without lock). Maybe the best is to pass the GLES2Interface to this function?

[sunnyps, 2016/05/25 02:18:43]

Done.

+      texture_id_ = gl->CreateAndConsumeTextureCHROMIUM(
+          resource_->target, resource_->mailbox().name());

[piman, 2016/05/06 01:55:30]

When called on the worker thread, it's not safe to access resource_, because
it's a pointer to an element of a std::vector, which may be modified
(reallocated) on the compositor thread.
Instead you can grab those values in the constructor and keep them as fields?

[sunnyps, 2016/05/25 02:18:43]

Done.

+      DCHECK(texture_id_);
+    }
+    return texture_id_;
+  }
+  return resource_->gl_id;

[piman, 2016/05/06 01:55:30]

(ditto)

[sunnyps, 2016/05/25 02:18:43]

Done.

+}
+
+void ResourceProvider::ScopedWriteLockGL::ReleaseTextureId() {
+  if (use_mailbox_) {
+    gpu::gles2::GLES2Interface* gl = resource_provider_->output_surface()
+                                         ->worker_context_provider()
+                                         ->ContextGL();

[piman, 2016/05/06 01:55:30]

And ditto wrt which context.

[sunnyps, 2016/05/25 02:18:43]

Done.

+    gl->DeleteTextures(1, &texture_id_);
+    texture_id_ = 0;
+  }
+}
+
 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,
@@ skipping 59 matching lines @@
     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)
+    ResourceId resource_id,
+    bool use_mailbox)
     : resource_provider_(resource_provider),
       resource_(resource_provider->LockForWrite(resource_id)),
+      use_mailbox_(use_mailbox),
+      texture_id_(0),
       set_sync_token_(false) {
   DCHECK(thread_checker_.CalledOnValidThread());
   resource_provider_->LazyAllocate(resource_);
   if (resource_->image_id && resource_->dirty_image)
     resource_provider_->BindImageForSampling(resource_);
+  if (use_mailbox_) {
+    resource_provider_->CreateMailboxAndBindResource(
+        resource_provider_->ContextGL(), resource_);
+  }
 }
 
 ResourceProvider::ScopedWriteLockGr::~ScopedWriteLockGr() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(resource_->locked_for_write);
+  DCHECK_EQ(texture_id_, 0u);
   if (set_sync_token_)
     resource_->UpdateSyncToken(sync_token_);
 
   resource_provider_->UnlockForWrite(resource_);
 }
 
 void ResourceProvider::ScopedWriteLockGr::InitSkSurface(
     bool use_distance_field_text,
     bool can_use_lcd_text,
     int msaa_sample_count) {
   DCHECK(resource_->locked_for_write);
 
+  if (use_mailbox_) {
+    gpu::gles2::GLES2Interface* gl = resource_provider_->output_surface()
+                                         ->worker_context_provider()
+                                         ->ContextGL();
+    texture_id_ = gl->CreateAndConsumeTextureCHROMIUM(
+        resource_->target, resource_->mailbox().name());

[piman, 2016/05/06 01:55:30]

Same as above, unsafe to access resource_

[sunnyps, 2016/05/25 02:18:43]

Done.

+  }
+
   GrGLTextureInfo texture_info;
-  texture_info.fID = resource_->gl_id;
+  texture_info.fID = use_mailbox_ ? texture_id_ : resource_->gl_id;
   texture_info.fTarget = resource_->target;
   GrBackendTextureDesc desc;
   desc.fFlags = kRenderTarget_GrBackendTextureFlag;
   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;
 
   bool use_worker_context = true;
   class GrContext* gr_context =
       resource_provider_->GrContext(use_worker_context);
   uint32_t flags =
       use_distance_field_text ? SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0;
   // Use unknown pixel geometry to disable LCD text.
   SkSurfaceProps surface_props(flags, kUnknown_SkPixelGeometry);
   if (can_use_lcd_text) {
     // LegacyFontHost will get LCD text and skia figures out what type to use.
     surface_props =
         SkSurfaceProps(flags, SkSurfaceProps::kLegacyFontHost_InitType);
   }
   sk_surface_ = SkSurface::MakeFromBackendTextureAsRenderTarget(
       gr_context, desc, &surface_props);
+  if (!sk_surface_ && use_mailbox_) {
+    gpu::gles2::GLES2Interface* gl = resource_provider_->output_surface()
+                                         ->worker_context_provider()
+                                         ->ContextGL();
+    gl->DeleteTextures(1, &texture_id_);
+    texture_id_ = 0;
+  }
 }
 
 void ResourceProvider::ScopedWriteLockGr::ReleaseSkSurface() {
   DCHECK(sk_surface_);
   sk_surface_->prepareForExternalIO();
   sk_surface_.reset();
+  if (use_mailbox_) {
+    gpu::gles2::GLES2Interface* gl = resource_provider_->output_surface()
+                                         ->worker_context_provider()
+                                         ->ContextGL();
+    gl->DeleteTextures(1, &texture_id_);
+    texture_id_ = 0;
+  }
 }
 
 ResourceProvider::SynchronousFence::SynchronousFence(
     gpu::gles2::GLES2Interface* gl)
     : gl_(gl), has_synchronized_(true) {
 }
 
 ResourceProvider::SynchronousFence::~SynchronousFence() {
 }
 
@@ skipping 805 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc