Convert base::Bind to base::Bind{Once,Repeating} in content/browser

This CL converts base::Bind to BindOnce or BindRepeating, and also changes
relevant base::Callbacks or base::Closures to appropriate types.

This CL is split from https://crrev.com/1831621.

This CL was uploaded by git cl split.

R=yangguo@chromium.org

Bug: 1007760
Change-Id: Id6da42c61527457fcb365f49ce3561bc0fce3399
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1849542
Commit-Queue: Yang Guo <yangguo@chromium.org>
Reviewed-by: Yang Guo <yangguo@chromium.org>
Auto-Submit: Makoto Shimazu <shimazu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#705069}

content/browser/devtools/devtools_http_handler.cc

@@ -710,8 +710,8 @@ void DevToolsHttpHandler::OnWebSocketRequest(
     scoped_refptr<DevToolsAgentHost> browser_agent =
         DevToolsAgentHost::CreateForBrowser(
             thread_->task_runner(),
-            base::Bind(&DevToolsSocketFactory::CreateForTethering,
-                       base::Unretained(socket_factory_.get())));
+            base::BindRepeating(&DevToolsSocketFactory::CreateForTethering,
+                                base::Unretained(socket_factory_.get())));
     connection_to_client_[connection_id].reset(new DevToolsAgentHostClientImpl(
         thread_->task_runner(), server_wrapper_.get(), connection_id,
         browser_agent));

content/browser/devtools/protocol/devtools_download_manager_delegate.cc

