Refactor Autofill for out of process iframes (OOPIF).

components/password_manager/core/browser/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 "components/password_manager/core/browser/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"
@@ skipping 108 matching lines @@
 
 #if defined(OS_WIN)
 // static
 void PasswordManager::RegisterLocalPrefs(PrefRegistrySimple* registry) {
   registry->RegisterInt64Pref(prefs::kOsPasswordLastChanged, 0);
   registry->RegisterBooleanPref(prefs::kOsPasswordBlank, false);
 }
 #endif
 
 PasswordManager::PasswordManager(PasswordManagerClient* client)
-    : client_(client), driver_(client->GetDriver()) {
+    : client_(client) {
   DCHECK(client_);
-  DCHECK(driver_);
   saving_passwords_enabled_.Init(prefs::kPasswordManagerSavingEnabled,
                                  client_->GetPrefs());
 
   ReportMetrics(*saving_passwords_enabled_, client_);
 }
 
 PasswordManager::~PasswordManager() {
   FOR_EACH_OBSERVER(LoginModelObserver, observers_, OnLoginModelDestroying());
 }
 
-void PasswordManager::SetFormHasGeneratedPassword(const PasswordForm& form) {
+void PasswordManager::SetFormHasGeneratedPassword(
+    password_manager::PasswordManagerDriver* driver,
+    const PasswordForm& form) {
   DCHECK(IsSavingEnabledForCurrentPage());
 
   for (ScopedVector<PasswordFormManager>::iterator iter =
            pending_login_managers_.begin();
        iter != pending_login_managers_.end();
        ++iter) {
     if ((*iter)->DoesManage(form) ==
         PasswordFormManager::RESULT_COMPLETE_MATCH) {
       (*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();
   PasswordFormManager* manager =
-      new PasswordFormManager(this, client_, driver_, form, ssl_valid);
+      new PasswordFormManager(this, client_, driver, form, ssl_valid);
   pending_login_managers_.push_back(manager);
   manager->SetHasGeneratedPassword();
   // TODO(gcasto): Add UMA stats to track this.
 }
 
 bool PasswordManager::IsEnabledForCurrentPage() const {
-  bool ssl_errors = driver_->DidLastPageLoadEncounterSSLErrors();
+  bool ssl_errors = client_->DidLastPageLoadEncounterSSLErrors();
   bool client_check = client_->IsPasswordManagerEnabledForCurrentPage();
 
   scoped_ptr<BrowserSavePasswordProgressLogger> logger;
   if (client_->IsLoggingActive()) {
     logger.reset(new BrowserSavePasswordProgressLogger(client_));
     logger->LogMessage(Logger::STRING_ENABLED_FOR_CURRENT_PAGE_METHOD);
     logger->LogBoolean(Logger::STRING_SSL_ERRORS_PRESENT, ssl_errors);
     logger->LogBoolean(Logger::STRING_CLIENT_CHECK_PRESENT, client_check);
   }
 
   return !ssl_errors && client_check;
 }
 
 bool PasswordManager::IsSavingEnabledForCurrentPage() const {
-  return *saving_passwords_enabled_ && !driver_->IsOffTheRecord() &&
+  return *saving_passwords_enabled_ && !client_->IsOffTheRecord() &&
          IsEnabledForCurrentPage();
 }
 
 void PasswordManager::ProvisionallySavePassword(const PasswordForm& form) {
   bool is_saving_enabled = IsSavingEnabledForCurrentPage();
 
   scoped_ptr<BrowserSavePasswordProgressLogger> logger;
   if (client_->IsLoggingActive()) {
     logger.reset(new BrowserSavePasswordProgressLogger(client_));
     logger->LogMessage(Logger::STRING_PROVISIONALLY_SAVE_PASSWORD_METHOD);
     logger->LogPasswordForm(Logger::STRING_PROVISIONALLY_SAVE_PASSWORD_FORM,
                             form);
     logger->LogBoolean(Logger::STRING_IS_SAVING_ENABLED, is_saving_enabled);
     logger->LogBoolean(Logger::STRING_SSL_ERRORS_PRESENT,
-                       driver_->DidLastPageLoadEncounterSSLErrors());
+                       client_->DidLastPageLoadEncounterSSLErrors());
   }
 
   if (!is_saving_enabled) {
     RecordFailure(SAVING_DISABLED, form.origin.host(), logger.get());
     return;
   }
 
   // No password to save? Then don't.
   if ((form.new_password_element.empty() && form.password_value.empty()) ||
       (!form.new_password_element.empty() && form.new_password_value.empty())) {
@@ skipping 76 matching lines @@
   if (ShouldDropSyncCredential() &&
       client_->IsSyncAccountCredential(
           base::UTF16ToUTF8(form.username_value), form.signon_realm)) {
     RecordFailure(SYNC_CREDENTIAL, form.origin.host(), logger.get());
     return;
   }
 
   PasswordForm provisionally_saved_form(form);
   provisionally_saved_form.ssl_valid =
       form.origin.SchemeIsSecure() &&
-      !driver_->DidLastPageLoadEncounterSSLErrors();
+      !client_->DidLastPageLoadEncounterSSLErrors();
   provisionally_saved_form.preferred = true;
   if (logger) {
     logger->LogPasswordForm(Logger::STRING_PROVISIONALLY_SAVED_FORM,
                             provisionally_saved_form);
   }
   PasswordFormManager::OtherPossibleUsernamesAction action =
       PasswordFormManager::IGNORE_OTHER_POSSIBLE_USERNAMES;
   if (OtherPossibleUsernamesEnabled())
     action = PasswordFormManager::ALLOW_OTHER_POSSIBLE_USERNAMES;
   if (logger) {
@@ skipping 63 matching lines @@
   observers_.AddObserver(observer);
 }
 
 void PasswordManager::RemoveObserver(LoginModelObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void PasswordManager::DidNavigateMainFrame(bool is_in_page) {
   // Clear data after main frame navigation if the navigation was to a
   // different page.
-  if (!is_in_page) {
+  if (!is_in_page)
     pending_login_managers_.clear();
-    // There is no PasswordAutofillManager on iOS.
-    if (driver_->GetPasswordAutofillManager())
-      driver_->GetPasswordAutofillManager()->Reset();
-  }
 }
 
 void PasswordManager::OnPasswordFormSubmitted(
+    password_manager::PasswordManagerDriver* driver,
     const PasswordForm& password_form) {
   ProvisionallySavePassword(password_form);
   for (size_t i = 0; i < submission_callbacks_.size(); ++i) {
     submission_callbacks_[i].Run(password_form);
   }
 
   pending_login_managers_.clear();
 }
 
 void PasswordManager::OnPasswordFormsParsed(
+    password_manager::PasswordManagerDriver* driver,
     const std::vector<PasswordForm>& forms) {
-  CreatePendingLoginManagers(forms);
+  CreatePendingLoginManagers(driver, forms);
 }
 
 void PasswordManager::CreatePendingLoginManagers(
+    password_manager::PasswordManagerDriver* driver,
     const std::vector<PasswordForm>& forms) {
   scoped_ptr<BrowserSavePasswordProgressLogger> logger;
   if (client_->IsLoggingActive()) {
     logger.reset(new BrowserSavePasswordProgressLogger(client_));
     logger->LogMessage(Logger::STRING_CREATE_LOGIN_MANAGERS_METHOD);
   }
 
   if (!IsEnabledForCurrentPage())
     return;
 
@@ skipping 19 matching lines @@
          !old_manager_found && old_manager != old_login_managers.end();
          ++old_manager) {
       old_manager_found = (*old_manager)->DoesManage(*iter) ==
                           PasswordFormManager::RESULT_COMPLETE_MATCH;
     }
     if (old_manager_found)
       continue;  // The current form is already managed.
 
     bool ssl_valid = iter->origin.SchemeIsSecure();
     PasswordFormManager* manager =
-        new PasswordFormManager(this, client_, driver_, *iter, ssl_valid);
+        new PasswordFormManager(this, client_, driver, *iter, ssl_valid);
     pending_login_managers_.push_back(manager);
 
     PasswordStore::AuthorizationPromptPolicy prompt_policy =
         client_->GetAuthorizationPromptPolicy(*iter);
 
     manager->FetchMatchingLoginsFromPasswordStore(prompt_policy);
   }
 
   if (logger) {
     logger->LogNumber(Logger::STRING_NEW_NUMBER_LOGIN_MANAGERS,
                       pending_login_managers_.size());
   }
 }
 
 bool PasswordManager::ShouldPromptUserToSavePassword() const {
   return !client_->IsAutomaticPasswordSavingEnabled() &&
          provisional_save_manager_->IsNewLogin() &&
          !provisional_save_manager_->HasGeneratedPassword() &&
          !provisional_save_manager_->IsPendingCredentialsPublicSuffixMatch();
 }
 
 void PasswordManager::OnPasswordFormsRendered(
+    password_manager::PasswordManagerDriver* driver,
     const std::vector<PasswordForm>& visible_forms,
     bool did_stop_loading) {
-  CreatePendingLoginManagers(visible_forms);
+  CreatePendingLoginManagers(driver, visible_forms);
   scoped_ptr<BrowserSavePasswordProgressLogger> logger;
   if (client_->IsLoggingActive()) {
     logger.reset(new BrowserSavePasswordProgressLogger(client_));
     logger->LogMessage(Logger::STRING_ON_PASSWORD_FORMS_RENDERED_METHOD);
   }
 
   if (!provisional_save_manager_.get()) {
     if (logger) {
       logger->LogMessage(Logger::STRING_NO_PROVISIONAL_SAVE_MANAGER);
     }
@@ skipping 112 matching lines @@
   base::FieldTrial::Probability enabled_probability =
       client_->GetProbabilityForExperiment(kOtherPossibleUsernamesExperiment);
   trial->AppendGroup("Enabled", enabled_probability);
 }
 
 bool PasswordManager::OtherPossibleUsernamesEnabled() const {
   return base::FieldTrialList::FindFullName(
              kOtherPossibleUsernamesExperiment) == "Enabled";
 }
 
-void PasswordManager::Autofill(const PasswordForm& form_for_autofill,
+void PasswordManager::Autofill(password_manager::PasswordManagerDriver* driver,
+                               const PasswordForm& form_for_autofill,
                                const PasswordFormMap& best_matches,
                                const PasswordForm& preferred_match,
                                bool wait_for_username) const {
   PossiblyInitializeUsernamesExperiment(best_matches);
 
   scoped_ptr<BrowserSavePasswordProgressLogger> logger;
   if (client_->IsLoggingActive()) {
     logger.reset(new BrowserSavePasswordProgressLogger(client_));
     logger->LogMessage(Logger::STRING_PASSWORDMANAGER_AUTOFILL);
   }
   switch (form_for_autofill.scheme) {
     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);
       if (logger)
         logger->LogBoolean(Logger::STRING_WAIT_FOR_USERNAME, wait_for_username);
-      driver_->FillPasswordForm(fill_data);
+      driver->FillPasswordForm(fill_data);
       break;
     }
     default:
       if (logger) {
         logger->LogBoolean(Logger::STRING_LOGINMODELOBSERVER_PRESENT,
                            observers_.might_have_observers());
       }
       FOR_EACH_OBSERVER(
           LoginModelObserver,
           observers_,
           OnAutofillDataAvailable(preferred_match.username_value,
                                   preferred_match.password_value));
       break;
   }
 
   client_->PasswordWasAutofilled(best_matches);
 }
 
 }  // namespace password_manager