Deprecate cache_expression_exact_match

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"
@@ skipping 97 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestPasswordProtectionService);
 };
 
 class PasswordProtectionServiceTest : public testing::Test {
  public:
   PasswordProtectionServiceTest(){};
 
   LoginReputationClientResponse CreateVerdictProto(
       LoginReputationClientResponse::VerdictType verdict,
       int cache_duration_sec,
-      const std::string& cache_expression,
-      bool exact_match) {
+      const std::string& cache_expression) {
     LoginReputationClientResponse verdict_proto;
     verdict_proto.set_verdict_type(verdict);
     verdict_proto.set_cache_duration_sec(cache_duration_sec);
     verdict_proto.set_cache_expression(cache_expression);
-    verdict_proto.set_cache_expression_exact_match(exact_match);
     return verdict_proto;
   }
 
   void SetUp() override {
     HostContentSettingsMap::RegisterProfilePrefs(test_pref_service_.registry());
     content_setting_map_ = new HostContentSettingsMap(
         &test_pref_service_, false /* incognito */, false /* guest_profile */);
     database_manager_ = new MockSafeBrowsingDatabaseManager();
     dummy_request_context_getter_ = new DummyURLRequestContextGetter();
     password_protection_service_ =
@@ skipping 20 matching lines @@
 
   bool PathVariantsMatchCacheExpression(const GURL& url,
                                         const std::string& cache_expression) {
     std::vector<std::string> paths;
     PasswordProtectionService::GeneratePathVariantsWithoutQuery(url, &paths);
     return PasswordProtectionService::PathVariantsMatchCacheExpression(
         paths,
         PasswordProtectionService::GetCacheExpressionPath(cache_expression));
   }
 
-  bool PathMatchCacheExpressionExactly(const GURL& url,
-                                       const std::string& cache_expression) {
-    std::vector<std::string> paths;
-    PasswordProtectionService::GeneratePathVariantsWithoutQuery(url, &paths);
-    return PasswordProtectionService::PathMatchCacheExpressionExactly(
-        paths,
-        PasswordProtectionService::GetCacheExpressionPath(cache_expression));
-  }
-
   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));
+    LoginReputationClientResponse response(
+        CreateVerdictProto(verdict, cache_duration_sec, cache_expression));
     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
@@ skipping 51 matching lines @@
       nullptr, &cache_creation_time, &response));
 
   // ParseVerdictEntry fails if the input dict value is invalid.
   EXPECT_FALSE(PasswordProtectionService::ParseVerdictEntry(
       invalid_verdict_entry.get(), &cache_creation_time, &response));
 }
 
 TEST_F(PasswordProtectionServiceTest, TestParseValidVerdictEntry) {
   base::Time expected_creation_time = base::Time::Now();
   LoginReputationClientResponse expected_verdict(CreateVerdictProto(
-      LoginReputationClientResponse::SAFE, 10 * 60, "test.com/foo", true));
+      LoginReputationClientResponse::SAFE, 10 * 60, "test.com/foo"));
   std::unique_ptr<base::DictionaryValue> valid_verdict_entry =
       PasswordProtectionService::CreateDictionaryFromVerdict(
           &expected_verdict, expected_creation_time);
 
   int actual_cache_creation_time;
   LoginReputationClientResponse actual_verdict;
   ASSERT_TRUE(PasswordProtectionService::ParseVerdictEntry(
       valid_verdict_entry.get(), &actual_cache_creation_time, &actual_verdict));
 
   EXPECT_EQ(static_cast<int>(expected_creation_time.ToDoubleT()),
             actual_cache_creation_time);
   EXPECT_EQ(expected_verdict.cache_duration_sec(),
             actual_verdict.cache_duration_sec());
   EXPECT_EQ(expected_verdict.verdict_type(), actual_verdict.verdict_type());
   EXPECT_EQ(expected_verdict.cache_expression(),
             actual_verdict.cache_expression());
-  EXPECT_EQ(expected_verdict.cache_expression_exact_match(),
-            actual_verdict.cache_expression_exact_match());
 }
 
 TEST_F(PasswordProtectionServiceTest, TestPathVariantsMatchCacheExpression) {
   // Cache expression without path.
   std::string cache_expression("google.com");
   std::string cache_expression_with_slash("google.com/");
   EXPECT_TRUE(PathVariantsMatchCacheExpression(GURL("https://www.google.com"),
                                                cache_expression));
   EXPECT_TRUE(PathVariantsMatchCacheExpression(GURL("https://www.google.com"),
                                                cache_expression_with_slash));
@@ skipping 20 matching lines @@
   EXPECT_TRUE(PathVariantsMatchCacheExpression(
       GURL("http://evil.com/bad/foo/index.html"), cache_expression));
   EXPECT_TRUE(PathVariantsMatchCacheExpression(
       GURL("http://evil.com/bad/foo/index.html"), cache_expression_with_slash));
   EXPECT_FALSE(PathVariantsMatchCacheExpression(
       GURL("http://evil.com/worse/index.html"), cache_expression));
   EXPECT_FALSE(PathVariantsMatchCacheExpression(
       GURL("http://evil.com/worse/index.html"), cache_expression_with_slash));
 }
 
