Notify all active login prompts when one login prompt is submitted. This allo...

chrome/browser/login_prompt.cc

 // Copyright (c) 2009 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/login_prompt.h"
 
 #include <vector>
 
 #include "app/l10n_util.h"
 #include "base/command_line.h"
@@ skipping 49 matching lines @@
     signon_realm = url.GetOrigin().spec();
     // This ends with a "/".
   }
   signon_realm.append(WideToUTF8(auth_info.realm));
   return signon_realm;
 }
 
 // ----------------------------------------------------------------------------
 // LoginHandler
 
-LoginHandler::LoginHandler(URLRequest* request)
+LoginHandler::LoginHandler(net::AuthChallengeInfo* auth_info,
+                           URLRequest* request)
     : handled_auth_(false),
       dialog_(NULL),
+      auth_info_(auth_info),
       request_(request),
       password_manager_(NULL),
       login_model_(NULL) {
   // This constructor is called on the I/O thread, so we cannot load the nib
   // here. BuildViewForPasswordManager() will be invoked on the UI thread
   // later, so wait with loading the nib until then.
-  DCHECK(request_) << "LoginHandlerMac constructed with NULL request";
+  DCHECK(request_) << "LoginHandler constructed with NULL request";
+  DCHECK(auth_info_) << "LoginHandler constructed with NULL auth info";
 
   AddRef();  // matched by ReleaseSoon::ReleaseSoon().
+
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
+      NewRunnableMethod(this, &LoginHandler::AddObservers));
+
   if (!ResourceDispatcherHost::RenderViewForRequest(
           request_, &render_process_host_id_,  &tab_contents_id_)) {
     NOTREACHED();
   }
 }
 
 LoginHandler::~LoginHandler() {
   SetModel(NULL);
 }
 
@@ skipping 22 matching lines @@
     password_form_.username_value = WideToUTF16Hack(username);
     password_form_.password_value = WideToUTF16Hack(password);
     password_manager_->ProvisionallySavePassword(password_form_);
   }
 
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(this, &LoginHandler::CloseContentsDeferred));
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
-      NewRunnableMethod(this, &LoginHandler::SendNotifications));
+      NewRunnableMethod(
+          this, &LoginHandler::NotifyAuthSupplied, username, password));
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
-      NewRunnableMethod(this, &LoginHandler::SetAuthDeferred,
-                        username, password));
+      NewRunnableMethod(
+          this, &LoginHandler::SetAuthDeferred, username, password));
 }
 
 void LoginHandler::CancelAuth() {
   if (WasAuthHandled(true))
     return;
 
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(this, &LoginHandler::CloseContentsDeferred));
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
-      NewRunnableMethod(this, &LoginHandler::SendNotifications));
+      NewRunnableMethod(this, &LoginHandler::NotifyAuthCancelled));
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       NewRunnableMethod(this, &LoginHandler::CancelAuthDeferred));
 }
 
 void LoginHandler::OnRequestCancelled() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::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.
   CancelAuth();
 }
 
