[Password Manager] Show omnibox icon and anchored prompt once user start typing password

components/password_manager/core/browser/password_manager_unittest.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 <string>
 #include <utility>
 #include <vector>
 
@@ skipping 47 matching lines @@
         .WillRepeatedly(Return(&filter_));
     ON_CALL(filter_, ShouldSave(_)).WillByDefault(Return(true));
   }
 
   MOCK_CONST_METHOD0(IsSavingAndFillingEnabledForCurrentPage, bool());
   MOCK_CONST_METHOD0(DidLastPageLoadEncounterSSLErrors, bool());
   MOCK_CONST_METHOD0(GetPasswordStore, PasswordStore*());
   // The code inside EXPECT_CALL for PromptUserToSaveOrUpdatePasswordPtr owns
   // the PasswordFormManager* argument.
   MOCK_METHOD1(PromptUserToSaveOrUpdatePasswordPtr, void(PasswordFormManager*));
+  MOCK_METHOD2(ShowManualFallbackPtr, void(PasswordFormManager*, bool));
+  MOCK_METHOD0(HideManualFallback, void());
   MOCK_METHOD1(NotifySuccessfulLoginWithExistingPassword,
                void(const autofill::PasswordForm&));
   MOCK_METHOD0(AutomaticPasswordSaveIndicator, void());
   MOCK_METHOD0(GetPrefs, PrefService*());
   MOCK_CONST_METHOD0(GetMainFrameURL, const GURL&());
   MOCK_METHOD0(GetDriver, PasswordManagerDriver*());
   MOCK_CONST_METHOD0(GetStoreResultFilter, const MockStoreResultFilter*());
 
   // Workaround for std::unique_ptr<> lacking a copy constructor.
   bool PromptUserToSaveOrUpdatePassword(
       std::unique_ptr<PasswordFormManager> manager,
       bool update_password) override {
     PromptUserToSaveOrUpdatePasswordPtr(manager.release());
     return false;
   }
+  void ShowManualFallback(std::unique_ptr<PasswordFormManager> manager,
+                          bool is_update) override {
+    ShowManualFallbackPtr(manager.release(), is_update);

[vasilii, 2017/07/21 12:48:21]

Memory leak here?

[kolos1, 2017/07/24 15:33:31]

Fixed.

+  }
   void AutomaticPasswordSave(
       std::unique_ptr<PasswordFormManager> manager) override {
     AutomaticPasswordSaveIndicator();
   }
 
   void FilterAllResultsForSaving() {
     EXPECT_CALL(filter_, ShouldSave(_)).WillRepeatedly(Return(false));
   }
 
  private:
@@ skipping 13 matching lines @@
   result.push_back(base::MakeUnique<PasswordForm>(form));
   arg0->OnGetPasswordStoreResults(std::move(result));
 }
 
 ACTION(InvokeEmptyConsumerWithForms) {
   arg0->OnGetPasswordStoreResults(std::vector<std::unique_ptr<PasswordForm>>());
 }
 
 ACTION_P(SaveToScopedPtr, scoped) { scoped->reset(arg0); }
 
