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 154 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);
+                       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_point || 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) {
+    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