Show user credentials chooser bubble.

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 "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/ui/browser_command_controller.h"
 #include "chrome/browser/ui/browser_dialogs.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"
 #include "chrome/browser/ui/passwords/password_bubble_experiment.h"
 #include "chrome/common/url_constants.h"
+#include "components/password_manager/content/common/credential_manager_types.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "content/public/browser/notification_service.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/android/chromium_application.h"
 #endif
 
 using autofill::PasswordFormMap;
 using password_manager::PasswordFormManager;
 
@@ skipping 27 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) {
+      state_(password_manager::ui::INACTIVE_STATE),
+      bubble_shown_(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())) {
     state_ = 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
+#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
 }
 
 void ManagePasswordsUIController::OnPasswordSubmitted(
     scoped_ptr<PasswordFormManager> form_manager) {
   form_manager_ = form_manager.Pass();
   password_form_map_ = ConstifyMap(form_manager_->best_matches());
-  origin_ = PendingCredentials().origin;
+  origin_ = PendingPassword().origin;
   state_ = password_manager::ui::PENDING_PASSWORD_AND_BUBBLE_STATE;
   UpdateBubbleAndIconVisibility();
 }
 
+bool ManagePasswordsUIController::OnChooseCredentials(
+    ScopedVector<autofill::PasswordForm> credentials,
+    base::Callback<void(const password_manager::CredentialInfo&)> callback){
+  DCHECK(!credentials.empty());
+  form_manager_.reset();
+  origin_ = credentials[0]->origin;
+  new_password_forms_.swap(credentials);
+  // The map is useless because usernames may overlap.

[Mike West, 2014/11/20 08:19:32]

TODO(vasilii)? :)

[vasilii, 2014/11/20 15:08:05]

TODO what? It's useful for other states.

[Mike West, 2014/11/21 11:21:12]

Yeah, I misunderstood this comment. Sorry for the noise.

+  password_form_map_.clear();
+  state_ = password_manager::ui::PENDING_CREDENTIALS_AND_BUBBLE_STATE;
+  UpdateBubbleAndIconVisibility();
+  if (bubble_shown_)

[Mike West, 2014/11/20 08:19:32]

When wouldn't the bubble be shown?

[vasilii, 2014/11/20 15:08:05]

There is a condition in ShowBubbleWithoutUserInteraction() about
input_in_progress(). Another one in ManagePasswordsBubbleView::ShowBubble -
IsShowing().

[Mike West, 2014/11/21 11:21:12]

Hrm. Ok. I hope that case will be impossible to reach for `request()`, but we'll
have to think about it in the future.

For example, if we auto-sign-in a user, we'll want to pop up a toast regardless
of whether they're typing in the omnibox or on the page.

+    credentials_callback_ = callback;

[Mike West, 2014/11/20 08:19:31]

We need to callback to Blink even if the user doesn't pick a credential,
otherwise the Promise will never resolve. Do you handle this case somewhere
else?

Also, don't we need to take ownership of the callback here?

[vasilii, 2014/11/20 15:08:05]

if we return false then this case is handled immediately in
content_credential_manager_dispatcher.cc and we don't need a callback. The
callback is copyable so there is no ownership.

[Mike West, 2014/11/21 11:21:12]

Acknowledged.

+  return bubble_shown_;
+}
+
 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;
   state_ = password_manager::ui::CONFIRMATION_STATE;
   UpdateBubbleAndIconVisibility();
 }
@@ skipping 37 matching lines @@
       if (changed_form.blacklisted_by_user)
         state_ = password_manager::ui::MANAGE_STATE;
     } else {
       new_password_forms_.push_back(new autofill::PasswordForm(changed_form));
       password_form_map_[changed_form.username_value] =
           new_password_forms_.back();
       if (changed_form.blacklisted_by_user)
         state_ = password_manager::ui::BLACKLIST_STATE;
     }
   }
+  // If we're in PENDING_CREDENTIALS_AND_BUBBLE_STATE just close the bubble.
+  if (current_state ==
+      password_manager::ui::PENDING_CREDENTIALS_AND_BUBBLE_STATE)
+    state_ = password_manager::ui::INACTIVE_STATE;

