Converted Ppapi post swap buffer sync point to use sync tokens.

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 32 matching lines @@
 
 const int32_t kCommandBufferSize = 1024 * 1024;
 const int32_t kTransferBufferSize = 1024 * 1024;
 
 }  // namespace
 
 PPB_Graphics3D_Impl::PPB_Graphics3D_Impl(PP_Instance instance)
     : PPB_Graphics3D_Shared(instance),
       bound_to_instance_(false),
       commit_pending_(false),
-      sync_point_(0),
       has_alpha_(false),
       weak_ptr_factory_(this) {}
 
 PPB_Graphics3D_Impl::~PPB_Graphics3D_Impl() {}
 
 // static
 PP_Resource PPB_Graphics3D_Impl::Create(PP_Instance instance,
                                         PP_Resource share_context,
                                         const int32_t* attrib_list) {
   PPB_Graphics3D_API* share_api = NULL;
@@ skipping 104 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() {
+int32_t PPB_Graphics3D_Impl::DoSwapBuffers(const gpu::SyncToken& sync_token) {
   DCHECK(command_buffer_);
+  if (sync_token.HasData())
+    sync_token_ = sync_token;
+
   // We do not have a GLES2 implementation when using an OOP proxy.
   // The plugin-side proxy is responsible for adding the SwapBuffers command
   // to the command buffer in that case.
-  if (gpu::gles2::GLES2Interface* gl = gles2_interface())
+  if (gpu::gles2::GLES2Interface* gl = gles2_interface()) {
+    // A valid sync token would indicate a swap buffer already happened somehow.
+    DCHECK(!sync_token.HasData());
+
     gl->SwapBuffers();
-
-  // Since the backing texture has been updated, a new sync point should be
-  // inserted.
-  sync_point_ = command_buffer_->InsertSyncPoint();
+    const GLuint64 fence_sync = gl->InsertFenceSyncCHROMIUM();
+    gl->OrderingBarrierCHROMIUM();
+    gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token_.GetData());
+  }
 
   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_->SignalSyncPoint(
-        sync_point_,
+    command_buffer_->SignalSyncToken(
+        sync_token_,
         base::Bind(&PPB_Graphics3D_Impl::OnSwapBuffers,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 bool PPB_Graphics3D_Impl::Init(PPB_Graphics3D_API* share_context,
                                const int32_t* attrib_list) {
   if (!InitRaw(share_context, attrib_list, NULL, NULL, NULL))
@@ skipping 94 matching lines @@
     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;
-  sync_point_ = command_buffer_->InsertSyncPoint();
 
   command_buffer_->SetContextLostCallback(base::Bind(
       &PPB_Graphics3D_Impl::OnContextLost, weak_ptr_factory_.GetWeakPtr()));
 
   command_buffer_->SetOnConsoleMessageCallback(base::Bind(
       &PPB_Graphics3D_Impl::OnConsoleMessage, weak_ptr_factory_.GetWeakPtr()));
   return true;
 }
 
 void PPB_Graphics3D_Impl::OnConsoleMessage(const std::string& message, int id) {
@@ skipping 53 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