Use CompletionOnceCallback in URLFetcherResponseWriter.

Bug: 807724
Change-Id: Ie6d9df68023730dc927984ef326223169f243c15
Reviewed-on: https://chromium-review.googlesource.com/1155087Reviewed-by: Peter Beverloo <peter@chromium.org>
Reviewed-by: Ryan Hamilton <rch@chromium.org>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Reviewed-by: Kazuhiro Inaba <kinaba@chromium.org>
Commit-Queue: Bence Béky <bnc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#579699}

chrome/browser/devtools/devtools_ui_bindings.cc

@@ -61,6 +61,7 @@
 #include "extensions/common/constants.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "ipc/ipc_channel.h"
+#include "net/base/completion_once_callback.h"
 #include "net/base/escape.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ -216,11 +217,11 @@ class ResponseWriter : public net::URLFetcherResponseWriter {
   ~ResponseWriter() override;
 
   // URLFetcherResponseWriter overrides:
-  int Initialize(const net::CompletionCallback& callback) override;
+  int Initialize(net::CompletionOnceCallback callback) override;
   int Write(net::IOBuffer* buffer,
             int num_bytes,
-            const net::CompletionCallback& callback) override;
-  int Finish(int net_error, const net::CompletionCallback& callback) override;
+            net::CompletionOnceCallback callback) override;
+  int Finish(int net_error, net::CompletionOnceCallback callback) override;
 
  private:
   base::WeakPtr<DevToolsUIBindings> bindings_;
