Link PasswordProtectionService to Profile and SB Service

components/safe_browsing/password_protection/password_protection_service_unittest.cc

 // Copyright 2017 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/safe_browsing/password_protection/password_protection_service.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/null_task_runner.h"
+#include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/safe_browsing/password_protection/password_protection_request.h"
 #include "components/safe_browsing_db/test_database_manager.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
@@ skipping 38 matching lines @@
 
   scoped_refptr<base::SingleThreadTaskRunner> dummy_task_runner_;
 };
 
 class TestPasswordProtectionService : public PasswordProtectionService {
  public:
   TestPasswordProtectionService(
       const scoped_refptr<SafeBrowsingDatabaseManager>& database_manager,
       scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_refptr<HostContentSettingsMap> content_setting_map)
-      : PasswordProtectionService(database_manager, request_context_getter),
-        content_setting_map_(content_setting_map) {}
-
-  HostContentSettingsMap* GetSettingMapForActiveProfile() override {
-    return content_setting_map_.get();
-  }
+      : PasswordProtectionService(database_manager,
+                                  request_context_getter,
+                                  nullptr,
+                                  content_setting_map.get()) {}
 
   void RequestFinished(
       PasswordProtectionRequest* request,
       std::unique_ptr<LoginReputationClientResponse> response) override {
     latest_response_ = std::move(response);
   }
 
+  // Intentionally do nothing.
+  void FillReferrerChain(const GURL& event_url,
+                         int event_tab_id,
+                         LoginReputationClientRequest::Frame* frame) override {}
+
+  bool IsExtendedReporting() override { return true; }
+
+  bool IsIncognito() override { return false; }

[Nathan Parker, 2017/03/30 21:38:12]

Do you test anywhere that these get used correctly?  Like if IsIncognito returns
false?

[Jialiu Lin, 2017/03/30 23:23:13]

Yes, these are just default returns. Situations like incognito, non-SBER, are
covered in 
TestNoRequestSentForIncognito, TestNoRequestSentForNonExtendedReporting.
I have refactored the testing code a little to make it easier to read.

+
+  bool IsPingingEnabled() override { return true; }
+
   LoginReputationClientResponse* latest_response() {
     return latest_response_.get();
   }
 
  private:
   std::unique_ptr<LoginReputationClientResponse> latest_response_;
-  scoped_refptr<HostContentSettingsMap> content_setting_map_;
   DISALLOW_COPY_AND_ASSIGN(TestPasswordProtectionService);
 };
 
 class PasswordProtectionServiceTest : public testing::Test {
  public:
   PasswordProtectionServiceTest(){};
 
   LoginReputationClientResponse CreateVerdictProto(
       LoginReputationClientResponse::VerdictType verdict,
       int cache_duration_sec,
@@ skipping 56 matching lines @@
   }
 
   void CacheVerdict(const GURL& url,
                     LoginReputationClientResponse::VerdictType verdict,
                     int cache_duration_sec,
                     const std::string& cache_expression,
                     bool exact_match,
                     const base::Time& verdict_received_time) {
     LoginReputationClientResponse response(CreateVerdictProto(
         verdict, cache_duration_sec, cache_expression, exact_match));
-    password_protection_service_->CacheVerdict(
-        url, &response, verdict_received_time, content_setting_map_.get());
+    password_protection_service_->CacheVerdict(url, &response,
+                                               verdict_received_time);
   }
 
   size_t GetStoredVerdictCount() {
     return password_protection_service_->GetStoredVerdictCount();
   }
 
  protected:
   // |thread_bundle_| is needed here because this test involves both UI and IO
   // threads.
   content::TestBrowserThreadBundle thread_bundle_;
@@ skipping 157 matching lines @@
 
   // Cache another verdict with the some origin and cache_expression should
   // override the cache.
   CacheVerdict(GURL("http://www.test.com/foo/index2.html"),
                LoginReputationClientResponse::PHISHING, 10 * 60, "test.com/foo",
                false, base::Time::Now());
   EXPECT_EQ(1U, GetStoredVerdictCount());
   LoginReputationClientResponse out_verdict;
   EXPECT_EQ(LoginReputationClientResponse::PHISHING,
             password_protection_service_->GetCachedVerdict(
-                content_setting_map_.get(),
                 GURL("http://www.test.com/foo/index2.html"), &out_verdict));
 
   // Cache another verdict with the same origin but different cache_expression
   // will not increase setting count, but will increase the number of verdicts
   // in the given origin.
   CacheVerdict(GURL("http://www.test.com/bar/index2.html"),
                LoginReputationClientResponse::SAFE, 10 * 60, "test.com/bar",
                false, base::Time::Now());
   EXPECT_EQ(2U, GetStoredVerdictCount());
 }