+void LoginHandler::AddObservers() {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+
+  registrar_.Add(this, NotificationType::AUTH_SUPPLIED,
+                 NotificationService::AllSources());
+  registrar_.Add(this, NotificationType::AUTH_CANCELLED,
+                 NotificationService::AllSources());
+}
+
+void LoginHandler::RemoveObservers() {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+
+  registrar_.Remove(this, NotificationType::AUTH_SUPPLIED,
+                    NotificationService::AllSources());
+  registrar_.Remove(this, NotificationType::AUTH_CANCELLED,
+                    NotificationService::AllSources());
+
+  DCHECK(registrar_.IsEmpty());
+}
+
+void LoginHandler::Observe(NotificationType type,
+                           const NotificationSource& source,
+                           const NotificationDetails& details) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  DCHECK(type == NotificationType::AUTH_SUPPLIED ||
+         type == NotificationType::AUTH_CANCELLED);
+
+  TabContents* requesting_contents = GetTabContentsForLogin();
+  if (!requesting_contents)
+    return;
+
+  NavigationController* this_controller = &requesting_contents->controller();
+  NavigationController* that_controller =
+      Source<NavigationController>(source).ptr();
+
+  // Only handle notifications from other handlers.
+  if (this_controller == that_controller)
+    return;
+
+  LoginNotificationDetails* login_details =
+      Details<LoginNotificationDetails>(details).ptr();
+
+  // Only handle notification for the identical auth info.
+  if (*login_details->handler()->auth_info() != *auth_info())
+    return;
+
+  // Set or cancel the auth in this handler.
+  if (type == NotificationType::AUTH_SUPPLIED) {
+    AuthSuppliedLoginNotificationDetails* supplied_details =
+        Details<AuthSuppliedLoginNotificationDetails>(details).ptr();
+    SetAuth(supplied_details->username(), supplied_details->password());
+  } else {
+    DCHECK(type == NotificationType::AUTH_CANCELLED);
+    CancelAuth();
+  }
+}
+
 void LoginHandler::SetModel(LoginModel* model) {
   if (login_model_)
     login_model_->SetObserver(NULL);
   login_model_ = model;
   if (login_model_)
     login_model_->SetObserver(this);
 }
 
 void LoginHandler::SetDialog(ConstrainedWindow* dialog) {
   dialog_ = dialog;
 }
 
-// Notify observers that authentication is needed or received.  The automation
-// proxy uses this for testing.
-void LoginHandler::SendNotifications() {
+void LoginHandler::NotifyAuthNeeded() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  if (WasAuthHandled(false))
+    return;
 
-  NotificationService* service = NotificationService::current();
   TabContents* requesting_contents = GetTabContentsForLogin();
   if (!requesting_contents)
     return;
 
+  NotificationService* service = NotificationService::current();
   NavigationController* controller = &requesting_contents->controller();
+  LoginNotificationDetails details(this);
 
-  if (!WasAuthHandled(false)) {
-    LoginNotificationDetails details(this);
-    service->Notify(NotificationType::AUTH_NEEDED,
-                    Source<NavigationController>(controller),
-                    Details<LoginNotificationDetails>(&details));
-  } else {
-    service->Notify(NotificationType::AUTH_SUPPLIED,
-                    Source<NavigationController>(controller),
-                    NotificationService::NoDetails());
-  }
+  service->Notify(NotificationType::AUTH_NEEDED,
+                  Source<NavigationController>(controller),
+                  Details<LoginNotificationDetails>(&details));
+}
+
+void LoginHandler::NotifyAuthCancelled() {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  DCHECK(WasAuthHandled(false));
+
+  TabContents* requesting_contents = GetTabContentsForLogin();
+  if (!requesting_contents)
+    return;
+
+  NotificationService* service = NotificationService::current();
+  NavigationController* controller = &requesting_contents->controller();
+  LoginNotificationDetails details(this);
+
+  service->Notify(NotificationType::AUTH_CANCELLED,
+                  Source<NavigationController>(controller),
+                  Details<LoginNotificationDetails>(&details));
+}
+
+void LoginHandler::NotifyAuthSupplied(const std::wstring& username,
+                                      const std::wstring& password) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  DCHECK(WasAuthHandled(false));
+
+  TabContents* requesting_contents = GetTabContentsForLogin();
+  if (!requesting_contents)
+    return;
+
+  NotificationService* service = NotificationService::current();
+  NavigationController* controller = &requesting_contents->controller();
+  AuthSuppliedLoginNotificationDetails details(this, username, password);
+
+  service->Notify(NotificationType::AUTH_SUPPLIED,
+                  Source<NavigationController>(controller),
+                  Details<AuthSuppliedLoginNotificationDetails>(&details));
 }
 
 void LoginHandler::ReleaseSoon() {
   if (!WasAuthHandled(true)) {
     ChromeThread::PostTask(
         ChromeThread::IO, FROM_HERE,
         NewRunnableMethod(this, &LoginHandler::CancelAuthDeferred));
     ChromeThread::PostTask(
         ChromeThread::UI, FROM_HERE,
-        NewRunnableMethod(this, &LoginHandler::SendNotifications));
+        NewRunnableMethod(this, &LoginHandler::NotifyAuthCancelled));
   }
 
