Ignore OnBubbleHidden() event when the password bubble is reopened.

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 <stddef.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 23 matching lines @@
 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());
 }
 
-void CleanStatisticsForSite(content::WebContents* web_contents,
-                            const GURL& origin) {
-  DCHECK(web_contents);
-  Profile* profile =
-      Profile::FromBrowserContext(web_contents->GetBrowserContext());
+void CleanStatisticsForSite(Profile* profile, const GURL& origin) {
+  DCHECK(profile);
   password_manager::PasswordStore* password_store =
       PasswordStoreFactory::GetForProfile(profile,
                                           ServiceAccessType::IMPLICIT_ACCESS)
           .get();
   password_store->RemoveSiteStats(origin.GetOrigin());
 }
 
 ScopedVector<const autofill::PasswordForm> DeepCopyForms(
     const std::vector<const autofill::PasswordForm*>& forms) {
   ScopedVector<const autofill::PasswordForm> result;
@@ skipping 107 matching lines @@
       }
     }
   }
 
   if (model->state() == password_manager::ui::CHROME_SIGN_IN_PROMO_STATE) {
     metrics_util::LogAutoSigninPromoUserAction(sign_in_promo_dismissal_reason_);
     if (sign_in_promo_dismissal_reason_ ==
             password_manager::metrics_util::CHROME_SIGNIN_OK ||
         sign_in_promo_dismissal_reason_ ==
             password_manager::metrics_util::CHROME_SIGNIN_CANCEL) {
-      DCHECK(model->web_contents());
+      DCHECK(model->delegate_);
       int show_count = model->GetProfile()->GetPrefs()->GetInteger(
           password_manager::prefs::kNumberSignInPasswordPromoShown);
       UMA_HISTOGRAM_COUNTS_100("PasswordManager.SignInPromoCountTilClick",
                                show_count);
     }
   } else if (model->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_);
   }
 
   if (model->state() == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE ||
       model->state() == password_manager::ui::PENDING_PASSWORD_STATE) {
     if (update_password_submission_event_ ==
         metrics_util::NO_UPDATE_SUBMISSION) {
       update_password_submission_event_ =
           model->GetUpdateDismissalReason(NO_INTERACTION);
-      PasswordsModelDelegate* delegate =
-          model->web_contents()
-              ? PasswordsModelDelegateFromWebContents(model->web_contents())
-              : nullptr;
-      if (delegate &&
+      if (model->delegate_ &&
           model->state() == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE)
-        delegate->OnNoInteractionOnUpdate();
+        model->delegate_->OnNoInteractionOnUpdate();
     }
 
     if (update_password_submission_event_ != metrics_util::NO_UPDATE_SUBMISSION)
       LogUpdatePasswordSubmissionEvent(update_password_submission_event_);
   }
 }
 
 ManagePasswordsBubbleModel::ManagePasswordsBubbleModel(
-    content::WebContents* web_contents,
+    base::WeakPtr<PasswordsModelDelegate> delegate,
     DisplayReason display_reason)
