Factoring duplicate code from platform-specific LoginHandlers into a base ...

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"
 #include "base/lock.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/password_manager/password_manager.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "chrome/browser/tab_contents/constrained_window.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
+#include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/notification_service.h"
 #include "grit/generated_resources.h"
 #include "net/base/auth.h"
 #include "net/base/net_util.h"
 #include "net/url_request/url_request.h"
 
 using webkit_glue::PasswordForm;
 
 class LoginHandlerImpl;
 
 // Helper to remove the ref from an URLRequest to the LoginHandler.
@@ skipping 25 matching lines @@
   } else {
     // Take scheme, host, and port from the url.
     signon_realm = url.GetOrigin().spec();
     // This ends with a "/".
   }
   signon_realm.append(WideToUTF8(auth_info.realm));
   return signon_realm;
 }
 
 // ----------------------------------------------------------------------------
+// LoginHandler
+
+LoginHandler::LoginHandler(URLRequest* request)
+    : handled_auth_(false),
+      dialog_(NULL),
+      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";
+
+  AddRef();  // matched by ReleaseSoon::ReleaseSoon().
+  if (!ResourceDispatcherHost::RenderViewForRequest(
+          request_, &render_process_host_id_,  &tab_contents_id_)) {
+    NOTREACHED();
+  }
+}
+
+LoginHandler::~LoginHandler() {
+  SetModel(NULL);
+}
+
+void LoginHandler::SetPasswordForm(const webkit_glue::PasswordForm& form) {
+  password_form_ = form;
+}
+
+void LoginHandler::SetPasswordManager(PasswordManager* password_manager) {
+  password_manager_ = password_manager;
+}
+
+TabContents* LoginHandler::GetTabContentsForLogin() const {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+
+  return tab_util::GetTabContentsByID(render_process_host_id_,
+                                      tab_contents_id_);
+}
+
+void LoginHandler::SetAuth(const std::wstring& username,
+                           const std::wstring& password) {
+  if (WasAuthHandled(true))
+    return;
+
+  // Tell the password manager the credentials were submitted / accepted.
+  if (password_manager_) {
+    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));
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      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));
+  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::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() {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+
+  NotificationService* service = NotificationService::current();
+  TabContents* requesting_contents = GetTabContentsForLogin();
+  if (!requesting_contents)
+    return;
+
+  NavigationController* controller = &requesting_contents->controller();
+
+  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());
+  }
+}
+
+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));
+  }
+
+  // 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)
+    handled_auth_ = true;
+  return was_handled;
+}
+
+// Calls SetAuth from the IO loop.
+void LoginHandler::SetAuthDeferred(const std::wstring& username,
+                                   const std::wstring& password) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
+
+  if (request_) {
+    request_->SetAuth(username, password);
+    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.
+    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.
+  if (dialog_)
+    dialog_->CloseConstrainedWindow();
+}
+
+// ----------------------------------------------------------------------------
 // LoginDialogTask
 
 // This task is run on the UI thread and creates a constrained window with
 // a LoginView to prompt the user.  The response will be sent to LoginHandler,
 // which then routes it to the URLRequest on the I/O thread.
 class LoginDialogTask : public Task {
  public:
   LoginDialogTask(const GURL& request_url,
                   net::AuthChallengeInfo* auth_info,
                   LoginHandler* handler)
@@ skipping 76 matching lines @@
 // Public API
 
 LoginHandler* CreateLoginPrompt(net::AuthChallengeInfo* auth_info,
                                 URLRequest* request) {
   LoginHandler* handler = LoginHandler::Create(request);
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE, new LoginDialogTask(
           request->url(), auth_info, handler));
   return handler;
 }