Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/extensions

chrome/browser/extensions/api/image_writer_private/operation.cc

 // Copyright 2013 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/extensions/api/image_writer_private/operation.h"
 
 #include <utility>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
@@ skipping 121 matching lines @@
       image_path_,
       base::Bind(&Operation::CompleteAndContinue, this, continuation),
       base::Bind(&Operation::OnUnzipFailure, this),
       base::Bind(&Operation::OnUnzipProgress,
                  this,
                  zip_reader_->current_entry_info()->original_size()));
 }
 
 void Operation::Finish() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE, base::Bind(&Operation::Finish, this));
+    BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+                            base::BindOnce(&Operation::Finish, this));
     return;
   }
 
   CleanUp();
 
   BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&OperationManager::OnComplete, manager_, extension_id_));
+      BrowserThread::UI, FROM_HERE,
+      base::BindOnce(&OperationManager::OnComplete, manager_, extension_id_));
 }
 
 void Operation::Error(const std::string& error_message) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
-    BrowserThread::PostTask(BrowserThread::FILE,
-                            FROM_HERE,
-                            base::Bind(&Operation::Error, this, error_message));
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
+        base::BindOnce(&Operation::Error, this, error_message));
     return;
   }
 
   BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&OperationManager::OnError,
-                 manager_,
-                 extension_id_,
-                 stage_,
-                 progress_,
-                 error_message));
+      BrowserThread::UI, FROM_HERE,
+      base::BindOnce(&OperationManager::OnError, manager_, extension_id_,
+                     stage_, progress_, error_message));
 
   CleanUp();
 }
 
 void Operation::SetProgress(int progress) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
     BrowserThread::PostTask(
-        BrowserThread::FILE,
-        FROM_HERE,
-        base::Bind(&Operation::SetProgress,
-                   this,
-                   progress));
+        BrowserThread::FILE, FROM_HERE,
+        base::BindOnce(&Operation::SetProgress, this, progress));
     return;
   }
 
   if (progress <= progress_) {
     return;
   }
 
   if (IsCancelled()) {
     return;
   }
 
   progress_ = progress;
 
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&OperationManager::OnProgress,
-                                     manager_,
-                                     extension_id_,
-                                     stage_,
-                                     progress_));
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::BindOnce(&OperationManager::OnProgress, manager_, extension_id_,
+                     stage_, progress_));
 }
 
 void Operation::SetStage(image_writer_api::Stage stage) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
-    BrowserThread::PostTask(
-        BrowserThread::FILE,
-        FROM_HERE,
-        base::Bind(&Operation::SetStage,
-                   this,
-                   stage));
+    BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+                            base::BindOnce(&Operation::SetStage, this, stage));
     return;
   }
 
   if (IsCancelled()) {
     return;
   }
 
   stage_ = stage;
   progress_ = 0;
 
   BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&OperationManager::OnProgress,
-                 manager_,
-                 extension_id_,
-                 stage_,
-                 progress_));
+      BrowserThread::UI, FROM_HERE,
+      base::BindOnce(&OperationManager::OnProgress, manager_, extension_id_,
+                     stage_, progress_));
 }
 
 bool Operation::IsCancelled() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   return stage_ == image_writer_api::STAGE_NONE;
 }
 
 void Operation::AddCleanUpFunction(const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
@@ skipping 59 matching lines @@
   if (file_size <= 0) {
     file_size = file.GetLength();
     if (file_size < 0) {
       Error(error::kImageOpenError);
       return;
     }
   }
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      base::Bind(&Operation::MD5Chunk, this, Passed(std::move(file)), 0,
-                 file_size, progress_offset, progress_scale, callback));
+      base::BindOnce(&Operation::MD5Chunk, this, Passed(std::move(file)), 0,
+                     file_size, progress_offset, progress_scale, callback));
 }
 
 void Operation::MD5Chunk(
     base::File file,
     int64_t bytes_processed,
     int64_t bytes_total,
     int progress_offset,
     int progress_scale,
     const base::Callback<void(const std::string&)>& callback) {
   if (IsCancelled())
@@ skipping 16 matching lines @@
     if (len == read_size) {
       // Process data.
       base::MD5Update(&md5_context_, base::StringPiece(buffer.get(), len));
       int percent_curr =
           ((bytes_processed + len) * progress_scale) / bytes_total +
           progress_offset;
       SetProgress(percent_curr);
 
       BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
-          base::Bind(&Operation::MD5Chunk, this, Passed(std::move(file)),
-                     bytes_processed + len, bytes_total, progress_offset,
-                     progress_scale, callback));
+          base::BindOnce(&Operation::MD5Chunk, this, Passed(std::move(file)),
+                         bytes_processed + len, bytes_total, progress_offset,
+                         progress_scale, callback));
       // Skip closing the file.
       return;
     } else {
       // We didn't read the bytes we expected.
       Error(error::kHashReadError);
     }
   }
 }
 
 void Operation::OnUnzipFailure() {
@@ skipping 13 matching lines @@
   for (std::vector<base::Closure>::iterator it = cleanup_functions_.begin();
        it != cleanup_functions_.end();
        ++it) {
     it->Run();
   }
   cleanup_functions_.clear();
 }
 
 }  // namespace image_writer
 }  // namespace extensions