cc: Add mailbox support to ResourceProvider write locks.

cc/resources/resource_provider.cc

Index: cc/resources/resource_provider.cc
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index 0a3f2421e4a67b4c4fd161b09f407d5c5fdd4c54..fd5757b57e733fe79b417e7369b28d3cea4a437b 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -763,11 +763,12 @@ void ResourceProvider::CopyToResource(ResourceId 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);
@@ -779,6 +780,7 @@ void ResourceProvider::CopyToResource(ResourceId id,
                         image_size.height(), GLDataFormat(resource->format),
                         GLDataType(resource->format), image);
     }
+    lock.ReleaseTextureId();
   }
 }
 
@@ -988,24 +990,54 @@ 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);
@@ -1085,19 +1117,27 @@ ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() {
 
 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_);
 
@@ -1110,8 +1150,16 @@ void ResourceProvider::ScopedWriteLockGr::InitSkSurface(
     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;
@@ -1136,12 +1184,26 @@ void ResourceProvider::ScopedWriteLockGr::InitSkSurface(
   }
   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(