Use OnceCallback on Mojo interfaces in //media/capture and //services/video_capture

This CL flips `use_once_callback` flag on the Mojo code generator, and
fixes all compile errors after it. After this CL, Mojo interfaces in
//media/capture and //services/video_capture start using base::OnceCallback
instead of base::Callback on its return value handling.

Bug: 714018
Change-Id: I0fcf6bfb2511332f53f1a1b01e269ebce4629a71
Reviewed-on: https://chromium-review.googlesource.com/567842
Commit-Queue: Taiju Tsuiki <tzik@chromium.org>
Reviewed-by: Christian Fremerey <chfremer@chromium.org>
Reviewed-by: Miguel Casas <mcasas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#487408}

content/browser/image_capture/image_capture_impl.cc

@@ -37,17 +37,17 @@ void RunFailedGetPhotoStateCallback(
   empty_capabilities->contrast = media::mojom::Range::New();
   empty_capabilities->saturation = media::mojom::Range::New();
   empty_capabilities->sharpness = media::mojom::Range::New();
-  cb.Run(std::move(empty_capabilities));
+  std::move(cb).Run(std::move(empty_capabilities));
 }
 
 void RunFailedSetOptionsCallback(ImageCaptureImpl::SetOptionsCallback cb) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  cb.Run(false);
+  std::move(cb).Run(false);
 }
 
 void RunFailedTakePhotoCallback(ImageCaptureImpl::TakePhotoCallback cb) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  cb.Run(media::mojom::Blob::New());
+  std::move(cb).Run(media::mojom::Blob::New());
 }
 
 void GetPhotoStateOnIOThread(
@@ -120,12 +120,13 @@ void ImageCaptureImpl::Create(
 }
 
 void ImageCaptureImpl::GetPhotoState(const std::string& source_id,
-                                     const GetPhotoStateCallback& callback) {
+                                     GetPhotoStateCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   media::ScopedResultCallback<GetPhotoStateCallback> scoped_callback(
-      media::BindToCurrentLoop(callback),
-      media::BindToCurrentLoop(base::Bind(&RunFailedGetPhotoStateCallback)));
+      media::BindToCurrentLoop(std::move(callback)),
+      media::BindToCurrentLoop(
+          base::BindOnce(&RunFailedGetPhotoStateCallback)));
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
@@ -136,11 +137,11 @@ void ImageCaptureImpl::GetPhotoState(const std::string& source_id,
 
 void ImageCaptureImpl::SetOptions(const std::string& source_id,
                                   media::mojom::PhotoSettingsPtr settings,
-                                  const SetOptionsCallback& callback) {
+                                  SetOptionsCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   media::ScopedResultCallback<SetOptionsCallback> scoped_callback(
-      media::BindToCurrentLoop(callback),
+      media::BindToCurrentLoop(std::move(callback)),
       media::BindToCurrentLoop(base::Bind(&RunFailedSetOptionsCallback)));
 
   BrowserThread::PostTask(
@@ -151,12 +152,12 @@ void ImageCaptureImpl::SetOptions(const std::string& source_id,
 }
 
 void ImageCaptureImpl::TakePhoto(const std::string& source_id,
-                                 const TakePhotoCallback& callback) {
+                                 TakePhotoCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   media::ScopedResultCallback<TakePhotoCallback> scoped_callback(
-      media::BindToCurrentLoop(callback),
-      media::BindToCurrentLoop(base::Bind(&RunFailedTakePhotoCallback)));
+      media::BindToCurrentLoop(std::move(callback)),
+      media::BindToCurrentLoop(base::BindOnce(&RunFailedTakePhotoCallback)));
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,

content/browser/image_capture/image_capture_impl.h

@@ -22,14 +22,14 @@ class ImageCaptureImpl : public media::mojom::ImageCapture {
                      media::mojom::ImageCaptureRequest request);
 
   void GetPhotoState(const std::string& source_id,
-                     const GetPhotoStateCallback& callback) override;
+                     GetPhotoStateCallback callback) override;
 
   void SetOptions(const std::string& source_id,
                   media::mojom::PhotoSettingsPtr settings,
-                  const SetOptionsCallback& callback) override;
+                  SetOptionsCallback callback) override;
 
   void TakePhoto(const std::string& source_id,
-                 const TakePhotoCallback& callback) override;
+                 TakePhotoCallback callback) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ImageCaptureImpl);

