Part I: Move from base::Bind to base::BindOnce and remove unneeded base::Passed (#12661)

atom/browser/api/atom_api_app.cc

@@ -431,8 +431,8 @@ bool NotificationCallbackWrapper(
   } else {
     scoped_refptr<base::SingleThreadTaskRunner> task_runner(
         base::ThreadTaskRunnerHandle::Get());
-    task_runner->PostTask(FROM_HERE,
+    task_runner->PostTask(
-                          base::Bind(base::IgnoreResult(callback), cmd, cwd));
+        FROM_HERE, base::BindOnce(base::IgnoreResult(callback), cmd, cwd));
   }
   // ProcessSingleton needs to know whether current process is quiting.
   return !Browser::Get()->is_shutting_down();

atom/browser/api/atom_api_browser_window.cc

@@ -141,7 +141,7 @@ void BrowserWindow::DidFirstVisuallyNonEmptyPaint() {
 
   // Emit the ReadyToShow event in next tick in case of pending drawing work.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(
+      FROM_HERE, base::BindOnce(
                      [](base::WeakPtr<BrowserWindow> self) {
                        if (self)
                          self->Emit("ready-to-show");

atom/browser/api/atom_api_cookies.cc

@@ -174,7 +174,7 @@ void RemoveCookieOnIOThread(scoped_refptr<net::URLRequestContextGetter> getter,
                             const std::string& name,
                             const base::Closure& callback) {
   GetCookieStore(getter)->DeleteCookieAsync(
-      url, name, base::Bind(RunCallbackInUI, callback));
+      url, name, base::BindOnce(RunCallbackInUI, callback));
 }
 
 // Callback of SetCookie.
@@ -187,7 +187,7 @@ void OnSetCookie(const Cookies::SetCallback& callback, bool success) {
 void FlushCookieStoreOnIOThread(
     scoped_refptr<net::URLRequestContextGetter> getter,
     const base::Closure& callback) {
-  GetCookieStore(getter)->FlushStore(base::Bind(RunCallbackInUI, callback));
+  GetCookieStore(getter)->FlushStore(base::BindOnce(RunCallbackInUI, callback));
 }
 
 // Sets cookie with |details| in IO thread.
@@ -232,7 +232,7 @@ void SetCookieOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
   GetCookieStore(getter)->SetCookieWithDetailsAsync(
       GURL(url), name, value, domain, path, creation_time, expiration_time,
       last_access_time, secure, http_only, net::CookieSameSite::DEFAULT_MODE,
-      net::COOKIE_PRIORITY_DEFAULT, base::Bind(OnSetCookie, callback));
+      net::COOKIE_PRIORITY_DEFAULT, base::BindOnce(OnSetCookie, callback));
 }
 
 }  // namespace
@@ -253,8 +253,8 @@ void Cookies::Get(const base::DictionaryValue& filter,
   auto* getter = browser_context_->GetRequestContext();
   content::BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::BindOnce(GetCookiesOnIO, base::RetainedRef(getter), Passed(&copied),
+      base::BindOnce(GetCookiesOnIO, base::RetainedRef(getter),
-                     callback));
+                     std::move(copied), callback));
 }
 
 void Cookies::Remove(const GURL& url,
@@ -273,8 +273,8 @@ void Cookies::Set(const base::DictionaryValue& details,
   auto* getter = browser_context_->GetRequestContext();
   content::BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::BindOnce(SetCookieOnIO, base::RetainedRef(getter), Passed(&copied),
+      base::BindOnce(SetCookieOnIO, base::RetainedRef(getter),
-                     callback));
+                     std::move(copied), callback));
 }
 
 void Cookies::FlushStore(const base::Closure& callback) {

atom/browser/api/atom_api_session.cc

@@ -244,7 +244,7 @@ class ResolveProxyHelper {
     scoped_refptr<net::URLRequestContextGetter> context_getter =
         browser_context->url_request_context_getter();
     context_getter->GetNetworkTaskRunner()->PostTask(
-        FROM_HERE, base::Bind(&ResolveProxyHelper::ResolveProxy,
+        FROM_HERE, base::BindOnce(&ResolveProxyHelper::ResolveProxy,
                                   base::Unretained(this), context_getter, url));
   }
 
@@ -252,7 +252,7 @@ class ResolveProxyHelper {
     std::string proxy;
     if (result == net::OK)
       proxy = proxy_info_.ToPacString();
-    original_thread_->PostTask(FROM_HERE, base::Bind(callback_, proxy));
+    original_thread_->PostTask(FROM_HERE, base::BindOnce(callback_, proxy));
     delete this;
   }
 
@@ -291,7 +291,7 @@ void RunCallbackInUI(const base::Callback<void()>& callback) {
 template <typename... T>
 void RunCallbackInUI(const base::Callback<void(T...)>& callback, T... result) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::Bind(callback, result...));
+                          base::BindOnce(callback, result...));
 }
 
 // Callback of HttpCache::GetBackend.
