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

content/common/gpu/client/gl_helper.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/common/gpu/client/gl_helper.h"
 
 #include <queue>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 115 matching lines @@
       return;
     std::string extensions_string =
         " " + std::string(reinterpret_cast<const char*>(extensions)) + " ";
     if (extensions_string.find(" GL_EXT_draw_buffers ") != std::string::npos) {
       gl_->GetIntegerv(GL_MAX_DRAW_BUFFERS_EXT, &max_draw_buffers_);
     }
   }
   ~CopyTextureToImpl() { CancelRequests(); }
 
   GLuint ConsumeMailboxToTexture(const gpu::Mailbox& mailbox,
-                                 uint32 sync_point) {
-    return helper_->ConsumeMailboxToTexture(mailbox, sync_point);
+                                 const gpu::SyncToken& sync_token) {
+    return helper_->ConsumeMailboxToTexture(mailbox, sync_token);
   }
 
   void CropScaleReadbackAndCleanTexture(
       GLuint src_texture,
       const gfx::Size& src_size,
       const gfx::Rect& src_subrect,
       const gfx::Size& dst_size,
       unsigned char* out,
       const SkColorType out_color_type,
       const base::Callback<void(bool)>& callback,
@@ skipping 118 matching lines @@
                     CopyTextureToImpl* copy_impl,
                     GLHelperScaling* scaler_impl,
                     GLHelper::ScalerQuality quality,
                     const gfx::Size& src_size,
                     const gfx::Rect& src_subrect,
                     const gfx::Size& dst_size,
                     bool flip_vertically,
                     ReadbackSwizzle swizzle);
 
     void ReadbackYUV(const gpu::Mailbox& mailbox,
-                     uint32 sync_point,
+                     const gpu::SyncToken& sync_token,
                      const scoped_refptr<media::VideoFrame>& target,
                      const gfx::Point& paste_location,
                      const base::Callback<void(bool)>& callback) override;
 
     ScalerInterface* scaler() override { return scaler_.scaler(); }
 
    private:
     GLES2Interface* gl_;
     CopyTextureToImpl* copy_impl_;
     gfx::Size dst_size_;
@@ skipping 15 matching lines @@
                     CopyTextureToImpl* copy_impl,
                     GLHelperScaling* scaler_impl,
                     GLHelper::ScalerQuality quality,
                     const gfx::Size& src_size,
                     const gfx::Rect& src_subrect,
                     const gfx::Size& dst_size,
                     bool flip_vertically,
                     ReadbackSwizzle swizzle);
 
     void ReadbackYUV(const gpu::Mailbox& mailbox,
-                     uint32 sync_point,
+                     const gpu::SyncToken& sync_token,
                      const scoped_refptr<media::VideoFrame>& target,
                      const gfx::Point& paste_location,
                      const base::Callback<void(bool)>& callback) override;
 
     ScalerInterface* scaler() override { return scaler_.scaler(); }
 
    private:
     GLES2Interface* gl_;
     CopyTextureToImpl* copy_impl_;
     gfx::Size dst_size_;
@@ skipping 485 matching lines @@
                                                           src_subrect,
                                                           dst_size,
                                                           out,
                                                           out_color_type,
                                                           callback,
                                                           quality);
 }
 
 void GLHelper::CropScaleReadbackAndCleanMailbox(
     const gpu::Mailbox& src_mailbox,
-    uint32 sync_point,
+    const gpu::SyncToken& sync_token,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     unsigned char* out,
     const SkColorType out_color_type,
     const base::Callback<void(bool)>& callback,
     GLHelper::ScalerQuality quality) {
-  GLuint mailbox_texture = ConsumeMailboxToTexture(src_mailbox, sync_point);
+  GLuint mailbox_texture = ConsumeMailboxToTexture(src_mailbox, sync_token);
   CropScaleReadbackAndCleanTexture(mailbox_texture,
                                    src_size,
                                    src_subrect,
                                    dst_size,
                                    out,
                                    out_color_type,
                                    callback,
                                    quality);
   gl_->DeleteTextures(1, &mailbox_texture);
 }
@@ skipping 110 matching lines @@
   gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   return texture;
 }
 
 void GLHelper::DeleteTexture(GLuint texture_id) {
   gl_->DeleteTextures(1, &texture_id);
 }
 
 uint32 GLHelper::InsertSyncPoint() { return gl_->InsertSyncPointCHROMIUM(); }
 