@@ -111,8 +111,8 @@ bool DevToolsDownloadManagerDelegate::DetermineDownloadTarget(
       base::FilePath::FromUTF8Unsafe(download_helper->GetDownloadPath());
 
   FilenameDeterminedCallback filename_determined_callback =
-      base::Bind(&DevToolsDownloadManagerDelegate::OnDownloadPathGenerated,
-                 base::Unretained(this), item->GetId(), callback);
+      base::BindOnce(&DevToolsDownloadManagerDelegate::OnDownloadPathGenerated,
+                     base::Unretained(this), item->GetId(), callback);
 
   PostTask(
       FROM_HERE,
@@ -159,7 +159,7 @@ void DevToolsDownloadManagerDelegate::GenerateFilename(
     const std::string& suggested_filename,
     const std::string& mime_type,
     const base::FilePath& suggested_directory,
-    const FilenameDeterminedCallback& callback) {
+    FilenameDeterminedCallback callback) {
   base::FilePath generated_name =
       net::GenerateFileName(url, content_disposition, std::string(),
                             suggested_filename, mime_type, "download");
@@ -169,7 +169,7 @@ void DevToolsDownloadManagerDelegate::GenerateFilename(
 
   base::FilePath suggested_path(suggested_directory.Append(generated_name));
   base::PostTask(FROM_HERE, {content::BrowserThread::UI},
-                 base::BindOnce(callback, suggested_path));
+                 base::BindOnce(std::move(callback), suggested_path));
 }
 
 void DevToolsDownloadManagerDelegate::OnDownloadPathGenerated(

content/browser/devtools/protocol/devtools_download_manager_delegate.h

@@ -54,15 +54,15 @@ class CONTENT_EXPORT DevToolsDownloadManagerDelegate
   static DevToolsDownloadManagerDelegate* GetInstance();
   ~DevToolsDownloadManagerDelegate() override;
 
-  typedef base::Callback<void(const base::FilePath&)>
-      FilenameDeterminedCallback;
+  using FilenameDeterminedCallback =
+      base::OnceCallback<void(const base::FilePath&)>;
 
   static void GenerateFilename(const GURL& url,
                                const std::string& content_disposition,
                                const std::string& suggested_filename,
                                const std::string& mime_type,
                                const base::FilePath& suggested_directory,
-                               const FilenameDeterminedCallback& callback);
+                               FilenameDeterminedCallback callback);
 
   void OnDownloadPathGenerated(uint32_t download_id,
                                const content::DownloadTargetCallback& callback,

content/browser/devtools/protocol/devtools_protocol_browsertest.cc

@@ -1918,7 +1918,7 @@ IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, CertificateExplanations) {
   std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params = WaitForMatchingNotification(
       "Security.securityStateChanged",
-      base::Bind(&SecurityStateChangedHasCertificateExplanation));
+      base::BindRepeating(&SecurityStateChangedHasCertificateExplanation));
 
   // There should be one explanation containing the server's certificate chain.
   net::SHA256HashValue cert_chain_fingerprint =
@@ -2182,8 +2182,8 @@ class DevToolsDownloadContentTest : public DevToolsProtocolTest {
 
   void WaitForCompletion(download::DownloadItem* download) {
     DownloadUpdatedObserver(
-        download,
-        base::Bind(&IsDownloadInState, download::DownloadItem::COMPLETE))
+        download, base::BindRepeating(&IsDownloadInState,
+                                      download::DownloadItem::COMPLETE))
         .WaitForEvent();
   }
 

content/browser/devtools/protocol/page_handler.cc

@@ -766,10 +766,11 @@ void PageHandler::CaptureScreenshot(
   // We don't support clip/emulation when capturing from window, bail out.
   if (!from_surface.fromMaybe(true)) {
     widget_host->GetSnapshotFromBrowser(
-        base::Bind(&PageHandler::ScreenshotCaptured, weak_factory_.GetWeakPtr(),
-                   base::Passed(std::move(callback)), screenshot_format,
-                   screenshot_quality, gfx::Size(), gfx::Size(),
-                   blink::WebDeviceEmulationParams()),
+        base::BindOnce(&PageHandler::ScreenshotCaptured,
+                       weak_factory_.GetWeakPtr(),
+                       base::Passed(std::move(callback)), screenshot_format,
+                       screenshot_quality, gfx::Size(), gfx::Size(),
+                       blink::WebDeviceEmulationParams()),
         false);
     return;
   }
@@ -866,10 +867,11 @@ void PageHandler::CaptureScreenshot(
   }
 
   widget_host->GetSnapshotFromBrowser(
-      base::Bind(&PageHandler::ScreenshotCaptured, weak_factory_.GetWeakPtr(),
-                 base::Passed(std::move(callback)), screenshot_format,
-                 screenshot_quality, original_view_size, requested_image_size,
-                 original_params),
+      base::BindOnce(&PageHandler::ScreenshotCaptured,
+                     weak_factory_.GetWeakPtr(),
+                     base::Passed(std::move(callback)), screenshot_format,
+                     screenshot_quality, original_view_size,
+                     requested_image_size, original_params),
       true);
 }
 

content/browser/devtools/protocol/service_worker_handler.cc

@@ -91,13 +91,13 @@ void StopServiceWorkerOnCoreThread(
 void GetDevToolsRouteInfoOnCoreThread(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     int64_t version_id,
-    const base::Callback<void(int, int)>& callback) {
+    base::OnceCallback<void(int, int)> callback) {
   if (content::ServiceWorkerVersion* version =
           context->GetLiveVersion(version_id)) {
     RunOrPostTaskOnThread(
         FROM_HERE, BrowserThread::UI,
         base::BindOnce(
-            callback, version->embedded_worker()->process_id(),
+            std::move(callback), version->embedded_worker()->process_id(),
             version->embedded_worker()->worker_devtools_agent_route_id()));
   }
 }
@@ -219,12 +219,13 @@ Response ServiceWorkerHandler::Enable() {
   enabled_ = true;
 
   context_watcher_ = new ServiceWorkerContextWatcher(
-      context_, base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationUpdated,
-                           weak_factory_.GetWeakPtr()),
-      base::Bind(&ServiceWorkerHandler::OnWorkerVersionUpdated,
-                 weak_factory_.GetWeakPtr()),
-      base::Bind(&ServiceWorkerHandler::OnErrorReported,
-                 weak_factory_.GetWeakPtr()));
+      context_,
+      base::BindRepeating(&ServiceWorkerHandler::OnWorkerRegistrationUpdated,
+                          weak_factory_.GetWeakPtr()),
+      base::BindRepeating(&ServiceWorkerHandler::OnWorkerVersionUpdated,
+                          weak_factory_.GetWeakPtr()),
+      base::BindRepeating(&ServiceWorkerHandler::OnErrorReported,
+                          weak_factory_.GetWeakPtr()));
   context_watcher_->Start();
 
   return Response::OK();
@@ -318,9 +319,10 @@ Response ServiceWorkerHandler::InspectWorker(const std::string& version_id) {
     return CreateInvalidVersionIdErrorResponse();
   RunOrPostTaskOnThread(
       FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
-      base::BindOnce(&GetDevToolsRouteInfoOnCoreThread, context_, id,
-                     base::Bind(&ServiceWorkerHandler::OpenNewDevToolsWindow,
-                                weak_factory_.GetWeakPtr())));
+      base::BindOnce(
+          &GetDevToolsRouteInfoOnCoreThread, context_, id,
+          base::BindOnce(&ServiceWorkerHandler::OpenNewDevToolsWindow,
+                         weak_factory_.GetWeakPtr())));
   return Response::OK();
 }
 

content/browser/devtools/protocol/tethering_handler.cc

@@ -63,7 +63,7 @@ net::NetworkTrafficAnnotationTag kTrafficAnnotation =
         })");
 
 using CreateServerSocketCallback =
