cc: Add mailbox support to ResourceProvider write locks.

cc/resources/video_resource_updater.cc

 // Copyright 2013 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/video_resource_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 201 matching lines @@
   if (resource_id == 0)
     return all_resources_.end();
 
   gpu::Mailbox mailbox;
   if (has_mailbox) {
     DCHECK(context_provider_);
 
     gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
 
     gl->GenMailboxCHROMIUM(mailbox.name);
-    ResourceProvider::ScopedWriteLockGL lock(resource_provider_, resource_id);
+    ResourceProvider::ScopedWriteLockGL lock(resource_provider_, resource_id,
+                                             false);
     gl->ProduceTextureDirectCHROMIUM(
-        lock.texture_id(),
+        lock.ProduceTextureId(),
         resource_provider_->GetResourceTextureTarget(resource_id),
         mailbox.name);
+    lock.ReleaseTextureId();
   }
   all_resources_.push_front(
       PlaneResource(resource_id, plane_size, format, mailbox));
   return all_resources_.begin();
 }
 
 void VideoResourceUpdater::DeleteResource(ResourceList::iterator resource_it) {
   DCHECK_EQ(resource_it->ref_count, 0);
   resource_provider_->DeleteResource(resource_it->resource_id);
   all_resources_.erase(resource_it);
@@ skipping 385 matching lines @@
   // Otherwise allocate a new resource.
   if (resource == all_resources_.end()) {
     const bool is_immutable = false;
     resource = AllocateResource(output_plane_resource_size, copy_target_format,
                                 true, is_immutable);
   }
 
   ++resource->ref_count;
 
   ResourceProvider::ScopedWriteLockGL lock(resource_provider_,
-                                           resource->resource_id);
-  uint32_t texture_id = lock.texture_id();
+                                           resource->resource_id, false);
+  uint32_t texture_id = lock.ProduceTextureId();
 
   DCHECK_EQ(resource_provider_->GetResourceTextureTarget(resource->resource_id),
             (GLenum)GL_TEXTURE_2D);
 
   gl->WaitSyncTokenCHROMIUM(mailbox_holder.sync_token.GetConstData());
   uint32_t src_texture_id = gl->CreateAndConsumeTextureCHROMIUM(
       mailbox_holder.texture_target, mailbox_holder.mailbox.name);
   gl->CopySubTextureCHROMIUM(src_texture_id, texture_id, 0, 0, 0, 0,
                              output_plane_resource_size.width(),
                              output_plane_resource_size.height(), false, false,
                              false);
   gl->DeleteTextures(1, &src_texture_id);
 
   // Sync point for use of frame copy.
   gpu::SyncToken sync_token;
   const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
   gl->ShallowFlushCHROMIUM();
   gl->GenSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
 
+  lock.ReleaseTextureId();
+
   // Done with the source video frame texture at this point.
   video_frame->UpdateReleaseSyncToken(&client);
 
   external_resources->mailboxes.push_back(
       TextureMailbox(resource->mailbox, sync_token, GL_TEXTURE_2D,
                      video_frame->coded_size(), false, false));
 
   external_resources->release_callbacks.push_back(
       base::Bind(&RecycleResource, AsWeakPtr(), resource->resource_id));
 }
@@ skipping 94 matching lines @@
                plane_resource.plane_index == 0;
       });
   if (resource_it == updater->all_resources_.end())
     return;
 
   resource_it->destructed = true;
 }
 #endif
 
 }  // namespace cc