CREDENTIAL: Only toggle 'skip_zero_click' state if API is used.

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 <vector>
@@ skipping 38 matching lines @@
 const char kTestAndroidRealm1[] = "android://hash@com.example.one.android/";
 const char kTestAndroidRealm2[] = "android://hash@com.example.two.android/";
 
 class MockPasswordManagerClient : public StubPasswordManagerClient {
  public:
   MOCK_CONST_METHOD0(IsSavingAndFillingEnabledForCurrentPage, bool());
   MOCK_CONST_METHOD0(IsOffTheRecord, bool());
   MOCK_CONST_METHOD0(DidLastPageLoadEncounterSSLErrors, bool());
   MOCK_METHOD1(NotifyUserAutoSigninPtr,
                bool(const std::vector<autofill::PasswordForm*>& local_forms));
-  MOCK_METHOD1(NotifyUserAutoSigninBlockedOnFirstRunPtr,
+  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));
 
   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,
                                         CredentialSourceType type,
                                         bool update_password) override {
     manager_.swap(manager);
     PromptUserToSavePasswordPtr(manager_.get(), type);
     return true;
   }
 
-  void NotifyUserAutoSigninBlockedOnFirstRun(
+  void NotifyUserCouldBeAutoSignedIn(
       scoped_ptr<autofill::PasswordForm> form) override {
-    NotifyUserAutoSigninBlockedOnFirstRunPtr(form.get());
+    NotifyUserCouldBeAutoSignedInPtr(form.get());
   }
 
   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,
@@ skipping 521 matching lines @@
             base::get<1>(send_param).type);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialWithZeroClickOnlyFullPasswordStore) {
   store_->AddLogin(form_);
   client_->set_first_run_seen(true);
 
   std::vector<GURL> federations;
 
-  EXPECT_CALL(*client_, NotifyUserAutoSigninBlockedOnFirstRunPtr(_)).Times(0);
+  EXPECT_CALL(*client_, NotifyUserCouldBeAutoSignedInPtr(_)).Times(0);
   dispatcher()->OnRequestCredential(kRequestId, true, true, federations);
 
   ExpectZeroClickSignInSuccess(CredentialType::CREDENTIAL_TYPE_PASSWORD);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialWithoutPasswords) {
   store_->AddLogin(form_);
   client_->set_first_run_seen(true);
 
   std::vector<GURL> federations;
 
-  EXPECT_CALL(*client_, NotifyUserAutoSigninBlockedOnFirstRunPtr(_)).Times(0);
+  EXPECT_CALL(*client_, NotifyUserCouldBeAutoSignedInPtr(_)).Times(0);
   dispatcher()->OnRequestCredential(kRequestId, true, false, federations);
 
   ExpectZeroClickSignInFailure();
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialFederatedMatch) {
   form_.federation_origin = url::Origin(GURL("https://example.com/"));
   store_->AddLogin(form_);
   client_->set_first_run_seen(true);
 
   std::vector<GURL> federations;
   federations.push_back(GURL("https://example.com/"));
 
-  EXPECT_CALL(*client_, NotifyUserAutoSigninBlockedOnFirstRunPtr(_)).Times(0);
+  EXPECT_CALL(*client_, NotifyUserCouldBeAutoSignedInPtr(_)).Times(0);
   dispatcher()->OnRequestCredential(kRequestId, true, true, federations);
 
   ExpectZeroClickSignInSuccess(CredentialType::CREDENTIAL_TYPE_FEDERATED);
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialFederatedNoMatch) {
   form_.federation_origin = url::Origin(GURL("https://example.com/"));
   store_->AddLogin(form_);
   client_->set_first_run_seen(true);
 
   std::vector<GURL> federations;
   federations.push_back(GURL("https://not-example.com/"));
 
-  EXPECT_CALL(*client_, NotifyUserAutoSigninBlockedOnFirstRunPtr(_)).Times(0);
+  EXPECT_CALL(*client_, NotifyUserCouldBeAutoSignedInPtr(_)).Times(0);
   dispatcher()->OnRequestCredential(kRequestId, true, true, federations);
 
   ExpectZeroClickSignInFailure();
 }
 
 TEST_F(CredentialManagerDispatcherTest,
        CredentialManagerOnRequestCredentialAffiliatedPasswordMatch) {
   store_->AddLogin(affiliated_form1_);
   client_->set_first_run_seen(true);
   auto mock_helper = make_scoped_ptr(new MockAffiliatedMatchHelper);
@@ skipping 80 matching lines @@
   ExpectZeroClickSignInFailure();
 }
 
 TEST_F(CredentialManagerDispatcherTest, RequestCredentialWithoutFirstRun) {
   client_->set_first_run_seen(false);
 
   store_->AddLogin(form_);
 
   std::vector<GURL> federations;
   EXPECT_CALL(*client_,
-              NotifyUserAutoSigninBlockedOnFirstRunPtr(testing::Pointee(form_)))
+              NotifyUserCouldBeAutoSignedInPtr(testing::Pointee(form_)))
       .Times(1);
   dispatcher()->OnRequestCredential(kRequestId, true, true, federations);
 
+  ExpectZeroClickSignInFailure();
+}
+
+TEST_F(CredentialManagerDispatcherTest, RequestCredentialWithFirstRunAndSkip) {
+  client_->set_first_run_seen(true);
+
+  form_.skip_zero_click = true;
+  store_->AddLogin(form_);
+
+  std::vector<GURL> federations;
+  EXPECT_CALL(*client_,
+              NotifyUserCouldBeAutoSignedInPtr(testing::Pointee(form_)))
+      .Times(1);
+  dispatcher()->OnRequestCredential(kRequestId, true, true, federations);
+
   ExpectZeroClickSignInFailure();
 }
 
 TEST_F(CredentialManagerDispatcherTest, RequestCredentialWithTLSErrors) {
   // If we encounter TLS errors, we won't return credentials.
   EXPECT_CALL(*client_, DidLastPageLoadEncounterSSLErrors())
       .WillRepeatedly(testing::Return(true));
 
   store_->AddLogin(form_);
 
@@ skipping 318 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