Update the |skip_zero_click| flag of a credential when selected in the account chooser.

components/password_manager/content/browser/credential_manager_dispatcher_unittest.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 "components/password_manager/content/browser/credential_manager_dispatcher.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <tuple>
@@ skipping 47 matching lines @@
   MOCK_METHOD1(NotifyUserAutoSigninPtr,
                bool(const std::vector<autofill::PasswordForm*>& local_forms));
   MOCK_METHOD1(NotifyUserCouldBeAutoSignedInPtr,
                bool(autofill::PasswordForm* form));
   MOCK_METHOD2(PromptUserToSavePasswordPtr,
                void(PasswordFormManager*, CredentialSourceType type));
   MOCK_METHOD4(PromptUserToChooseCredentialsPtr,
                bool(const std::vector<autofill::PasswordForm*>& local_forms,
                     const std::vector<autofill::PasswordForm*>& federated_forms,
                     const GURL& origin,
-                    base::Callback<void(const CredentialInfo&)> callback));
+                    const CredentialsCallback& callback));
 
   explicit MockPasswordManagerClient(PasswordStore* store) : store_(store) {
     prefs_.registry()->RegisterBooleanPref(prefs::kCredentialsEnableAutosignin,
                                            true);
     prefs_.registry()->RegisterBooleanPref(
         prefs::kWasAutoSignInFirstRunExperienceShown, true);
   }
   ~MockPasswordManagerClient() override {}
 
   bool PromptUserToSaveOrUpdatePassword(scoped_ptr<PasswordFormManager> manager,
@@ skipping 10 matching lines @@
   }
 
   PasswordStore* GetPasswordStore() const override { return store_; }
 
   PrefService* GetPrefs() override { return &prefs_; }
 
   bool PromptUserToChooseCredentials(
       ScopedVector<autofill::PasswordForm> local_forms,
       ScopedVector<autofill::PasswordForm> federated_forms,
       const GURL& origin,
-      base::Callback<void(const CredentialInfo&)> callback) {
+      const CredentialsCallback& callback) {
     EXPECT_FALSE(local_forms.empty() && federated_forms.empty());
-    CredentialInfo info(
-        local_forms.empty() ? *federated_forms[0] : *local_forms[0],
-        local_forms.empty() ? CredentialType::CREDENTIAL_TYPE_FEDERATED
-                            : CredentialType::CREDENTIAL_TYPE_PASSWORD);
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                  base::Bind(callback, info));
+    const autofill::PasswordForm* form =
+        local_forms.empty() ? federated_forms[0] : local_forms[0];
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(callback, base::Owned(new autofill::PasswordForm(*form))));
     PromptUserToChooseCredentialsPtr(local_forms.get(), federated_forms.get(),
                                      origin, callback);
     return true;
   }
 
   void NotifyUserAutoSignin(ScopedVector<autofill::PasswordForm> local_forms,
                             const GURL& origin) override {
     EXPECT_FALSE(local_forms.empty());
     NotifyUserAutoSigninPtr(local_forms.get());
   }
@@ skipping 288 matching lines @@
   // Allow the PasswordFormManager to talk to the password store, determine
   // the form is a match for an existing form, and update the PasswordStore.
   RunAllPendingTasks();
 
   // Verify that the update didn't toggle the skip_zero_click flag off.
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
   EXPECT_TRUE(passwords[form_.signon_realm][0].skip_zero_click);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
+       CredentialManagerGetOverwriteZeroClick) {
+  // Set the global zero click flag on, and populate the PasswordStore with a
+  // form that's set to skip zero click and has a primary key that won't match
+  // credentials initially created via `store()`.
+  client_->set_zero_click_enabled(true);
+  form_.skip_zero_click = true;
+  form_.username_element = base::ASCIIToUTF16("username-element");
+  form_.password_element = base::ASCIIToUTF16("password-element");
+  form_.signon_realm = "this is a realm";
+  form_.origin = GURL("https://example.com/old_form.html");
+  store_->AddLogin(form_);
+  RunAllPendingTasks();
+
+  std::vector<GURL> federations;
+  EXPECT_CALL(*client_, PromptUserToChooseCredentialsPtr(_, _, _, _))
+      .Times(testing::Exactly(1));
+  EXPECT_CALL(*client_, NotifyUserAutoSigninPtr(_)).Times(testing::Exactly(0));
+
+  dispatcher()->OnRequestCredential(kRequestId, false, true, federations);
+
+  RunAllPendingTasks();
+
+  const uint32_t kMsgID = CredentialManagerMsg_SendCredential::ID;

[vabr (Chromium), 2016/03/29 08:45:55]

heads-up: If you get rebasing conflicts or post-rebaseing errors, check out
https://codereview.chromium.org/1762603002/ which, once landed, will switch from
IPC to Mojo.

[vasilii, 2016/03/29 09:57:44]

No conflicts.

+  const IPC::Message* message =
+      process()->sink().GetFirstMessageMatching(kMsgID);
+  EXPECT_TRUE(message);
+
+  // Verify that the update toggled the skip_zero_click flag.
+  TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
+  EXPECT_FALSE(passwords[form_.signon_realm][0].skip_zero_click);
+}
+
+TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerSignInWithSavingDisabledForCurrentPage) {
   CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_PASSWORD);
   EXPECT_CALL(*client_, IsSavingAndFillingEnabledForCurrentPage())
       .WillRepeatedly(testing::Return(false));
   EXPECT_CALL(*client_, PromptUserToSavePasswordPtr(
                             _, CredentialSourceType::CREDENTIAL_SOURCE_API))
       .Times(testing::Exactly(0));
 
   dispatcher()->OnStore(kRequestId, info);
 
@@ skipping 696 matching lines @@
 TEST_F(CredentialManagerDispatcherTest, GetSynthesizedFormForOrigin) {
   autofill::PasswordForm synthesized =
       dispatcher_->GetSynthesizedFormForOrigin();
   EXPECT_EQ(kTestWebOrigin, synthesized.origin.spec());
   EXPECT_EQ(kTestWebOrigin, synthesized.signon_realm);
   EXPECT_EQ(autofill::PasswordForm::SCHEME_HTML, synthesized.scheme);
   EXPECT_TRUE(synthesized.ssl_valid);
 }
 
 }  // namespace password_manager