Modified old wait sync point functions to also accept new sync tokens.

ppapi/proxy/compositor_layer_resource.cc

 // Copyright 2014 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 "ppapi/proxy/compositor_layer_resource.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/mailbox.h"
+#include "gpu/command_buffer/common/sync_token.h"
 #include "ppapi/proxy/compositor_resource.h"
 #include "ppapi/shared_impl/ppb_graphics_3d_shared.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_graphics_3d_api.h"
 #include "ppapi/thunk/ppb_image_data_api.h"
 
 using gpu::gles2::GLES2Implementation;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_ImageData_API;
 using ppapi::thunk::PPB_Graphics3D_API;
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 float clamp(float value) {
   return std::min(std::max(value, 0.0f), 1.0f);
 }
 
-void OnTextureReleased(
-    const ScopedPPResource& layer,
-    const ScopedPPResource& context,
-    uint32_t texture,
-    const scoped_refptr<TrackedCallback>& release_callback,
-    int32_t result,
-    uint32_t sync_point,
-    bool is_lost) {
+void OnTextureReleased(const ScopedPPResource& layer,
+                       const ScopedPPResource& context,
+                       uint32_t texture,
+                       const scoped_refptr<TrackedCallback>& release_callback,
+                       int32_t result,
+                       const gpu::SyncToken& sync_token,
+                       bool is_lost) {
   if (!TrackedCallback::IsPending(release_callback))
     return;
 
   if (result != PP_OK) {
     release_callback->Run(result);
     return;
   }
 
   do {
-    if (!sync_point)
+    if (!sync_token.HasData())
       break;
 
     EnterResourceNoLock<PPB_Graphics3D_API> enter(context.get(), true);
     if (enter.failed())
       break;
 
     PPB_Graphics3D_Shared* graphics =
         static_cast<PPB_Graphics3D_Shared*>(enter.object());
 
     GLES2Implementation* gl = graphics->gles2_impl();
-    gl->WaitSyncPointCHROMIUM(sync_point);
+    gl->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
   } while (false);
 
   release_callback->Run(is_lost ? PP_ERROR_FAILED : PP_OK);
 }
 
-void OnImageReleased(
-    const ScopedPPResource& layer,
-    const ScopedPPResource& image,
-    const scoped_refptr<TrackedCallback>& release_callback,
-    int32_t result,
-    uint32_t sync_point,
-    bool is_lost) {
+void OnImageReleased(const ScopedPPResource& layer,
+                     const ScopedPPResource& image,
+                     const scoped_refptr<TrackedCallback>& release_callback,
+                     int32_t result,
+                     const gpu::SyncToken& sync_token,
+                     bool is_lost) {
   if (!TrackedCallback::IsPending(release_callback))
     return;
   release_callback->Run(result);
 }
 
 }  // namespace
 
 CompositorLayerResource::CompositorLayerResource(
     Connection connection,
     PP_Instance instance,
@@ skipping 84 matching lines @@
       texture, target,
       reinterpret_cast<const GLbyte*>(data_.texture->mailbox.name));
 
   // Set the source size to (1, 1). It will be used to verify the source_rect
   // passed to SetSourceRect().
   source_size_ = PP_MakeFloatSize(1.0f, 1.0f);
 
   data_.common.size = *size;
   data_.common.resource_id = compositor_->GenerateResourceId();
   data_.texture->target = target;
-  data_.texture->sync_point = gl->InsertSyncPointCHROMIUM();
+  data_.texture->sync_token = gpu::SyncToken(gl->InsertSyncPointCHROMIUM());
   data_.texture->source_rect.point = PP_MakeFloatPoint(0.0f, 0.0f);
   data_.texture->source_rect.size = source_size_;
 
   // If the PP_Resource of this layer is released by the plugin, the
   // release_callback will be aborted immediately, but the texture or image
   // in this layer may still being used by chromium compositor. So we have to
   // use ScopedPPResource to keep this resource alive until the texture or image
   // is released by the chromium compositor.
   release_callback_ = base::Bind(
       &OnTextureReleased,
@@ skipping 190 matching lines @@
 
   // Do not allow using a block callback as a release callback.
   if (release_callback->is_blocking())
     return PP_ERROR_BADARGUMENT;
 
   return PP_OK;
 }
 
 }  // namespace proxy
 }  // namespace ppapi