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

content/renderer/media/android/webmediaplayer_android.cc

 // Copyright 2013 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/media/android/webmediaplayer_android.h"
 
 #include <limits>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
@@ skipping 69 matching lines @@
 using media::VideoFrame;
 
 namespace {
 // Prefix for histograms related to Encrypted Media Extensions.
 const char* kMediaEme = "Media.EME.";
 
 // File-static function is to allow it to run even after WMPA is deleted.
 void OnReleaseTexture(
     const scoped_refptr<content::StreamTextureFactory>& factories,
     uint32 texture_id,
-    uint32 release_sync_point) {
+    const gpu::SyncToken& sync_token) {
   GLES2Interface* gl = factories->ContextGL();
-  gl->WaitSyncPointCHROMIUM(release_sync_point);
+  gl->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
   gl->DeleteTextures(1, &texture_id);
   // Flush to ensure that the stream texture gets deleted in a timely fashion.
   gl->ShallowFlushCHROMIUM();
 }
 
 bool IsSkBitmapProperlySizedTexture(const SkBitmap* bitmap,
                                     const gfx::Size& size) {
   return bitmap->getTexture() && bitmap->width() == size.width() &&
          bitmap->height() == size.height();
 }
@@ skipping 20 matching lines @@
 
   SkImageInfo info = SkImageInfo::MakeN32Premul(desc.fWidth, desc.fHeight);
   SkGrPixelRef* pixel_ref = new SkGrPixelRef(info, texture.get());
   if (!pixel_ref)
     return false;
   bitmap->setInfo(info);
   bitmap->setPixelRef(pixel_ref)->unref();
   return true;
 }
 
-class SyncPointClientImpl : public media::VideoFrame::SyncPointClient {
+class SyncTokenClientImpl : public media::VideoFrame::SyncTokenClient {
  public:
-  explicit SyncPointClientImpl(
+  explicit SyncTokenClientImpl(
       blink::WebGraphicsContext3D* web_graphics_context)
       : web_graphics_context_(web_graphics_context) {}
-  ~SyncPointClientImpl() override {}
+  ~SyncTokenClientImpl() override {}
   uint32 InsertSyncPoint() override {
-    return web_graphics_context_->insertSyncPoint();
+    gpu::SyncToken sync_token;
+    if (!web_graphics_context_->insertSyncPoint(sync_token.GetData()))
+      return 0;
+    return static_cast<uint32>(sync_token.release_count());
   }
-  void WaitSyncPoint(uint32 sync_point) override {
-    web_graphics_context_->waitSyncPoint(sync_point);
+  void WaitSyncToken(const gpu::SyncToken& sync_token) override {
+    web_graphics_context_->waitSyncToken(sync_token.GetConstData());
   }
 
  private:
   blink::WebGraphicsContext3D* web_graphics_context_;
 };
 
 }  // namespace
 
 namespace content {
 
@@ skipping 523 matching lines @@
   }
 
   if (!video_frame.get() || !video_frame->HasTextures())
     return false;
   DCHECK_EQ(1u, media::VideoFrame::NumPlanes(video_frame->format()));
   const gpu::MailboxHolder& mailbox_holder = video_frame->mailbox_holder(0);
   DCHECK((!is_remote_ &&
           mailbox_holder.texture_target == GL_TEXTURE_EXTERNAL_OES) ||
          (is_remote_ && mailbox_holder.texture_target == GL_TEXTURE_2D));
 
-  web_graphics_context->waitSyncPoint(mailbox_holder.sync_point);
+  web_graphics_context->waitSyncToken(mailbox_holder.sync_token.GetConstData());
 
   // Ensure the target of texture is set before copyTextureCHROMIUM, otherwise
   // an invalid texture target may be used for copy texture.
   uint32 src_texture =
       web_graphics_context->createAndConsumeTextureCHROMIUM(
           mailbox_holder.texture_target, mailbox_holder.mailbox.name);
 
   // Application itself needs to take care of setting the right flip_y
   // value down to get the expected result.
   // flip_y==true means to reverse the video orientation while
   // flip_y==false means to keep the intrinsic orientation.
   web_graphics_context->copyTextureCHROMIUM(
       GL_TEXTURE_2D, src_texture, texture, internal_format, type,
       flip_y, premultiply_alpha, false);
 
   web_graphics_context->deleteTexture(src_texture);
   web_graphics_context->flush();
 
-  SyncPointClientImpl client(web_graphics_context);
-  video_frame->UpdateReleaseSyncPoint(&client);
+  SyncTokenClientImpl client(web_graphics_context);
+  video_frame->UpdateReleaseSyncToken(&client);
   return true;
 }
 
 bool WebMediaPlayerAndroid::hasSingleSecurityOrigin() const {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (player_type_ != MEDIA_PLAYER_TYPE_URL)
     return true;
 
   if (!info_loader_ || !info_loader_->HasSingleOrigin())
     return false;
@@ skipping 503 matching lines @@
                    0 /* border */,
                    GL_RGBA /* format */,
                    GL_UNSIGNED_BYTE /* type */,
                    bitmap.getPixels());
   }
 
   gpu::Mailbox texture_mailbox;
   gl->GenMailboxCHROMIUM(texture_mailbox.name);
   gl->ProduceTextureCHROMIUM(texture_target, texture_mailbox.name);
   gl->Flush();
