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,
+                       uint32_t sync_point,
+                       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_point && !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->WaitSyncPointCHROMIUM(sync_point, 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,
+                     uint32_t sync_point,
+                     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 295 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