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

This reverts commit 23fa6714.

Reason for revert: Caused a regression around the port forwarding in Android due to wrong conversion. Let me revert this first to unblock beta release.

Original change's description:
> 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}

TBR=yangguo@chromium.org,shimazu@chromium.org

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: 1007760, 1014376
Change-Id: Iadb6008679b5ccfc6df8591f8bda3c9eb922d739
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1866339Reviewed-by: Makoto Shimazu <shimazu@chromium.org>
Commit-Queue: Makoto Shimazu <shimazu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#707237}

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::BindRepeating(&DevToolsSocketFactory::CreateForTethering,
-                                base::Unretained(socket_factory_.get())));
+            base::Bind(&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::BindOnce(&DevToolsDownloadManagerDelegate::OnDownloadPathGenerated,
-                     base::Unretained(this), item->GetId(), callback);
+      base::Bind(&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,
-    FilenameDeterminedCallback callback) {
+    const 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(std::move(callback), suggested_path));
+                 base::BindOnce(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;
 
-  using FilenameDeterminedCallback =
-      base::OnceCallback<void(const base::FilePath&)>;
+  typedef base::Callback<void(const base::FilePath&)>
+      FilenameDeterminedCallback;
 
   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,
-                               FilenameDeterminedCallback callback);
+                               const 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::BindRepeating(&SecurityStateChangedHasCertificateExplanation));
+      base::Bind(&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::BindRepeating(&IsDownloadInState,
-                                      download::DownloadItem::COMPLETE))
+        download,
+        base::Bind(&IsDownloadInState, download::DownloadItem::COMPLETE))
         .WaitForEvent();
   }
 

content/browser/devtools/protocol/page_handler.cc

