Convert base::Bind and base::Callback in //components/chromeos_camera to Once or Repeating

This CL converts base::Bind and base::Callback in
//components/chromeos_camera to Once or Repeating.

Bug: 1007676
Change-Id: I50160fe35211329df7a29b4b2ec64c768695dbf9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2062947Reviewed-by: Shik Chen <shik@chromium.org>
Commit-Queue: Jun Cai <juncai@chromium.org>
Cr-Commit-Position: refs/heads/master@{#745553}

components/chromeos_camera/gpu_mjpeg_decode_accelerator_factory.cc

@@ -62,9 +62,9 @@ std::unique_ptr<MjpegDecodeAccelerator> CreateFakeMjpegDecodeAccelerator(
 // static
 bool GpuMjpegDecodeAcceleratorFactory::IsAcceleratedJpegDecodeSupported() {
   auto accelerator_factory_functions = GetAcceleratorFactories();
-  for (const auto& factory_function : accelerator_factory_functions) {
+  for (auto& factory_function : accelerator_factory_functions) {
     std::unique_ptr<MjpegDecodeAccelerator> accelerator =
-        factory_function.Run(base::ThreadTaskRunnerHandle::Get());
+        std::move(factory_function).Run(base::ThreadTaskRunnerHandle::Get());
     if (accelerator && accelerator->IsSupported())
       return true;
   }
@@ -76,16 +76,18 @@ std::vector<GpuMjpegDecodeAcceleratorFactory::CreateAcceleratorCB>
 GpuMjpegDecodeAcceleratorFactory::GetAcceleratorFactories() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseFakeMjpegDecodeAccelerator)) {
-    return {base::Bind(&CreateFakeMjpegDecodeAccelerator)};
+    std::vector<CreateAcceleratorCB> result;
+    result.push_back(base::BindOnce(&CreateFakeMjpegDecodeAccelerator));
+    return result;
   }
 
   // This list is ordered by priority of use.
   std::vector<CreateAcceleratorCB> result;
 #if defined(USE_V4L2_MJPEG_DECODE_ACCELERATOR)
-  result.push_back(base::Bind(&CreateV4L2MjpegDecodeAccelerator));
+  result.push_back(base::BindOnce(&CreateV4L2MjpegDecodeAccelerator));
 #endif
 #if BUILDFLAG(USE_VAAPI)
-  result.push_back(base::Bind(&CreateVaapiMjpegDecodeAccelerator));
+  result.push_back(base::BindOnce(&CreateVaapiMjpegDecodeAccelerator));
 #endif
   return result;
 }

components/chromeos_camera/gpu_mjpeg_decode_accelerator_factory.h

@@ -17,7 +17,7 @@ namespace chromeos_camera {
 class GpuMjpegDecodeAcceleratorFactory {
  public:
   using CreateAcceleratorCB =
-      base::Callback<std::unique_ptr<MjpegDecodeAccelerator>(
+      base::OnceCallback<std::unique_ptr<MjpegDecodeAccelerator>(
           scoped_refptr<base::SingleThreadTaskRunner>)>;
 
   // Static query for JPEG supported. This query calls the appropriate

components/chromeos_camera/mjpeg_decode_accelerator.h

@@ -32,7 +32,7 @@ namespace chromeos_camera {
 class MjpegDecodeAccelerator {
  public:
   // Callback for JPEG decoder initialization.
-  typedef base::Callback<void(bool success)> InitCB;
+  typedef base::OnceCallback<void(bool success)> InitCB;
 
   static const int32_t kInvalidTaskId = -1;
 

components/chromeos_camera/mjpeg_decode_accelerator_unittest.cc

@@ -567,8 +567,9 @@ void JpegClient::CreateJpegDecoder() {
     return;
   }
 
-  for (const auto& create_jda_func : jda_factories) {
-    decoder_ = create_jda_func.Run(base::ThreadTaskRunnerHandle::Get());
+  for (auto& create_jda_func : jda_factories) {
+    decoder_ =
+        std::move(create_jda_func).Run(base::ThreadTaskRunnerHandle::Get());
     if (decoder_)
       break;
   }

components/chromeos_camera/mojo_mjpeg_decode_accelerator.cc

@@ -40,11 +40,11 @@ void MojoMjpegDecodeAccelerator::InitializeAsync(Client* client,
 
   // base::Unretained is safe because |this| owns |jpeg_decoder_|.
   jpeg_decoder_.set_disconnect_handler(
-      base::Bind(&MojoMjpegDecodeAccelerator::OnLostConnectionToJpegDecoder,
-                 base::Unretained(this)));
+      base::BindOnce(&MojoMjpegDecodeAccelerator::OnLostConnectionToJpegDecoder,
+                     base::Unretained(this)));
   jpeg_decoder_->Initialize(
-      base::Bind(&MojoMjpegDecodeAccelerator::OnInitializeDone,
-                 base::Unretained(this), std::move(init_cb), client));
+      base::BindOnce(&MojoMjpegDecodeAccelerator::OnInitializeDone,
+                     base::Unretained(this), std::move(init_cb), client));
 }
 
 void MojoMjpegDecodeAccelerator::Decode(
@@ -72,8 +72,8 @@ void MojoMjpegDecodeAccelerator::Decode(
   jpeg_decoder_->Decode(std::move(bitstream_buffer), video_frame->coded_size(),
                         std::move(output_frame_handle),
                         base::checked_cast<uint32_t>(output_buffer_size),
-                        base::Bind(&MojoMjpegDecodeAccelerator::OnDecodeAck,
-                                   base::Unretained(this)));
+                        base::BindOnce(&MojoMjpegDecodeAccelerator::OnDecodeAck,
+                                       base::Unretained(this)));
 }
 
 void MojoMjpegDecodeAccelerator::Decode(

components/chromeos_camera/mojo_mjpeg_decode_accelerator_service.cc

@@ -101,9 +101,9 @@ void MojoMjpegDecodeAcceleratorService::Initialize(
   // needs to be updated.
 
   std::unique_ptr<::chromeos_camera::MjpegDecodeAccelerator> accelerator;
-  for (const auto& create_jda_function : accelerator_factory_functions_) {
+  for (auto& create_jda_function : accelerator_factory_functions_) {
     std::unique_ptr<::chromeos_camera::MjpegDecodeAccelerator> tmp_accelerator =
-        create_jda_function.Run(base::ThreadTaskRunnerHandle::Get());
+        std::move(create_jda_function).Run(base::ThreadTaskRunnerHandle::Get());
     if (tmp_accelerator && tmp_accelerator->Initialize(this)) {
       accelerator = std::move(tmp_accelerator);
       break;

components/chromeos_camera/mojo_mjpeg_decode_accelerator_service.h

@@ -77,7 +77,7 @@ class MojoMjpegDecodeAcceleratorService
       int32_t bitstream_buffer_id,
       ::chromeos_camera::MjpegDecodeAccelerator::Error error);
 
-  const std::vector<GpuMjpegDecodeAcceleratorFactory::CreateAcceleratorCB>
+  std::vector<GpuMjpegDecodeAcceleratorFactory::CreateAcceleratorCB>
       accelerator_factory_functions_;
 
   // A map from |task_id| to MojoCallback.

components/chromeos_camera/mojo_mjpeg_decode_accelerator_service_unittest.cc

@@ -32,16 +32,16 @@ class MojoMjpegDecodeAcceleratorServiceTest : public ::testing::Test {
         switches::kUseFakeMjpegDecodeAccelerator);
   }
 
-  void OnInitializeDone(const base::Closure& continuation, bool success) {
+  void OnInitializeDone(base::OnceClosure continuation, bool success) {
     EXPECT_TRUE(success);
-    continuation.Run();
+    std::move(continuation).Run();
   }
 
-  void OnDecodeAck(const base::Closure& continuation,
+  void OnDecodeAck(base::OnceClosure continuation,
                    int32_t bitstream_buffer_id,
                    MjpegDecodeAccelerator::Error error) {
     EXPECT_EQ(kArbitraryBitstreamBufferId, bitstream_buffer_id);
-    continuation.Run();
+    std::move(continuation).Run();
   }
 
  private:
@@ -57,8 +57,8 @@ TEST_F(MojoMjpegDecodeAcceleratorServiceTest, InitializeAndDecode) {
 
   base::RunLoop run_loop;
   jpeg_decoder->Initialize(
-      base::Bind(&MojoMjpegDecodeAcceleratorServiceTest::OnInitializeDone,
-                 base::Unretained(this), run_loop.QuitClosure()));
+      base::BindOnce(&MojoMjpegDecodeAcceleratorServiceTest::OnInitializeDone,
+                     base::Unretained(this), run_loop.QuitClosure()));
   run_loop.Run();
 
   const size_t kInputBufferSizeInBytes = 512;
@@ -91,8 +91,8 @@ TEST_F(MojoMjpegDecodeAcceleratorServiceTest, InitializeAndDecode) {
       std::move(bitstream_buffer), kDummyFrameCodedSize,
       std::move(output_frame_handle),
       base::checked_cast<uint32_t>(kOutputFrameSizeInBytes),
-      base::Bind(&MojoMjpegDecodeAcceleratorServiceTest::OnDecodeAck,
-                 base::Unretained(this), run_loop2.QuitClosure()));
+      base::BindOnce(&MojoMjpegDecodeAcceleratorServiceTest::OnDecodeAck,
+                     base::Unretained(this), run_loop2.QuitClosure()));
   run_loop2.Run();
 }