-TEST_F(PasswordProtectionServiceTest, TestPathMatchCacheExpressionExactly) {
-  // Cache expression without path.
-  std::string cache_expression("www.google.com");
-  EXPECT_TRUE(PathMatchCacheExpressionExactly(GURL("https://www.google.com"),
-                                              cache_expression));
-  EXPECT_TRUE(PathMatchCacheExpressionExactly(GURL("https://www.google.com/"),
-                                              cache_expression));
-  EXPECT_TRUE(PathMatchCacheExpressionExactly(
-      GURL("https://www.google.com/index.html"), cache_expression));
-  EXPECT_FALSE(PathMatchCacheExpressionExactly(
-      GURL("https://www.google.com/abc/"), cache_expression));
-  EXPECT_FALSE(PathMatchCacheExpressionExactly(
-      GURL("https://www.google.com/def/login"), cache_expression));
-
-  // Cache expression with path.
-  cache_expression = "evil.com/bad";
-  EXPECT_FALSE(PathMatchCacheExpressionExactly(GURL("http://evil.com"),
-                                               cache_expression));
-  EXPECT_FALSE(PathMatchCacheExpressionExactly(GURL("http://evil.com/"),
-                                               cache_expression));
-  EXPECT_TRUE(PathMatchCacheExpressionExactly(GURL("http://evil.com/bad/"),
-                                              cache_expression));
-  EXPECT_TRUE(PathMatchCacheExpressionExactly(
-      GURL("http://evil.com/bad/index.html"), cache_expression));
-  EXPECT_FALSE(PathMatchCacheExpressionExactly(GURL("http://evil.com/bad/abc/"),
-                                               cache_expression));
-  EXPECT_FALSE(PathMatchCacheExpressionExactly(
-      GURL("http://evil.com/bad/abc/login.jsp"), cache_expression));
-}
-
 TEST_F(PasswordProtectionServiceTest, TestCachedVerdicts) {
   ASSERT_EQ(0U, GetStoredVerdictCount());
   // Assume each verdict has a TTL of 10 minutes.
   // Cache a verdict for http://www.test.com/foo/index.html
   CacheVerdict(GURL("http://www.test.com/foo/index.html"),
                LoginReputationClientResponse::SAFE, 10 * 60, "test.com/foo",
-               false, base::Time::Now());
+               base::Time::Now());
 
   EXPECT_EQ(1U, GetStoredVerdictCount());
 
   // 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());
+               base::Time::Now());
   EXPECT_EQ(1U, GetStoredVerdictCount());
   LoginReputationClientResponse out_verdict;
   EXPECT_EQ(LoginReputationClientResponse::PHISHING,
             password_protection_service_->GetCachedVerdict(
                 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());
+               base::Time::Now());
   EXPECT_EQ(2U, GetStoredVerdictCount());
 }
 
 TEST_F(PasswordProtectionServiceTest, TestGetCachedVerdicts) {
   ASSERT_EQ(0U, GetStoredVerdictCount());
-  // Prepare 3 verdicts of the same origin with different cache expressions:
-  // (1) require exact match, not expired.
-  // (2) not require exact match, not expired.
-  // (3) require exact match, expired.
+  // Prepare 2 verdicts of the same origin with different cache expressions,
+  // one is expired, the other is not.
   base::Time now = base::Time::Now();
   CacheVerdict(GURL("http://test.com/login.html"),
-               LoginReputationClientResponse::SAFE, 10 * 60, "test.com", true,
-               now);
-  CacheVerdict(GURL("http://test.com/abc/index.jsp"),
-               LoginReputationClientResponse::LOW_REPUTATION, 10 * 60,
-               "test.com/abc", false, now);
+               LoginReputationClientResponse::SAFE, 10 * 60, "test.com", now);
   CacheVerdict(
       GURL("http://test.com/def/index.jsp"),
-      LoginReputationClientResponse::PHISHING, 10 * 60, "test.com/def", false,
+      LoginReputationClientResponse::PHISHING, 10 * 60, "test.com/def",
       base::Time::FromDoubleT(now.ToDoubleT() -
                               24.0 * 60.0 * 60.0));  // Yesterday, expired.