@@ -766,11 +766,10 @@ void PageHandler::CaptureScreenshot(
   // We don't support clip/emulation when capturing from window, bail out.
   if (!from_surface.fromMaybe(true)) {
     widget_host->GetSnapshotFromBrowser(
-        base::BindOnce(&PageHandler::ScreenshotCaptured,
-                       weak_factory_.GetWeakPtr(),
-                       base::Passed(std::move(callback)), screenshot_format,
-                       screenshot_quality, gfx::Size(), gfx::Size(),
-                       blink::WebDeviceEmulationParams()),
+        base::Bind(&PageHandler::ScreenshotCaptured, weak_factory_.GetWeakPtr(),
+                   base::Passed(std::move(callback)), screenshot_format,
+                   screenshot_quality, gfx::Size(), gfx::Size(),
+                   blink::WebDeviceEmulationParams()),
         false);
     return;
   }
@@ -867,11 +866,10 @@ void PageHandler::CaptureScreenshot(
   }
 
   widget_host->GetSnapshotFromBrowser(
-      base::BindOnce(&PageHandler::ScreenshotCaptured,
-                     weak_factory_.GetWeakPtr(),
-                     base::Passed(std::move(callback)), screenshot_format,
-                     screenshot_quality, original_view_size,
-                     requested_image_size, original_params),
+      base::Bind(&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,
-    base::OnceCallback<void(int, int)> callback) {
+    const base::Callback<void(int, int)>& callback) {
   if (content::ServiceWorkerVersion* version =
           context->GetLiveVersion(version_id)) {
     RunOrPostTaskOnThread(
         FROM_HERE, BrowserThread::UI,
         base::BindOnce(
-            std::move(callback), version->embedded_worker()->process_id(),
+            callback, version->embedded_worker()->process_id(),
             version->embedded_worker()->worker_devtools_agent_route_id()));
   }
 }
@@ -219,13 +219,12 @@ Response ServiceWorkerHandler::Enable() {
   enabled_ = true;
 
   context_watcher_ = new ServiceWorkerContextWatcher(
-      context_,
-      base::BindRepeating(&ServiceWorkerHandler::OnWorkerRegistrationUpdated,
-                          weak_factory_.GetWeakPtr()),
-      base::BindRepeating(&ServiceWorkerHandler::OnWorkerVersionUpdated,
-                          weak_factory_.GetWeakPtr()),
-      base::BindRepeating(&ServiceWorkerHandler::OnErrorReported,
-                          weak_factory_.GetWeakPtr()));
+      context_, base::Bind(&ServiceWorkerHandler::OnWorkerRegistrationUpdated,
+                           weak_factory_.GetWeakPtr()),
+      base::Bind(&ServiceWorkerHandler::OnWorkerVersionUpdated,
+                 weak_factory_.GetWeakPtr()),
+      base::Bind(&ServiceWorkerHandler::OnErrorReported,
+                 weak_factory_.GetWeakPtr()));
   context_watcher_->Start();
 
   return Response::OK();
@@ -319,10 +318,9 @@ Response ServiceWorkerHandler::InspectWorker(const std::string& version_id) {
     return CreateInvalidVersionIdErrorResponse();
   RunOrPostTaskOnThread(
       FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
-      base::BindOnce(
-          &GetDevToolsRouteInfoOnCoreThread, context_, id,
-          base::BindOnce(&ServiceWorkerHandler::OpenNewDevToolsWindow,
-                         weak_factory_.GetWeakPtr())));
+      base::BindOnce(&GetDevToolsRouteInfoOnCoreThread, context_, id,
+                     base::Bind(&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::OnceCallback<std::unique_ptr<net::ServerSocket>(std::string*)>;
+    base::Callback<std::unique_ptr<net::ServerSocket>(std::string*)>;
 
 class SocketPump {
  public:
@@ -73,9 +73,9 @@ class SocketPump {
         pending_destruction_(false) {
   }
 
-  std::string Init(CreateServerSocketCallback socket_callback) {
+  std::string Init(const CreateServerSocketCallback& socket_callback) {
     std::string channel_name;
-    server_socket_ = std::move(socket_callback).Run(&channel_name);
+    server_socket_ = socket_callback.Run(&channel_name);
     if (!server_socket_.get() || channel_name.empty()) {
       SelfDestruct();
       return std::string();
@@ -189,13 +189,12 @@ class SocketPump {
 
 class BoundSocket {
  public:
-  using AcceptedCallback =
-      base::OnceCallback<void(uint16_t, const std::string&)>;
+  typedef base::Callback<void(uint16_t, const std::string&)> AcceptedCallback;
 
   BoundSocket(AcceptedCallback accepted_callback,
-              CreateServerSocketCallback socket_callback)
-      : accepted_callback_(std::move(accepted_callback)),
-        socket_callback_(std::move(socket_callback)),
+              const CreateServerSocketCallback& socket_callback)
+      : accepted_callback_(accepted_callback),
+        socket_callback_(socket_callback),
         socket_(new net::TCPServerSocket(nullptr, net::NetLogSource())),
         port_(0) {}
 
@@ -244,9 +243,9 @@ class BoundSocket {
       return;
 
     SocketPump* pump = new SocketPump(accept_socket_.release());
-    std::string name = pump->Init(std::move(socket_callback_));
+    std::string name = pump->Init(socket_callback_);
     if (!name.empty())
-      std::move(accepted_callback_).Run(port_, name);
+      accepted_callback_.Run(port_, name);
   }
 
   AcceptedCallback accepted_callback_;
@@ -280,7 +279,9 @@ class TetheringHandler::TetheringImpl {
 TetheringHandler::TetheringImpl::TetheringImpl(
     base::WeakPtr<TetheringHandler> handler,
     const CreateServerSocketCallback& socket_callback)
-    : handler_(handler), socket_callback_(std::move(socket_callback)) {}
+    : handler_(handler),
+      socket_callback_(socket_callback) {
+}
 
 TetheringHandler::TetheringImpl::~TetheringImpl() = default;
 
@@ -294,7 +295,7 @@ void TetheringHandler::TetheringImpl::Bind(
     return;
   }
 
-  BoundSocket::AcceptedCallback accepted = base::BindOnce(
+  BoundSocket::AcceptedCallback accepted = base::Bind(
       &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::RepeatingCallback<std::unique_ptr<net::ServerSocket>(std::string*)>;
+      base::Callback<std::unique_ptr<net::ServerSocket>(std::string*)>;
 
   TetheringHandler(const CreateServerSocketCallback& socket_callback,
                    scoped_refptr<base::SingleThreadTaskRunner> task_runner);