@@ -239,13 +240,13 @@ ResponseWriter::ResponseWriter(base::WeakPtr<DevToolsUIBindings> bindings,
 ResponseWriter::~ResponseWriter() {
 }
 
-int ResponseWriter::Initialize(const net::CompletionCallback& callback) {
+int ResponseWriter::Initialize(net::CompletionOnceCallback callback) {
   return net::OK;
 }
 
 int ResponseWriter::Write(net::IOBuffer* buffer,
                           int num_bytes,
-                          const net::CompletionCallback& callback) {
+                          net::CompletionOnceCallback callback) {
   std::string chunk = std::string(buffer->data(), num_bytes);
   bool encoded = false;
   if (!base::IsStringUTF8(chunk)) {
@@ -266,7 +267,7 @@ int ResponseWriter::Write(net::IOBuffer* buffer,
 }
 
 int ResponseWriter::Finish(int net_error,
-                           const net::CompletionCallback& callback) {
+                           net::CompletionOnceCallback callback) {
   return net::OK;
 }
 

content/shell/browser/shell_devtools_bindings.cc

@@ -30,6 +30,7 @@
 #include "content/shell/browser/shell_browser_main_parts.h"
 #include "content/shell/browser/shell_content_browser_client.h"
 #include "content/shell/browser/shell_devtools_manager_delegate.h"
+#include "net/base/completion_once_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
@@ -75,11 +76,11 @@ class ResponseWriter : public net::URLFetcherResponseWriter {
   ~ResponseWriter() override;
 
   // URLFetcherResponseWriter overrides:
-  int Initialize(const net::CompletionCallback& callback) override;
+  int Initialize(net::CompletionOnceCallback callback) override;
   int Write(net::IOBuffer* buffer,
             int num_bytes,
-            const net::CompletionCallback& callback) override;
-  int Finish(int net_error, const net::CompletionCallback& callback) override;
+            net::CompletionOnceCallback callback) override;
+  int Finish(int net_error, net::CompletionOnceCallback callback) override;
 
  private:
   base::WeakPtr<ShellDevToolsBindings> devtools_bindings_;
@@ -95,13 +96,13 @@ ResponseWriter::ResponseWriter(
 
 ResponseWriter::~ResponseWriter() {}
 
-int ResponseWriter::Initialize(const net::CompletionCallback& callback) {
+int ResponseWriter::Initialize(net::CompletionOnceCallback callback) {
   return net::OK;
 }
 
 int ResponseWriter::Write(net::IOBuffer* buffer,
                           int num_bytes,
-                          const net::CompletionCallback& callback) {
+                          net::CompletionOnceCallback callback) {
   std::string chunk = std::string(buffer->data(), num_bytes);
   if (!base::IsStringUTF8(chunk))
     return num_bytes;
@@ -118,7 +119,7 @@ int ResponseWriter::Write(net::IOBuffer* buffer,
 }
 
 int ResponseWriter::Finish(int net_error,
-                           const net::CompletionCallback& callback) {
+                           net::CompletionOnceCallback callback) {
   return net::OK;
 }
 

google_apis/drive/base_requests.cc

@@ -277,9 +277,9 @@ void ResponseWriter::DisownFile() {
   file_writer_->DisownFile();
 }
 
-int ResponseWriter::Initialize(const net::CompletionCallback& callback) {
+int ResponseWriter::Initialize(net::CompletionOnceCallback callback) {
   if (file_writer_)
-    return file_writer_->Initialize(callback);
+    return file_writer_->Initialize(std::move(callback));
 
   data_.clear();
   return net::OK;
@@ -287,7 +287,7 @@ int ResponseWriter::Initialize(const net::CompletionCallback& callback) {
 
 int ResponseWriter::Write(net::IOBuffer* buffer,
                           int num_bytes,
-                          const net::CompletionCallback& callback) {
+                          net::CompletionOnceCallback callback) {
   if (!get_content_callback_.is_null()) {
     get_content_callback_.Run(
         HTTP_SUCCESS, std::make_unique<std::string>(buffer->data(), num_bytes));
@@ -296,10 +296,11 @@ int ResponseWriter::Write(net::IOBuffer* buffer,
   if (file_writer_) {
     const int result = file_writer_->Write(
         buffer, num_bytes,
-        base::Bind(&ResponseWriter::DidWrite, weak_ptr_factory_.GetWeakPtr(),
-                   base::WrapRefCounted(buffer), callback));
+        base::BindOnce(&ResponseWriter::DidWrite,
+                       weak_ptr_factory_.GetWeakPtr(),
+                       base::WrapRefCounted(buffer), std::move(callback)));
     if (result != net::ERR_IO_PENDING)
-      DidWrite(buffer, net::CompletionCallback(), result);
+      DidWrite(buffer, net::CompletionOnceCallback(), result);
     return result;
   }
 
@@ -308,15 +309,15 @@ int ResponseWriter::Write(net::IOBuffer* buffer,
 }
 
 int ResponseWriter::Finish(int net_error,
-                           const net::CompletionCallback& callback) {
+                           net::CompletionOnceCallback callback) {
   if (file_writer_)
-    return file_writer_->Finish(net_error, callback);
+    return file_writer_->Finish(net_error, std::move(callback));
 
   return net::OK;
 }
 
 void ResponseWriter::DidWrite(scoped_refptr<net::IOBuffer> buffer,
-                              const net::CompletionCallback& callback,
+                              net::CompletionOnceCallback callback,
                               int result) {
   if (result > 0) {
     // Even if file_writer_ is used, append the data to |data_|, so that it can
@@ -330,7 +331,7 @@ void ResponseWriter::DidWrite(scoped_refptr<net::IOBuffer> buffer,
   }
 
   if (!callback.is_null())
-    callback.Run(result);
+    std::move(callback).Run(result);
 }
 
 //============================ UrlFetchRequestBase ===========================

google_apis/drive/base_requests.h

@@ -19,6 +19,7 @@
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "google_apis/drive/drive_api_error_codes.h"
+#include "net/base/completion_once_callback.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_fetcher_response_writer.h"
@@ -131,15 +132,15 @@ class ResponseWriter : public net::URLFetcherResponseWriter {
   void DisownFile();
 
   // URLFetcherResponseWriter overrides:
-  int Initialize(const net::CompletionCallback& callback) override;
+  int Initialize(net::CompletionOnceCallback callback) override;
   int Write(net::IOBuffer* buffer,
             int num_bytes,
-            const net::CompletionCallback& callback) override;
-  int Finish(int net_error, const net::CompletionCallback& callback) override;
+            net::CompletionOnceCallback callback) override;
+  int Finish(int net_error, net::CompletionOnceCallback callback) override;
 
  private:
   void DidWrite(scoped_refptr<net::IOBuffer> buffer,
-                const net::CompletionCallback& callback,
+                net::CompletionOnceCallback callback,
                 int result);
 
   const GetContentCallback get_content_callback_;

net/url_request/url_fetcher_response_writer.cc

@@ -4,6 +4,8 @@
 
 #include "net/url_request/url_fetcher_response_writer.h"
 
+#include <utility>
+
 #include "base/callback_helpers.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
@@ -27,20 +29,20 @@ URLFetcherStringWriter::URLFetcherStringWriter() = default;
 
 URLFetcherStringWriter::~URLFetcherStringWriter() = default;
 
-int URLFetcherStringWriter::Initialize(const CompletionCallback& callback) {
+int URLFetcherStringWriter::Initialize(CompletionOnceCallback callback) {
   data_.clear();
   return OK;
 }
 
 int URLFetcherStringWriter::Write(IOBuffer* buffer,
                                   int num_bytes,
-                                  const CompletionCallback& callback) {
+                                  CompletionOnceCallback callback) {
   data_.append(buffer->data(), num_bytes);
   return num_bytes;
 }
 
 int URLFetcherStringWriter::Finish(int net_error,
-                                   const CompletionCallback& callback) {
+                                   CompletionOnceCallback callback) {
   // Do nothing.
   return OK;
 }
@@ -63,7 +65,7 @@ URLFetcherFileWriter::~URLFetcherFileWriter() {
   CloseAndDeleteFile();
 }
 
-int URLFetcherFileWriter::Initialize(const CompletionCallback& callback) {
+int URLFetcherFileWriter::Initialize(CompletionOnceCallback callback) {
   DCHECK(!callback_);
 
   file_stream_.reset(new FileStream(file_task_runner_));
@@ -89,7 +91,7 @@ int URLFetcherFileWriter::Initialize(const CompletionCallback& callback) {
   }
 
   if (result == ERR_IO_PENDING) {
-    callback_ = callback;
+    callback_ = std::move(callback);
     return result;
   }
   if (result < 0)
@@ -99,7 +101,7 @@ int URLFetcherFileWriter::Initialize(const CompletionCallback& callback) {
 
 int URLFetcherFileWriter::Write(IOBuffer* buffer,
                                 int num_bytes,
-                                const CompletionCallback& callback) {
+                                CompletionOnceCallback callback) {
   DCHECK(file_stream_);
   DCHECK(owns_file_);
   DCHECK(!callback_);
@@ -108,7 +110,7 @@ int URLFetcherFileWriter::Write(IOBuffer* buffer,
       buffer, num_bytes, base::Bind(&URLFetcherFileWriter::OnIOCompleted,
                                     weak_factory_.GetWeakPtr()));
   if (result == ERR_IO_PENDING) {
-    callback_ = callback;
+    callback_ = std::move(callback);
     return result;
   }
   if (result < 0)
@@ -117,7 +119,7 @@ int URLFetcherFileWriter::Write(IOBuffer* buffer,
 }
 
 int URLFetcherFileWriter::Finish(int net_error,
-                                 const CompletionCallback& callback) {
+                                 CompletionOnceCallback callback) {
   DCHECK_NE(ERR_IO_PENDING, net_error);
 
   // If an error occurred, simply delete the file after any pending operation
@@ -136,7 +138,7 @@ int URLFetcherFileWriter::Finish(int net_error,
     int result = file_stream_->Close(base::Bind(
         &URLFetcherFileWriter::CloseComplete, weak_factory_.GetWeakPtr()));
     if (result == ERR_IO_PENDING) {
-      callback_ = callback;
+      callback_ = std::move(callback);
       return result;
     }
     file_stream_.reset();

net/url_request/url_fetcher_response_writer.h

@@ -12,7 +12,7 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
-#include "net/base/completion_callback.h"
+#include "net/base/completion_once_callback.h"
 #include "net/base/net_export.h"
 
 namespace base {
@@ -35,14 +35,14 @@ class NET_EXPORT URLFetcherResponseWriter {
   // Initializes this instance. If ERR_IO_PENDING is returned, |callback| will
   // be run later with the result. Calling this method again after a
   // Initialize() success results in discarding already written data.
-  virtual int Initialize(const CompletionCallback& callback) = 0;
+  virtual int Initialize(CompletionOnceCallback callback) = 0;
 
   // Writes |num_bytes| bytes in |buffer|, and returns the number of bytes
   // written or an error code. If ERR_IO_PENDING is returned, |callback| will be
   // run later with the result.
   virtual int Write(IOBuffer* buffer,
                     int num_bytes,
-                    const CompletionCallback& callback) = 0;
+                    CompletionOnceCallback callback) = 0;
 
   // Finishes writing. If |net_error| is not OK, this method can be called
   // in the middle of another operation (eg. Initialize() and Write()). On
@@ -51,7 +51,7 @@ class NET_EXPORT URLFetcherResponseWriter {
   // graceful shutdown and completion of the pending operation. After such a
   // failure, the URLFetcherResponseWriter may be reused. If ERR_IO_PENDING is
   // returned, |callback| will be run later with the result.
-  virtual int Finish(int net_error, const CompletionCallback& callback) = 0;
+  virtual int Finish(int net_error, CompletionOnceCallback callback) = 0;
 
   // Returns this instance's pointer as URLFetcherStringWriter when possible.
   virtual URLFetcherStringWriter* AsStringWriter();
@@ -69,11 +69,11 @@ class NET_EXPORT URLFetcherStringWriter : public URLFetcherResponseWriter {
   const std::string& data() const { return data_; }
 
   // URLFetcherResponseWriter overrides:
-  int Initialize(const CompletionCallback& callback) override;
+  int Initialize(CompletionOnceCallback callback) override;
   int Write(IOBuffer* buffer,
             int num_bytes,
-            const CompletionCallback& callback) override;
-  int Finish(int net_error, const CompletionCallback& callback) override;
+            CompletionOnceCallback callback) override;
+  int Finish(int net_error, CompletionOnceCallback callback) override;
   URLFetcherStringWriter* AsStringWriter() override;
 
  private:
@@ -95,11 +95,11 @@ class NET_EXPORT URLFetcherFileWriter : public URLFetcherResponseWriter {
   const base::FilePath& file_path() const { return file_path_; }
 
   // URLFetcherResponseWriter overrides:
-  int Initialize(const CompletionCallback& callback) override;
+  int Initialize(CompletionOnceCallback callback) override;
   int Write(IOBuffer* buffer,
             int num_bytes,
-            const CompletionCallback& callback) override;
-  int Finish(int net_error, const CompletionCallback& callback) override;
+            CompletionOnceCallback callback) override;
+  int Finish(int net_error, CompletionOnceCallback callback) override;
   URLFetcherFileWriter* AsFileWriter() override;
 
   // Drops ownership of the file at |file_path_|.
@@ -132,7 +132,7 @@ class NET_EXPORT URLFetcherFileWriter : public URLFetcherResponseWriter {
 
   std::unique_ptr<FileStream> file_stream_;
 
-  CompletionCallback callback_;
+  CompletionOnceCallback callback_;
 
   base::WeakPtrFactory<URLFetcherFileWriter> weak_factory_;