media/capture/mojo/BUILD.gn

@@ -21,9 +21,6 @@ mojom("image_capture") {
     "image_capture.mojom",
   ]
 
-  # TODO(crbug.com/714018): Convert the implementation to use OnceCallback.
-  use_once_callback = false
-
   # TODO(crbug.com/699569): Convert to use the new JS bindings.
   use_new_js_bindings = false
 }

media/capture/video/fake_video_capture_device_unittest.cc

@@ -163,13 +163,24 @@ class ImageCaptureClient : public base::RefCounted<ImageCaptureClient> {
     OnCorrectGetPhotoState();
   }
   MOCK_METHOD0(OnCorrectGetPhotoState, void(void));
-  MOCK_METHOD1(OnGetPhotoStateFailure,
-               void(base::Callback<void(mojom::PhotoStatePtr)>));
+
+  void OnGetPhotoStateFailure(
+      mojom::ImageCapture::GetPhotoStateCallback callback) {
+    OnGetPhotoStateFailureInternal(callback);
+  }
+  MOCK_METHOD1(OnGetPhotoStateFailureInternal,
+               void(mojom::ImageCapture::GetPhotoStateCallback&));
 
   const mojom::PhotoState* state() { return state_.get(); }
 
   MOCK_METHOD1(OnCorrectSetPhotoOptions, void(bool));