@@ -529,9 +529,9 @@ template <Session::CacheAction action>
 void Session::DoCacheAction(const net::CompletionCallback& callback) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&DoCacheActionInIO,
+      base::BindOnce(&DoCacheActionInIO,
-                 WrapRefCounted(browser_context_->GetRequestContext()), action,
+                     WrapRefCounted(browser_context_->GetRequestContext()),
-                 callback));
+                     action, callback));
 }
 
 void Session::ClearStorageData(mate::Arguments* args) {
@@ -592,7 +592,7 @@ void Session::EnableNetworkEmulation(const mate::Dictionary& options) {
       devtools_network_emulation_client_id_, std::move(conditions));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(
+      base::BindOnce(
           &SetDevToolsNetworkEmulationClientIdInIO,
           base::RetainedRef(browser_context_->url_request_context_getter()),
           devtools_network_emulation_client_id_));
@@ -604,7 +604,7 @@ void Session::DisableNetworkEmulation() {
       devtools_network_emulation_client_id_, std::move(conditions));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(
+      base::BindOnce(
           &SetDevToolsNetworkEmulationClientIdInIO,
           base::RetainedRef(browser_context_->url_request_context_getter()),
           std::string()));
@@ -620,8 +620,9 @@ void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&SetCertVerifyProcInIO,
+      base::BindOnce(&SetCertVerifyProcInIO,
-                 WrapRefCounted(browser_context_->GetRequestContext()), proc));
+                     WrapRefCounted(browser_context_->GetRequestContext()),
+                     proc));
 }
 
 void Session::SetPermissionRequestHandler(v8::Local<v8::Value> val,
@@ -642,7 +643,7 @@ void Session::ClearHostResolverCache(mate::Arguments* args) {
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&ClearHostResolverCacheInIO,
+      base::BindOnce(&ClearHostResolverCacheInIO,
                      WrapRefCounted(browser_context_->GetRequestContext()),
                      callback));
 }
@@ -658,15 +659,15 @@ void Session::ClearAuthCache(mate::Arguments* args) {
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&ClearAuthCacheInIO,
+      base::BindOnce(&ClearAuthCacheInIO,
-                 WrapRefCounted(browser_context_->GetRequestContext()), options,
+                     WrapRefCounted(browser_context_->GetRequestContext()),
-                 callback));
+                     options, callback));
 }
 
 void Session::AllowNTLMCredentialsForDomains(const std::string& domains) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&AllowNTLMCredentialsForDomainsInIO,
+      base::BindOnce(&AllowNTLMCredentialsForDomainsInIO,
                      WrapRefCounted(browser_context_->GetRequestContext()),
                      domains));
 }
@@ -682,7 +683,7 @@ void Session::SetUserAgent(const std::string& user_agent,
       browser_context_->GetRequestContext());
   getter->GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
