Move ShouldFilterAutofillResult from ChromePasswordManagerClient to PasswordManager

chrome/browser/password_manager/chrome_password_manager_client_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 "chrome/browser/password_manager/chrome_password_manager_client.h"
 
 #include "base/command_line.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service_mock.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/autofill/content/common/autofill_messages.h"
 #include "components/password_manager/content/browser/password_manager_internals_service_factory.h"
 #include "components/password_manager/content/common/credential_manager_messages.h"
 #include "components/password_manager/core/browser/log_receiver.h"
 #include "components/password_manager/core/browser/password_manager_internals_service.h"
+#include "components/password_manager/core/browser/store_result_filter.h"
 #include "components/password_manager/core/common/credential_manager_types.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "components/password_manager/core/common/password_manager_switches.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserContext;
 using content::WebContents;
 using testing::Return;
 using testing::_;
 
 namespace {
 
 const char kTestText[] = "abcd1234";
 
 class MockLogReceiver : public password_manager::LogReceiver {
  public:
   MOCK_METHOD1(LogSavePasswordProgress, void(const std::string&));
 };
 
 // TODO(vabr): Get rid of the mocked client in the client's own test, see
 // http://crbug.com/474577.
 class MockChromePasswordManagerClient : public ChromePasswordManagerClient {
  public:
-  MOCK_CONST_METHOD0(IsPasswordManagementEnabledForCurrentPage, bool());

[engedy, 2015/08/04 10:11:29]

nit: Why this is going away? Is it just drive-by refactoring?

[vabr (Chromium), 2015/08/04 12:21:25]

Yes. I will mention it in the CL description, this is for
http://crbug.com/474577 in particular.

   MOCK_CONST_METHOD0(DidLastPageLoadEncounterSSLErrors, bool());
   MOCK_CONST_METHOD2(IsSyncAccountCredential,
                      bool(const std::string& username,
                           const std::string& origin));
 
   explicit MockChromePasswordManagerClient(content::WebContents* web_contents)
       : ChromePasswordManagerClient(web_contents, nullptr) {
     ON_CALL(*this, DidLastPageLoadEncounterSSLErrors())
         .WillByDefault(testing::Return(false));
-    ON_CALL(*this, IsPasswordManagementEnabledForCurrentPage())
-        .WillByDefault(testing::Return(true));
   }
   ~MockChromePasswordManagerClient() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockChromePasswordManagerClient);
 };
 
 }  // namespace
 
 class ChromePasswordManagerClientTest : public ChromeRenderViewHostTestHarness {
@@ skipping 157 matching lines @@
   service_->RegisterReceiver(&receiver_);
   EXPECT_TRUE(client->IsLoggingActive());
 
   EXPECT_CALL(receiver_, LogSavePasswordProgress(kTestText)).Times(1);
   client->LogSavePasswordProgress(kTestText);
 
   service_->UnregisterReceiver(&receiver_);
   EXPECT_FALSE(client->IsLoggingActive());
 }
 