-  MOCK_METHOD1(OnSetPhotoOptionsFailure, void(base::Callback<void(bool)>));
+
+  void OnSetPhotoOptionsFailure(
+      mojom::ImageCapture::SetOptionsCallback callback) {
+    OnSetPhotoOptionsFailureInternal(callback);
+  }
+  MOCK_METHOD1(OnSetPhotoOptionsFailureInternal,
+               void(mojom::ImageCapture::SetOptionsCallback&));
 
   // GMock doesn't support move-only arguments, so we use this forward method.
   void DoOnPhotoTaken(mojom::BlobPtr blob) {
@@ -184,7 +195,12 @@ class ImageCaptureClient : public base::RefCounted<ImageCaptureClient> {
     OnCorrectPhotoTaken();
   }
   MOCK_METHOD0(OnCorrectPhotoTaken, void(void));
-  MOCK_METHOD1(OnTakePhotoFailure, void(base::Callback<void(mojom::BlobPtr)>));
+
+  void OnTakePhotoFailure(mojom::ImageCapture::TakePhotoCallback callback) {
+    OnTakePhotoFailureInternal(callback);
+  }
+  MOCK_METHOD1(OnTakePhotoFailureInternal,
+               void(mojom::ImageCapture::TakePhotoCallback&));
 
  private:
   friend class base::RefCounted<ImageCaptureClient>;
@@ -376,9 +392,10 @@ TEST_F(FakeVideoCaptureDeviceTest, GetAndSetCapabilities) {
   device->AllocateAndStart(capture_params, std::move(client_));
 
   VideoCaptureDevice::GetPhotoStateCallback scoped_get_callback(
-      base::Bind(&ImageCaptureClient::DoOnGetPhotoState, image_capture_client_),
-      base::Bind(&ImageCaptureClient::OnGetPhotoStateFailure,
-                 image_capture_client_));
+      base::BindOnce(&ImageCaptureClient::DoOnGetPhotoState,
+                     image_capture_client_),
+      base::BindOnce(&ImageCaptureClient::OnGetPhotoStateFailure,
+                     image_capture_client_));
 
   EXPECT_CALL(*image_capture_client_.get(), OnCorrectGetPhotoState()).Times(1);
   device->GetPhotoState(std::move(scoped_get_callback));
@@ -445,10 +462,10 @@ TEST_F(FakeVideoCaptureDeviceTest, GetAndSetCapabilities) {
   // Set options: zoom to the maximum value.
   const int max_zoom_value = state->zoom->max;
   VideoCaptureDevice::SetPhotoOptionsCallback scoped_set_callback(
-      base::Bind(&ImageCaptureClient::OnCorrectSetPhotoOptions,
-                 image_capture_client_),
-      base::Bind(&ImageCaptureClient::OnSetPhotoOptionsFailure,
-                 image_capture_client_));
+      base::BindOnce(&ImageCaptureClient::OnCorrectSetPhotoOptions,
+                     image_capture_client_),
+      base::BindOnce(&ImageCaptureClient::OnSetPhotoOptionsFailure,
+                     image_capture_client_));
 
   mojom::PhotoSettingsPtr settings = mojom::PhotoSettings::New();
   settings->zoom = max_zoom_value;
@@ -490,9 +507,10 @@ TEST_F(FakeVideoCaptureDeviceTest, TakePhoto) {
   device->AllocateAndStart(capture_params, std::move(client_));
 
   VideoCaptureDevice::TakePhotoCallback scoped_callback(
-      base::Bind(&ImageCaptureClient::DoOnPhotoTaken, image_capture_client_),
-      base::Bind(&ImageCaptureClient::OnTakePhotoFailure,
-                 image_capture_client_));
+      base::BindOnce(&ImageCaptureClient::DoOnPhotoTaken,
+                     image_capture_client_),
+      base::BindOnce(&ImageCaptureClient::OnTakePhotoFailure,
+                     image_capture_client_));
 
   EXPECT_CALL(*image_capture_client_.get(), OnCorrectPhotoTaken()).Times(1);
   device->TakePhoto(std::move(scoped_callback));

media/capture/video/video_capture_device.h

@@ -275,13 +275,13 @@ class CAPTURE_EXPORT VideoCaptureDevice
   // levels etc). On success, invokes |callback|. On failure, drops callback
   // without invoking it.
   using GetPhotoStateCallback =
-      ScopedResultCallback<base::Callback<void(mojom::PhotoStatePtr)>>;
+      ScopedResultCallback<base::OnceCallback<void(mojom::PhotoStatePtr)>>;
   virtual void GetPhotoState(GetPhotoStateCallback callback);
 
   // On success, invokes |callback| with value |true|. On failure, drops
   // callback without invoking it.
   using SetPhotoOptionsCallback =
-      ScopedResultCallback<base::Callback<void(bool)>>;
+      ScopedResultCallback<base::OnceCallback<void(bool)>>;
   virtual void SetPhotoOptions(mojom::PhotoSettingsPtr settings,
                                SetPhotoOptionsCallback callback);
 
@@ -290,7 +290,7 @@ class CAPTURE_EXPORT VideoCaptureDevice
   // where TakePhoto() is called, if the photo was successfully taken. On
   // failure, drops callback without invoking it.
   using TakePhotoCallback =
-      ScopedResultCallback<base::Callback<void(mojom::BlobPtr blob)>>;
+      ScopedResultCallback<base::OnceCallback<void(mojom::BlobPtr blob)>>;
   virtual void TakePhoto(TakePhotoCallback callback);
 
   // Gets the power line frequency, either from the params if specified by the

media/capture/video/video_capture_device_unittest.cc

@@ -192,7 +192,13 @@ class MockImageCaptureClient
     }
   }
   MOCK_METHOD0(OnCorrectPhotoTaken, void(void));
-  MOCK_METHOD1(OnTakePhotoFailure, void(base::Callback<void(mojom::BlobPtr)>));
+
+  void OnTakePhotoFailure(mojom::ImageCapture::TakePhotoCallback callback) {
+    OnTakePhotoFailureInternal(callback);
+  }
+
+  MOCK_METHOD1(OnTakePhotoFailureInternal,
+               void(mojom::ImageCapture::TakePhotoCallback&));
 
   // GMock doesn't support move-only arguments, so we use this forward method.
   void DoOnGetPhotoState(mojom::PhotoStatePtr state) {
@@ -200,8 +206,13 @@ class MockImageCaptureClient
     OnCorrectGetPhotoState();
   }
   MOCK_METHOD0(OnCorrectGetPhotoState, void(void));
-  MOCK_METHOD1(OnGetPhotoStateFailure,
-               void(base::Callback<void(mojom::PhotoStatePtr)>));
+
+  void OnGetPhotoStateFailure(
+      mojom::ImageCapture::GetPhotoStateCallback callback) {
+    OnGetPhotoStateFailureInternal(callback);
+  }
+  MOCK_METHOD1(OnGetPhotoStateFailureInternal,
+               void(mojom::ImageCapture::GetPhotoStateCallback&));
 
   const mojom::PhotoState* capabilities() { return state_.get(); }
 