-      base::Bind(&SetUserAgentInIO, getter, accept_lang, user_agent));
+      base::BindOnce(&SetUserAgentInIO, getter, accept_lang, user_agent));
 }
 
 std::string Session::GetUserAgent() {
@@ -697,8 +698,8 @@ void Session::GetBlobData(const std::string& uuid,
   AtomBlobReader* blob_reader = browser_context()->GetBlobReader();
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&AtomBlobReader::StartReading, base::Unretained(blob_reader),
+      base::BindOnce(&AtomBlobReader::StartReading,
-                 uuid, callback));
+                     base::Unretained(blob_reader), uuid, callback));
 }
 
 void Session::CreateInterruptedDownload(const mate::Dictionary& options) {

atom/browser/api/atom_api_web_contents.cc

@@ -1363,7 +1363,8 @@ void WebContents::HasServiceWorker(const base::Callback<void(bool)>& callback) {
 
   context->CheckHasServiceWorker(
       web_contents()->GetLastCommittedURL(), GURL::EmptyGURL(),
-      base::Bind(&WrappedCallback::Run, base::Unretained(wrapped_callback)));
+      base::BindOnce(&WrappedCallback::Run,
+                     base::Unretained(wrapped_callback)));
 }
 
 void WebContents::UnregisterServiceWorker(

atom/browser/api/atom_api_web_request.cc

@@ -100,9 +100,9 @@ void WebRequest::SetListener(Method method, Event type, mate::Arguments* args) {
     return;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CallNetworkDelegateMethod<Method, Event, Listener>,
+      base::BindOnce(&CallNetworkDelegateMethod<Method, Event, Listener>,
-                 base::RetainedRef(url_request_context_getter), method, type,
+                     base::RetainedRef(url_request_context_getter), method,
-                 std::move(patterns), std::move(listener)));
+                     type, std::move(patterns), std::move(listener)));
 }
 
 // static

atom/browser/api/event_subscriber.h

@@ -71,7 +71,7 @@ class EventSubscriber : internal::EventSubscriberBase {
       ptr->handler_ = nullptr;
       content::BrowserThread::PostTask(
           content::BrowserThread::UI, FROM_HERE,
-          base::Bind(
+          base::BindOnce(
               [](EventSubscriber<HandlerType>* subscriber) {
                 {
                   // It is possible that this function will execute in the UI

atom/browser/atom_blob_reader.cc

@@ -61,7 +61,7 @@ void AtomBlobReader::StartReading(
   auto callback = base::Bind(&RunCallbackInUI, completion_callback);
   if (!blob_data_handle) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                            base::Bind(callback, nullptr, 0));
+                            base::BindOnce(callback, nullptr, 0));
     return;
   }
 
@@ -117,7 +117,7 @@ void AtomBlobReader::BlobReadHelper::DidReadBlobData(
   char* data = new char[size];
   memcpy(data, blob_data->data(), size);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::Bind(completion_callback_, data, size));
+                          base::BindOnce(completion_callback_, data, size));
   delete this;
 }
 

atom/browser/atom_download_manager_delegate.cc

@@ -43,7 +43,7 @@ void CreateDownloadPath(
 
   base::FilePath path(default_download_path.Append(generated_name));
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-                                   base::Bind(callback, path));
+                                   base::BindOnce(callback, path));
 }
 
 }  // namespace
@@ -165,7 +165,7 @@ bool AtomDownloadManagerDelegate::DetermineDownloadTarget(
 
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&CreateDownloadPath, download->GetURL(),
+      base::BindOnce(&CreateDownloadPath, download->GetURL(),
                      download->GetContentDisposition(),
                      download->GetSuggestedFilename(), download->GetMimeType(),
                      default_download_path, download_path_callback));

atom/browser/atom_resource_dispatcher_host_delegate.cc

@@ -117,7 +117,7 @@ bool AtomResourceDispatcherHostDelegate::HandleExternalProtocol(
     const GURL& url,
     content::ResourceRequestInfo* info) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::Bind(&HandleExternalProtocolInUI, url,
+                          base::BindOnce(&HandleExternalProtocolInUI, url,
                                          info->GetWebContentsGetterForRequest(),
                                          info->HasUserGesture()));
   return true;

atom/browser/common_web_contents_delegate.cc

@@ -312,8 +312,9 @@ void CommonWebContentsDelegate::DevToolsSaveToFile(const std::string& url,
 
   saved_files_[url] = path;
   BrowserThread::PostTaskAndReply(
-      BrowserThread::FILE, FROM_HERE, base::Bind(&WriteToFile, path, content),
+      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&CommonWebContentsDelegate::OnDevToolsSaveToFile,
+      base::BindOnce(&WriteToFile, path, content),
+      base::BindOnce(&CommonWebContentsDelegate::OnDevToolsSaveToFile,
                      base::Unretained(this), url));
 }
 
