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

gpu/ipc/client/command_buffer_proxy_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 "gpu/ipc/client/command_buffer_proxy_impl.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 599 matching lines @@
   // catches upwith the command buffer.
   // A malicious caller trying to create a collision by making next_signal_id
   // would have to make calls at an astounding rate (300B/s) and even if they
   // could do that, all they would do is to prevent some callbacks from getting
   // called, leading to stalled threads and/or memory leaks.
   uint32_t signal_id = next_signal_id_++;
   Send(new GpuCommandBufferMsg_SignalQuery(route_id_, query, signal_id));
   signal_tasks_.insert(std::make_pair(signal_id, callback));
 }
 
-bool CommandBufferProxyImpl::ProduceFrontBuffer(const gpu::Mailbox& mailbox) {
-  CheckLock();
+bool CommandBufferProxyImpl::TakeFrontBuffer(const gpu::Mailbox& mailbox,
+                                             gpu::SyncToken* sync_token) {
+  std::unique_ptr<base::AutoLock> lock;
+  if (lock_)
+    lock.reset(new base::AutoLock(*lock_));

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

These should be CheckLock(). The client is responsible for taking the lock (if
needed). The lock is only acquired inside of CommandBufferProxyImpl for tasks
posted by CommandBufferProxyImpl itself, or the channel (e.g.
OnMessageReceived).

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

Done.

   if (last_state_.error != gpu::error::kNoError)
     return false;
 
-  Send(new GpuCommandBufferMsg_ProduceFrontBuffer(route_id_, mailbox));
+  Send(new GpuCommandBufferMsg_TakeFrontBuffer(route_id_, mailbox));
+
+  uint64_t fence = GenerateFenceSyncRelease();

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

This will not do the right thing for Pepper, where the namespace for fences (and
sync tokens) is handled by PpapiCommandBufferProxy on the plugin side. This will
cause out-of-order fences, which will cause synchronization issues.

I think the way to approach the problem is to do the TakeFrontBuffer from the
plugin side: in Graphics3D::DoSwapBuffers, do the TakeFrontBuffer, pass the
mailbox and sync token to the renderer side (add the former to the
PpapiHostMsg_PPBGraphics3D_SwapBuffers message).
An argument could be made for doing the ReturnFrontBuffer there too, but that's
not strictly necessary.

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

Got it. I now generate the sync token on the pepper side, but I still had to
plumb through TakeFrontBuffer to the renderer so that the Mailboxes can be
reused in ReturnFrontBuffer.

+  *sync_token = gpu::SyncToken(GetNamespaceID(), GetExtraCommandBufferData(),
+                               GetCommandBufferID(), fence);
+
+  // Force a synchronous IPC to validate sync token.
+  EnsureWorkVisible();
+  sync_token->SetVerifyFlush();
   return true;
 }
 
+void CommandBufferProxyImpl::ReturnFrontBuffer(const gpu::Mailbox& mailbox,
+                                               const gpu::SyncToken& sync_token,
+                                               bool is_lost) {
+  std::unique_ptr<base::AutoLock> lock;
+  if (lock_)
+    lock.reset(new base::AutoLock(*lock_));
+  if (last_state_.error != gpu::error::kNoError)
+    return;
+
+  Send(new GpuCommandBufferMsg_ReturnFrontBuffer(route_id_, mailbox, sync_token,
+                                                 is_lost));
+}
+
 gpu::error::Error CommandBufferProxyImpl::GetLastError() {
   return last_state_.error;
 }
 
 bool CommandBufferProxyImpl::Send(IPC::Message* msg) {
   // Caller should not intentionally send a message if the context is lost.
   DCHECK(last_state_.error == gpu::error::kNoError);
   DCHECK(channel_);
 
   if (!msg->is_sync()) {
@@ skipping 80 matching lines @@
 }
 
 void CommandBufferProxyImpl::InvalidGpuReplyOnClientThread() {
   std::unique_ptr<base::AutoLock> lock;
   if (lock_)
     lock.reset(new base::AutoLock(*lock_));
   OnDestroyed(gpu::error::kInvalidGpuMessage, gpu::error::kLostContext);
 }
 
 }  // namespace gpu