@@ -604,8 +615,8 @@ TEST_F(VideoCaptureDeviceTest, MAYBE_TakePhoto) {
   device->AllocateAndStart(capture_params, std::move(video_capture_client_));
 
   VideoCaptureDevice::TakePhotoCallback scoped_callback(
-      base::Bind(&MockImageCaptureClient::DoOnPhotoTaken,
-                 image_capture_client_),
+      base::BindOnce(&MockImageCaptureClient::DoOnPhotoTaken,
+                     image_capture_client_),
       media::BindToCurrentLoop(base::Bind(
           &MockImageCaptureClient::OnTakePhotoFailure, image_capture_client_)));
 
@@ -656,11 +667,11 @@ TEST_F(VideoCaptureDeviceTest, MAYBE_GetPhotoState) {
   device->AllocateAndStart(capture_params, std::move(video_capture_client_));
 
   VideoCaptureDevice::GetPhotoStateCallback scoped_get_callback(
-      base::Bind(&MockImageCaptureClient::DoOnGetPhotoState,
-                 image_capture_client_),
+      base::BindOnce(&MockImageCaptureClient::DoOnGetPhotoState,
+                     image_capture_client_),
       media::BindToCurrentLoop(
-          base::Bind(&MockImageCaptureClient::OnGetPhotoStateFailure,
-                     image_capture_client_)));
+          base::BindOnce(&MockImageCaptureClient::OnGetPhotoStateFailure,
+                         image_capture_client_)));
 
   base::RunLoop run_loop;
   base::Closure quit_closure = media::BindToCurrentLoop(run_loop.QuitClosure());

services/video_capture/device_factory_media_to_mojo_adapter.cc

