Deprecate cache_expression_exact_match

components/safe_browsing/password_protection/password_protection_service.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/bind.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 113 matching lines @@
   std::unique_ptr<base::DictionaryValue> verdict_dictionary =
       base::DictionaryValue::From(content_settings_->GetWebsiteSetting(
           hostname, GURL(), CONTENT_SETTINGS_TYPE_PASSWORD_PROTECTION,
           std::string(), nullptr));
   // Return early if there is no verdict cached for this origin.
   if (!verdict_dictionary.get() || verdict_dictionary->empty())
     return LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED;
 
   std::vector<std::string> paths;
   GeneratePathVariantsWithoutQuery(url, &paths);
-  size_t max_path_depth = 0U;
+  int max_path_depth = -1;
   LoginReputationClientResponse::VerdictType most_matching_verdict =
       LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED;
   // For all the verdicts of the same origin, we key them by |cache_expression|.
   // Its corresponding value is a DictionaryValue contains its creation time and
   // the serialized verdict proto.
   for (base::DictionaryValue::Iterator it(*verdict_dictionary.get());
        !it.IsAtEnd(); it.Advance()) {
     base::DictionaryValue* verdict_entry = nullptr;
     CHECK(verdict_dictionary->GetDictionaryWithoutPathExpansion(
         it.key() /* cache_expression */, &verdict_entry));
     int verdict_received_time;
     LoginReputationClientResponse verdict;
     CHECK(ParseVerdictEntry(verdict_entry, &verdict_received_time, &verdict));
     // Since password protection content settings are keyed by origin, we only
     // need to compare the path part of the cache_expression and the given url.
     std::string cache_expression_path =
         GetCacheExpressionPath(verdict.cache_expression());
 
-    if (verdict.cache_expression_exact_match()) {
-      if (PathMatchCacheExpressionExactly(paths, cache_expression_path)) {
-        if (!IsCacheExpired(verdict_received_time,
-                            verdict.cache_duration_sec())) {
-          out_response->CopyFrom(verdict);
-          return verdict.verdict_type();
-        } else {  // verdict expired
-          return LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED;
-        }
-      }
-    } else {
-      // If it doesn't require exact match, we need to find the most specific
-      // match.
-      size_t path_depth = GetPathDepth(cache_expression_path);
-      if (path_depth > max_path_depth &&
-          PathVariantsMatchCacheExpression(paths, cache_expression_path) &&
-          !IsCacheExpired(verdict_received_time,
-                          verdict.cache_duration_sec())) {
-        max_path_depth = path_depth;
-        most_matching_verdict = verdict.verdict_type();
-        out_response->CopyFrom(verdict);
-      }
+    // Finds the most specific match.
+    int path_depth = static_cast<int>(GetPathDepth(cache_expression_path));
+    if (path_depth > max_path_depth &&
+        PathVariantsMatchCacheExpression(paths, cache_expression_path)) {
+      max_path_depth = path_depth;
+      // If the most matching verdict is expired, set the result to
+      // VERDICT_TYPE_UNSPECIFIED.
+      most_matching_verdict =
+          IsCacheExpired(verdict_received_time, verdict.cache_duration_sec())
+              ? LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED
+              : verdict.verdict_type();
+      out_response->CopyFrom(verdict);
     }
   }
   return most_matching_verdict;
 }
 
 void PasswordProtectionService::CacheVerdict(
     const GURL& url,
     LoginReputationClientResponse* verdict,
     const base::Time& receive_time) {
   DCHECK(verdict);
@@ skipping 180 matching lines @@
                 verdict_entry->Get(kVerdictProto, &binary_value);
   if (!result)
     return false;
   DCHECK(result);
   DCHECK_EQ(base::Value::Type::BINARY, binary_value->type());
   const auto blob = binary_value->GetBlob();
   const std::string serialized_verdict_proto(blob.begin(), blob.end());
   return out_verdict->ParseFromString(serialized_verdict_proto);
 }
 
-bool PasswordProtectionService::PathMatchCacheExpressionExactly(
-    const std::vector<std::string>& generated_paths,
-    const std::string& cache_expression_path) {
-  size_t cache_expression_path_depth = GetPathDepth(cache_expression_path);
-  if (generated_paths.size() <= cache_expression_path_depth) {
-    return false;
-  }
-  std::string canonical_path = generated_paths.back();
-  size_t last_slash_pos = canonical_path.find_last_of("/");
-  DCHECK_NE(std::string::npos, last_slash_pos);
-  return canonical_path.substr(0, last_slash_pos + 1) == cache_expression_path;
-}
-
 bool PasswordProtectionService::PathVariantsMatchCacheExpression(
     const std::vector<std::string>& generated_paths,
     const std::string& cache_expression_path) {
   for (const auto& path : generated_paths) {
-    if (cache_expression_path == path) {
+    if (cache_expression_path == path)
       return true;
-    }
   }
   return false;
 }
 
 bool PasswordProtectionService::IsCacheExpired(int cache_creation_time,
                                                int cache_duration) {
   // TODO(jialiul): For now, we assume client's clock is accurate or almost
   // accurate. Need some logic to handle cases where client's clock is way
   // off.
   return base::Time::Now().ToDoubleT() >
@@ skipping 43 matching lines @@
   const std::vector<char> verdict_blob(serialized_proto.begin(),
                                        serialized_proto.end());
   std::unique_ptr<base::Value> binary_value =
       base::MakeUnique<base::Value>(verdict_blob);
   DCHECK_EQ(base::Value::Type::BINARY, binary_value->type());
   result->Set(kVerdictProto, std::move(binary_value));
   return result;
 }
 
 }  // namespace safe_browsing