Convert services/video_capture away from base::Bind/base::Callback

base::Bind/base::Callback are deprecated in favor of either
base::BindOnce/base::OnceCallback or base::BindRepeating/
base::RepeatingCallback (depending on whether the callback
is invoked once or multiple time).

Convert all uses of base::Bind/base::Callback in
services/video_capture to the recommended methods/types.

Bug: 1007831
Change-Id: I51a9f07a0d3e88a07968739325a86440ce22f07b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1837811
Auto-Submit: Sylvain Defresne <sdefresne@chromium.org>
Reviewed-by: Colin Blundell <blundell@chromium.org>
Commit-Queue: Sylvain Defresne <sdefresne@chromium.org>
Cr-Commit-Position: refs/heads/master@{#705503}

services/video_capture/device_factory_media_to_mojo_adapter.cc

@@ -101,7 +101,7 @@ DeviceFactoryMediaToMojoAdapter::~DeviceFactoryMediaToMojoAdapter() = default;
 void DeviceFactoryMediaToMojoAdapter::GetDeviceInfos(
     GetDeviceInfosCallback callback) {
   capture_system_->GetDeviceInfosAsync(
-      base::Bind(&TranslateDeviceInfos, base::Passed(&callback)));
+      base::BindOnce(&TranslateDeviceInfos, std::move(callback)));
   has_called_get_device_infos_ = true;
 }
 