[Mike West, 2014/11/20 08:19:31]

This seems wrong; if I have another window open, and I save a password there,
the bubble would close here. Why should those behaviors be tied together?

Also: we need to callback into Blink to resolve the Promise with an empty
credential when we close the bubble automagically. I don't see where that's done
here.

[vasilii, 2014/11/20 15:08:05]

You are right. I removed this code. What should we do? Repopulate the bubble?

[Mike West, 2014/11/21 11:21:12]

I'd just add a TODO for now; I don't think we have a good answer. One option
would be to refresh the bubble, another would just be to pretend that nothing
happened. Since the credential is only returned to the page if the user selects
it, I'm not terribly worried about user confusion for the moment.

[vasilii, 2014/11/21 16:45:37]

Done.

   if (current_state != state_)
     UpdateBubbleAndIconVisibility();
 }
 
 void ManagePasswordsUIController::
     NavigateToPasswordManagerSettingsPage() {
 #if defined(OS_ANDROID)
   chrome::android::ChromiumApplication::ShowPasswordSettings();
 #else
   chrome::ShowSettingsSubPage(
       chrome::FindBrowserWithWebContents(web_contents()),
       chrome::kPasswordManagerSubPage);
 #endif
 }
 
 void ManagePasswordsUIController::SavePassword() {
   DCHECK(PasswordPendingUserDecision());
   SavePasswordInternal();
   state_ = password_manager::ui::MANAGE_STATE;
   UpdateBubbleAndIconVisibility();
 }
 
+void ManagePasswordsUIController::ChooseCredential(
+    bool was_chosen,
+    const autofill::PasswordForm& form) {
+  DCHECK_EQ(password_manager::ui::PENDING_CREDENTIALS_AND_BUBBLE_STATE, state_);
+  DCHECK(!credentials_callback_.is_null());
+  password_manager::CredentialInfo info = was_chosen ?
+      password_manager::CredentialInfo(form) :
+      password_manager::CredentialInfo();
+  credentials_callback_.Run(info);
+  state_ = password_manager::ui::INACTIVE_STATE;
+  UpdateBubbleAndIconVisibility();
+}
+
 void ManagePasswordsUIController::SavePasswordInternal() {
   DCHECK(form_manager_.get());
   form_manager_->Save();
 }
 
 void ManagePasswordsUIController::NeverSavePassword() {
   DCHECK(PasswordPendingUserDecision());
   NeverSavePasswordInternal();
   state_ = password_manager::ui::BLACKLIST_STATE;
   UpdateBubbleAndIconVisibility();
@@ skipping 41 matching lines @@
   timer_.reset(new base::ElapsedTimer());
 }
 
 void ManagePasswordsUIController::WasHidden() {
 #if !defined(OS_ANDROID)
   chrome::CloseManagePasswordsBubble(web_contents());
 #endif
 }
 
 const autofill::PasswordForm& ManagePasswordsUIController::
-    PendingCredentials() const {
+    PendingPassword() const {
   DCHECK(form_manager_);
   return form_manager_->pending_credentials();
 }
 
 void ManagePasswordsUIController::UpdateIconAndBubbleState(
     ManagePasswordsIcon* icon) {
   if (password_manager::ui::IsAutomaticDisplayState(state_)) {
     // 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);
     ShowBubbleWithoutUserInteraction();
     state_ = end_state;
   } else {
     icon->SetState(state_);
   }
 }
 
+void ManagePasswordsUIController::OnBubbleShown() {
+  bubble_shown_ = true;
+}
+
 void ManagePasswordsUIController::ShowBubbleWithoutUserInteraction() {
   DCHECK(password_manager::ui::IsAutomaticDisplayState(state_));
 #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 state_ == password_manager::ui::PENDING_PASSWORD_STATE ||
          state_ == password_manager::ui::PENDING_PASSWORD_AND_BUBBLE_STATE;
 }