-  GLuint texture_mailbox_sync_point = gl->InsertSyncPointCHROMIUM();
+  gpu::SyncToken texture_mailbox_sync_token(gl->InsertSyncPointCHROMIUM());
 
   scoped_refptr<VideoFrame> new_frame = VideoFrame::WrapNativeTexture(
       media::PIXEL_FORMAT_ARGB,
-      gpu::MailboxHolder(texture_mailbox, texture_target,
-                         texture_mailbox_sync_point),
+      gpu::MailboxHolder(texture_mailbox, texture_mailbox_sync_token,
+                         texture_target),
       media::BindToCurrentLoop(base::Bind(&OnReleaseTexture,
                                           stream_texture_factory_,
                                           remote_playback_texture_id)),
       canvas_size /* coded_size */, gfx::Rect(canvas_size) /* visible_rect */,
       canvas_size /* natural_size */, base::TimeDelta() /* timestamp */);
   SetCurrentFrameInternal(new_frame);
 }
 
 void WebMediaPlayerAndroid::ReallocateVideoFrame() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
@@ skipping 12 matching lines @@
     }
 #else
     NOTIMPLEMENTED() << "Hole punching not supported without VIDEO_HOLE flag";
 #endif  // defined(VIDEO_HOLE)
   } else if (!is_remote_ && texture_id_) {
     GLES2Interface* gl = stream_texture_factory_->ContextGL();
     GLuint texture_target = kGLTextureExternalOES;
     GLuint texture_id_ref = gl->CreateAndConsumeTextureCHROMIUM(
         texture_target, texture_mailbox_.name);
     gl->Flush();
-    GLuint texture_mailbox_sync_point = gl->InsertSyncPointCHROMIUM();
+    gpu::SyncToken texture_mailbox_sync_token(gl->InsertSyncPointCHROMIUM());
 
     scoped_refptr<VideoFrame> new_frame = VideoFrame::WrapNativeTexture(
         media::PIXEL_FORMAT_ARGB,
-        gpu::MailboxHolder(texture_mailbox_, texture_target,
-                           texture_mailbox_sync_point),
+        gpu::MailboxHolder(texture_mailbox_, texture_mailbox_sync_token,
+                           texture_target),
         media::BindToCurrentLoop(base::Bind(
             &OnReleaseTexture, stream_texture_factory_, texture_id_ref)),
         natural_size_, gfx::Rect(natural_size_), natural_size_,
         base::TimeDelta());
     SetCurrentFrameInternal(new_frame);
   }
 }
 
 void WebMediaPlayerAndroid::SetVideoFrameProviderClient(
     cc::VideoFrameProvider::Client* client) {
@@ skipping 634 matching lines @@
 
   bool is_hls = IsHLSStream();
   UMA_HISTOGRAM_BOOLEAN("Media.Android.IsHttpLiveStreamingMedia", is_hls);
   if (is_hls) {
     media::RecordOriginOfHLSPlayback(
         GURL(frame_->document().securityOrigin().toString()));
   }
 }
 
 }  // namespace content