Clean password_manager::ui::State

chrome/browser/ui/passwords/manage_passwords_ui_controller.cc

 // Copyright 2014 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_ui_controller.h"
 
+#include "base/auto_reset.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/password_manager/chrome_password_manager_client.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/ui/browser_command_controller.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/location_bar/location_bar.h"
 #include "chrome/browser/ui/passwords/manage_passwords_icon.h"
@@ skipping 43 matching lines @@
 }
 
 }  // namespace
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(ManagePasswordsUIController);
 
 ManagePasswordsUIController::ManagePasswordsUIController(
     content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       state_(password_manager::ui::INACTIVE_STATE),
-      bubble_shown_(false) {
+      should_pop_up_bubble_(false) {
   password_manager::PasswordStore* password_store =
       GetPasswordStore(web_contents);
   if (password_store)
     password_store->AddObserver(this);
 }
 
 ManagePasswordsUIController::~ManagePasswordsUIController() {}
 
 void ManagePasswordsUIController::UpdateBubbleAndIconVisibility() {
-  bubble_shown_ = false;
   // If we're not on a "webby" URL (e.g. "chrome://sign-in"), we shouldn't
   // display either the bubble or the icon.
   if (!BrowsingDataHelper::IsWebScheme(
           web_contents()->GetLastCommittedURL().scheme())) {
     SetState(password_manager::ui::INACTIVE_STATE);
   }
 
 #if !defined(OS_ANDROID)
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents());
   if (!browser)
     return;
   LocationBar* location_bar = browser->window()->GetLocationBar();
   DCHECK(location_bar);
   location_bar->UpdateManagePasswordsIconAndBubble();
 #endif
 }
 
 base::TimeDelta ManagePasswordsUIController::Elapsed() const {
   return timer_ ? timer_->Elapsed() : base::TimeDelta::Max();
 }
 
 void ManagePasswordsUIController::OnAskToReportURL(const GURL& url) {
   origin_ = url;
-  SetState(password_manager::ui::ASK_USER_REPORT_URL_STATE);
+  SetState(password_manager::ui::
+           ASK_USER_REPORT_URL_BUBBLE_SHOWN_BEFORE_TRANSITION_STATE);
+  base::AutoReset<bool> resetter(&should_pop_up_bubble_, true);
   UpdateBubbleAndIconVisibility();
 }
 
 void ManagePasswordsUIController::OnPasswordSubmitted(
     scoped_ptr<PasswordFormManager> form_manager) {
   form_manager_ = form_manager.Pass();
   password_form_map_ = ConstifyMap(form_manager_->best_matches());
   origin_ = PendingPassword().origin;
-  SetState(password_manager::ui::PENDING_PASSWORD_AND_BUBBLE_STATE);
-  timer_.reset(new base::ElapsedTimer());
+  SetState(password_manager::ui::PENDING_PASSWORD_STATE);
+  timer_.reset(new base::ElapsedTimer);
+  base::AutoReset<bool> resetter(&should_pop_up_bubble_, true);
   UpdateBubbleAndIconVisibility();
 }
 
 bool ManagePasswordsUIController::OnChooseCredentials(
     ScopedVector<autofill::PasswordForm> local_credentials,
     ScopedVector<autofill::PasswordForm> federated_credentials,
     const GURL& origin,
     base::Callback<void(const password_manager::CredentialInfo&)> callback) {
   DCHECK(!local_credentials.empty() || !federated_credentials.empty());
   form_manager_.reset();
   origin_ = origin;
   local_credentials_forms_.swap(local_credentials);
   federated_credentials_forms_.swap(federated_credentials);
   // The map is useless because usernames may overlap.
   password_form_map_.clear();
-  SetState(password_manager::ui::CREDENTIAL_REQUEST_AND_BUBBLE_STATE);
+  SetState(password_manager::ui::CREDENTIAL_REQUEST_STATE);
+  base::AutoReset<bool> resetter(&should_pop_up_bubble_, true);
   UpdateBubbleAndIconVisibility();
-  if (bubble_shown_)
+  if (!should_pop_up_bubble_) {
     credentials_callback_ = callback;
-  return bubble_shown_;
+    return true;
+  }
+  return false;
 }
 
 void ManagePasswordsUIController::OnAutomaticPasswordSave(
     scoped_ptr<PasswordFormManager> form_manager) {
   form_manager_ = form_manager.Pass();
   password_form_map_ = ConstifyMap(form_manager_->best_matches());
   password_form_map_[form_manager_->associated_username()] =
       &form_manager_->pending_credentials();
   origin_ = form_manager_->pending_credentials().origin;
   SetState(password_manager::ui::CONFIRMATION_STATE);
+  base::AutoReset<bool> resetter(&should_pop_up_bubble_, true);
   UpdateBubbleAndIconVisibility();
 }
 
 void ManagePasswordsUIController::OnPasswordAutofilled(
     const PasswordFormMap& password_form_map) {
   DeepCopyMap(password_form_map, &password_form_map_, &new_password_forms_);
   origin_ = password_form_map_.begin()->second->origin;
   // Don't show the UI for PSL matched passwords. They are not stored for this
   // page and cannot be deleted.
   SetState(password_form_map_.begin()->second->IsPublicSuffixMatch()
@@ skipping 52 matching lines @@
 void ManagePasswordsUIController::SavePassword() {
   DCHECK(PasswordPendingUserDecision());
   SavePasswordInternal();
   SetState(password_manager::ui::MANAGE_STATE);
   UpdateBubbleAndIconVisibility();
 }
 
 void ManagePasswordsUIController::ChooseCredential(
     const autofill::PasswordForm& form,
     password_manager::CredentialType credential_type) {
-  DCHECK(password_manager::ui::IsCredentialsState(state_));
+  DCHECK_EQ(password_manager::ui::CREDENTIAL_REQUEST_STATE, state_);
   DCHECK(!credentials_callback_.is_null());
 
   // Here, |credential_type| refers to whether the credential was originally
   // passed into ::OnChooseCredentials as part of the |local_credentials| or
   // |federated_credentials| lists (e.g. whether it is an existing credential
   // saved for this origin, or whether we should synthesize a new
   // FederatedCredential).
   //
   // If |credential_type| is federated, the credential MUST be returned as
   // a FederatedCredential in order to prevent password information leaking
@@ skipping 12 matching lines @@
   } else if (credential_type ==
              password_manager::CredentialType::CREDENTIAL_TYPE_EMPTY) {
     type_to_return = password_manager::CredentialType::CREDENTIAL_TYPE_EMPTY;
   } else {
     type_to_return =
         password_manager::CredentialType::CREDENTIAL_TYPE_FEDERATED;
   }
   password_manager::CredentialInfo info =
       password_manager::CredentialInfo(form, type_to_return);
   credentials_callback_.Run(info);
-  SetState(password_manager::ui::INACTIVE_STATE);
-  UpdateBubbleAndIconVisibility();
+  credentials_callback_.Reset();
 }
 
 void ManagePasswordsUIController::SavePasswordInternal() {
   DCHECK(form_manager_.get());
   form_manager_->Save();
 }
 
 void ManagePasswordsUIController::NeverSavePassword() {
   DCHECK(PasswordPendingUserDecision());
   NeverSavePasswordInternal();
@@ skipping 73 matching lines @@
 }
 
 const autofill::PasswordForm& ManagePasswordsUIController::
     PendingPassword() const {
   DCHECK(form_manager_);
   return form_manager_->pending_credentials();
 }
 
 void ManagePasswordsUIController::UpdateIconAndBubbleState(
     ManagePasswordsIcon* icon) {
-  if (password_manager::ui::IsAutomaticDisplayState(state_)) {
+  if (should_pop_up_bubble_) {
     // We must display the icon before showing the bubble, as the bubble would
-    // be otherwise unanchored. However, we can't change the controller's state
-    // until _after_ the bubble is shown, as our metrics depend on the seeing
-    // the original state to determine if the bubble opened automagically or via
-    // user action.
-    password_manager::ui::State end_state =
-        GetEndStateForAutomaticState(state_);
-    icon->SetState(end_state);
+    // be otherwise unanchored.
+    icon->SetState(state_);
     ShowBubbleWithoutUserInteraction();
-    SetState(end_state);
   } else {
     icon->SetState(state_);
   }
 }
 
 void ManagePasswordsUIController::OnBubbleShown() {
-  bubble_shown_ = true;
+  should_pop_up_bubble_ = false;
+}
+
+void ManagePasswordsUIController::OnBubbleHidden() {
+  password_manager::ui::State next_state = state_;
+  if (state_ == password_manager::ui::CREDENTIAL_REQUEST_STATE)
+    next_state = password_manager::ui::INACTIVE_STATE;
+  else if (state_ == password_manager::ui::CONFIRMATION_STATE)
+    next_state = password_manager::ui::MANAGE_STATE;
+
+  if (next_state != state_) {
+    SetState(next_state);
+    UpdateBubbleAndIconVisibility();
+  }
 }
 
 void ManagePasswordsUIController::ShowBubbleWithoutUserInteraction() {
-  DCHECK(password_manager::ui::IsAutomaticDisplayState(state_));
+  DCHECK(should_pop_up_bubble_);
 #if !defined(OS_ANDROID)
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents());
   if (!browser || browser->toolbar_model()->input_in_progress())
     return;
-  if (state_ == password_manager::ui::PENDING_PASSWORD_AND_BUBBLE_STATE &&
-      !password_bubble_experiment::ShouldShowBubble(
-          browser->profile()->GetPrefs()))
-    return;
   CommandUpdater* updater = browser->command_controller()->command_updater();
   updater->ExecuteCommand(IDC_MANAGE_PASSWORDS_FOR_PAGE);
 #endif
 }
 
 bool ManagePasswordsUIController::PasswordPendingUserDecision() const {
-  return password_manager::ui::IsPendingState(state_);
+  return state_ == password_manager::ui::PENDING_PASSWORD_STATE;
 }
 
 void ManagePasswordsUIController::WebContentsDestroyed() {
   password_manager::PasswordStore* password_store =
       GetPasswordStore(web_contents());
   if (password_store)
     password_store->RemoveObserver(this);
 }