+ACTION_P(SaveConsumerToList, list) {
+  list->push_back(arg0);
+}
+
 }  // namespace
 
 class PasswordManagerTest : public testing::Test {
  protected:
   void SetUp() override {
     store_ = new testing::StrictMock<MockPasswordStore>;
     EXPECT_CALL(*store_, ReportMetrics(_, _)).Times(AnyNumber());
     EXPECT_CALL(*store_, GetLoginsForSameOrganizationName(_, _))
         .Times(AnyNumber());
     CHECK(store_->Init(syncer::SyncableService::StartSyncFlare(), nullptr));
@@ skipping 1672 matching lines @@
   std::unique_ptr<PasswordFormManager> form_manager_to_save;
   EXPECT_CALL(client_, PromptUserToSaveOrUpdatePasswordPtr(_))
       .WillOnce(WithArg<0>(SaveToScopedPtr(&form_manager_to_save)));
 
   OnPasswordFormSubmitted(form);
   observed.clear();
   manager()->OnPasswordFormsRendered(&driver_, observed, true);
 }
 #endif
 
+TEST_F(PasswordManagerTest, ManualFallbackForSaving) {
+  EXPECT_CALL(client_, IsSavingAndFillingEnabledForCurrentPage())
+      .WillRepeatedly(Return(true));
+
+  std::vector<PasswordForm> observed;
+  PasswordForm form(MakeSimpleForm());
+  observed.push_back(form);
+  PasswordForm stored_form = form;
+  stored_form.password_value = ASCIIToUTF16("old_password");
+  EXPECT_CALL(*store_, GetLogins(_, _))
+      .WillRepeatedly(WithArg<1>(InvokeConsumer(stored_form)));

[vasilii, 2017/07/21 12:48:21]

I'm concerned if it happens more than once. Is it true?

[kolos1, 2017/07/24 15:33:30]

Yes, it is called twice.

In tests above, WillRepeatedly is used.

[vasilii, 2017/07/25 11:17:46]

Why is it called twice if the form is only one?

[kolos1, 2017/07/26 13:40:57]

Investigated the case. Here it is called once actually. Fixed.

In the test below, it is called twice, because of cloning PasswordFormManager
for showing the fallback. It clones FormFetcher too. Since the original 
FormFetcher is still waiting for credentials, the clone will fetch credentials
too.
Fixed the second test and added a comment.

+  EXPECT_CALL(driver_, FillPasswordForm(_)).Times(2);
+  manager()->OnPasswordFormsParsed(&driver_, observed);
+  manager()->OnPasswordFormsRendered(&driver_, observed, true);
+
+  // The username of the stored form is the same, there should be update bubble.
+  EXPECT_CALL(client_, ShowManualFallbackPtr(_, true));

[vasilii, 2017/07/21 12:48:21]

Why don't we check anything about the form being passed

[kolos1, 2017/07/24 15:33:31]

Added some checks.

+  manager()->ShowManualFallback(&driver_, form);
+
+  // The username of the stored form is different, there should be save bubble.
+  PasswordForm new_form = form;
+  new_form.username_value = ASCIIToUTF16("another_username");
+  EXPECT_CALL(client_, ShowManualFallbackPtr(_, false));
+  manager()->ShowManualFallback(&driver_, new_form);
+
+  // Hide the manual fallback.
+  EXPECT_CALL(client_, HideManualFallback());
+  manager()->HideManualFallback();
+}
+
+// Tests that the manual fallback for saving isn't shown if there is no response
+// from the password storage. When crbug.com/741537 is fixed, change this test.
+TEST_F(PasswordManagerTest, ManualFallbackForSaving_SlowBackend) {
+  EXPECT_CALL(client_, IsSavingAndFillingEnabledForCurrentPage())
+      .WillRepeatedly(Return(true));
+
+  std::vector<PasswordForm> observed;
+  PasswordForm form(MakeSimpleForm());
+  observed.push_back(form);
+  std::vector<PasswordStoreConsumer*> consumers;
+  EXPECT_CALL(*store_, GetLogins(_, _))
+      .WillRepeatedly(WithArg<1>(SaveConsumerToList(&consumers)));
+  manager()->OnPasswordFormsParsed(&driver_, observed);
+  manager()->OnPasswordFormsRendered(&driver_, observed, true);
+
+  // There is no response from the store. Don't show the fallback.
+  EXPECT_CALL(client_, ShowManualFallbackPtr(_, _)).Times(0);
+  manager()->ShowManualFallback(&driver_, form);
+
+  // The storage responded. The fallback can be shown.
+  EXPECT_CALL(client_, ShowManualFallbackPtr(_, false));

[vasilii, 2017/07/21 12:48:21]

Move down to ShowManualFallback. Do I understand right that the fallback isn't
shown automatically upon receiving the forms?

[kolos1, 2017/07/24 15:33:31]

Good point. Done.

+  for (PasswordStoreConsumer* consumer : consumers) {
+    ASSERT_TRUE(consumer);
+    consumer->OnGetPasswordStoreResults(
+        std::vector<std::unique_ptr<PasswordForm>>());
+  }
+  manager()->ShowManualFallback(&driver_, form);
+}
+
 }  // namespace password_manager