@@ -28,7 +28,7 @@ namespace {
 // happen in VideoCaptureDeviceClient, and talk only to VideoCaptureDeviceClient
 // instead of VideoCaptureSystem.
 static void TranslateDeviceInfos(
-    const video_capture::mojom::DeviceFactory::GetDeviceInfosCallback& callback,
+    video_capture::mojom::DeviceFactory::GetDeviceInfosCallback callback,
     const std::vector<media::VideoCaptureDeviceInfo>& device_infos) {
   std::vector<media::VideoCaptureDeviceInfo> translated_device_infos;
   for (const auto& device_info : device_infos) {
@@ -52,13 +52,13 @@ static void TranslateDeviceInfos(
       continue;
     translated_device_infos.push_back(translated_device_info);
   }
-  callback.Run(translated_device_infos);
+  std::move(callback).Run(translated_device_infos);
 }
 
 static void DiscardDeviceInfosAndCallContinuation(
-    base::Closure continuation,
+    base::OnceClosure continuation,
     const std::vector<media::VideoCaptureDeviceInfo>&) {
-  continuation.Run();
+  std::move(continuation).Run();
 }
 
 }  // anonymous namespace
@@ -92,16 +92,16 @@ DeviceFactoryMediaToMojoAdapter::DeviceFactoryMediaToMojoAdapter(
 DeviceFactoryMediaToMojoAdapter::~DeviceFactoryMediaToMojoAdapter() = default;
 
 void DeviceFactoryMediaToMojoAdapter::GetDeviceInfos(
-    const GetDeviceInfosCallback& callback) {
+    GetDeviceInfosCallback callback) {
   capture_system_->GetDeviceInfosAsync(
-      base::Bind(&TranslateDeviceInfos, callback));
+      base::Bind(&TranslateDeviceInfos, base::Passed(&callback)));
   has_called_get_device_infos_ = true;
 }
 
 void DeviceFactoryMediaToMojoAdapter::CreateDevice(
     const std::string& device_id,
     mojom::DeviceRequest device_request,
-    const CreateDeviceCallback& callback) {
+    CreateDeviceCallback callback) {
   auto active_device_iter = active_devices_by_id_.find(device_id);
   if (active_device_iter != active_devices_by_id_.end()) {
     // The requested device is already in use.
@@ -113,32 +113,34 @@ void DeviceFactoryMediaToMojoAdapter::CreateDevice(
     device_entry.binding->set_connection_error_handler(base::Bind(
         &DeviceFactoryMediaToMojoAdapter::OnClientConnectionErrorOrClose,
         base::Unretained(this), device_id));
-    callback.Run(mojom::DeviceAccessResultCode::SUCCESS);
+    std::move(callback).Run(mojom::DeviceAccessResultCode::SUCCESS);
     return;
   }
 
-  const auto create_and_add_new_device_cb =
-      base::Bind(&DeviceFactoryMediaToMojoAdapter::CreateAndAddNewDevice,
-                 weak_factory_.GetWeakPtr(), device_id,
-                 base::Passed(&device_request), callback);
+  auto create_and_add_new_device_cb =
+      base::BindOnce(&DeviceFactoryMediaToMojoAdapter::CreateAndAddNewDevice,
+                     weak_factory_.GetWeakPtr(), device_id,
+                     std::move(device_request), std::move(callback));
 
   if (has_called_get_device_infos_) {
-    create_and_add_new_device_cb.Run();
+    std::move(create_and_add_new_device_cb).Run();
     return;
   }
 
-  capture_system_->GetDeviceInfosAsync(base::Bind(
-      &DiscardDeviceInfosAndCallContinuation, create_and_add_new_device_cb));
+  capture_system_->GetDeviceInfosAsync(
+      base::Bind(&DiscardDeviceInfosAndCallContinuation,
+                 base::Passed(&create_and_add_new_device_cb)));
 }
 
 void DeviceFactoryMediaToMojoAdapter::CreateAndAddNewDevice(
     const std::string& device_id,
     mojom::DeviceRequest device_request,
-    const CreateDeviceCallback& callback) {
+    CreateDeviceCallback callback) {
   std::unique_ptr<media::VideoCaptureDevice> media_device =
       capture_system_->CreateDevice(device_id);
   if (media_device == nullptr) {
-    callback.Run(mojom::DeviceAccessResultCode::ERROR_DEVICE_NOT_FOUND);
+    std::move(callback).Run(
+        mojom::DeviceAccessResultCode::ERROR_DEVICE_NOT_FOUND);
     return;
   }
 
@@ -154,7 +156,7 @@ void DeviceFactoryMediaToMojoAdapter::CreateAndAddNewDevice(
       base::Unretained(this), device_id));
   active_devices_by_id_[device_id] = std::move(device_entry);
 
-  callback.Run(mojom::DeviceAccessResultCode::SUCCESS);
+  std::move(callback).Run(mojom::DeviceAccessResultCode::SUCCESS);
 }
 
 void DeviceFactoryMediaToMojoAdapter::OnClientConnectionErrorOrClose(

services/video_capture/device_factory_media_to_mojo_adapter.h

@@ -31,10 +31,10 @@ class DeviceFactoryMediaToMojoAdapter : public mojom::DeviceFactory {
   ~DeviceFactoryMediaToMojoAdapter() override;
 
   // mojom::DeviceFactory implementation.
-  void GetDeviceInfos(const GetDeviceInfosCallback& callback) override;
+  void GetDeviceInfos(GetDeviceInfosCallback callback) override;
   void CreateDevice(const std::string& device_id,
                     mojom::DeviceRequest device_request,
-                    const CreateDeviceCallback& callback) override;
+                    CreateDeviceCallback callback) override;
 
  private:
   struct ActiveDeviceEntry {
@@ -52,7 +52,7 @@ class DeviceFactoryMediaToMojoAdapter : public mojom::DeviceFactory {
 
   void CreateAndAddNewDevice(const std::string& device_id,
                              mojom::DeviceRequest device_request,
-                             const CreateDeviceCallback& callback);
+                             CreateDeviceCallback callback);
   void OnClientConnectionErrorOrClose(const std::string& device_id);
 
   const std::unique_ptr<service_manager::ServiceContextRef> service_ref_;

services/video_capture/device_media_to_mojo_adapter.cc

@@ -20,17 +20,17 @@ namespace {
 static const int kMaxBufferCount = 3;
 
 void RunFailedGetPhotoStateCallback(
-    base::Callback<void(media::mojom::PhotoStatePtr)> cb) {
-  cb.Run(nullptr);
+    base::OnceCallback<void(media::mojom::PhotoStatePtr)> cb) {
+  std::move(cb).Run(nullptr);
 }
 
-void RunFailedSetOptionsCallback(base::Callback<void(bool)> cb) {
-  cb.Run(false);
+void RunFailedSetOptionsCallback(base::OnceCallback<void(bool)> cb) {
+  std::move(cb).Run(false);
 }
 
 void RunFailedTakePhotoCallback(
-    base::Callback<void(media::mojom::BlobPtr blob)> cb) {
-  cb.Run(nullptr);
+    base::OnceCallback<void(media::mojom::BlobPtr blob)> cb) {
+  std::move(cb).Run(nullptr);
 }
 
 }  // anonymous namespace
@@ -112,29 +112,29 @@ void DeviceMediaToMojoAdapter::Resume() {
   device_->Resume();
 }
 
-void DeviceMediaToMojoAdapter::GetPhotoState(
-    const GetPhotoStateCallback& callback) {
+void DeviceMediaToMojoAdapter::GetPhotoState(GetPhotoStateCallback callback) {
   media::VideoCaptureDevice::GetPhotoStateCallback scoped_callback(
-      media::BindToCurrentLoop(callback),
-      media::BindToCurrentLoop(base::Bind(&RunFailedGetPhotoStateCallback)));
+      media::BindToCurrentLoop(std::move(callback)),
+      media::BindToCurrentLoop(
+          base::BindOnce(&RunFailedGetPhotoStateCallback)));
   device_->GetPhotoState(std::move(scoped_callback));
 }
 
 void DeviceMediaToMojoAdapter::SetPhotoOptions(
     media::mojom::PhotoSettingsPtr settings,
-    const SetPhotoOptionsCallback& callback) {
+    SetPhotoOptionsCallback callback) {
   media::ScopedResultCallback<media::mojom::ImageCapture::SetOptionsCallback>
-      scoped_callback(
-          media::BindToCurrentLoop(std::move(callback)),
-          media::BindToCurrentLoop(base::Bind(&RunFailedSetOptionsCallback)));
+      scoped_callback(media::BindToCurrentLoop(std::move(callback)),
+                      media::BindToCurrentLoop(
+                          base::BindOnce(&RunFailedSetOptionsCallback)));
   device_->SetPhotoOptions(std::move(settings), std::move(scoped_callback));
 }
 
-void DeviceMediaToMojoAdapter::TakePhoto(const TakePhotoCallback& callback) {
+void DeviceMediaToMojoAdapter::TakePhoto(TakePhotoCallback callback) {
   media::ScopedResultCallback<media::mojom::ImageCapture::TakePhotoCallback>
-      scoped_callback(
-          media::BindToCurrentLoop(callback),
-          media::BindToCurrentLoop(base::Bind(&RunFailedTakePhotoCallback)));
+      scoped_callback(media::BindToCurrentLoop(std::move(callback)),
+                      media::BindToCurrentLoop(
+                          base::BindOnce(&RunFailedTakePhotoCallback)));
   device_->TakePhoto(std::move(scoped_callback));
 }
 

services/video_capture/device_media_to_mojo_adapter.h

@@ -35,10 +35,10 @@ class DeviceMediaToMojoAdapter : public mojom::Device {
   void RequestRefreshFrame() override;
   void MaybeSuspend() override;
   void Resume() override;
-  void GetPhotoState(const GetPhotoStateCallback& callback) override;
+  void GetPhotoState(GetPhotoStateCallback callback) override;
   void SetPhotoOptions(media::mojom::PhotoSettingsPtr settings,
-                       const SetPhotoOptionsCallback& callback) override;
-  void TakePhoto(const TakePhotoCallback& callback) override;
+                       SetPhotoOptionsCallback callback) override;
+  void TakePhoto(TakePhotoCallback callback) override;
 
   void Stop();
   void OnClientConnectionErrorOrClose();

services/video_capture/public/interfaces/BUILD.gn

@@ -19,9 +19,6 @@ mojom("interfaces") {
     "//media/mojo/interfaces",
     "//ui/gfx/geometry/mojo",
   ]
-
-  # TODO(crbug.com/714018): Convert the implementation to use OnceCallback.
-  use_once_callback = false
 }
 
 mojom("constants") {