[Credential Management] Smart lock save Credentials bubble should not always pop up.

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/testing_pref_service.h"
@@ skipping 19 matching lines @@
 using testing::_;
 
 namespace {
 
 // Chosen by fair dice roll. Guaranteed to be random.
 const int kRequestId = 4;
 
 class MockPasswordManagerClient
     : public password_manager::StubPasswordManagerClient {
  public:
+  MOCK_CONST_METHOD0(IsPasswordManagerEnabledForCurrentPage, bool());
   MOCK_CONST_METHOD0(IsOffTheRecord, bool());
+  MOCK_CONST_METHOD0(DidLastPageLoadEncounterSSLErrors, bool());
   MOCK_METHOD1(NotifyUserAutoSigninPtr,
                bool(const std::vector<autofill::PasswordForm*>& local_forms));
   MOCK_METHOD2(PromptUserToSavePasswordPtr,
                void(password_manager::PasswordFormManager*,
                     password_manager::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 password_manager::CredentialInfo&)> callback));
 
   MockPasswordManagerClient(password_manager::PasswordStore* store)
       : store_(store) {
     prefs_.registry()->RegisterBooleanPref(
         password_manager::prefs::kPasswordManagerAutoSignin, true);
+    prefs_.registry()->RegisterBooleanPref(
+        password_manager::prefs::kPasswordManagerSavingEnabled, true);
   }
   ~MockPasswordManagerClient() override {}
 
   bool PromptUserToSavePassword(
       scoped_ptr<password_manager::PasswordFormManager> manager,
       password_manager::CredentialSourceType type) override {
     manager_.swap(manager);
     PromptUserToSavePasswordPtr(manager_.get(), type);
     return true;
   }
@@ skipping 25 matching lines @@
   void NotifyUserAutoSignin(
       ScopedVector<autofill::PasswordForm> local_forms) override {
     EXPECT_FALSE(local_forms.empty());
     NotifyUserAutoSigninPtr(local_forms.get());
   }
 
   password_manager::PasswordFormManager* pending_manager() const {
     return manager_.get();
   }
 
+  void set_password_manager_saving_enabled(bool is_enabled) {
+    prefs_.SetBoolean(password_manager::prefs::kPasswordManagerSavingEnabled,
+                      is_enabled);
+  }
+
   void set_zero_click_enabled(bool zero_click_enabled) {
     prefs_.SetBoolean(password_manager::prefs::kPasswordManagerAutoSignin,
                       zero_click_enabled);
   }
 
  private:
   TestingPrefServiceSimple prefs_;
   password_manager::PasswordStore* store_;
   scoped_ptr<password_manager::PasswordFormManager> manager_;
 
@@ skipping 43 matching lines @@
  public:
   CredentialManagerDispatcherTest() {}
 
   void SetUp() override {
     content::RenderViewHostTestHarness::SetUp();
     store_ = new TestPasswordStore;
     client_.reset(new MockPasswordManagerClient(store_.get()));
     dispatcher_.reset(new TestCredentialManagerDispatcher(
         web_contents(), client_.get(), &stub_driver_));
     ON_CALL(*client_, IsOffTheRecord()).WillByDefault(testing::Return(false));
+    ON_CALL(*client_, DidLastPageLoadEncounterSSLErrors())
+        .WillByDefault(testing::Return(false));
+    ON_CALL(*client_, IsPasswordManagerEnabledForCurrentPage())
+        .WillByDefault(testing::Return(true));
 
     NavigateAndCommit(GURL("https://example.com/test.html"));
 
     form_.username_value = base::ASCIIToUTF16("Username");
     form_.display_name = base::ASCIIToUTF16("Display Name");
     form_.password_value = base::ASCIIToUTF16("Password");
     form_.origin = web_contents()->GetLastCommittedURL().GetOrigin();
     form_.signon_realm = form_.origin.spec();
     form_.scheme = autofill::PasswordForm::SCHEME_HTML;
     form_.skip_zero_click = false;
@@ skipping 95 matching lines @@
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   EXPECT_TRUE(message);
   process()->sink().ClearMessages();
 
   RunAllPendingTasks();
 
   EXPECT_FALSE(client_->pending_manager());
 }
 
+TEST_F(CredentialManagerDispatcherTest, CredentialManagerSignInWithSSLErrors) {
+  CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_LOCAL);
+  EXPECT_CALL(*client_, DidLastPageLoadEncounterSSLErrors())
+      .WillRepeatedly(testing::Return(true));
+  EXPECT_CALL(
+      *client_,
+      PromptUserToSavePasswordPtr(
+          _, password_manager::CredentialSourceType::CREDENTIAL_SOURCE_API))
+      .Times(testing::Exactly(0));
+
+  dispatcher()->OnNotifySignedIn(kRequestId, info);
+
+  const uint32 kMsgID = CredentialManagerMsg_AcknowledgeSignedIn::ID;
+  const IPC::Message* message =
+      process()->sink().GetFirstMessageMatching(kMsgID);
+  EXPECT_TRUE(message);
+  process()->sink().ClearMessages();
+
+  RunAllPendingTasks();
+
+  EXPECT_FALSE(client_->pending_manager());
+}
+
+TEST_F(CredentialManagerDispatcherTest,
+       CredentialManagerSignInWithDisabledPasswordManager) {
+  CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_LOCAL);
+  client_->set_password_manager_saving_enabled(false);
+  EXPECT_CALL(
+      *client_,
+      PromptUserToSavePasswordPtr(
+          _, password_manager::CredentialSourceType::CREDENTIAL_SOURCE_API))
+      .Times(testing::Exactly(0));
+
+  dispatcher()->OnNotifySignedIn(kRequestId, info);
+
+  const uint32 kMsgID = CredentialManagerMsg_AcknowledgeSignedIn::ID;
+  const IPC::Message* message =
+      process()->sink().GetFirstMessageMatching(kMsgID);
+  EXPECT_TRUE(message);
+  process()->sink().ClearMessages();
+
+  RunAllPendingTasks();
+
+  EXPECT_FALSE(client_->pending_manager());
+}
+
+TEST_F(CredentialManagerDispatcherTest,
+       CredentialManagerSignInWthPasswordManagerDisabledForCurrentPage) {
+  CredentialInfo info(form_, CredentialType::CREDENTIAL_TYPE_LOCAL);
+  EXPECT_CALL(*client_, IsPasswordManagerEnabledForCurrentPage())
+      .WillRepeatedly(testing::Return(false));
+  EXPECT_CALL(
+      *client_,
+      PromptUserToSavePasswordPtr(
+          _, password_manager::CredentialSourceType::CREDENTIAL_SOURCE_API))
+      .Times(testing::Exactly(0));
+
+  dispatcher()->OnNotifySignedIn(kRequestId, info);
+
+  const uint32 kMsgID = CredentialManagerMsg_AcknowledgeSignedIn::ID;
+  const IPC::Message* message =
+      process()->sink().GetFirstMessageMatching(kMsgID);
+  EXPECT_TRUE(message);
+  process()->sink().ClearMessages();
+
+  RunAllPendingTasks();
+
+  EXPECT_FALSE(client_->pending_manager());
+}
+
 TEST_F(CredentialManagerDispatcherTest, CredentialManagerOnNotifySignedOut) {
   store_->AddLogin(form_);
   store_->AddLogin(cross_origin_form_);
   RunAllPendingTasks();
 
   TestPasswordStore::PasswordMap passwords = store_->stored_passwords();
   EXPECT_EQ(2U, passwords.size());
   EXPECT_EQ(1U, passwords[form_.signon_realm].size());
   EXPECT_EQ(1U, passwords[cross_origin_form_.signon_realm].size());
   EXPECT_FALSE(passwords[form_.signon_realm][0].skip_zero_click);
@@ skipping 317 matching lines @@
   const uint32 kMsgID = CredentialManagerMsg_SendCredential::ID;
   const IPC::Message* message =
       process()->sink().GetFirstMessageMatching(kMsgID);
   ASSERT_TRUE(message);
   CredentialManagerMsg_SendCredential::Param param;
   CredentialManagerMsg_SendCredential::Read(message, &param);
   EXPECT_EQ(CredentialType::CREDENTIAL_TYPE_EMPTY, get<1>(param).type);
 }
 
 }  // namespace password_manager