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

content/browser/renderer_host/media/video_capture_device_client.cc

 // Copyright 2015 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/browser/renderer_host/media/video_capture_device_client.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 120 matching lines @@
  private:
   ~AutoReleaseBuffer() override { pool_->RelinquishProducerReservation(id_); }
 
   const int id_;
   const scoped_refptr<VideoCaptureBufferPool> pool_;
   const scoped_ptr<VideoCaptureBufferPool::BufferHandle> buffer_handle_;
 };
 
 // Internal ref-counted class wrapping an incoming GpuMemoryBuffer into a
 // Texture backed VideoFrame. This VideoFrame creation is balanced by a waiting
-// on the associated |sync_point|. After VideoFrame consumption the inserted
+// on the associated |sync_token|. After VideoFrame consumption the inserted
 // ReleaseCallback() will be called, where the Texture is destroyed.
 //
 // This class jumps between threads due to GPU-related thread limitations, i.e.
 // some objects cannot be accessed from IO Thread whereas others need to be
 // constructed on UI Thread. For this reason most of the operations are carried
 // out on Capture Thread (|capture_task_runner_|).
 class VideoCaptureDeviceClient::TextureWrapHelper final
     : public base::RefCountedThreadSafe<TextureWrapHelper> {
  public:
   TextureWrapHelper(
@@ skipping 13 matching lines @@
 
   // Creates some necessary members in |capture_task_runner_|.
   void Init();
   // Runs the bottom half of the GlHelper creation.
   void CreateGlHelper(
       scoped_refptr<ContextProviderCommandBuffer> capture_thread_context);
 
   // Recycles |memory_buffer|, deletes Image and Texture on VideoFrame release.
   void ReleaseCallback(const std::vector<GLuint>& image_ids,
                        const std::vector<GLuint>& texture_ids,
-                       uint32 sync_point);
+                       const gpu::SyncToken& sync_token);
 
   // The Command Buffer lost the GL context, f.i. GPU process crashed. Signal
   // error to our owner so the capture can be torn down.
   void LostContextCallback();
 
   // Prints the error |message| and notifies |controller_| of an error.
   void OnError(const std::string& message);
 
   // |controller_| should only be used on IO thread.
   const base::WeakPtr<VideoCaptureController> controller_;
@@ skipping 455 matching lines @@
                                                                  texture_id);
       gl->BindTexImage2DCHROMIUM(GL_TEXTURE_2D, image_id);
     }
     texture_ids.push_back(texture_id);
 
     const gpu::MailboxHolder& mailbox_holder(
         gl_helper_->ProduceMailboxHolderFromTexture(texture_id));
     DCHECK(!mailbox_holder.mailbox.IsZero());
     DCHECK(mailbox_holder.mailbox.Verify());
     DCHECK(mailbox_holder.texture_target);
-    DCHECK(mailbox_holder.sync_point);
+    DCHECK(mailbox_holder.sync_token.HasData());
     mailbox_holders.push_back(mailbox_holder);
   }
 
   scoped_refptr<media::VideoFrame> video_frame =
       VideoFrame::WrapYUV420NativeTextures(
           mailbox_holders[VideoFrame::kYPlane],
           mailbox_holders[VideoFrame::kUPlane],
           mailbox_holders[VideoFrame::kVPlane],
           media::BindToCurrentLoop(base::Bind(
               &VideoCaptureDeviceClient::TextureWrapHelper::ReleaseCallback,
@@ skipping 70 matching lines @@
   // At this point, |capture_thread_context| is a cc::ContextProvider. Creation
   // of our GLHelper should happen on Capture Thread.
   gl_helper_.reset(new GLHelper(capture_thread_context->ContextGL(),
                                 capture_thread_context->ContextSupport()));
   DCHECK(gl_helper_);
 }
 
 void VideoCaptureDeviceClient::TextureWrapHelper::ReleaseCallback(
     const std::vector<GLuint>& image_ids,
     const std::vector<GLuint>& texture_ids,
-    uint32 sync_point) {
+    const gpu::SyncToken& sync_token) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(image_ids.size(), texture_ids.size());
 
   if (!gl_helper_)
     return;
   for (size_t i = 0; i < image_ids.size(); ++i) {
     gl_helper_->DeleteTexture(texture_ids[i]);
     capture_thread_context_->ContextGL()->DestroyImageCHROMIUM(image_ids[i]);
   }
 }
 
 void VideoCaptureDeviceClient::TextureWrapHelper::LostContextCallback() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
   // Prevent incoming frames from being processed while OnError gets groked.
   gl_helper_.reset();
   OnError("GLContext lost");
 }
 
 void VideoCaptureDeviceClient::TextureWrapHelper::OnError(
     const std::string& message) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
   DLOG(ERROR) << message;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&VideoCaptureController::DoErrorOnIOThread, controller_));
 }
 
 }  // namespace content