-    : content::WebContentsObserver(web_contents),
-      password_overridden_(false) {
-  PasswordsModelDelegate* delegate =
-      PasswordsModelDelegateFromWebContents(web_contents);
-
-  origin_ = delegate->GetOrigin();
-  state_ = delegate->GetState();
+    : password_overridden_(false),
+      delegate_(std::move(delegate)) {
+  origin_ = delegate_->GetOrigin();
+  state_ = delegate_->GetState();
   if (state_ == password_manager::ui::PENDING_PASSWORD_STATE ||
       state_ == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE) {
-    pending_password_ = delegate->GetPendingPassword();
-    local_credentials_ = DeepCopyForms(delegate->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::AUTO_SIGNIN_STATE) {
-    pending_password_ = delegate->GetPendingPassword();
+    pending_password_ = delegate_->GetPendingPassword();
   } else {
-    local_credentials_ = DeepCopyForms(delegate->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::AUTO_SIGNIN_STATE) {
     // There is no title.
@@ skipping 18 matching lines @@
     size_t offset;
     save_confirmation_text_ =
         l10n_util::GetStringFUTF16(
             confirmation_text_id, save_confirmation_link, &offset);
     save_confirmation_link_range_ =
         gfx::Range(offset, offset + save_confirmation_link.length());
   } else if (state_ == password_manager::ui::PENDING_PASSWORD_STATE) {
     interaction_stats.origin_domain = origin_.GetOrigin();
     interaction_stats.username_value = pending_password_.username_value;
     password_manager::InteractionsStats* stats =
-        delegate->GetCurrentInteractionStats();
+        delegate_->GetCurrentInteractionStats();
     if (stats) {
       DCHECK_EQ(interaction_stats.username_value, stats->username_value);
       DCHECK_EQ(interaction_stats.origin_domain, stats->origin_domain);
       interaction_stats.dismissal_count = stats->dismissal_count;
     }
   } else if (state_ == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE) {
-    password_overridden_ = delegate->IsPasswordOverridden();
+    password_overridden_ = delegate_->IsPasswordOverridden();
   }
 
   manage_link_ =
       l10n_util::GetStringUTF16(IDS_OPTIONS_PASSWORDS_MANAGE_PASSWORDS_LINK);
 
   password_manager::metrics_util::UIDisplayDisposition display_disposition =
       metrics_util::AUTOMATIC_WITH_PASSWORD_PENDING;
   if (display_reason == USER_ACTION) {
     switch (state_) {
       case password_manager::ui::PENDING_PASSWORD_STATE:
@@ skipping 35 matching lines @@
       case password_manager::ui::CHROME_SIGN_IN_PROMO_STATE:
       case password_manager::ui::INACTIVE_STATE:
         NOTREACHED();
         break;
     }
   }
   metrics_util::LogUIDisplayDisposition(display_disposition);
   interaction_keeper_.reset(new InteractionKeeper(std::move(interaction_stats),
                                                   display_disposition));
 
-  delegate->OnBubbleShown();
+  delegate_->OnBubbleShown();
 }
 
 ManagePasswordsBubbleModel::~ManagePasswordsBubbleModel() {
   interaction_keeper_->ReportInteractions(this);
-  // web_contents() is nullptr if the tab is closing.
-  PasswordsModelDelegate* delegate =
-      web_contents() ? PasswordsModelDelegateFromWebContents(web_contents())
-                     : nullptr;
-  if (delegate)
-    delegate->OnBubbleHidden();
+  if (delegate_)
+    delegate_->OnBubbleHidden();
 }
 
 void ManagePasswordsBubbleModel::OnNeverForThisSiteClicked() {
   DCHECK_EQ(password_manager::ui::PENDING_PASSWORD_STATE, state_);
   interaction_keeper_->set_dismissal_reason(metrics_util::CLICKED_NEVER);
   interaction_keeper_->set_update_password_submission_event(
       GetUpdateDismissalReason(NOPE_CLICKED));
-  CleanStatisticsForSite(web_contents(), origin_);
-  PasswordsModelDelegateFromWebContents(web_contents())->NeverSavePassword();
+  CleanStatisticsForSite(GetProfile(), origin_);
+  delegate_->NeverSavePassword();
 }
 
 void ManagePasswordsBubbleModel::OnSaveClicked() {
   DCHECK_EQ(password_manager::ui::PENDING_PASSWORD_STATE, state_);
   interaction_keeper_->set_dismissal_reason(metrics_util::CLICKED_SAVE);
   interaction_keeper_->set_update_password_submission_event(
       GetUpdateDismissalReason(UPDATE_CLICKED));
-  CleanStatisticsForSite(web_contents(), origin_);
-  PasswordsModelDelegateFromWebContents(web_contents())->SavePassword();
+  CleanStatisticsForSite(GetProfile(), origin_);
+  delegate_->SavePassword();
 }
 
 void ManagePasswordsBubbleModel::OnNopeUpdateClicked() {
   interaction_keeper_->set_update_password_submission_event(
       GetUpdateDismissalReason(NOPE_CLICKED));
-  PasswordsModelDelegateFromWebContents(web_contents())->OnNopeUpdateClicked();
+  delegate_->OnNopeUpdateClicked();
 }
 
 void ManagePasswordsBubbleModel::OnUpdateClicked(
     const autofill::PasswordForm& password_form) {
   interaction_keeper_->set_update_password_submission_event(
       GetUpdateDismissalReason(UPDATE_CLICKED));
-  PasswordsModelDelegateFromWebContents(web_contents())->UpdatePassword(
-      password_form);
+  delegate_->UpdatePassword(password_form);
 }
 
 void ManagePasswordsBubbleModel::OnDoneClicked() {
   interaction_keeper_->set_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() {
   interaction_keeper_->set_dismissal_reason(metrics_util::CLICKED_OK);
 }
 
 void ManagePasswordsBubbleModel::OnManageLinkClicked() {
   interaction_keeper_->set_dismissal_reason(metrics_util::CLICKED_MANAGE);
   if (GetSmartLockBrandingState(GetProfile()) ==
       password_bubble_experiment::SmartLockBranding::FULL) {
-    PasswordsModelDelegateFromWebContents(web_contents())
-        ->NavigateToExternalPasswordManager();
+    delegate_->NavigateToExternalPasswordManager();
   } else {
-    PasswordsModelDelegateFromWebContents(web_contents())
-        ->NavigateToPasswordManagerSettingsPage();
+    delegate_->NavigateToPasswordManagerSettingsPage();
   }
 }
 
 void ManagePasswordsBubbleModel::OnBrandLinkClicked() {
   interaction_keeper_->set_dismissal_reason(metrics_util::CLICKED_BRAND_NAME);
-  PasswordsModelDelegateFromWebContents(web_contents())
-      ->NavigateToSmartLockHelpPage();
+  delegate_->NavigateToSmartLockHelpPage();
 }
 
 void ManagePasswordsBubbleModel::OnAutoSignInToastTimeout() {
   interaction_keeper_->set_dismissal_reason(
       metrics_util::AUTO_SIGNIN_TOAST_TIMEOUT);
 }
 
 void ManagePasswordsBubbleModel::OnPasswordAction(
     const autofill::PasswordForm& password_form,
     PasswordAction action) {
   Profile* profile = GetProfile();
   if (!profile)
     return;
   password_manager::PasswordStore* password_store =
       PasswordStoreFactory::GetForProfile(
           profile, ServiceAccessType::EXPLICIT_ACCESS).get();
   DCHECK(password_store);
   if (action == REMOVE_PASSWORD)
     password_store->RemoveLogin(password_form);
   else
     password_store->AddLogin(password_form);
 }
 
 void ManagePasswordsBubbleModel::OnSignInToChromeClicked() {
   interaction_keeper_->set_sign_in_promo_dismissal_reason(
       metrics_util::CHROME_SIGNIN_OK);
   GetProfile()->GetPrefs()->SetBoolean(
       password_manager::prefs::kWasSignInPasswordPromoClicked, true);
-  PasswordsModelDelegateFromWebContents(web_contents())
-      ->NavigateToChromeSignIn();
+  delegate_->NavigateToChromeSignIn();
 }
 
 void ManagePasswordsBubbleModel::OnSkipSignInClicked() {
   interaction_keeper_->set_sign_in_promo_dismissal_reason(
       metrics_util::CHROME_SIGNIN_CANCEL);
   GetProfile()->GetPrefs()->SetBoolean(
       password_manager::prefs::kWasSignInPasswordPromoClicked, true);
 }
 
 Profile* ManagePasswordsBubbleModel::GetProfile() const {
-  return GetProfileFromWebContents(web_contents());
+  return GetProfileFromWebContents(GetWebContents());
+}
+
+content::WebContents* ManagePasswordsBubbleModel::GetWebContents() const {
+  return delegate_ ? delegate_->GetWebContents() : nullptr;
 }
 
 bool ManagePasswordsBubbleModel::ShouldShowMultipleAccountUpdateUI() const {
   return state_ == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE &&
          local_credentials_.size() > 1 && !password_overridden_;
 }
 
 bool ManagePasswordsBubbleModel::ShouldShowGoogleSmartLockWelcome() const {
   Profile* profile = GetProfile();
   if (GetSmartLockBrandingState(profile) ==
@@ skipping 32 matching lines @@
 
 void ManagePasswordsBubbleModel::UpdatePendingStateTitle() {
   title_brand_link_range_ = gfx::Range();
   PasswordTittleType type =
       state_ == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE
           ? PasswordTittleType::UPDATE_PASSWORD
           : (pending_password_.federation_origin.unique()
                  ? PasswordTittleType::SAVE_PASSWORD
                  : PasswordTittleType::SAVE_ACCOUNT);
   GetSavePasswordDialogTitleTextAndLinkRange(
-      web_contents()->GetVisibleURL(), origin_,
+      GetWebContents()->GetVisibleURL(), origin_,
       GetSmartLockBrandingState(GetProfile()) !=
           password_bubble_experiment::SmartLockBranding::NONE,
       type, &title_, &title_brand_link_range_);
 }
 
 void ManagePasswordsBubbleModel::UpdateManageStateTitle() {
-  GetManagePasswordsDialogTitleText(web_contents()->GetVisibleURL(), origin_,
+  GetManagePasswordsDialogTitleText(GetWebContents()->GetVisibleURL(), origin_,
                                     &title_);
 }
 
 metrics_util::UpdatePasswordSubmissionEvent
 ManagePasswordsBubbleModel::GetUpdateDismissalReason(
     UserBehaviorOnUpdateBubble behavior) const {
   static const metrics_util::UpdatePasswordSubmissionEvent update_events[4][3] =
       {{metrics_util::NO_ACCOUNTS_CLICKED_UPDATE,
         metrics_util::NO_ACCOUNTS_CLICKED_NOPE,
         metrics_util::NO_ACCOUNTS_NO_INTERACTION},
@@ skipping 13 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];
 }