Parse the whitelist expressions from the phishing verdict response if

chrome/browser/safe_browsing/safe_browsing_util.cc

 // Copyright (c) 2011 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/safe_browsing/safe_browsing_util.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
@@ skipping 399 matching lines @@
       paths->push_back(std::string(path.begin(), i + 1));
   }
 
   if (!paths->empty() && paths->back() != path)
     paths->push_back(path);
 
   if (!query.empty())
     paths->push_back(path + "?" + query);
 }
 
+void GeneratePatternsToCheck(const GURL& url, std::vector<std::string>* urls) {
+  std::vector<std::string> hosts, paths;
+  GenerateHostsToCheck(url, &hosts);
+  GeneratePathsToCheck(url, &paths);
+  for (size_t h = 0; h < hosts.size(); ++h) {
+    for (size_t p = 0; p < paths.size(); ++p) {
+      urls->push_back(hosts[h] + paths[p]);
+    }
+  }
+}
+
 int GetHashIndex(const SBFullHash& hash,
                  const std::vector<SBFullHashResult>& full_hashes) {
   for (size_t i = 0; i < full_hashes.size(); ++i) {
     if (hash == full_hashes[i].hash)
       return static_cast<int>(i);
   }
   return -1;
 }
 
 int GetUrlHashIndex(const GURL& url,
                     const std::vector<SBFullHashResult>& full_hashes) {
   if (full_hashes.empty())
     return -1;
 
-  std::vector<std::string> hosts, paths;
-  GenerateHostsToCheck(url, &hosts);
-  GeneratePathsToCheck(url, &paths);
+  std::vector<std::string> patterns;
+  GeneratePatternsToCheck(url, &patterns);
 
-  for (size_t h = 0; h < hosts.size(); ++h) {
-    for (size_t p = 0; p < paths.size(); ++p) {
-      SBFullHash key;
-      crypto::SHA256HashString(hosts[h] + paths[p],
-                               key.full_hash,
-                               sizeof(SBFullHash));
-      int index = GetHashIndex(key, full_hashes);
-      if (index != -1) return index;
-    }
+  for (size_t i = 0; i < patterns.size(); ++i) {
+    SBFullHash key;
+    crypto::SHA256HashString(patterns[i], key.full_hash, sizeof(SBFullHash));
+    int index = GetHashIndex(key, full_hashes);
+    if (index != -1)
+      return index;
   }
-
   return -1;
 }
 
 bool IsPhishingList(const std::string& list_name) {
   return list_name.compare(kPhishingList) == 0;
 }
 
 bool IsMalwareList(const std::string& list_name) {
   return list_name.compare(kMalwareList) == 0;
 }
@@ skipping 69 matching lines @@
 void StringToSBFullHash(const std::string& hash_in, SBFullHash* hash_out) {
   DCHECK_EQ(static_cast<size_t>(crypto::SHA256_LENGTH), hash_in.size());
   memcpy(hash_out->full_hash, hash_in.data(), crypto::SHA256_LENGTH);
 }
 
 std::string SBFullHashToString(const SBFullHash& hash) {
   DCHECK_EQ(static_cast<size_t>(crypto::SHA256_LENGTH), sizeof(hash.full_hash));
   return std::string(hash.full_hash, sizeof(hash.full_hash));
 }
 }  // namespace safe_browsing_util