-    base::Callback<std::unique_ptr<net::ServerSocket>(std::string*)>;
+    base::OnceCallback<std::unique_ptr<net::ServerSocket>(std::string*)>;
 
 class SocketPump {
  public:
@@ -73,9 +73,9 @@ class SocketPump {
         pending_destruction_(false) {
   }
 
-  std::string Init(const CreateServerSocketCallback& socket_callback) {
+  std::string Init(CreateServerSocketCallback socket_callback) {
     std::string channel_name;
-    server_socket_ = socket_callback.Run(&channel_name);
+    server_socket_ = std::move(socket_callback).Run(&channel_name);
     if (!server_socket_.get() || channel_name.empty()) {
       SelfDestruct();
       return std::string();
@@ -189,12 +189,13 @@ class SocketPump {
 
 class BoundSocket {
  public:
-  typedef base::Callback<void(uint16_t, const std::string&)> AcceptedCallback;
+  using AcceptedCallback =
+      base::OnceCallback<void(uint16_t, const std::string&)>;
 
   BoundSocket(AcceptedCallback accepted_callback,
-              const CreateServerSocketCallback& socket_callback)
-      : accepted_callback_(accepted_callback),
-        socket_callback_(socket_callback),
+              CreateServerSocketCallback socket_callback)
+      : accepted_callback_(std::move(accepted_callback)),
+        socket_callback_(std::move(socket_callback)),
         socket_(new net::TCPServerSocket(nullptr, net::NetLogSource())),
         port_(0) {}
 
@@ -243,9 +244,9 @@ class BoundSocket {
       return;
 
     SocketPump* pump = new SocketPump(accept_socket_.release());
-    std::string name = pump->Init(socket_callback_);
+    std::string name = pump->Init(std::move(socket_callback_));
     if (!name.empty())
-      accepted_callback_.Run(port_, name);
+      std::move(accepted_callback_).Run(port_, name);
   }
 
   AcceptedCallback accepted_callback_;
@@ -279,9 +280,7 @@ class TetheringHandler::TetheringImpl {
 TetheringHandler::TetheringImpl::TetheringImpl(
     base::WeakPtr<TetheringHandler> handler,
     const CreateServerSocketCallback& socket_callback)
-    : handler_(handler),
-      socket_callback_(socket_callback) {
-}
+    : handler_(handler), socket_callback_(std::move(socket_callback)) {}
 
 TetheringHandler::TetheringImpl::~TetheringImpl() = default;
 
@@ -295,7 +294,7 @@ void TetheringHandler::TetheringImpl::Bind(
     return;
   }
 
-  BoundSocket::AcceptedCallback accepted = base::Bind(
+  BoundSocket::AcceptedCallback accepted = base::BindOnce(
       &TetheringHandler::TetheringImpl::Accepted, base::Unretained(this));
   std::unique_ptr<BoundSocket> bound_socket =
       std::make_unique<BoundSocket>(std::move(accepted), socket_callback_);

content/browser/devtools/protocol/tethering_handler.h

@@ -28,7 +28,7 @@ class TetheringHandler : public DevToolsDomainHandler,
                          public Tethering::Backend {
  public:
   using CreateServerSocketCallback =
-      base::Callback<std::unique_ptr<net::ServerSocket>(std::string*)>;
+      base::RepeatingCallback<std::unique_ptr<net::ServerSocket>(std::string*)>;
 
   TetheringHandler(const CreateServerSocketCallback& socket_callback,
                    scoped_refptr<base::SingleThreadTaskRunner> task_runner);