-TEST_F(ChromePasswordManagerClientTest, ShouldFilterAutofillResult_Reauth) {
-  // Make client disallow only reauth requests.
-  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-  command_line->AppendSwitch(
-      password_manager::switches::kDisallowAutofillSyncCredentialForReauth);
-  scoped_ptr<MockChromePasswordManagerClient> client(
-      new MockChromePasswordManagerClient(web_contents()));
-  autofill::PasswordForm form;
-
-  EXPECT_CALL(*client, IsSyncAccountCredential(_, _))
-      .WillRepeatedly(Return(false));
-  NavigateAndCommit(
-      GURL("https://accounts.google.com/login?rart=123&continue=blah"));
-  EXPECT_FALSE(client->ShouldFilterAutofillResult(form));
-
-  EXPECT_CALL(*client, IsSyncAccountCredential(_, _))
-      .WillRepeatedly(Return(true));
-  NavigateAndCommit(
-      GURL("https://accounts.google.com/login?rart=123&continue=blah"));
-  EXPECT_TRUE(client->ShouldFilterAutofillResult(form));
-
-  // This counts as a reauth url, though a valid URL should have a value for
-  // "rart"
-  NavigateAndCommit(GURL("https://accounts.google.com/addlogin?rart"));
-  EXPECT_TRUE(client->ShouldFilterAutofillResult(form));
-
-  NavigateAndCommit(GURL("https://accounts.google.com/login?param=123"));
-  EXPECT_FALSE(client->ShouldFilterAutofillResult(form));
-
-  NavigateAndCommit(GURL("https://site.com/login?rart=678"));
-  EXPECT_FALSE(client->ShouldFilterAutofillResult(form));
-}
-
-TEST_F(ChromePasswordManagerClientTest, ShouldFilterAutofillResult) {
-  // Normally the client should allow any credentials through, even if they
-  // are the sync credential.
-  scoped_ptr<MockChromePasswordManagerClient> client(
-      new MockChromePasswordManagerClient(web_contents()));
-  autofill::PasswordForm form;
-  EXPECT_CALL(*client, IsSyncAccountCredential(_, _))
-      .WillRepeatedly(Return(true));
-  NavigateAndCommit(GURL("https://accounts.google.com/Login"));
-  EXPECT_FALSE(client->ShouldFilterAutofillResult(form));
-
-  // Adding disallow switch should cause sync credential to be filtered.
-  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-  command_line->AppendSwitch(
-      password_manager::switches::kDisallowAutofillSyncCredential);
-  client.reset(new MockChromePasswordManagerClient(web_contents()));
-  EXPECT_CALL(*client, IsSyncAccountCredential(_, _))
-      .WillRepeatedly(Return(true));
-  NavigateAndCommit(GURL("https://accounts.google.com/Login"));
-  EXPECT_TRUE(client->ShouldFilterAutofillResult(form));
-}
-
 TEST_F(ChromePasswordManagerClientTest,
        IsPasswordManagementEnabledForCurrentPage) {
   ChromePasswordManagerClient* client = GetClient();
   NavigateAndCommit(
       GURL("https://accounts.google.com/ServiceLogin?continue="
            "https://passwords.google.com/settings&rart=123"));
   EXPECT_FALSE(client->IsPasswordManagementEnabledForCurrentPage());
 
   // Password site is inaccesible via HTTP, but because of HSTS the following
   // link should still continue to https://passwords.google.com.
@@ skipping 155 matching lines @@
   profile()->ForceIncognito(true);
   EXPECT_FALSE(client->IsSavingEnabledForCurrentPage());
 
   // Functionality disabled in Incognito mode also when manager itself is
   // enabled.
   prefs()->SetUserPref(password_manager::prefs::kPasswordManagerSavingEnabled,
                        new base::FundamentalValue(true));
   EXPECT_FALSE(client->IsSavingEnabledForCurrentPage());
   profile()->ForceIncognito(false);
 }
+
+TEST_F(ChromePasswordManagerClientTest, GetLastCommittedEntryURL_Empty) {
+  EXPECT_EQ(GURL::EmptyGURL(), GetClient()->GetLastCommittedEntryURL());
+}
+
+TEST_F(ChromePasswordManagerClientTest, GetLastCommittedEntryURL) {
+  GURL kUrl(
+      "https://accounts.google.com/ServiceLogin?continue="
+      "https://passwords.google.com/settings&rart=123");
+  NavigateAndCommit(kUrl);
+  EXPECT_EQ(kUrl, GetClient()->GetLastCommittedEntryURL());
+}
+
+TEST_F(ChromePasswordManagerClientTest, CreateStoreResulFilter) {
+  scoped_ptr<password_manager::StoreResultFilter> filter1 =
+      GetClient()->CreateStoreResultFilter();
+  scoped_ptr<password_manager::StoreResultFilter> filter2 =
+      GetClient()->CreateStoreResultFilter();
+  EXPECT_TRUE(filter1);
+  EXPECT_TRUE(filter2);
+  EXPECT_NE(filter1.get(), filter2.get());
+}