@@ -326,8 +327,8 @@ void CommonWebContentsDelegate::DevToolsAppendToFile(
 
   BrowserThread::PostTaskAndReply(
       BrowserThread::FILE, FROM_HERE,
-      base::Bind(&AppendToFile, it->second, content),
+      base::BindOnce(&AppendToFile, it->second, content),
-      base::Bind(&CommonWebContentsDelegate::OnDevToolsAppendToFile,
+      base::BindOnce(&CommonWebContentsDelegate::OnDevToolsAppendToFile,
                      base::Unretained(this), url));
 }
 

atom/browser/login_handler.cc

@@ -47,9 +47,9 @@ LoginHandler::LoginHandler(net::AuthChallengeInfo* auth_info,
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&Browser::RequestLogin, base::Unretained(Browser::Get()),
+      base::BindOnce(&Browser::RequestLogin, base::Unretained(Browser::Get()),
                      base::RetainedRef(WrapRefCounted(this)),
-                 base::Passed(&request_details)));
+                     std::move(request_details)));
 }
 
 LoginHandler::~LoginHandler() {}
@@ -69,7 +69,7 @@ void LoginHandler::Login(const base::string16& username,
     return;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&LoginHandler::DoLogin, this, username, password));
+      base::BindOnce(&LoginHandler::DoLogin, this, username, password));
 }
 
 void LoginHandler::CancelAuth() {
@@ -77,7 +77,7 @@ void LoginHandler::CancelAuth() {
   if (TestAndSetAuthHandled())
     return;
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&LoginHandler::DoCancelAuth, this));
+                          base::BindOnce(&LoginHandler::DoCancelAuth, this));
 }
 
 void LoginHandler::OnRequestCancelled() {

atom/browser/net/asar/url_request_asar_job.cc

@@ -109,14 +109,14 @@ void URLRequestAsarJob::Start() {
     }
     file_task_runner_->PostTaskAndReply(
         FROM_HERE,
-        base::Bind(&URLRequestAsarJob::FetchMetaInfo, file_path_, type_,
+        base::BindOnce(&URLRequestAsarJob::FetchMetaInfo, file_path_, type_,
                        base::Unretained(meta_info)),
-        base::Bind(&URLRequestAsarJob::DidFetchMetaInfo,
+        base::BindOnce(&URLRequestAsarJob::DidFetchMetaInfo,
                        weak_ptr_factory_.GetWeakPtr(), base::Owned(meta_info)));
   } else {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
+        FROM_HERE, base::BindOnce(&URLRequestAsarJob::DidOpen,
-        base::Bind(&URLRequestAsarJob::DidOpen, weak_ptr_factory_.GetWeakPtr(),
+                                  weak_ptr_factory_.GetWeakPtr(),
                                   net::ERR_FILE_NOT_FOUND));
   }
 }

atom/browser/net/atom_cert_verifier.cc

@@ -100,8 +100,8 @@ class CertVerifierRequest : public AtomCertVerifier::Request {
                                         weak_ptr_factory_.GetWeakPtr());
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&CertVerifierRequest::OnVerifyRequestInUI,
+        base::BindOnce(&CertVerifierRequest::OnVerifyRequestInUI,
-                   cert_verifier_->verify_proc(), base::Passed(&request),
+                       cert_verifier_->verify_proc(), std::move(request),
                        response_callback));
   }
 
@@ -116,7 +116,7 @@ class CertVerifierRequest : public AtomCertVerifier::Request {
                              int result) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&CertVerifierRequest::NotifyResponseInIO, self, result));