-  ASSERT_EQ(3U, GetStoredVerdictCount());
+  ASSERT_EQ(2U, 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(
                 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,
+  // Return SAFE if look up for a URL that matches "test.com" cache expression.
+  EXPECT_EQ(LoginReputationClientResponse::SAFE,
             password_protection_service_->GetCachedVerdict(
                 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.
+  // test.com/def, but the corresponding verdict is expired.
   EXPECT_EQ(LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED,
             password_protection_service_->GetCachedVerdict(
                 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(
-                GURL("http://test.com/ghi/index.html"), &actual_verdict));
-  EXPECT_EQ(LoginReputationClientResponse::SAFE,
-            password_protection_service_->GetCachedVerdict(
-                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(
-                GURL("http://test.com/abc/"), &actual_verdict));
-  EXPECT_EQ(LoginReputationClientResponse::LOW_REPUTATION,
-            password_protection_service_->GetCachedVerdict(
-                GURL("http://test.com/abc/bar.jsp"), &actual_verdict));
-  EXPECT_EQ(LoginReputationClientResponse::LOW_REPUTATION,
-            password_protection_service_->GetCachedVerdict(
-                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);
+               "foo.com/abc", now);
   CacheVerdict(GURL("http://bar.com/index.jsp"),
                LoginReputationClientResponse::PHISHING, 10 * 60, "bar.com",
-               false, now);
+               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);
   EXPECT_EQ(1U, GetStoredVerdictCount());
   LoginReputationClientResponse actual_verdict;
@@ skipping 39 matching lines @@
                             10000 /* timeout in ms*/);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(nullptr, password_protection_service_->latest_response());
   EXPECT_THAT(histograms_.GetAllSamples(kRequestOutcomeHistogramName),
               testing::ElementsAre(base::Bucket(4 /* MATCHED_WHITELIST */, 1)));
 }
 
 TEST_F(PasswordProtectionServiceTest, TestNoRequestSentIfVerdictAlreadyCached) {
   histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
   CacheVerdict(GURL(kTargetUrl), LoginReputationClientResponse::LOW_REPUTATION,
-               600, GURL(kTargetUrl).host(), true, base::Time::Now());
+               600, GURL(kTargetUrl).host(), base::Time::Now());
   InitializeAndStartRequest(false /* match whitelist */,
                             10000 /* timeout in ms*/);
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(
       histograms_.GetAllSamples(kRequestOutcomeHistogramName),
       testing::ElementsAre(base::Bucket(5 /* RESPONSE_ALREADY_CACHED */, 1)));
   EXPECT_EQ(LoginReputationClientResponse::LOW_REPUTATION,
             password_protection_service_->latest_response()->verdict_type());
 }
 
@@ skipping 42 matching lines @@
               testing::ElementsAre(base::Bucket(3 /* TIMEDOUT */, 1)));
 }
 
 TEST_F(PasswordProtectionServiceTest, TestRequestAndResponseSuccessfull) {
   histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
   // Set up valid response.
   net::TestURLFetcher fetcher(0, GURL("http://bar.com"), nullptr);
   fetcher.set_status(
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, net::OK));
   fetcher.set_response_code(200);
-  LoginReputationClientResponse expected_response =
-      CreateVerdictProto(LoginReputationClientResponse::PHISHING, 600,
-                         GURL(kTargetUrl).host(), true);
+  LoginReputationClientResponse expected_response = CreateVerdictProto(
+      LoginReputationClientResponse::PHISHING, 600, GURL(kTargetUrl).host());
   fetcher.SetResponseString(expected_response.SerializeAsString());
 
   InitializeAndStartRequest(false /* match whitelist */,
                             10000 /* timeout in ms*/);
   request_->OnURLFetchComplete(&fetcher);
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(histograms_.GetAllSamples(kRequestOutcomeHistogramName),
               testing::ElementsAre(base::Bucket(1 /* SUCCEEDED */, 1)));
   LoginReputationClientResponse* actual_response =
       password_protection_service_->latest_response();
   EXPECT_EQ(expected_response.verdict_type(), actual_response->verdict_type());
   EXPECT_EQ(expected_response.cache_expression(),
             actual_response->cache_expression());
-  EXPECT_EQ(expected_response.cache_expression_exact_match(),
-            actual_response->cache_expression_exact_match());
   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);
 
   // 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