-void GLHelper::WaitSyncPoint(uint32 sync_point) {
-  gl_->WaitSyncPointCHROMIUM(sync_point);
+void GLHelper::WaitSyncToken(const gpu::SyncToken& sync_token) {
+  gl_->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
 }
 
 gpu::MailboxHolder GLHelper::ProduceMailboxHolderFromTexture(
     GLuint texture_id) {
   gpu::Mailbox mailbox;
   gl_->GenMailboxCHROMIUM(mailbox.name);
   gl_->ProduceTextureDirectCHROMIUM(texture_id, GL_TEXTURE_2D, mailbox.name);
-  return gpu::MailboxHolder(mailbox, GL_TEXTURE_2D, InsertSyncPoint());
+  return gpu::MailboxHolder(mailbox, gpu::SyncToken(InsertSyncPoint()),
+                            GL_TEXTURE_2D);
 }
 
 GLuint GLHelper::ConsumeMailboxToTexture(const gpu::Mailbox& mailbox,
-                                         uint32 sync_point) {
+                                         const gpu::SyncToken& sync_token) {
   if (mailbox.IsZero())
     return 0;
-  if (sync_point)
-    WaitSyncPoint(sync_point);
+  if (sync_token.HasData())
+    WaitSyncToken(sync_token);
   GLuint texture =
       gl_->CreateAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   return texture;
 }
 
 void GLHelper::ResizeTexture(GLuint texture, const gfx::Size& size) {
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
   gl_->TexImage2D(GL_TEXTURE_2D,
                   0,
                   GL_RGB,
@@ skipping 125 matching lines @@
 
 static void CallbackKeepingVideoFrameAlive(
     scoped_refptr<media::VideoFrame> video_frame,
     const base::Callback<void(bool)>& callback,
     bool success) {
   callback.Run(success);
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackYUVImpl::ReadbackYUV(
     const gpu::Mailbox& mailbox,
-    uint32 sync_point,
+    const gpu::SyncToken& sync_token,
     const scoped_refptr<media::VideoFrame>& target,
     const gfx::Point& paste_location,
     const base::Callback<void(bool)>& callback) {
   DCHECK(!(paste_location.x() & 1));
   DCHECK(!(paste_location.y() & 1));
 
   GLuint mailbox_texture =
-      copy_impl_->ConsumeMailboxToTexture(mailbox, sync_point);
+      copy_impl_->ConsumeMailboxToTexture(mailbox, sync_token);
 
   // Scale texture to right size.
   scaler_.Scale(mailbox_texture);
   gl_->DeleteTextures(1, &mailbox_texture);
 
   // Convert the scaled texture in to Y, U and V planes.
   y_.Scale(scaler_.texture());
   u_.Scale(scaler_.texture());
   v_.Scale(scaler_.texture());
 
@@ skipping 92 matching lines @@
                  (dst_size.width() + 3) / 4,
                  dst_size.height(),
                  0,
                  GL_RGBA,
                  GL_UNSIGNED_BYTE,
                  NULL);
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackYUV_MRT::ReadbackYUV(
     const gpu::Mailbox& mailbox,
-    uint32 sync_point,
+    const gpu::SyncToken& sync_token,
     const scoped_refptr<media::VideoFrame>& target,
     const gfx::Point& paste_location,
     const base::Callback<void(bool)>& callback) {
   DCHECK(!(paste_location.x() & 1));
   DCHECK(!(paste_location.y() & 1));
 
   GLuint mailbox_texture =
-      copy_impl_->ConsumeMailboxToTexture(mailbox, sync_point);
+      copy_impl_->ConsumeMailboxToTexture(mailbox, sync_token);
 
   GLuint texture;
   if (quality_ == GLHelper::SCALER_QUALITY_FAST) {
     // Optimization: SCALER_QUALITY_FAST is just a single bilinear
     // pass, which pass1_shader_ can do just as well, so let's skip
     // the actual scaling in that case.
     texture = mailbox_texture;
   } else {
     // Scale texture to right size.
     scaler_.Scale(mailbox_texture);
@@ skipping 109 matching lines @@
   InitCopyTextToImpl();
   return copy_texture_to_impl_->CreateReadbackPipelineYUV(quality,
                                                           src_size,
                                                           src_subrect,
                                                           dst_size,
                                                           flip_vertically,
                                                           use_mrt);
 }
 
 }  // namespace content