+        base::BindOnce(&CertVerifierRequest::NotifyResponseInIO, self, result));
   }
 
   void NotifyResponseInIO(int result) {

atom/browser/net/atom_network_delegate.cc

@@ -403,7 +403,7 @@ int AtomNetworkDelegate::HandleResponseEvent(
                  base::Unretained(this), request->identifier(), out);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(RunResponseListener, info.listener, base::Passed(&details),
+      base::BindOnce(RunResponseListener, info.listener, std::move(details),
                      render_process_id, render_frame_id, response));
   return net::ERR_IO_PENDING;
 }
@@ -425,7 +425,7 @@ void AtomNetworkDelegate::HandleSimpleEvent(SimpleEvent type,
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(RunSimpleListener, info.listener, base::Passed(&details),
+      base::BindOnce(RunSimpleListener, info.listener, std::move(details),
                      render_process_id, render_frame_id));
 }
 
@@ -453,8 +453,8 @@ void AtomNetworkDelegate::OnListenerResultInUI(
   std::unique_ptr<base::DictionaryValue> copy = response.CreateDeepCopy();
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&AtomNetworkDelegate::OnListenerResultInIO<T>,
+      base::BindOnce(&AtomNetworkDelegate::OnListenerResultInIO<T>,
-                 base::Unretained(this), id, out, base::Passed(&copy)));
+                     base::Unretained(this), id, out, std::move(copy)));
 }
 
 }  // namespace atom

atom/browser/net/atom_url_request.cc

@@ -79,8 +79,9 @@ scoped_refptr<AtomURLRequest> AtomURLRequest::Create(
   scoped_refptr<AtomURLRequest> atom_url_request(new AtomURLRequest(delegate));
   if (content::BrowserThread::PostTask(
           content::BrowserThread::IO, FROM_HERE,
-          base::Bind(&AtomURLRequest::DoInitialize, atom_url_request,
+          base::BindOnce(&AtomURLRequest::DoInitialize, atom_url_request,
-                     request_context_getter, method, url, redirect_policy))) {
+                         request_context_getter, method, url,
+                         redirect_policy))) {
     return atom_url_request;
   }
   return nullptr;
@@ -91,7 +92,7 @@ void AtomURLRequest::Terminate() {
   delegate_ = nullptr;
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&AtomURLRequest::DoTerminate, this));
+      base::BindOnce(&AtomURLRequest::DoTerminate, this));
 }
 
 void AtomURLRequest::DoInitialize(
@@ -141,7 +142,7 @@ bool AtomURLRequest::Write(scoped_refptr<const net::IOBufferWithSize> buffer,
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&AtomURLRequest::DoWriteBuffer, this, buffer, is_last));
+      base::BindOnce(&AtomURLRequest::DoWriteBuffer, this, buffer, is_last));
 }
 
 void AtomURLRequest::SetChunkedUpload(bool is_chunked_upload) {
@@ -155,15 +156,16 @@ void AtomURLRequest::SetChunkedUpload(bool is_chunked_upload) {
 
 void AtomURLRequest::Cancel() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
+  content::BrowserThread::PostTask(
-                                   base::Bind(&AtomURLRequest::DoCancel, this));
+      content::BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&AtomURLRequest::DoCancel, this));
 }
 
 void AtomURLRequest::FollowRedirect() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&AtomURLRequest::DoFollowRedirect, this));
+      base::BindOnce(&AtomURLRequest::DoFollowRedirect, this));
 }
 
 void AtomURLRequest::SetExtraHeader(const std::string& name,
@@ -171,14 +173,14 @@ void AtomURLRequest::SetExtraHeader(const std::string& name,
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&AtomURLRequest::DoSetExtraHeader, this, name, value));
+      base::BindOnce(&AtomURLRequest::DoSetExtraHeader, this, name, value));
 }
 
 void AtomURLRequest::RemoveExtraHeader(const std::string& name) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&AtomURLRequest::DoRemoveExtraHeader, this, name));
+      base::BindOnce(&AtomURLRequest::DoRemoveExtraHeader, this, name));
 }
 
 void AtomURLRequest::PassLoginInformation(
@@ -188,11 +190,11 @@ void AtomURLRequest::PassLoginInformation(
   if (username.empty() || password.empty()) {
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&AtomURLRequest::DoCancelAuth, this));
+        base::BindOnce(&AtomURLRequest::DoCancelAuth, this));
   } else {
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&AtomURLRequest::DoSetAuth, this, username, password));
+        base::BindOnce(&AtomURLRequest::DoSetAuth, this, username, password));
   }
 }
 
