Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/{i,l,m,n,p,r}*

chrome/browser/image_decoder.cc

 // Copyright (c) 2012 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 "chrome/browser/image_decoder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 22 matching lines @@
   if (!image.isNull() && !image.empty())
     success_callback.Run(image, request_id);
   else
     fail_callback.Run(request_id);
 }
 
 void BindToBrowserConnector(service_manager::mojom::ConnectorRequest request) {
   if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
-        base::Bind(&BindToBrowserConnector, base::Passed(&request)));
+        base::BindOnce(&BindToBrowserConnector, base::Passed(&request)));
     return;
   }
 
   content::ServiceManagerConnection::GetForProcess()->GetConnector()
       ->BindConnectorRequest(std::move(request));
 }
 
 void RunDecodeCallbackOnTaskRunner(
     const data_decoder::mojom::ImageDecoder::DecodeImageCallback& callback,
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     const SkBitmap& image) {
-  task_runner->PostTask(FROM_HERE, base::Bind(callback, image));
+  task_runner->PostTask(FROM_HERE, base::BindOnce(callback, image));
 }
 
 void DecodeImage(
     std::vector<uint8_t> image_data,
     data_decoder::mojom::ImageCodec codec,
     bool shrink_to_fit,
     const gfx::Size& desired_image_frame_size,
     const data_decoder::mojom::ImageDecoder::DecodeImageCallback& callback,
     scoped_refptr<base::SequencedTaskRunner> callback_task_runner) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
@@ skipping 100 matching lines @@
       base::Bind(&ImageDecoder::OnDecodeImageFailed, base::Unretained(this)),
       base::Bind(&ImageDecoder::OnDecodeImageSucceeded, base::Unretained(this)),
       request_id);
 
   // NOTE: There exist ImageDecoder consumers which implicitly rely on this
   // operation happening on a thread which always has a ThreadTaskRunnerHandle.
   // We arbitrarily use the IO thread here to match details of the legacy
   // implementation.
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&DecodeImage, base::Passed(&image_data), codec, shrink_to_fit,
-                 desired_image_frame_size, callback,
-                 make_scoped_refptr(image_request->task_runner())));
+      base::BindOnce(&DecodeImage, base::Passed(&image_data), codec,
+                     shrink_to_fit, desired_image_frame_size, callback,
+                     make_scoped_refptr(image_request->task_runner())));
 }
 
 // static
 void ImageDecoder::Cancel(ImageRequest* image_request) {
   DCHECK(image_request);
   ImageDecoder::GetInstance()->CancelImpl(image_request);
 }
 
 void ImageDecoder::CancelImpl(ImageRequest* image_request) {
   base::AutoLock lock(map_lock_);
@@ skipping 31 matching lines @@
     auto it = image_request_id_map_.find(request_id);
     if (it == image_request_id_map_.end())
       return;
     image_request = it->second;
     image_request_id_map_.erase(it);
   }
 
   DCHECK(image_request->task_runner()->RunsTasksOnCurrentThread());
   image_request->OnDecodeImageFailed();
 }