Introduce PasswordsModelDelegate as an abstraction between ManagePasswordsBubbleModel and ManagePas…

chrome/browser/ui/passwords/manage_passwords_bubble_model.cc

 // Copyright 2013 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/passwords/manage_passwords_bubble_model.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
-#include "chrome/browser/ui/passwords/manage_passwords_ui_controller.h"
 #include "chrome/browser/ui/passwords/manage_passwords_view_utils.h"
+#include "chrome/browser/ui/passwords/passwords_model_delegate.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
 #include "components/password_manager/core/browser/password_bubble_experiment.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/password_manager/core/common/credential_manager_types.h"
 #include "components/password_manager/core/common/password_manager_ui.h"
+#include "content/public/browser/web_contents.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace metrics_util = password_manager::metrics_util;
 
 namespace {
 
 Profile* GetProfileFromWebContents(content::WebContents* web_contents) {
   if (!web_contents)
     return nullptr;
   return Profile::FromBrowserContext(web_contents->GetBrowserContext());
@@ skipping 31 matching lines @@
 
 }  // namespace
 
 ManagePasswordsBubbleModel::ManagePasswordsBubbleModel(
     content::WebContents* web_contents,
     DisplayReason display_reason)
     : content::WebContentsObserver(web_contents),
       display_disposition_(metrics_util::AUTOMATIC_WITH_PASSWORD_PENDING),
       dismissal_reason_(metrics_util::NO_DIRECT_INTERACTION),
       update_password_submission_event_(metrics_util::NO_UPDATE_SUBMISSION) {
-  ManagePasswordsUIController* controller =
-      ManagePasswordsUIController::FromWebContents(web_contents);
+  PasswordsModelDelegate* delegate =
+      PasswordsModelDelegateFromWebContents(web_contents);
 
-  origin_ = controller->origin();
-  state_ = controller->state();
-  password_overridden_ = controller->PasswordOverridden();
+  origin_ = delegate->GetOrigin();
+  state_ = delegate->GetState();
+  password_overridden_ = delegate->IsPasswordOverridden();
   if (state_ == password_manager::ui::PENDING_PASSWORD_STATE ||
       state_ == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE) {
-    pending_password_ = controller->PendingPassword();
-    local_credentials_ = DeepCopyForms(controller->GetCurrentForms());
+    pending_password_ = delegate->GetPendingPassword();
+    local_credentials_ = DeepCopyForms(delegate->GetCurrentForms());
   } else if (state_ == password_manager::ui::CONFIRMATION_STATE) {
     // We don't need anything.
   } else if (state_ == password_manager::ui::CREDENTIAL_REQUEST_STATE) {
-    local_credentials_ = DeepCopyForms(controller->GetCurrentForms());
-    federated_credentials_ = DeepCopyForms(controller->GetFederatedForms());
+    local_credentials_ = DeepCopyForms(delegate->GetCurrentForms());
+    federated_credentials_ = DeepCopyForms(delegate->GetFederatedForms());
   } else if (state_ == password_manager::ui::AUTO_SIGNIN_STATE) {
-    pending_password_ = controller->PendingPassword();
+    pending_password_ = delegate->GetPendingPassword();
   } else {
-    local_credentials_ = DeepCopyForms(controller->GetCurrentForms());
+    local_credentials_ = DeepCopyForms(delegate->GetCurrentForms());
   }
 
   if (state_ == password_manager::ui::PENDING_PASSWORD_STATE ||
       state_ == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE) {
     UpdatePendingStateTitle();
   } else if (state_ == password_manager::ui::CONFIRMATION_STATE) {
     title_ =
         l10n_util::GetStringUTF16(IDS_MANAGE_PASSWORDS_CONFIRM_GENERATED_TITLE);
   } else if (state_ == password_manager::ui::CREDENTIAL_REQUEST_STATE) {
     GetAccountChooserDialogTitleTextAndLinkRange(
@@ skipping 30 matching lines @@
     GetAutoSigninPromptFirstRunExperienceExplanation(
         GetSmartLockBrandingState(GetProfile()) ==
         password_bubble_experiment::SmartLockBranding::FULL,
         &autosignin_welcome_text_,
         &autosignin_welcome_link_range_);
   } else if (state_ == password_manager::ui::PENDING_PASSWORD_STATE) {
     interaction_stats_.origin_domain = origin_.GetOrigin();
     interaction_stats_.username_value = pending_password_.username_value;
     interaction_stats_.update_time = base::Time::Now();
     password_manager::InteractionsStats* stats =
-        controller->GetCurrentInteractionStats();
+        delegate->GetCurrentInteractionStats();
     if (stats) {
       // TODO(vasilii): DCHECK that username and origin are the same.
       interaction_stats_.dismissal_count = stats->dismissal_count;
     }
   }
 
   manage_link_ =
       l10n_util::GetStringUTF16(IDS_OPTIONS_PASSWORDS_MANAGE_PASSWORDS_LINK);
 
   if (display_reason == USER_ACTION) {
@@ skipping 35 matching lines @@
         display_disposition_ = metrics_util::AUTOMATIC_SIGNIN_TOAST;
         break;
       case password_manager::ui::MANAGE_STATE:
       case password_manager::ui::INACTIVE_STATE:
         NOTREACHED();
         break;
     }
   }
   metrics_util::LogUIDisplayDisposition(display_disposition_);
 
-  controller->OnBubbleShown();
+  delegate->OnBubbleShown();
 }
 
 ManagePasswordsBubbleModel::~ManagePasswordsBubbleModel() {
   if (state_ == password_manager::ui::PENDING_PASSWORD_STATE) {
     Profile* profile = GetProfile();
     if (profile) {
       if (GetSmartLockBrandingState(profile) ==
           password_bubble_experiment::SmartLockBranding::FULL) {
         password_bubble_experiment::RecordSavePromptFirstRunExperienceWasShown(
             profile->GetPrefs());
       }
       if (dismissal_reason_ == metrics_util::NO_DIRECT_INTERACTION &&
           display_disposition_ ==
               metrics_util::AUTOMATIC_WITH_PASSWORD_PENDING) {
         if (interaction_stats_.dismissal_count <
             std::numeric_limits<decltype(
                 interaction_stats_.dismissal_count)>::max())
           interaction_stats_.dismissal_count++;
         password_manager::PasswordStore* password_store =
             PasswordStoreFactory::GetForProfile(
                 profile, ServiceAccessType::EXPLICIT_ACCESS)
                 .get();
         password_store->AddSiteStats(interaction_stats_);
       }
     }
   }
-  ManagePasswordsUIController* manage_passwords_ui_controller =
-      web_contents() ?
-          ManagePasswordsUIController::FromWebContents(web_contents())
-          : nullptr;
-  if (manage_passwords_ui_controller)
-    manage_passwords_ui_controller->OnBubbleHidden();
+  PasswordsModelDelegate* delegate =
+      web_contents() ? PasswordsModelDelegateFromWebContents(web_contents())
+                     : nullptr;
+  if (delegate)
+    delegate->OnBubbleHidden();
   if (dismissal_reason_ == metrics_util::NOT_DISPLAYED)
     return;
 
   if (state_ != password_manager::ui::PENDING_PASSWORD_UPDATE_STATE) {
     // We have separate metrics for the Update bubble so do not record dismissal
     // reason for it.
     metrics_util::LogUIDismissalReason(dismissal_reason_);
   }
   // Check if this was update password and record update statistics.
   if (update_password_submission_event_ == metrics_util::NO_UPDATE_SUBMISSION &&
       (state_ == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE ||
        state_ == password_manager::ui::PENDING_PASSWORD_STATE)) {
     update_password_submission_event_ =
         GetUpdateDismissalReason(NO_INTERACTION);
     if (state_ == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE &&
-        manage_passwords_ui_controller)
-      manage_passwords_ui_controller->OnNoInteractionOnUpdate();
+        delegate)
+      delegate->OnNoInteractionOnUpdate();
   }
   if (update_password_submission_event_ != metrics_util::NO_UPDATE_SUBMISSION)
     LogUpdatePasswordSubmissionEvent(update_password_submission_event_);
 }
 
 void ManagePasswordsBubbleModel::OnCancelClicked() {
   DCHECK_EQ(password_manager::ui::CREDENTIAL_REQUEST_STATE, state_);
   dismissal_reason_ = metrics_util::CLICKED_CANCEL;
 }
 
 void ManagePasswordsBubbleModel::OnNeverForThisSiteClicked() {
   DCHECK_EQ(password_manager::ui::PENDING_PASSWORD_STATE, state_);
   dismissal_reason_ = metrics_util::CLICKED_NEVER;
   update_password_submission_event_ = GetUpdateDismissalReason(NOPE_CLICKED);
   CleanStatisticsForSite(web_contents(), origin_);
-  ManagePasswordsUIController* manage_passwords_ui_controller =
-      ManagePasswordsUIController::FromWebContents(web_contents());
-  manage_passwords_ui_controller->NeverSavePassword();
+  PasswordsModelDelegateFromWebContents(web_contents())->NeverSavePassword();
 }
 
 void ManagePasswordsBubbleModel::OnSaveClicked() {
   DCHECK_EQ(password_manager::ui::PENDING_PASSWORD_STATE, state_);
   dismissal_reason_ = metrics_util::CLICKED_SAVE;
   update_password_submission_event_ = GetUpdateDismissalReason(UPDATE_CLICKED);
   CleanStatisticsForSite(web_contents(), origin_);
-  ManagePasswordsUIController* manage_passwords_ui_controller =
-      ManagePasswordsUIController::FromWebContents(web_contents());
-  manage_passwords_ui_controller->SavePassword();
+  PasswordsModelDelegateFromWebContents(web_contents())->SavePassword();
 }
 
 void ManagePasswordsBubbleModel::OnNopeUpdateClicked() {
   update_password_submission_event_ = GetUpdateDismissalReason(NOPE_CLICKED);
-  ManagePasswordsUIController* manage_passwords_ui_controller =
-      ManagePasswordsUIController::FromWebContents(web_contents());
-  manage_passwords_ui_controller->OnNopeUpdateClicked();
+  PasswordsModelDelegateFromWebContents(web_contents())->OnNopeUpdateClicked();
 }
 
 void ManagePasswordsBubbleModel::OnUpdateClicked(
     const autofill::PasswordForm& password_form) {
   update_password_submission_event_ = GetUpdateDismissalReason(UPDATE_CLICKED);
-  ManagePasswordsUIController* manage_passwords_ui_controller =
-      ManagePasswordsUIController::FromWebContents(web_contents());
-  manage_passwords_ui_controller->UpdatePassword(password_form);
+  PasswordsModelDelegateFromWebContents(web_contents())->UpdatePassword(
+      password_form);
 }
 
 void ManagePasswordsBubbleModel::OnDoneClicked() {
   dismissal_reason_ = metrics_util::CLICKED_DONE;
 }
 
 // TODO(gcasto): Is it worth having this be separate from OnDoneClicked()?
 // User intent is pretty similar in both cases.
 void ManagePasswordsBubbleModel::OnOKClicked() {
   dismissal_reason_ = metrics_util::CLICKED_OK;
 }
 
 void ManagePasswordsBubbleModel::OnManageLinkClicked() {
   dismissal_reason_ = metrics_util::CLICKED_MANAGE;
   if (GetSmartLockBrandingState(GetProfile()) ==
       password_bubble_experiment::SmartLockBranding::FULL) {
-    ManagePasswordsUIController::FromWebContents(web_contents())
+    PasswordsModelDelegateFromWebContents(web_contents())
         ->NavigateToExternalPasswordManager();
   } else {
-    ManagePasswordsUIController::FromWebContents(web_contents())
+    PasswordsModelDelegateFromWebContents(web_contents())
         ->NavigateToPasswordManagerSettingsPage();
   }
 }
 
 void ManagePasswordsBubbleModel::OnBrandLinkClicked() {
   dismissal_reason_ = metrics_util::CLICKED_BRAND_NAME;
   switch (GetSmartLockBrandingState(GetProfile())) {
     case password_bubble_experiment::SmartLockBranding::FULL:
-      ManagePasswordsUIController::FromWebContents(web_contents())
+      PasswordsModelDelegateFromWebContents(web_contents())
           ->NavigateToSmartLockPage();
       break;
     case password_bubble_experiment::SmartLockBranding::SAVE_BUBBLE_ONLY:
-      ManagePasswordsUIController::FromWebContents(web_contents())
+      PasswordsModelDelegateFromWebContents(web_contents())
           ->NavigateToSmartLockHelpPage();
       break;
     case password_bubble_experiment::SmartLockBranding::NONE:
       NOTREACHED();
       break;
   }
 }
 
 void ManagePasswordsBubbleModel::OnAutoSignInToastTimeout() {
   DCHECK_EQ(password_manager::ui::AUTO_SIGNIN_STATE, state_);
@@ skipping 23 matching lines @@
   if (action == REMOVE_PASSWORD)
     password_store->RemoveLogin(password_form);
   else
     password_store->AddLogin(password_form);
 }
 
 void ManagePasswordsBubbleModel::OnChooseCredentials(
     const autofill::PasswordForm& password_form,
     password_manager::CredentialType credential_type) {
   dismissal_reason_ = metrics_util::CLICKED_CREDENTIAL;
-  ManagePasswordsUIController* manage_passwords_ui_controller =
-      ManagePasswordsUIController::FromWebContents(web_contents());
-  manage_passwords_ui_controller->ChooseCredential(password_form,
-                                                   credential_type);
+  PasswordsModelDelegateFromWebContents(web_contents())->ChooseCredential(
+      password_form, credential_type);
 }
 
 Profile* ManagePasswordsBubbleModel::GetProfile() const {
   return GetProfileFromWebContents(web_contents());
 }
 
 bool ManagePasswordsBubbleModel::ShouldShowMultipleAccountUpdateUI() const {
   return state_ == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE &&
          local_credentials_.size() > 1 && !password_overridden_;
 }
@@ skipping 50 matching lines @@
     return metrics_util::NO_UPDATE_SUBMISSION;
   }
   if (state_ != password_manager::ui::PENDING_PASSWORD_UPDATE_STATE)
     return metrics_util::NO_UPDATE_SUBMISSION;
   if (password_overridden_)
     return update_events[3][behavior];
   if (ShouldShowMultipleAccountUpdateUI())
     return update_events[2][behavior];
   return update_events[1][behavior];
 }