@@ skipping 15 matching lines @@
       GURL("http://test.com/def/index.jsp"),
       LoginReputationClientResponse::PHISHING, 10 * 60, "test.com/def", false,
       base::Time::FromDoubleT(now.ToDoubleT() -
                               24.0 * 60.0 * 60.0));  // Yesterday, expired.
   ASSERT_EQ(3U, GetStoredVerdictCount());
 
   // Return VERDICT_TYPE_UNSPECIFIED if look up for a URL with unknown origin.
   LoginReputationClientResponse actual_verdict;
   EXPECT_EQ(LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED,
             password_protection_service_->GetCachedVerdict(
-                content_setting_map_.get(), GURL("http://www.unknown.com/"),
-                &actual_verdict));
+                GURL("http://www.unknown.com/"), &actual_verdict));
 
   // Return VERDICT_TYPE_UNSPECIFIED if look up for a URL with http://test.com
   // origin, but doesn't match any known cache_expression.
   EXPECT_EQ(LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED,
             password_protection_service_->GetCachedVerdict(
-                content_setting_map_.get(), GURL("http://test.com/xyz/foo.jsp"),
-                &actual_verdict));
+                GURL("http://test.com/xyz/foo.jsp"), &actual_verdict));
 
   // Return VERDICT_TYPE_UNSPECIFIED if look up for a URL whose variants match
   // test.com/def, since corresponding entry is expired.
   EXPECT_EQ(LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED,
             password_protection_service_->GetCachedVerdict(
-                content_setting_map_.get(),
                 GURL("http://test.com/def/ghi/index.html"), &actual_verdict));
 
   // Return VERDICT_TYPE_UNSPECIFIED if look up for a URL whose variants match
   // test.com, but not match it exactly. Return SAFE if it is a exact match of
   // test.com.
   EXPECT_EQ(LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED,
             password_protection_service_->GetCachedVerdict(
-                content_setting_map_.get(),
                 GURL("http://test.com/ghi/index.html"), &actual_verdict));
   EXPECT_EQ(LoginReputationClientResponse::SAFE,
             password_protection_service_->GetCachedVerdict(
-                content_setting_map_.get(),
                 GURL("http://test.com/term_of_service.html"), &actual_verdict));
 
   // Return LOW_REPUTATION if look up for a URL whose variants match
   // test.com/abc.
   EXPECT_EQ(LoginReputationClientResponse::LOW_REPUTATION,
             password_protection_service_->GetCachedVerdict(
-                content_setting_map_.get(), GURL("http://test.com/abc/"),
-                &actual_verdict));
+                GURL("http://test.com/abc/"), &actual_verdict));
   EXPECT_EQ(LoginReputationClientResponse::LOW_REPUTATION,
             password_protection_service_->GetCachedVerdict(
-                content_setting_map_.get(), GURL("http://test.com/abc/bar.jsp"),
-                &actual_verdict));
+                GURL("http://test.com/abc/bar.jsp"), &actual_verdict));
   EXPECT_EQ(LoginReputationClientResponse::LOW_REPUTATION,
             password_protection_service_->GetCachedVerdict(
-                content_setting_map_.get(),
                 GURL("http://test.com/abc/foo/bar.html"), &actual_verdict));
 }
 
 TEST_F(PasswordProtectionServiceTest, TestCleanUpCachedVerdicts) {
   ASSERT_EQ(0U, GetStoredVerdictCount());
   // Prepare 2 verdicts. One is for origin "http://foo.com", and the other is
   // for "http://bar.com".
   base::Time now = base::Time::Now();
   CacheVerdict(GURL("http://foo.com/abc/index.jsp"),
                LoginReputationClientResponse::LOW_REPUTATION, 10 * 60,
                "foo.com/abc", false, now);
   CacheVerdict(GURL("http://bar.com/index.jsp"),
                LoginReputationClientResponse::PHISHING, 10 * 60, "bar.com",
                false, now);
   ASSERT_EQ(2U, GetStoredVerdictCount());
 
   // Delete a bar.com URL. Corresponding content setting keyed on
   // origin "http://bar.com" should be removed,
   history::URLRows deleted_urls;
   deleted_urls.push_back(history::URLRow(GURL("http://bar.com")));
   password_protection_service_->RemoveContentSettingsOnURLsDeleted(
-      false /* all_history */, deleted_urls, content_setting_map_.get());
+      false /* all_history */, deleted_urls);
   EXPECT_EQ(1U, GetStoredVerdictCount());
   LoginReputationClientResponse actual_verdict;
-  EXPECT_EQ(
-      LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED,
-      password_protection_service_->GetCachedVerdict(
-          content_setting_map_.get(), GURL("http://bar.com"), &actual_verdict));
+  EXPECT_EQ(LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED,
+            password_protection_service_->GetCachedVerdict(
+                GURL("http://bar.com"), &actual_verdict));
 
   // If delete all history. All password protection content settings should be
   // gone.
   password_protection_service_->RemoveContentSettingsOnURLsDeleted(
-      true /* all_history */, history::URLRows(), content_setting_map_.get());
+      true /* all_history */, history::URLRows());
   EXPECT_EQ(0U, GetStoredVerdictCount());
 }
 
 TEST_F(PasswordProtectionServiceTest, TestNoRequestSentForIncognito) {
   histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
   InitializeAndStartRequest(true /* extended_reporting */, true /* incognito */,
                             false /* match whitelist */, 10 /* timeout */);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(nullptr, password_protection_service_->latest_response());
   EXPECT_THAT(histograms_.GetAllSamples(kRequestOutcomeHistogramName),
@@ skipping 117 matching lines @@
   EXPECT_EQ(expected_response.cache_duration_sec(),
             actual_response->cache_duration_sec());
 }
 
 TEST_F(PasswordProtectionServiceTest, TestTearDownWithPendingRequests) {
   histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
   GURL target_url(kTargetUrl);
   EXPECT_CALL(*database_manager_.get(), MatchCsdWhitelistUrl(target_url))
       .WillRepeatedly(testing::Return(false));
   password_protection_service_->StartRequest(
-      target_url, LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE,
-      true /* extended_reporting */, false /* incognito */);
+      target_url, LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE);
 
   // Destroy password_protection_service_ while there is one request pending.
   password_protection_service_.reset();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(histograms_.GetAllSamples(kRequestOutcomeHistogramName),
               testing::ElementsAre(base::Bucket(2 /* CANCELED */, 1)));
 }
 }  // namespace safe_browsing