@@ -200,7 +202,7 @@ void AtomURLRequest::SetLoadFlags(int flags) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&AtomURLRequest::DoSetLoadFlags, this, flags));
+      base::BindOnce(&AtomURLRequest::DoSetLoadFlags, this, flags));
 }
 
 void AtomURLRequest::DoWriteBuffer(
@@ -308,7 +310,7 @@ void AtomURLRequest::DoCancelWithError(const std::string& error,
   DoCancel();
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&AtomURLRequest::InformDelegateErrorOccured, this, error,
+      base::BindOnce(&AtomURLRequest::InformDelegateErrorOccured, this, error,
                      isRequestError));
 }
 
@@ -337,7 +339,7 @@ void AtomURLRequest::OnReceivedRedirect(net::URLRequest* request,
         request->response_headers();
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
-        base::Bind(&AtomURLRequest::InformDelegateReceivedRedirect, this,
+        base::BindOnce(&AtomURLRequest::InformDelegateReceivedRedirect, this,
                        info.status_code, info.new_method, info.new_url,
                        response_headers));
   }
@@ -349,8 +351,8 @@ void AtomURLRequest::OnAuthRequired(net::URLRequest* request,
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&AtomURLRequest::InformDelegateAuthenticationRequired, this,
+      base::BindOnce(&AtomURLRequest::InformDelegateAuthenticationRequired,
-                 scoped_refptr<net::AuthChallengeInfo>(auth_info)));
+                     this, scoped_refptr<net::AuthChallengeInfo>(auth_info)));
 }
 
 void AtomURLRequest::OnResponseStarted(net::URLRequest* request) {
@@ -367,7 +369,7 @@ void AtomURLRequest::OnResponseStarted(net::URLRequest* request) {
     // Success or pending trigger a Read.
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
-        base::Bind(&AtomURLRequest::InformDelegateResponseStarted, this,
+        base::BindOnce(&AtomURLRequest::InformDelegateResponseStarted, this,
                        response_headers));
     ReadResponse();
   } else if (status.status() == net::URLRequestStatus::Status::FAILED) {
@@ -426,7 +428,7 @@ void AtomURLRequest::OnReadCompleted(net::URLRequest* request, int bytes_read) {
   } else if (data_ended) {
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
-        base::Bind(&AtomURLRequest::InformDelegateResponseCompleted, this));
+        base::BindOnce(&AtomURLRequest::InformDelegateResponseCompleted, this));
     DoTerminate();
   } else if (data_transfer_error) {
     // We abort the request on corrupted data transfer.
@@ -449,7 +451,7 @@ bool AtomURLRequest::CopyAndPostBuffer(int bytes_read) {
 
   return content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&AtomURLRequest::InformDelegateResponseData, this,
+      base::BindOnce(&AtomURLRequest::InformDelegateResponseData, this,
                      buffer_copy));
 }
 

atom/browser/net/js_asker.cc

@@ -23,7 +23,7 @@ void HandlerCallback(const BeforeStartCallback& before_start,
   v8::Local<v8::Value> value;
   if (!args->GetNext(&value)) {
     content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
-                                     base::Bind(callback, false, nullptr));
+                                     base::BindOnce(callback, false, nullptr));
     return;
   }
 
@@ -36,7 +36,7 @@ void HandlerCallback(const BeforeStartCallback& before_start,
   std::unique_ptr<base::Value> options(converter.FromV8Value(value, context));
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(callback, true, base::Passed(&options)));
+      base::BindOnce(callback, true, std::move(options)));
 }
 
 }  // namespace

atom/browser/net/js_asker.h

@@ -74,9 +74,9 @@ class JsAsker : public RequestJob {
     FillRequestDetails(request_details.get(), RequestJob::request());
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
-        base::Bind(
+        base::BindOnce(
             &internal::AskForOptions, isolate_, handler_,
-            base::Passed(&request_details),
+            std::move(request_details),
             base::Bind(&JsAsker::BeforeStartInUI, weak_factory_.GetWeakPtr()),
             base::Bind(&JsAsker::OnResponse, weak_factory_.GetWeakPtr())));
   }