@@ -117,7 +117,7 @@ void DeviceFactoryMediaToMojoAdapter::CreateDevice(
     device_entry.binding->Unbind();
     device_entry.device->Stop();
     device_entry.binding->Bind(std::move(device_request));
-    device_entry.binding->set_connection_error_handler(base::Bind(
+    device_entry.binding->set_connection_error_handler(base::BindOnce(
         &DeviceFactoryMediaToMojoAdapter::OnClientConnectionErrorOrClose,
         base::Unretained(this), device_id));
     std::move(callback).Run(mojom::DeviceAccessResultCode::SUCCESS);
@@ -135,8 +135,8 @@ void DeviceFactoryMediaToMojoAdapter::CreateDevice(
   }
 
   capture_system_->GetDeviceInfosAsync(
-      base::Bind(&DiscardDeviceInfosAndCallContinuation,
-                 base::Passed(&create_and_add_new_device_cb)));
+      base::BindOnce(&DiscardDeviceInfosAndCallContinuation,
+                     std::move(create_and_add_new_device_cb)));
   has_called_get_device_infos_ = true;
 }
 
@@ -185,7 +185,7 @@ void DeviceFactoryMediaToMojoAdapter::CreateAndAddNewDevice(
 #endif  // defined(OS_CHROMEOS)
   device_entry.binding = std::make_unique<mojo::Binding<mojom::Device>>(
       device_entry.device.get(), std::move(device_request));
-  device_entry.binding->set_connection_error_handler(base::Bind(
+  device_entry.binding->set_connection_error_handler(base::BindOnce(
       &DeviceFactoryMediaToMojoAdapter::OnClientConnectionErrorOrClose,
       base::Unretained(this), device_id));
   active_devices_by_id_[device_id] = std::move(device_entry);

services/video_capture/device_media_to_mojo_adapter.cc

@@ -67,8 +67,8 @@ void DeviceMediaToMojoAdapter::Start(
   DCHECK(thread_checker_.CalledOnValidThread());
   mojo::Remote<mojom::Receiver> receiver(std::move(receiver_pending_remote));
   receiver.set_disconnect_handler(
-      base::Bind(&DeviceMediaToMojoAdapter::OnClientConnectionErrorOrClose,
-                 weak_factory_.GetWeakPtr()));
+      base::BindOnce(&DeviceMediaToMojoAdapter::OnClientConnectionErrorOrClose,
+                     weak_factory_.GetWeakPtr()));
 
   receiver_ = std::make_unique<ReceiverMojoToMediaAdapter>(std::move(receiver));
   auto media_receiver = std::make_unique<media::VideoFrameReceiverOnTaskRunner>(

services/video_capture/test/fake_device_descriptor_unittest.cc

@@ -61,9 +61,9 @@ TEST_F(FakeVideoCaptureDeviceDescriptorTest, AccessIsRevokedOnSecondAccess) {
   factory_->CreateDevice(
       i420_fake_device_info_.descriptor.device_id,
       mojo::MakeRequest(&device_proxy_1),
-      base::Bind(&MockCreateDeviceProxyCallback::Run,
-                 base::Unretained(&create_device_proxy_callback_1)));
-  device_proxy_1.set_connection_error_handler(base::Bind(
+      base::BindOnce(&MockCreateDeviceProxyCallback::Run,
+                     base::Unretained(&create_device_proxy_callback_1)));
+  device_proxy_1.set_connection_error_handler(base::BindOnce(
       [](bool* access_revoked, base::RunLoop* wait_loop_1) {
         *access_revoked = true;
         wait_loop_1->Quit();
@@ -81,11 +81,11 @@ TEST_F(FakeVideoCaptureDeviceDescriptorTest, AccessIsRevokedOnSecondAccess) {
   factory_->CreateDevice(
       i420_fake_device_info_.descriptor.device_id,
       mojo::MakeRequest(&device_proxy_2),
-      base::Bind(&MockCreateDeviceProxyCallback::Run,
-                 base::Unretained(&create_device_proxy_callback_2)));
+      base::BindOnce(&MockCreateDeviceProxyCallback::Run,
+                     base::Unretained(&create_device_proxy_callback_2)));
   device_proxy_2.set_connection_error_handler(
-      base::Bind([](bool* access_revoked) { *access_revoked = true; },
-                 &device_access_2_revoked));
+      base::BindOnce([](bool* access_revoked) { *access_revoked = true; },
+                     &device_access_2_revoked));
   wait_loop_1.Run();
   wait_loop_2.Run();
   ASSERT_TRUE(device_access_1_revoked);
@@ -103,7 +103,7 @@ TEST_F(FakeVideoCaptureDeviceDescriptorTest, CanUseSecondRequestedProxy) {
   factory_->CreateDevice(
       i420_fake_device_info_.descriptor.device_id,
       mojo::MakeRequest(&device_proxy_2),
-      base::Bind(
+      base::BindOnce(
           [](base::RunLoop* wait_loop,
              mojom::DeviceAccessResultCode result_code) { wait_loop->Quit(); },
           &wait_loop));

services/video_capture/test/virtual_device_unittest.cc

@@ -71,15 +71,17 @@ class VirtualDeviceTest : public ::testing::Test {
          i++) {
       device_adapter_->RequestFrameBuffer(
           kTestFrameSize, kTestPixelFormat, nullptr,
-          base::Bind(&VirtualDeviceTest::OnFrameBufferReceived,
-                     base::Unretained(this), true /* valid_buffer_expected */));
+          base::BindOnce(&VirtualDeviceTest::OnFrameBufferReceived,
+                         base::Unretained(this),
+                         true /* valid_buffer_expected */));
     }
 
     // No more buffer available. Invalid buffer id should be returned.
     device_adapter_->RequestFrameBuffer(
         kTestFrameSize, kTestPixelFormat, nullptr,
-        base::Bind(&VirtualDeviceTest::OnFrameBufferReceived,
-                   base::Unretained(this), false /* valid_buffer_expected */));
+        base::BindOnce(&VirtualDeviceTest::OnFrameBufferReceived,
+                       base::Unretained(this),
+                       false /* valid_buffer_expected */));
 
     wait_loop.RunUntilIdle();
     Mock::VerifyAndClearExpectations(producer_.get());
@@ -115,8 +117,8 @@ TEST_F(VirtualDeviceTest, OnFrameReadyInBufferWithoutReceiver) {
   EXPECT_CALL(*producer_, DoOnNewBuffer(_, _, _)).Times(0);
   device_adapter_->RequestFrameBuffer(
       kTestFrameSize, kTestPixelFormat, nullptr,
-      base::Bind(&VirtualDeviceTest::OnFrameBufferReceived,
-                 base::Unretained(this), true /* valid_buffer_expected */));
+      base::BindOnce(&VirtualDeviceTest::OnFrameBufferReceived,
+                     base::Unretained(this), true /* valid_buffer_expected */));
 
   wait_loop.RunUntilIdle();
 }

services/video_capture/virtual_device_enabled_device_factory.cc

@@ -114,9 +114,9 @@ void VirtualDeviceEnabledDeviceFactory::CreateDevice(
     }
     device_entry.EstablishConsumerBinding(
         std::move(device_request),
-        base::Bind(&VirtualDeviceEnabledDeviceFactory::
-                       OnVirtualDeviceConsumerConnectionErrorOrClose,
-                   base::Unretained(this), device_id));
+        base::BindOnce(&VirtualDeviceEnabledDeviceFactory::
+                           OnVirtualDeviceConsumerConnectionErrorOrClose,
+                       base::Unretained(this), device_id));
     std::move(callback).Run(mojom::DeviceAccessResultCode::SUCCESS);
     return;
   }
@@ -139,9 +139,9 @@ void VirtualDeviceEnabledDeviceFactory::AddSharedMemoryVirtualDevice(
   }
 
   producer.set_connection_error_handler(
-      base::Bind(&VirtualDeviceEnabledDeviceFactory::
-                     OnVirtualDeviceProducerConnectionErrorOrClose,
-                 base::Unretained(this), device_id));
+      base::BindOnce(&VirtualDeviceEnabledDeviceFactory::
+                         OnVirtualDeviceProducerConnectionErrorOrClose,
+                     base::Unretained(this), device_id));
   auto device = std::make_unique<SharedMemoryVirtualDeviceMojoAdapter>(
       std::move(producer),
       send_buffer_handles_to_producer_as_raw_file_descriptors);
@@ -149,9 +149,9 @@ void VirtualDeviceEnabledDeviceFactory::AddSharedMemoryVirtualDevice(
       std::make_unique<mojo::Binding<mojom::SharedMemoryVirtualDevice>>(
           device.get(), std::move(virtual_device_request));
   producer_binding->set_connection_error_handler(
-      base::Bind(&VirtualDeviceEnabledDeviceFactory::
-                     OnVirtualDeviceProducerConnectionErrorOrClose,
-                 base::Unretained(this), device_id));
+      base::BindOnce(&VirtualDeviceEnabledDeviceFactory::
+                         OnVirtualDeviceProducerConnectionErrorOrClose,
+                     base::Unretained(this), device_id));
   VirtualDeviceEntry device_entry(device_info, std::move(device),
                                   std::move(producer_binding));
   virtual_devices_by_id_.insert(