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

chrome/browser/io_thread.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/io_thread.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 246 matching lines @@
   }
   return value;
 }
 
 // This function is for forwarding metrics usage pref changes to the metrics
 // service on the appropriate thread.
 // TODO(gayane): Reduce the frequency of posting tasks from IO to UI thread.
 void UpdateMetricsUsagePrefsOnUIThread(const std::string& service_name,
                                        int message_size,
                                        bool is_cellular) {
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind([](const std::string& service_name,
-                    int message_size,
-                    bool is_cellular) {
-                   // Some unit tests use IOThread but do not initialize
-                   // MetricsService. In that case it's fine to skip the update.
-                   auto* metrics_service = g_browser_process->metrics_service();
-                   if (metrics_service) {
-                     metrics_service->UpdateMetricsUsagePrefs(service_name,
-                                                              message_size,
-                                                              is_cellular);
-                   }
-                 },
-                 service_name,
-                 message_size,
-                 is_cellular));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::BindOnce(
+                              [](const std::string& service_name,
+                                 int message_size, bool is_cellular) {
+                                // Some unit tests use IOThread but do not
+                                // initialize MetricsService. In that case it's
+                                // fine to skip the update.
+                                auto* metrics_service =
+                                    g_browser_process->metrics_service();
+                                if (metrics_service) {
+                                  metrics_service->UpdateMetricsUsagePrefs(
+                                      service_name, message_size, is_cellular);
+                                }
+                              },
+                              service_name, message_size, is_cellular));
 }
 
 }  // namespace
 
 class SystemURLRequestContextGetter : public net::URLRequestContextGetter {
  public:
   explicit SystemURLRequestContextGetter(IOThread* io_thread);
 
   // Implementation for net::UrlRequestContextGetter.
   net::URLRequestContext* GetURLRequestContext() override;
@@ skipping 173 matching lines @@
   globals_ = globals;
 }
 
 net_log::ChromeNetLog* IOThread::net_log() {
   return net_log_;
 }
 
 void IOThread::ChangedToOnTheRecord() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&IOThread::ChangedToOnTheRecordOnIOThread,
-                 base::Unretained(this)));
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&IOThread::ChangedToOnTheRecordOnIOThread,
+                     base::Unretained(this)));
 }
 
 net::URLRequestContextGetter* IOThread::system_url_request_context_getter() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!system_url_request_context_getter_.get()) {
     InitSystemRequestContext();
   }
   return system_url_request_context_getter_.get();
 }
 
@@ skipping 176 matching lines @@
   // InitSystemRequestContext turns right around and posts a task back
   // to the IO thread, so we can't let it run until we know the IO
   // thread has started.
   //
   // Note that since we are at BrowserThread::Init time, the UI thread
   // is blocked waiting for the thread to start.  Therefore, posting
   // this task to the main thread's message loop here is guaranteed to
   // get it onto the message loop while the IOThread object still
   // exists.  However, the message might not be processed on the UI
   // thread until after IOThread is gone, so use a weak pointer.
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&IOThread::InitSystemRequestContext,
-                                     weak_factory_.GetWeakPtr()));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::BindOnce(&IOThread::InitSystemRequestContext,
+                                         weak_factory_.GetWeakPtr()));
 
 #if defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
   // Record how common CPUs with broken NEON units are. See
   // https://crbug.com/341598.
   crypto::EnsureOpenSSLInit();
   UMA_HISTOGRAM_BOOLEAN("Net.HasBrokenNEON", CRYPTO_has_broken_NEON());
 #endif
 }
 
 void IOThread::CleanUp() {
@@ skipping 146 matching lines @@
   // If we're in unit_tests, IOThread may not be run.
   if (!BrowserThread::IsMessageLoopValid(BrowserThread::IO))
     return;
   system_proxy_config_service_ = ProxyServiceFactory::CreateProxyConfigService(
       pref_proxy_config_tracker_.get());
   system_url_request_context_getter_ =
       new SystemURLRequestContextGetter(this);
   // Safe to post an unretained this pointer, since IOThread is
   // guaranteed to outlive the IO BrowserThread.
   BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&IOThread::InitSystemRequestContextOnIOThread,
-                 base::Unretained(this)));
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&IOThread::InitSystemRequestContextOnIOThread,
+                     base::Unretained(this)));
 }
 
 void IOThread::InitSystemRequestContextOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!globals_->system_proxy_service.get());
   DCHECK(system_proxy_config_service_.get());
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   globals_->system_proxy_service = ProxyServiceFactory::CreateProxyService(
@@ skipping 240 matching lines @@
 
   // TODO(rtenneti): We should probably use HttpServerPropertiesManager for the
   // system URLRequestContext too. There's no reason this should be tied to a
   // profile.
   return context;
 }
 
 metrics::UpdateUsagePrefCallbackType IOThread::GetMetricsDataUseForwarder() {
   return base::Bind(&UpdateMetricsUsagePrefsOnUIThread);
 }