atom/browser/net/url_request_about_job.cc

@@ -14,7 +14,7 @@ URLRequestAboutJob::URLRequestAboutJob(net::URLRequest* request,
 
 void URLRequestAboutJob::Start() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&URLRequestAboutJob::StartAsync,
+      FROM_HERE, base::BindOnce(&URLRequestAboutJob::StartAsync,
                                 weak_ptr_factory_.GetWeakPtr()));
 }
 

atom/browser/net/url_request_stream_job.cc

@@ -120,8 +120,9 @@ void URLRequestStreamJob::OnError(mate::Arguments* args) {
 int URLRequestStreamJob::ReadRawData(net::IOBuffer* dest, int dest_size) {
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&URLRequestStreamJob::CopyMoreData, weak_factory_.GetWeakPtr(),
+      base::BindOnce(&URLRequestStreamJob::CopyMoreData,
-                 WrapRefCounted(dest), dest_size));
+                     weak_factory_.GetWeakPtr(), WrapRefCounted(dest),
+                     dest_size));
   return net::ERR_IO_PENDING;
 }
 
@@ -168,7 +169,7 @@ void URLRequestStreamJob::CopyMoreData(scoped_refptr<net::IOBuffer> io_buf,
     int status = (errored_ && !read_count) ? net::ERR_FAILED : read_count;
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&URLRequestStreamJob::CopyMoreDataDone,
+        base::BindOnce(&URLRequestStreamJob::CopyMoreDataDone,
                        weak_factory_.GetWeakPtr(), io_buf, status));
   }
 }

atom/browser/osr/osr_render_widget_host_view.cc

@@ -167,7 +167,7 @@ class AtomCopyFrameGenerator {
         next_frame_time_ += frame_duration_;
         content::BrowserThread::PostDelayedTask(
             content::BrowserThread::UI, FROM_HERE,
-            base::Bind(&AtomCopyFrameGenerator::OnCopyFrameCaptureSuccess,
+            base::BindOnce(&AtomCopyFrameGenerator::OnCopyFrameCaptureSuccess,
                            weak_ptr_factory_.GetWeakPtr(), damage_rect, bitmap),
             next_frame_in);
       } else {
@@ -187,7 +187,7 @@ class AtomCopyFrameGenerator {
       // Retry with the same |damage_rect|.
       content::BrowserThread::PostTask(
           content::BrowserThread::UI, FROM_HERE,
-          base::Bind(&AtomCopyFrameGenerator::GenerateCopyFrame,
+          base::BindOnce(&AtomCopyFrameGenerator::GenerateCopyFrame,
                          weak_ptr_factory_.GetWeakPtr(), damage_rect));
     }
   }
@@ -1030,7 +1030,7 @@ void OffScreenRenderWidgetHostView::ReleaseResize() {
     pending_resize_ = false;
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
-        base::Bind(&OffScreenRenderWidgetHostView::WasResized,
+        base::BindOnce(&OffScreenRenderWidgetHostView::WasResized,
                        weak_ptr_factory_.GetWeakPtr()));
   }
 }
@@ -1131,7 +1131,7 @@ void OffScreenRenderWidgetHostView::ProcessMouseWheelEvent(
         // other callback.
         content::BrowserThread::PostTask(
             content::BrowserThread::UI, FROM_HERE,
-            base::Bind(&OffScreenRenderWidgetHostView::CancelWidget,
+            base::BindOnce(&OffScreenRenderWidgetHostView::CancelWidget,
                            popup_host_view_->weak_ptr_factory_.GetWeakPtr()));
       }
     }

atom/common/node_bindings.cc

@@ -318,7 +318,7 @@ void NodeBindings::UvRunOnce() {
 
 void NodeBindings::WakeupMainThread() {
   DCHECK(task_runner_);
-  task_runner_->PostTask(FROM_HERE, base::Bind(&NodeBindings::UvRunOnce,
+  task_runner_->PostTask(FROM_HERE, base::BindOnce(&NodeBindings::UvRunOnce,
                                                    weak_factory_.GetWeakPtr()));
 }
 

atom/renderer/atom_autofill_agent.cc

@@ -84,7 +84,7 @@ void AutofillAgent::TextFieldDidChange(
 
   weak_ptr_factory_.InvalidateWeakPtrs();
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&AutofillAgent::TextFieldDidChangeImpl,
+      FROM_HERE, base::BindOnce(&AutofillAgent::TextFieldDidChangeImpl,
                                 weak_ptr_factory_.GetWeakPtr(), element));
 }
 

atom/renderer/guest_view_container.cc

@@ -53,7 +53,7 @@ void GuestViewContainer::DidResizeElement(const gfx::Size& new_size) {
     return;
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(element_resize_callback_, new_size));
+      FROM_HERE, base::BindOnce(element_resize_callback_, new_size));
 }
 
 base::WeakPtr<content::BrowserPluginDelegate> GuestViewContainer::GetWeakPtr() {

brightray/browser/devtools_file_system_indexer.cc

@@ -279,13 +279,14 @@ void DevToolsFileSystemIndexer::FileSystemIndexingJob::Start() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      Bind(&FileSystemIndexingJob::CollectFilesToIndex, this));
+      BindOnce(&FileSystemIndexingJob::CollectFilesToIndex, this));
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::Stop() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+  BrowserThread::PostTask(
-                          Bind(&FileSystemIndexingJob::StopOnFileThread, this));
+      BrowserThread::FILE, FROM_HERE,
+      BindOnce(&FileSystemIndexingJob::StopOnFileThread, this));
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::StopOnFileThread() {
@@ -304,7 +305,7 @@ void DevToolsFileSystemIndexer::FileSystemIndexingJob::CollectFilesToIndex() {
   if (file_path.empty()) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        Bind(total_work_callback_, file_path_times_.size()));
+        BindOnce(total_work_callback_, file_path_times_.size()));
     indexing_it_ = file_path_times_.begin();
     IndexFiles();
     return;
