Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/ui

chrome/browser/ui/login/login_handler.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/ui/login/login_handler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 103 matching lines @@
   DCHECK(request_) << "LoginHandler constructed with NULL request";
   DCHECK(auth_info_.get()) << "LoginHandler constructed with NULL auth info";
 
   AddRef();  // matched by LoginHandler::ReleaseSoon().
 
   const content::ResourceRequestInfo* info =
       ResourceRequestInfo::ForRequest(request);
   DCHECK(info);
   web_contents_getter_ = info->GetWebContentsGetterForRequest();
 
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&LoginHandler::AddObservers, this));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::BindOnce(&LoginHandler::AddObservers, this));
 }
 
 void LoginHandler::OnRequestCancelled() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)) <<
       "Why is OnRequestCancelled called from the UI thread?";
 
   // Reference is no longer valid.
   request_ = NULL;
 
   // Give up on auth if the request was cancelled. Since the dialog was canceled
@@ skipping 67 matching lines @@
   // Calling NotifyAuthSupplied() directly instead of posting a task
   // allows other LoginHandler instances to queue their
   // CloseContentsDeferred() before ours.  Closing dialogs in the
   // opposite order as they were created avoids races where remaining
   // dialogs in the same tab may be briefly displayed to the user
   // before they are removed.
   NotifyAuthSupplied(username, password);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&LoginHandler::CloseContentsDeferred, this));
+      base::BindOnce(&LoginHandler::CloseContentsDeferred, this));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&LoginHandler::SetAuthDeferred, this, username, password));
+      base::BindOnce(&LoginHandler::SetAuthDeferred, this, username, password));
 }
 
 void LoginHandler::CancelAuth() {
   // Cancel the auth without canceling the navigation, so that the auth error
   // page commits.
   DoCancelAuth(false);
 }
 
 void LoginHandler::Observe(int type,
                            const content::NotificationSource& source,
@@ skipping 77 matching lines @@
 
   service->Notify(chrome::NOTIFICATION_AUTH_NEEDED,
                   content::Source<NavigationController>(controller),
                   content::Details<LoginNotificationDetails>(&details));
 }
 
 void LoginHandler::ReleaseSoon() {
   if (!TestAndSetAuthHandled()) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&LoginHandler::CancelAuthDeferred, this));
+        base::BindOnce(&LoginHandler::CancelAuthDeferred, this));
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&LoginHandler::NotifyAuthCancelled, this, false));
+        base::BindOnce(&LoginHandler::NotifyAuthCancelled, this, false));
   }
 
-  BrowserThread::PostTask(
-    BrowserThread::UI, FROM_HERE,
-    base::Bind(&LoginHandler::RemoveObservers, this));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::BindOnce(&LoginHandler::RemoveObservers, this));
 
   // Delete this object once all InvokeLaters have been called.
   BrowserThread::ReleaseSoon(BrowserThread::IO, FROM_HERE, this);
 }
 
 void LoginHandler::AddObservers() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // This is probably OK; we need to listen to everything and we break out of
   // the Observe() if we aren't handling the same auth_info().
@@ skipping 79 matching lines @@
 
 void LoginHandler::DoCancelAuth(bool dismiss_navigation) {
   if (TestAndSetAuthHandled())
     return;
 
   // Similar to how we deal with notifications above in SetAuth().
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     NotifyAuthCancelled(dismiss_navigation);
   } else {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                            base::Bind(&LoginHandler::NotifyAuthCancelled, this,
-                                       dismiss_navigation));
+                            base::BindOnce(&LoginHandler::NotifyAuthCancelled,
+                                           this, dismiss_navigation));
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&LoginHandler::CloseContentsDeferred, this));
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&LoginHandler::CancelAuthDeferred, this));
+      base::BindOnce(&LoginHandler::CloseContentsDeferred, this));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&LoginHandler::CancelAuthDeferred, this));
 }
 
 // Calls CancelAuth from the IO loop.
 void LoginHandler::CancelAuthDeferred() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (request_) {
     request_->CancelAuth();
     // Verify that CancelAuth doesn't destroy the request via our delegate.
     DCHECK(request_ != NULL);
@@ skipping 215 matching lines @@
 // ----------------------------------------------------------------------------
 // Public API
 
 LoginHandler* CreateLoginPrompt(net::AuthChallengeInfo* auth_info,
                                 net::URLRequest* request) {
   bool is_main_frame =
       (request->load_flags() & net::LOAD_MAIN_FRAME_DEPRECATED) != 0;
   LoginHandler* handler = LoginHandler::Create(auth_info, request);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&LoginHandler::LoginDialogCallback, request->url(),
-                 base::RetainedRef(auth_info), base::RetainedRef(handler),
-                 is_main_frame));
+      base::BindOnce(&LoginHandler::LoginDialogCallback, request->url(),
+                     base::RetainedRef(auth_info), base::RetainedRef(handler),
+                     is_main_frame));
   return handler;
 }