Expose PasswordManagerDriver as a public interface to core Password code.

chrome/browser/password_manager/password_manager.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/password_manager/password_manager.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "chrome/browser/password_manager/password_form_manager.h"
 #include "chrome/browser/password_manager/password_manager_delegate.h"
+#include "chrome/browser/password_manager/password_manager_driver.h"
 #include "chrome/browser/password_manager/password_manager_metrics_util.h"
 #include "chrome/browser/password_manager/password_manager_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/passwords/manage_passwords_bubble_ui_controller.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "components/autofill/content/common/autofill_messages.h"
 #include "components/autofill/core/common/password_autofill_util.h"
 #include "components/user_prefs/pref_registry_syncable.h"
@@ skipping 79 matching lines @@
     return;
   }
 
   contents->SetUserData(UserDataKey(),
                         new PasswordManager(contents, delegate));
 }
 
 PasswordManager::PasswordManager(WebContents* web_contents,
                                  PasswordManagerDelegate* delegate)
     : content::WebContentsObserver(web_contents),
-      delegate_(delegate) {
+      delegate_(delegate),
+      driver_(delegate->GetDriver()) {
   DCHECK(delegate_);
+  DCHECK(driver_);
   password_manager_enabled_.Init(prefs::kPasswordManagerEnabled,
                                  delegate_->GetProfile()->GetPrefs());
 
   ReportMetrics(*password_manager_enabled_);
 }
 
 PasswordManager::~PasswordManager() {
   FOR_EACH_OBSERVER(LoginModelObserver, observers_, OnLoginModelDestroying());
 }
 
 void PasswordManager::SetFormHasGeneratedPassword(const PasswordForm& form) {
   for (ScopedVector<PasswordFormManager>::iterator iter =
            pending_login_managers_.begin();
        iter != pending_login_managers_.end(); ++iter) {
     if ((*iter)->DoesManage(
         form, PasswordFormManager::ACTION_MATCH_REQUIRED)) {
       (*iter)->SetHasGeneratedPassword();
       return;
     }
   }
   // If there is no corresponding PasswordFormManager, we create one. This is
   // not the common case, and should only happen when there is a bug in our
   // ability to detect forms.
   bool ssl_valid = (form.origin.SchemeIsSecure() &&
-                    !delegate_->DidLastPageLoadEncounterSSLErrors());
+                    !driver_->DidLastPageLoadEncounterSSLErrors());
   PasswordFormManager* manager =
       new PasswordFormManager(delegate_->GetProfile(),
                               this,
                               web_contents(),
                               form,
                               ssl_valid);
   pending_login_managers_.push_back(manager);
   manager->SetHasGeneratedPassword();
   // TODO(gcasto): Add UMA stats to track this.
 }
@@ skipping 75 matching lines @@
   // autocomplete attribute if autocomplete='off' is not ignored.
   if (!autofill::ShouldIgnoreAutocompleteOffForPasswordFields() &&
       !manager->HasGeneratedPassword() &&
       !form.password_autocomplete_set) {
     RecordFailure(AUTOCOMPLETE_OFF, form.origin.host());
     return;
   }
 
   PasswordForm provisionally_saved_form(form);
   provisionally_saved_form.ssl_valid = form.origin.SchemeIsSecure() &&
-      !delegate_->DidLastPageLoadEncounterSSLErrors();
+      !driver_->DidLastPageLoadEncounterSSLErrors();
   provisionally_saved_form.preferred = true;
   PasswordFormManager::OtherPossibleUsernamesAction action =
       PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES;
   if (OtherPossibleUsernamesEnabled())
     action = PasswordFormManager::ALLOW_OTHER_POSSIBLE_USERNAMES;
   manager->ProvisionallySave(provisionally_saved_form, action);
   provisional_save_manager_.swap(manager);
 }
 
 void PasswordManager::RecordFailure(ProvisionalSaveFailure failure,
@@ skipping 54 matching lines @@
   for (size_t i = 0; i < submission_callbacks_.size(); ++i) {
     submission_callbacks_[i].Run(password_form);
   }
 
   pending_login_managers_.clear();
 }
 
 void PasswordManager::OnPasswordFormsParsed(
     const std::vector<PasswordForm>& forms) {
   // Ask the SSLManager for current security.
-  bool had_ssl_error = delegate_->DidLastPageLoadEncounterSSLErrors();
+  bool had_ssl_error = driver_->DidLastPageLoadEncounterSSLErrors();
 
   for (std::vector<PasswordForm>::const_iterator iter = forms.begin();
        iter != forms.end(); ++iter) {
     // Don't involve the password manager if this form corresponds to
     // SpdyProxy authentication, as indicated by the realm.
     if (EndsWith(iter->signon_realm, kSpdyProxyRealm, true))
       continue;
 
     bool ssl_valid = iter->origin.SchemeIsSecure() && !had_ssl_error;
     PasswordFormManager* manager =
@@ skipping 122 matching lines @@
     case PasswordForm::SCHEME_HTML: {
       // Note the check above is required because the observers_ for a non-HTML
       // schemed password form may have been freed, so we need to distinguish.
       autofill::PasswordFormFillData fill_data;
       InitPasswordFormFillData(form_for_autofill,
                                best_matches,
                                &preferred_match,
                                wait_for_username,
                                OtherPossibleUsernamesEnabled(),
                                &fill_data);
-      delegate_->FillPasswordForm(fill_data);
+      driver_->FillPasswordForm(fill_data);
       break;
     }
     default:
       FOR_EACH_OBSERVER(
           LoginModelObserver,
           observers_,
           OnAutofillDataAvailable(preferred_match.username_value,
                                   preferred_match.password_value));
       break;
   }
 
   ManagePasswordsBubbleUIController* manage_passwords_bubble_ui_controller =
       ManagePasswordsBubbleUIController::FromWebContents(web_contents());
   if (manage_passwords_bubble_ui_controller &&
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableSavePasswordBubble)) {
     manage_passwords_bubble_ui_controller->OnPasswordAutofilled(best_matches);
   }
 }