@@ -318,7 +319,7 @@ void DevToolsFileSystemIndexer::FileSystemIndexingJob::CollectFilesToIndex() {
   }
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      Bind(&FileSystemIndexingJob::CollectFilesToIndex, this));
+      BindOnce(&FileSystemIndexingJob::CollectFilesToIndex, this));
 }
 
 void DevToolsFileSystemIndexer::FileSystemIndexingJob::IndexFiles() {
@@ -429,7 +430,7 @@ void DevToolsFileSystemIndexer::FileSystemIndexingJob::ReportWorked() {
   if (should_send_worked_nitification) {
     last_worked_notification_time_ = current_time;
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                            Bind(worked_callback_, files_indexed_));
+                            BindOnce(worked_callback_, files_indexed_));
     files_indexed_ = 0;
   }
 }
@@ -458,7 +459,7 @@ void DevToolsFileSystemIndexer::SearchInPath(const string& file_system_path,
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      Bind(&DevToolsFileSystemIndexer::SearchInPathOnFileThread, this,
+      BindOnce(&DevToolsFileSystemIndexer::SearchInPathOnFileThread, this,
                file_system_path, query, callback));
 }
 
@@ -475,7 +476,8 @@ void DevToolsFileSystemIndexer::SearchInPathOnFileThread(
     if (path.IsParent(*it))
       result.push_back(it->AsUTF8Unsafe());
   }
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, Bind(callback, result));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          BindOnce(callback, result));
 }
 
 }  // namespace brightray

brightray/browser/inspectable_web_contents_impl.cc

@@ -171,9 +171,9 @@ int ResponseWriter::Write(net::IOBuffer* buffer,
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&InspectableWebContentsImpl::CallClientFunction, bindings_,
+      base::BindOnce(&InspectableWebContentsImpl::CallClientFunction, bindings_,
-                 "DevToolsAPI.streamWrite", base::Owned(id), base::Owned(chunk),
+                     "DevToolsAPI.streamWrite", base::Owned(id),
-                 nullptr));
+                     base::Owned(chunk), nullptr));
   return num_bytes;
 }