Pepper takes ownership of a mailbox before passing it to the texture layer.

content/renderer/pepper/ppb_graphics_3d_impl.cc

 // Copyright (c) 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 "content/renderer/pepper/ppb_graphics_3d_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 125 matching lines @@
 gpu::CommandBuffer* PPB_Graphics3D_Impl::GetCommandBuffer() {
   return command_buffer_.get();
 }
 
 gpu::GpuControl* PPB_Graphics3D_Impl::GetGpuControl() {
   return command_buffer_.get();
 }
 
 int32_t PPB_Graphics3D_Impl::DoSwapBuffers(const gpu::SyncToken& sync_token) {
   DCHECK(command_buffer_);
-  if (sync_token.HasData())
-    sync_token_ = sync_token;
 
   if (bound_to_instance_) {
     // If we are bound to the instance, we need to ask the compositor
     // to commit our backing texture so that the graphics appears on the page.
     // When the backing texture will be committed we get notified via
     // ViewFlushedPaint().
     //
     // Don't need to check for NULL from GetPluginInstance since when we're
     // bound, we know our instance is valid.
     HostGlobals::Get()->GetInstance(pp_instance())->CommitBackingTexture();
     commit_pending_ = true;
   } else {
     // Wait for the command to complete on the GPU to allow for throttling.
     command_buffer_->SignalSyncToken(
-        sync_token_,
-        base::Bind(&PPB_Graphics3D_Impl::OnSwapBuffers,
-                   weak_ptr_factory_.GetWeakPtr()));
+        sync_token, base::Bind(&PPB_Graphics3D_Impl::OnSwapBuffers,
+                               weak_ptr_factory_.GetWeakPtr()));
   }
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 bool PPB_Graphics3D_Impl::InitRaw(PPB_Graphics3D_API* share_context,
                                   const int32_t* attrib_list,
                                   gpu::Capabilities* capabilities,
                                   base::SharedMemoryHandle* shared_state_handle,
                                   gpu::CommandBufferId* command_buffer_id) {
@@ skipping 80 matching lines @@
   if (!command_buffer_->Initialize())
     return false;
 
   if (shared_state_handle)
     *shared_state_handle = command_buffer_->GetSharedStateHandle();
   if (capabilities)
     *capabilities = command_buffer_->GetCapabilities();
   if (command_buffer_id)
     *command_buffer_id = command_buffer_->GetCommandBufferID();
 
-  mailbox_ = gpu::Mailbox::Generate();
-  if (!command_buffer_->ProduceFrontBuffer(mailbox_))
-    return false;
+  return true;
+}
 
+bool PPB_Graphics3D_Impl::TakeBackingMailbox(gpu::Mailbox* mailbox,
+                                             gpu::SyncToken* sync_token) {
+  *mailbox = gpu::Mailbox::Generate();

[piman, 2016/04/26 01:54:01]

This is kind of costly (generate a crypto-secure number). Also, the
MailboxManager keeps a list of all mailboxes associated with a TextureRef, so
this would cause a logical leak. Could we keep a queue of these, recycling in
ReturnBackingMailbox?

[erikchen, 2016/04/27 16:31:23]

Done.

+  command_buffer_->TakeFrontBuffer(*mailbox, sync_token);
   return true;
 }
 
+void PPB_Graphics3D_Impl::ReturnBackingMailbox(const gpu::Mailbox& mailbox,
+                                               const gpu::SyncToken& sync_token,
+                                               bool is_lost) {
+  command_buffer_->ReturnFrontBuffer(mailbox, sync_token, is_lost);
+}
+
 void PPB_Graphics3D_Impl::OnGpuControlErrorMessage(const char* message,
                                                    int32_t id) {
   if (!bound_to_instance_)
     return;
   WebPluginContainer* container =
       HostGlobals::Get()->GetInstance(pp_instance())->container();
   if (!container)
     return;
   WebLocalFrame* frame = container->element().document().frame();
   if (!frame)
@@ skipping 51 matching lines @@
       instance->module()->GetPluginInterface(PPP_GRAPHICS_3D_INTERFACE));
   // We have to check *again* that the instance exists, because it could have
   // been deleted during GetPluginInterface(). Even the PluginModule could be
   // deleted, but in that case, the instance should also be gone, so the
   // GetInstance check covers both cases.
   if (ppp_graphics_3d && HostGlobals::Get()->GetInstance(this_pp_instance))
     ppp_graphics_3d->Graphics3DContextLost(this_pp_instance);
 }
 
 }  // namespace content