+  ChromeThread::PostTask(
+    ChromeThread::UI, FROM_HERE,
+    NewRunnableMethod(this, &LoginHandler::RemoveObservers));
+
   // Delete this object once all InvokeLaters have been called.
   ChromeThread::ReleaseSoon(ChromeThread::IO, FROM_HERE, this);
 }
 
 // Returns whether authentication had been handled (SetAuth or CancelAuth).
 // If |set_handled| is true, it will mark authentication as handled.
 bool LoginHandler::WasAuthHandled(bool set_handled) {
   AutoLock lock(handled_auth_lock_);
   bool was_handled = handled_auth_;
   if (set_handled)
@@ skipping 11 matching lines @@
     ResetLoginHandlerForRequest(request_);
   }
 }
 
 // Calls CancelAuth from the IO loop.
 void LoginHandler::CancelAuthDeferred() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   if (request_) {
     request_->CancelAuth();
-    // Verify that CancelAuth does destroy the request via our delegate.
+    // Verify that CancelAuth doesn't destroy the request via our delegate.
     DCHECK(request_ != NULL);
     ResetLoginHandlerForRequest(request_);
   }
 }
 
 // Closes the view_contents from the UI loop.
 void LoginHandler::CloseContentsDeferred() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   // The hosting ConstrainedWindow may have been freed.
@@ skipping 51 matching lines @@
     if (LowerCaseEqualsASCII(auth_info_->scheme, "basic")) {
       dialog_form.scheme = PasswordForm::SCHEME_BASIC;
     } else if (LowerCaseEqualsASCII(auth_info_->scheme, "digest")) {
       dialog_form.scheme = PasswordForm::SCHEME_DIGEST;
     } else {
       dialog_form.scheme = PasswordForm::SCHEME_OTHER;
     }
     std::string host_and_port(WideToASCII(auth_info_->host_and_port));
     if (net::GetHostAndPort(request_url_) != host_and_port) {
       dialog_form.origin = GURL();
-      NOTREACHED();
+      NOTREACHED();  // crbug.com/32718
     } else if (auth_info_->is_proxy) {
       std::string origin = host_and_port;
       // We don't expect this to already start with http:// or https://.
       DCHECK(origin.find("http://") != 0 && origin.find("https://") != 0);
       origin = std::string("http://") + origin;
       dialog_form.origin = GURL(origin);
     } else {
       dialog_form.origin = GURL(request_url_.scheme() + "://" + host_and_port);
     }
     dialog_form.signon_realm = GetSignonRealm(dialog_form.origin, *auth_info_);
     password_manager_input->push_back(dialog_form);
     // Set the password form for the handler (by copy).
     handler_->SetPasswordForm(dialog_form);
   }
 
   // The url from the URLRequest initiating the auth challenge.
   GURL request_url_;
 
   // Info about who/where/what is asking for authentication.
   scoped_refptr<net::AuthChallengeInfo> auth_info_;
 
   // Where to send the authentication when obtained.
   // This is owned by the ResourceDispatcherHost that invoked us.
   LoginHandler* handler_;
 
-  DISALLOW_EVIL_CONSTRUCTORS(LoginDialogTask);
+  DISALLOW_COPY_AND_ASSIGN(LoginDialogTask);
 };
 
 // ----------------------------------------------------------------------------
 // Public API
 
 LoginHandler* CreateLoginPrompt(net::AuthChallengeInfo* auth_info,
                                 URLRequest* request) {
-  LoginHandler* handler = LoginHandler::Create(request);
+  LoginHandler* handler = LoginHandler::Create(auth_info, request);
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE, new LoginDialogTask(
           request->url(), auth_info, handler));
   return handler;
 }