1. Pull all code unrelated to chunking from chrome/browser/safe_browsing/safe_brwsing_util.h into components/safe_browsing_db.

2. All code that was formerly under the safe_browsing_util namespace is now under safe_browsing. That's the only namespace we plan to use going forward.
3. Chunking related code will stay in the old location and removed once we switch to PVER4.

The next CL in this series will move the structures/enums currently under the global namespace in safe_browsing_db_util.h into safe_browsing. I did not do that as part of this CL to keep it smaller and easier to review.

BUG=543161

Review URL: https://codereview.chromium.org/1420123003

Cr-Commit-Position: refs/heads/master@{#357763}

30 files changed, 930 insertions, 795 deletions

diff --git a/chrome/browser/extensions/fake_safe_browsing_database_manager.cc b/chrome/browser/extensions/fake_safe_browsing_database_manager.cc
index 0897401..3dc4274 100644
--- a/chrome/browser/extensions/fake_safe_browsing_database_manager.cc
+++ b/chrome/browser/extensions/fake_safe_browsing_database_manager.cc
@@ -100,14 +100,14 @@ bool FakeSafeBrowsingDatabaseManager::CheckExtensionIDs(
   std::vector<SBFullHash> extension_id_hashes;
   std::transform(extension_ids_vector.begin(), extension_ids_vector.end(),
                  std::back_inserter(extension_id_hashes),
-                 safe_browsing_util::StringToSBFullHash);
+                 safe_browsing::StringToSBFullHash);
 
   scoped_ptr<SafeBrowsingCheck> safe_browsing_check(
       new SafeBrowsingCheck(
           std::vector<GURL>(),
           extension_id_hashes,
           client,
-          safe_browsing_util::EXTENSIONBLACKLIST,
+          safe_browsing::EXTENSIONBLACKLIST,
           std::vector<SBThreatType>(1, SB_THREAT_TYPE_EXTENSION)));
 
   for (size_t i = 0; i < extension_ids_vector.size(); ++i) {
diff --git a/chrome/browser/prerender/prerender_browsertest.cc b/chrome/browser/prerender/prerender_browsertest.cc
index 82324f0..a9a6c01 100644
--- a/chrome/browser/prerender/prerender_browsertest.cc
+++ b/chrome/browser/prerender/prerender_browsertest.cc
@@ -755,7 +755,7 @@ class FakeSafeBrowsingDatabaseManager
         std::vector<GURL>(1, gurl),
         std::vector<SBFullHash>(),
         client,
-        safe_browsing_util::MALWARE,
+        safe_browsing::MALWARE,
         expected_threats);
     sb_check.url_results[0] = threat_type_;
     sb_check.OnSafeBrowsingResult();
diff --git a/chrome/browser/safe_browsing/database_manager.h b/chrome/browser/safe_browsing/database_manager.h
index cc0840b..8a438c7 100644
--- a/chrome/browser/safe_browsing/database_manager.h
+++ b/chrome/browser/safe_browsing/database_manager.h
@@ -15,7 +15,7 @@
 #include <vector>
 
 #include "base/memory/ref_counted.h"
-#include "chrome/browser/safe_browsing/safe_browsing_util.h"
+#include "components/safe_browsing_db/util.h"
 #include "content/public/common/resource_type.h"
 #include "url/gurl.h"
 
diff --git a/chrome/browser/safe_browsing/download_protection_service_unittest.cc b/chrome/browser/safe_browsing/download_protection_service_unittest.cc
index 8e32777..cbe556e 100644
--- a/chrome/browser/safe_browsing/download_protection_service_unittest.cc
+++ b/chrome/browser/safe_browsing/download_protection_service_unittest.cc
@@ -204,7 +204,7 @@ ACTION_P(CheckDownloadUrlDone, threat_type) {
           arg0,
           std::vector<SBFullHash>(),
           arg1,
-          safe_browsing_util::BINURL,
+          safe_browsing::BINURL,
           std::vector<SBThreatType>(1, SB_THREAT_TYPE_BINARY_MALWARE_URL));
   for (size_t i = 0; i < check->url_results.size(); ++i)
     check->url_results[i] = threat_type;
diff --git a/chrome/browser/safe_browsing/local_database_manager.cc b/chrome/browser/safe_browsing/local_database_manager.cc
index f50e098..9f23af3 100644
--- a/chrome/browser/safe_browsing/local_database_manager.cc
+++ b/chrome/browser/safe_browsing/local_database_manager.cc
@@ -32,6 +32,7 @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
+#include "components/safe_browsing_db/util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "url/url_constants.h"
@@ -47,7 +48,7 @@ const int kCheckTimeoutMs = 10000;
 // |true| if there were any prefix hits in |full_hashes|.
 void RecordGetHashCheckStatus(
     bool hit,
-    safe_browsing_util::ListType check_type,
+    safe_browsing::ListType check_type,
     const std::vector<SBFullHashResult>& full_hashes) {
   SafeBrowsingProtocolManager::ResultType result;
   if (full_hashes.empty()) {
@@ -57,7 +58,7 @@ void RecordGetHashCheckStatus(
   } else {
     result = SafeBrowsingProtocolManager::GET_HASH_FULL_HASH_MISS;
   }
-  bool is_download = check_type == safe_browsing_util::BINURL;
+  bool is_download = check_type == safe_browsing::BINURL;
   SafeBrowsingProtocolManager::RecordGetHashResult(is_download, result);
 }
 
@@ -71,32 +72,32 @@ bool IsExpectedThreat(
 
 // Return the severest list id from the results in |full_hashes| which matches
 // |hash|, or INVALID if none match.
-safe_browsing_util::ListType GetHashSeverestThreatListType(
+safe_browsing::ListType GetHashSeverestThreatListType(
     const SBFullHash& hash,
     const std::vector<SBFullHashResult>& full_hashes,
     size_t* index) {
-  safe_browsing_util::ListType pending_threat = safe_browsing_util::INVALID;
+  safe_browsing::ListType pending_threat = safe_browsing::INVALID;
   for (size_t i = 0; i < full_hashes.size(); ++i) {
-    if (SBFullHashEqual(hash, full_hashes[i].hash)) {
-      const safe_browsing_util::ListType threat =
-          static_cast<safe_browsing_util::ListType>(full_hashes[i].list_id);
+    if (safe_browsing::SBFullHashEqual(hash, full_hashes[i].hash)) {
+      const safe_browsing::ListType threat =
+          static_cast<safe_browsing::ListType>(full_hashes[i].list_id);
       switch (threat) {
-        case safe_browsing_util::INVALID:
+        case safe_browsing::INVALID:
           // |full_hashes| should never contain INVALID as a |list_id|.
           NOTREACHED();
           break;
-        case safe_browsing_util::MALWARE:                  // Falls through.
-        case safe_browsing_util::PHISH:                    // Falls through.
-        case safe_browsing_util::BINURL:                   // Falls through.
-        case safe_browsing_util::CSDWHITELIST:             // Falls through.
-        case safe_browsing_util::DOWNLOADWHITELIST:        // Falls through.
-        case safe_browsing_util::INCLUSIONWHITELIST:       // Falls through.
-        case safe_browsing_util::EXTENSIONBLACKLIST:       // Falls through.
-        case safe_browsing_util::IPBLACKLIST:
+        case safe_browsing::MALWARE:                  // Falls through.
+        case safe_browsing::PHISH:                    // Falls through.
+        case safe_browsing::BINURL:                   // Falls through.
+        case safe_browsing::CSDWHITELIST:             // Falls through.
+        case safe_browsing::DOWNLOADWHITELIST:        // Falls through.
+        case safe_browsing::INCLUSIONWHITELIST:       // Falls through.
+        case safe_browsing::EXTENSIONBLACKLIST:       // Falls through.
+        case safe_browsing::IPBLACKLIST:
           if (index)
             *index = i;
           return threat;
-        case safe_browsing_util::UNWANTEDURL:
+        case safe_browsing::UNWANTEDURL:
           // UNWANTEDURL is considered less severe than other threats, keep
           // looking.
           pending_threat = threat;
@@ -112,34 +113,34 @@ safe_browsing_util::ListType GetHashSeverestThreatListType(
 // Given a URL, compare all the possible host + path full hashes to the set of
 // provided full hashes.  Returns the list id of the severest matching result
 // from |full_hashes|, or INVALID if none match.
-safe_browsing_util::ListType GetUrlSeverestThreatListType(
+safe_browsing::ListType GetUrlSeverestThreatListType(
     const GURL& url,
     const std::vector<SBFullHashResult>& full_hashes,
     size_t* index) {
   if (full_hashes.empty())
-    return safe_browsing_util::INVALID;
+    return safe_browsing::INVALID;
 
   std::vector<std::string> patterns;
-  safe_browsing_util::GeneratePatternsToCheck(url, &patterns);
+  safe_browsing::GeneratePatternsToCheck(url, &patterns);
 
-  safe_browsing_util::ListType pending_threat = safe_browsing_util::INVALID;
+  safe_browsing::ListType pending_threat = safe_browsing::INVALID;
   for (size_t i = 0; i < patterns.size(); ++i) {
-    safe_browsing_util::ListType threat = GetHashSeverestThreatListType(
-        SBFullHashForString(patterns[i]), full_hashes, index);
+    safe_browsing::ListType threat = GetHashSeverestThreatListType(
+        safe_browsing::SBFullHashForString(patterns[i]), full_hashes, index);
     switch (threat) {
-      case safe_browsing_util::INVALID:
+      case safe_browsing::INVALID:
         // Ignore patterns with no matching threat.
         break;
-      case safe_browsing_util::MALWARE:                  // Falls through.
-      case safe_browsing_util::PHISH:                    // Falls through.
-      case safe_browsing_util::BINURL:                   // Falls through.
-      case safe_browsing_util::CSDWHITELIST:             // Falls through.
-      case safe_browsing_util::DOWNLOADWHITELIST:        // Falls through.
-      case safe_browsing_util::INCLUSIONWHITELIST:       // Falls through.
-      case safe_browsing_util::EXTENSIONBLACKLIST:       // Falls through.
-      case safe_browsing_util::IPBLACKLIST:
+      case safe_browsing::MALWARE:                  // Falls through.
+      case safe_browsing::PHISH:                    // Falls through.
+      case safe_browsing::BINURL:                   // Falls through.
+      case safe_browsing::CSDWHITELIST:             // Falls through.
+      case safe_browsing::DOWNLOADWHITELIST:        // Falls through.
+      case safe_browsing::INCLUSIONWHITELIST:       // Falls through.
+      case safe_browsing::EXTENSIONBLACKLIST:       // Falls through.
+      case safe_browsing::IPBLACKLIST:
         return threat;
-      case safe_browsing_util::UNWANTEDURL:
+      case safe_browsing::UNWANTEDURL:
         // UNWANTEDURL is considered less severe than other threats, keep
         // looking.
         pending_threat = threat;
@@ -149,17 +150,17 @@ safe_browsing_util::ListType GetUrlSeverestThreatListType(
   return pending_threat;
 }
 
-SBThreatType GetThreatTypeFromListType(safe_browsing_util::ListType list_type) {
+SBThreatType GetThreatTypeFromListType(safe_browsing::ListType list_type) {
   switch (list_type) {
-    case safe_browsing_util::PHISH:
+    case safe_browsing::PHISH:
       return SB_THREAT_TYPE_URL_PHISHING;
-    case safe_browsing_util::MALWARE:
+    case safe_browsing::MALWARE:
       return SB_THREAT_TYPE_URL_MALWARE;
-    case safe_browsing_util::UNWANTEDURL:
+    case safe_browsing::UNWANTEDURL:
       return SB_THREAT_TYPE_URL_UNWANTED;
-    case safe_browsing_util::BINURL:
+    case safe_browsing::BINURL:
       return SB_THREAT_TYPE_BINARY_MALWARE_URL;
-    case safe_browsing_util::EXTENSIONBLACKLIST:
+    case safe_browsing::EXTENSIONBLACKLIST:
       return SB_THREAT_TYPE_EXTENSION;
     default:
       DVLOG(1) << "Unknown safe browsing list id " << list_type;
@@ -190,7 +191,7 @@ LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::SafeBrowsingCheck(
     const std::vector<GURL>& urls,
     const std::vector<SBFullHash>& full_hashes,
     Client* client,
-    safe_browsing_util::ListType check_type,
+    safe_browsing::ListType check_type,
     const std::vector<SBThreatType>& expected_threats)
     : urls(urls),
       url_results(urls.size(), SB_THREAT_TYPE_SAFE),
@@ -218,14 +219,14 @@ void LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::
   if (!urls.empty()) {
     DCHECK(full_hashes.empty());
     switch (check_type) {
-      case safe_browsing_util::MALWARE:
-      case safe_browsing_util::PHISH:
-      case safe_browsing_util::UNWANTEDURL:
+      case safe_browsing::MALWARE:
+      case safe_browsing::PHISH:
+      case safe_browsing::UNWANTEDURL:
         DCHECK_EQ(1u, urls.size());
         client->OnCheckBrowseUrlResult(urls[0], url_results[0],
                                        url_metadata[0]);
         break;
-      case safe_browsing_util::BINURL:
+      case safe_browsing::BINURL:
         DCHECK_EQ(urls.size(), url_results.size());
         client->OnCheckDownloadUrlResult(
             urls, *std::max_element(url_results.begin(), url_results.end()));
@@ -235,11 +236,11 @@ void LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::
     }
   } else if (!full_hashes.empty()) {
     switch (check_type) {
-      case safe_browsing_util::EXTENSIONBLACKLIST: {
+      case safe_browsing::EXTENSIONBLACKLIST: {
         std::set<std::string> unsafe_extension_ids;
         for (size_t i = 0; i < full_hashes.size(); ++i) {
           std::string extension_id =
-              safe_browsing_util::SBFullHashToString(full_hashes[i]);
+              safe_browsing::SBFullHashToString(full_hashes[i]);
           if (full_hash_results[i] == SB_THREAT_TYPE_EXTENSION)
             unsafe_extension_ids.insert(extension_id);
         }
@@ -338,7 +339,7 @@ bool LocalSafeBrowsingDatabaseManager::CheckDownloadUrl(
       new SafeBrowsingCheck(url_chain,
                             std::vector<SBFullHash>(),
                             client,
-                            safe_browsing_util::BINURL,
+                            safe_browsing::BINURL,
                             std::vector<SBThreatType>(1,
                                 SB_THREAT_TYPE_BINARY_MALWARE_URL));
   std::vector<SBPrefix> prefixes;
@@ -361,7 +362,7 @@ bool LocalSafeBrowsingDatabaseManager::CheckExtensionIDs(
   std::vector<SBFullHash> extension_id_hashes;
   std::transform(extension_ids.begin(), extension_ids.end(),
                  std::back_inserter(extension_id_hashes),
-                 safe_browsing_util::StringToSBFullHash);
+                 safe_browsing::StringToSBFullHash);
   std::vector<SBPrefix> prefixes;
   for (const SBFullHash& hash : extension_id_hashes)
     prefixes.push_back(hash.prefix);
@@ -370,7 +371,7 @@ bool LocalSafeBrowsingDatabaseManager::CheckExtensionIDs(
       std::vector<GURL>(),
       extension_id_hashes,
       client,
-      safe_browsing_util::EXTENSIONBLACKLIST,
+      safe_browsing::EXTENSIONBLACKLIST,
       std::vector<SBThreatType>(1, SB_THREAT_TYPE_EXTENSION));
   StartSafeBrowsingCheck(
       check,
@@ -458,7 +459,7 @@ bool LocalSafeBrowsingDatabaseManager::CheckBrowseUrl(const GURL& url,
 
   const base::TimeTicks start = base::TimeTicks::Now();
   if (!MakeDatabaseAvailable()) {
-    QueuedCheck queued_check(safe_browsing_util::MALWARE,  // or PHISH
+    QueuedCheck queued_check(safe_browsing::MALWARE,  // or PHISH
                              client,
                              url,
                              expected_threats,
@@ -509,7 +510,7 @@ bool LocalSafeBrowsingDatabaseManager::CheckBrowseUrl(const GURL& url,
   SafeBrowsingCheck* check = new SafeBrowsingCheck(std::vector<GURL>(1, url),
                                                    std::vector<SBFullHash>(),
                                                    client,
-                                                   safe_browsing_util::MALWARE,
+                                                   safe_browsing::MALWARE,
                                                    expected_threats);
   check->need_get_hash = cache_hits.empty();
   check->prefix_hits.swap(prefix_hits);
@@ -671,7 +672,7 @@ void LocalSafeBrowsingDatabaseManager::NotifyDatabaseUpdateFinished(
 }
 
 LocalSafeBrowsingDatabaseManager::QueuedCheck::QueuedCheck(
-    const safe_browsing_util::ListType check_type,
+    const safe_browsing::ListType check_type,
     Client* client,
     const GURL& url,
     const std::vector<SBThreatType>& expected_threats,
@@ -871,7 +872,7 @@ void LocalSafeBrowsingDatabaseManager::RequestFullHash(
   if (!enabled_)
     return;
 
-  bool is_download = check->check_type == safe_browsing_util::BINURL;
+  bool is_download = check->check_type == safe_browsing::BINURL;
   sb_service_->protocol_manager()->GetFullHash(
       check->prefix_hits,
       base::Bind(&LocalSafeBrowsingDatabaseManager::HandleGetHashResults,
@@ -1024,7 +1025,7 @@ void LocalSafeBrowsingDatabaseManager::OnHandleGetHashResults(
     SafeBrowsingCheck* check,
     const std::vector<SBFullHashResult>& full_hashes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  safe_browsing_util::ListType check_type = check->check_type;
+  safe_browsing::ListType check_type = check->check_type;
   SBPrefix prefix = check->prefix_hits[0];
   GetHashRequests::iterator it = gethash_requests_.find(prefix);
   if (check->prefix_hits.size() > 1 || it == gethash_requests_.end()) {
diff --git a/chrome/browser/safe_browsing/local_database_manager.h b/chrome/browser/safe_browsing/local_database_manager.h
index 509a604..a848f1a6 100644
--- a/chrome/browser/safe_browsing/local_database_manager.h
+++ b/chrome/browser/safe_browsing/local_database_manager.h
@@ -24,7 +24,7 @@
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
-#include "chrome/browser/safe_browsing/safe_browsing_util.h"
+#include "components/safe_browsing_db/util.h"
 #include "url/gurl.h"
 
 class SafeBrowsingService;
@@ -57,7 +57,7 @@ class LocalSafeBrowsingDatabaseManager
     SafeBrowsingCheck(const std::vector<GURL>& urls,
                       const std::vector<SBFullHash>& full_hashes,
                       Client* client,
-                      safe_browsing_util::ListType check_type,
+                      safe_browsing::ListType check_type,
                       const std::vector<SBThreatType>& expected_threats);
     ~SafeBrowsingCheck();
 
@@ -74,7 +74,7 @@ class LocalSafeBrowsingDatabaseManager
     bool is_extended_reporting;
     bool need_get_hash;
     base::TimeTicks start;  // When check was sent to SB service.
-    safe_browsing_util::ListType check_type;  // See comment in constructor.
+    safe_browsing::ListType check_type;  // See comment in constructor.
     std::vector<SBThreatType> expected_threats;
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
@@ -154,13 +154,13 @@ class LocalSafeBrowsingDatabaseManager
 
   // Clients that we've queued up for checking later once the database is ready.
   struct QueuedCheck {
-    QueuedCheck(const safe_browsing_util::ListType check_type,
+    QueuedCheck(const safe_browsing::ListType check_type,
                 Client* client,
                 const GURL& url,
                 const std::vector<SBThreatType>& expected_threats,
                 const base::TimeTicks& start);
     ~QueuedCheck();
-    safe_browsing_util::ListType check_type;
+    safe_browsing::ListType check_type;
     Client* client;
     GURL url;
     std::vector<SBThreatType> expected_threats;
diff --git a/chrome/browser/safe_browsing/local_database_manager_unittest.cc b/chrome/browser/safe_browsing/local_database_manager_unittest.cc
index de8dc96..b4bbc30 100644
--- a/chrome/browser/safe_browsing/local_database_manager_unittest.cc
+++ b/chrome/browser/safe_browsing/local_database_manager_unittest.cc
@@ -40,7 +40,7 @@ class TestClient : public SafeBrowsingDatabaseManager::Client {
 
 class SafeBrowsingDatabaseManagerTest : public PlatformTest {
  public:
-  bool RunSBHashTest(const safe_browsing_util::ListType list_type,
+  bool RunSBHashTest(const safe_browsing::ListType list_type,
                      const std::vector<SBThreatType>& expected_threats,
                      const std::string& result_list);
 
@@ -49,7 +49,7 @@ class SafeBrowsingDatabaseManagerTest : public PlatformTest {
 };
 
 bool SafeBrowsingDatabaseManagerTest::RunSBHashTest(
-    const safe_browsing_util::ListType list_type,
+    const safe_browsing::ListType list_type,
     const std::vector<SBThreatType>& expected_threats,
     const std::string& result_list) {
   scoped_refptr<SafeBrowsingService> sb_service_(
@@ -69,7 +69,7 @@ bool SafeBrowsingDatabaseManagerTest::RunSBHashTest(
 
   const SBFullHashResult full_hash_result = {
       same_full_hash,
-      safe_browsing_util::GetListId(result_list)
+      safe_browsing::GetListId(result_list)
   };
 
   std::vector<SBFullHashResult> fake_results(1, full_hash_result);
@@ -82,23 +82,23 @@ bool SafeBrowsingDatabaseManagerTest::RunSBHashTest(
 TEST_F(SafeBrowsingDatabaseManagerTest, CheckCorrespondsListType) {
   std::vector<SBThreatType> malware_threat(1,
                                            SB_THREAT_TYPE_BINARY_MALWARE_URL);
-  EXPECT_FALSE(RunSBHashTest(safe_browsing_util::BINURL,
+  EXPECT_FALSE(RunSBHashTest(safe_browsing::BINURL,
                              malware_threat,
-                             safe_browsing_util::kMalwareList));
-  EXPECT_TRUE(RunSBHashTest(safe_browsing_util::BINURL,
+                             safe_browsing::kMalwareList));
+  EXPECT_TRUE(RunSBHashTest(safe_browsing::BINURL,
                             malware_threat,
-                            safe_browsing_util::kBinUrlList));
+                            safe_browsing::kBinUrlList));
 
   // Check for multiple threats
   std::vector<SBThreatType> multiple_threats;
   multiple_threats.push_back(SB_THREAT_TYPE_URL_MALWARE);
   multiple_threats.push_back(SB_THREAT_TYPE_URL_PHISHING);
-  EXPECT_FALSE(RunSBHashTest(safe_browsing_util::MALWARE,
+  EXPECT_FALSE(RunSBHashTest(safe_browsing::MALWARE,
                              multiple_threats,
-                             safe_browsing_util::kBinUrlList));
-  EXPECT_TRUE(RunSBHashTest(safe_browsing_util::MALWARE,
+                             safe_browsing::kBinUrlList));
+  EXPECT_TRUE(RunSBHashTest(safe_browsing::MALWARE,
                             multiple_threats,
-                            safe_browsing_util::kMalwareList));
+                            safe_browsing::kMalwareList));
 }
 
 TEST_F(SafeBrowsingDatabaseManagerTest, GetUrlSeverestThreatType) {
@@ -111,31 +111,35 @@ TEST_F(SafeBrowsingDatabaseManagerTest, GetUrlSeverestThreatType) {
       "http://www.unwantedandmalware.com/page.html");
   const GURL kSafeUrl("http://www.safe.com/page.html");
 
-  const SBFullHash kMalwareHostHash = SBFullHashForString("malware.com/");
-  const SBFullHash kPhishingHostHash = SBFullHashForString("phishing.com/");
-  const SBFullHash kUnwantedHostHash = SBFullHashForString("unwanted.com/");
+  const SBFullHash kMalwareHostHash =
+      safe_browsing::SBFullHashForString("malware.com/");
+  const SBFullHash kPhishingHostHash =
+      safe_browsing::SBFullHashForString("phishing.com/");
+  const SBFullHash kUnwantedHostHash =
+      safe_browsing::SBFullHashForString("unwanted.com/");
   const SBFullHash kUnwantedAndMalwareHostHash =
-      SBFullHashForString("unwantedandmalware.com/");
-  const SBFullHash kSafeHostHash = SBFullHashForString("www.safe.com/");
+      safe_browsing::SBFullHashForString("unwantedandmalware.com/");
+  const SBFullHash kSafeHostHash =
+      safe_browsing::SBFullHashForString("www.safe.com/");
 
   {
     SBFullHashResult full_hash;
     full_hash.hash = kMalwareHostHash;
-    full_hash.list_id = static_cast<int>(safe_browsing_util::MALWARE);
+    full_hash.list_id = static_cast<int>(safe_browsing::MALWARE);
     full_hashes.push_back(full_hash);
   }
 
   {
     SBFullHashResult full_hash;
     full_hash.hash = kPhishingHostHash;
-    full_hash.list_id = static_cast<int>(safe_browsing_util::PHISH);
+    full_hash.list_id = static_cast<int>(safe_browsing::PHISH);
     full_hashes.push_back(full_hash);
   }
 
   {
     SBFullHashResult full_hash;
     full_hash.hash = kUnwantedHostHash;
-    full_hash.list_id = static_cast<int>(safe_browsing_util::UNWANTEDURL);
+    full_hash.list_id = static_cast<int>(safe_browsing::UNWANTEDURL);
     full_hashes.push_back(full_hash);
   }
 
@@ -144,13 +148,12 @@ TEST_F(SafeBrowsingDatabaseManagerTest, GetUrlSeverestThreatType) {
     // kUnwantedAndMalwareHostHash.
     SBFullHashResult full_hash_malware;
     full_hash_malware.hash = kUnwantedAndMalwareHostHash;
-    full_hash_malware.list_id = static_cast<int>(safe_browsing_util::MALWARE);
+    full_hash_malware.list_id = static_cast<int>(safe_browsing::MALWARE);
     full_hashes.push_back(full_hash_malware);
 
     SBFullHashResult full_hash_unwanted;
     full_hash_unwanted.hash = kUnwantedAndMalwareHostHash;
-    full_hash_unwanted.list_id =
-        static_cast<int>(safe_browsing_util::UNWANTEDURL);
+    full_hash_unwanted.list_id = static_cast<int>(safe_browsing::UNWANTEDURL);
     full_hashes.push_back(full_hash_unwanted);
   }
 
diff --git a/chrome/browser/safe_browsing/protocol_manager.cc b/chrome/browser/safe_browsing/protocol_manager.cc
index 745a9d7..658453b 100644
--- a/chrome/browser/safe_browsing/protocol_manager.cc
+++ b/chrome/browser/safe_browsing/protocol_manager.cc
@@ -18,6 +18,7 @@
 #include "base/timer/timer.h"
 #include "chrome/browser/safe_browsing/protocol_parser.h"
 #include "chrome/common/env_vars.h"
+#include "components/safe_browsing_db/util.h"
 #include "components/variations/variations_associated_data.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
@@ -631,10 +632,10 @@ void SafeBrowsingProtocolManager::OnGetChunksComplete(
   bool found_phishing = false;
   for (size_t i = 0; i < lists.size(); ++i) {
     update_list_data_.append(safe_browsing::FormatList(lists[i]));
-    if (lists[i].name == safe_browsing_util::kPhishingList)
+    if (lists[i].name == safe_browsing::kPhishingList)
       found_phishing = true;
 
-    if (lists[i].name == safe_browsing_util::kMalwareList)
+    if (lists[i].name == safe_browsing::kMalwareList)
       found_malware = true;
   }
 
@@ -645,11 +646,11 @@ void SafeBrowsingProtocolManager::OnGetChunksComplete(
   // removed.
   if (!found_phishing) {
     update_list_data_.append(safe_browsing::FormatList(
-        SBListChunkRanges(safe_browsing_util::kPhishingList)));
+        SBListChunkRanges(safe_browsing::kPhishingList)));
   }
   if (!found_malware) {
     update_list_data_.append(safe_browsing::FormatList(
-        SBListChunkRanges(safe_browsing_util::kMalwareList)));
+        SBListChunkRanges(safe_browsing::kMalwareList)));
   }
 
   // Large requests are (probably) a sign of database corruption.
diff --git a/chrome/browser/safe_browsing/protocol_manager_unittest.cc b/chrome/browser/safe_browsing/protocol_manager_unittest.cc
index 31b18f9..d1705df 100644
--- a/chrome/browser/safe_browsing/protocol_manager_unittest.cc
+++ b/chrome/browser/safe_browsing/protocol_manager_unittest.cc
@@ -408,7 +408,7 @@ TEST_F(SafeBrowsingProtocolManagerTest, ExistingDatabase) {
   net::TestURLFetcherFactory url_fetcher_factory;
 
   std::vector<SBListChunkRanges> ranges;
-  SBListChunkRanges range_phish(safe_browsing_util::kPhishingList);
+  SBListChunkRanges range_phish(safe_browsing::kPhishingList);
   range_phish.adds = "adds_phish";
   range_phish.subs = "subs_phish";
   ranges.push_back(range_phish);
diff --git a/chrome/browser/safe_browsing/protocol_parser.cc b/chrome/browser/safe_browsing/protocol_parser.cc
index 05378c4..135e76f 100644
--- a/chrome/browser/safe_browsing/protocol_parser.cc
+++ b/chrome/browser/safe_browsing/protocol_parser.cc
@@ -199,7 +199,7 @@ bool ParseGetHash(const char* chunk_data,
       return false;
 
     SBFullHashResult full_hash;
-    full_hash.list_id = safe_browsing_util::GetListId(cmd_parts[0]);
+    full_hash.list_id = safe_browsing::GetListId(cmd_parts[0]);
 
     size_t hash_len;
     if (!base::StringToSizeT(cmd_parts[1], &hash_len))
diff --git a/chrome/browser/safe_browsing/protocol_parser_unittest.cc b/chrome/browser/safe_browsing/protocol_parser_unittest.cc
index 70872b3..d145b81 100644
--- a/chrome/browser/safe_browsing/protocol_parser_unittest.cc
+++ b/chrome/browser/safe_browsing/protocol_parser_unittest.cc
@@ -88,8 +88,10 @@ TEST(SafeBrowsingProtocolParsingTest, TestAddFullChunk) {
   EXPECT_TRUE(chunks[0]->IsFullHash());
 
   ASSERT_EQ(2U, chunks[0]->FullHashCount());
-  EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1));
-  EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2));
+  EXPECT_TRUE(
+      safe_browsing::SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1));
+  EXPECT_TRUE(
+      safe_browsing::SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2));
 }
 
 // Test parsing multiple add chunks. We'll use the same chunk as above, and add
@@ -282,9 +284,11 @@ TEST(SafeBrowsingProtocolParsingTest, TestSubFullChunk) {
   EXPECT_TRUE(chunks[0]->IsFullHash());
 
   ASSERT_EQ(2U, chunks[0]->FullHashCount());
-  EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1));
+  EXPECT_TRUE(
+      safe_browsing::SBFullHashEqual(chunks[0]->FullHashAt(0), full_hash1));
   EXPECT_EQ(7, chunks[0]->AddChunkNumberAt(0));
-  EXPECT_TRUE(SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2));
+  EXPECT_TRUE(
+      safe_browsing::SBFullHashEqual(chunks[0]->FullHashAt(1), full_hash2));
   EXPECT_EQ(9, chunks[0]->AddChunkNumberAt(1));
 }
 
@@ -396,15 +400,15 @@ TEST(SafeBrowsingProtocolParsingTest, TestGetHash) {
   EXPECT_EQ(memcmp(&full_hashes[0].hash,
                    "00112233445566778899aabbccddeeff",
                    sizeof(SBFullHash)), 0);
-  EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id);
+  EXPECT_EQ(safe_browsing::PHISH, full_hashes[0].list_id);
   EXPECT_EQ(memcmp(&full_hashes[1].hash,
                    "00001111222233334444555566667777",
                    sizeof(SBFullHash)), 0);
-  EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[1].list_id);
+  EXPECT_EQ(safe_browsing::PHISH, full_hashes[1].list_id);
   EXPECT_EQ(memcmp(&full_hashes[2].hash,
                    "ffffeeeeddddccccbbbbaaaa99998888",
                    sizeof(SBFullHash)), 0);
-  EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[2].list_id);
+  EXPECT_EQ(safe_browsing::PHISH, full_hashes[2].list_id);
 
   // Test multiple lists in the GetHash results.
   const std::string get_hash2(base::StringPrintf(
@@ -423,15 +427,15 @@ TEST(SafeBrowsingProtocolParsingTest, TestGetHash) {
   EXPECT_EQ(memcmp(&full_hashes[0].hash,
                    "00112233445566778899aabbccddeeff",
                    sizeof(SBFullHash)), 0);
-  EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id);
+  EXPECT_EQ(safe_browsing::PHISH, full_hashes[0].list_id);
   EXPECT_EQ(memcmp(&full_hashes[1].hash,
                    "cafebeefcafebeefdeaddeaddeaddead",
                    sizeof(SBFullHash)), 0);
-  EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id);
+  EXPECT_EQ(safe_browsing::MALWARE, full_hashes[1].list_id);
   EXPECT_EQ(memcmp(&full_hashes[2].hash,
                    "zzzzyyyyxxxxwwwwvvvvuuuuttttssss",
                    sizeof(SBFullHash)), 0);
-  EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[2].list_id);
+  EXPECT_EQ(safe_browsing::MALWARE, full_hashes[2].list_id);
 
   // Test metadata parsing.
   const std::string get_hash3(base::StringPrintf(
@@ -451,17 +455,17 @@ TEST(SafeBrowsingProtocolParsingTest, TestGetHash) {
   EXPECT_EQ(memcmp(&full_hashes[0].hash,
                    "zzzzyyyyxxxxwwwwvvvvuuuuttttssss",
                    sizeof(SBFullHash)), 0);
-  EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[0].list_id);
+  EXPECT_EQ(safe_browsing::MALWARE, full_hashes[0].list_id);
   EXPECT_EQ(std::string("ab"), full_hashes[0].metadata);
   EXPECT_EQ(memcmp(&full_hashes[1].hash,
                    "00112233445566778899aabbccddeeff",
                    sizeof(SBFullHash)), 0);
-  EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id);
+  EXPECT_EQ(safe_browsing::MALWARE, full_hashes[1].list_id);
   EXPECT_EQ(std::string("xy"), full_hashes[1].metadata);
   EXPECT_EQ(memcmp(&full_hashes[2].hash,
                    "cafebeefcafebeefdeaddeaddeaddead",
                    sizeof(SBFullHash)), 0);
-  EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[2].list_id);
+  EXPECT_EQ(safe_browsing::PHISH, full_hashes[2].list_id);
   EXPECT_EQ(std::string(), full_hashes[2].metadata);
 }
 
@@ -483,7 +487,7 @@ TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownList) {
   ASSERT_EQ(1U, full_hashes.size());
   EXPECT_EQ(memcmp("12345678901234567890123456789012",
                    &full_hashes[0].hash, sizeof(SBFullHash)), 0);
-  EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id);
+  EXPECT_EQ(safe_browsing::PHISH, full_hashes[0].list_id);
 
   hash_response += base::StringPrintf(
       "%s:32:1\n"
@@ -498,10 +502,10 @@ TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownList) {
   EXPECT_EQ(2U, full_hashes.size());
   EXPECT_EQ(memcmp("12345678901234567890123456789012",
                    &full_hashes[0].hash, sizeof(SBFullHash)), 0);
-  EXPECT_EQ(safe_browsing_util::PHISH, full_hashes[0].list_id);
+  EXPECT_EQ(safe_browsing::PHISH, full_hashes[0].list_id);
   EXPECT_EQ(memcmp("abcdefghijklmnopqrstuvwxyz123457",
                    &full_hashes[1].hash, sizeof(SBFullHash)), 0);
-  EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[1].list_id);
+  EXPECT_EQ(safe_browsing::MALWARE, full_hashes[1].list_id);
 }
 
 TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownListAndMetadata) {
@@ -523,7 +527,7 @@ TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownListAndMetadata) {
   EXPECT_EQ(memcmp(&full_hashes[0].hash,
                    "0123456789hashhashhashhashhashha",
                    sizeof(SBFullHash)), 0);
-  EXPECT_EQ(safe_browsing_util::MALWARE, full_hashes[0].list_id);
+  EXPECT_EQ(safe_browsing::MALWARE, full_hashes[0].list_id);
   EXPECT_EQ(std::string(), full_hashes[0].metadata);
 }
 
diff --git a/chrome/browser/safe_browsing/safe_browsing_blocking_page_test.cc b/chrome/browser/safe_browsing/safe_browsing_blocking_page_test.cc
index 92c7c85..9decd2a 100644
--- a/chrome/browser/safe_browsing/safe_browsing_blocking_page_test.cc
+++ b/chrome/browser/safe_browsing/safe_browsing_blocking_page_test.cc
@@ -92,7 +92,7 @@ class FakeSafeBrowsingDatabaseManager : public TestSafeBrowsingDatabaseManager {
         std::vector<GURL>(1, gurl),
         std::vector<SBFullHash>(),
         client,
-        safe_browsing_util::MALWARE,
+        safe_browsing::MALWARE,
         expected_threats);
     sb_check.url_results[0] = badurls[gurl.spec()];
     sb_check.OnSafeBrowsingResult();
diff --git a/chrome/browser/safe_browsing/safe_browsing_database.cc b/chrome/browser/safe_browsing/safe_browsing_database.cc
index 81948a6..80c16f7 100644
--- a/chrome/browser/safe_browsing/safe_browsing_database.cc
+++ b/chrome/browser/safe_browsing/safe_browsing_database.cc
@@ -107,7 +107,7 @@ int DecodeChunkId(int encoded_chunk_id) {
   return encoded_chunk_id >> 1;
 }
 int EncodeChunkId(const int chunk, const int list_id) {
-  DCHECK_NE(list_id, safe_browsing_util::INVALID);
+  DCHECK_NE(list_id, safe_browsing::INVALID);
   return chunk << 1 | list_id % 2;
 }
 
@@ -128,16 +128,17 @@ void UrlToFullHashes(const GURL& url,
   if (url.HostIsIPAddress()) {
     hosts.push_back(url.host());
   } else {
-    safe_browsing_util::GenerateHostsToCheck(url, &hosts);
+    safe_browsing::GenerateHostsToCheck(url, &hosts);
   }
 
   std::vector<std::string> paths;
-  safe_browsing_util::GeneratePathsToCheck(url, &paths);
+  safe_browsing::GeneratePathsToCheck(url, &paths);
 
   for (size_t i = 0; i < hosts.size(); ++i) {
     for (size_t j = 0; j < paths.size(); ++j) {
       const std::string& path = paths[j];
-      full_hashes->push_back(SBFullHashForString(hosts[i] + path));
+      full_hashes->push_back(safe_browsing::SBFullHashForString(
+          hosts[i] + path));
 
       // We may have /foo as path-prefix in the whitelist which should
       // also match with /foo/bar and /foo?bar.  Hence, for every path
@@ -146,7 +147,8 @@ void UrlToFullHashes(const GURL& url,
           path.size() > 1 &&
           path[path.size() - 1] == '/') {
         full_hashes->push_back(
-            SBFullHashForString(hosts[i] + path.substr(0, path.size() - 1)));
+            safe_browsing::SBFullHashForString(
+                hosts[i] + path.substr(0, path.size() - 1)));
       }
     }
   }
@@ -230,10 +232,10 @@ void UpdateChunkRanges(SafeBrowsingStore* store,
 
   for (size_t i = 0; i < listnames.size(); ++i) {
     const std::string& listname = listnames[i];
-    DCHECK_EQ(safe_browsing_util::GetListId(listname) % 2,
+    DCHECK_EQ(safe_browsing::GetListId(listname) % 2,
               static_cast<int>(i % 2));
-    DCHECK_NE(safe_browsing_util::GetListId(listname),
-              safe_browsing_util::INVALID);
+    DCHECK_NE(safe_browsing::GetListId(listname),
+              safe_browsing::INVALID);
     lists->push_back(SBListChunkRanges(listname));
     lists->back().adds.swap(adds[i]);
     lists->back().subs.swap(subs[i]);
@@ -289,7 +291,7 @@ bool GetCachedFullHash(std::map<SBPrefix, SBCachedFullHashResult>* cache,
   // Find full-hash matches.
   std::vector<SBFullHashResult>& cached_hashes = cached_result.full_hashes;
   for (size_t i = 0; i < cached_hashes.size(); ++i) {
-    if (SBFullHashEqual(full_hash, cached_hashes[i].hash))
+    if (safe_browsing::SBFullHashEqual(full_hash, cached_hashes[i].hash))
       results->push_back(cached_hashes[i]);
   }
 
@@ -445,22 +447,22 @@ SafeBrowsingStore* SafeBrowsingDatabaseNew::GetStore(const int list_id) {
   // Stores are not thread safe.
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
-  if (list_id == safe_browsing_util::PHISH ||
-      list_id == safe_browsing_util::MALWARE) {
+  if (list_id == safe_browsing::PHISH ||
+      list_id == safe_browsing::MALWARE) {
     return browse_store_.get();
-  } else if (list_id == safe_browsing_util::BINURL) {
+  } else if (list_id == safe_browsing::BINURL) {
     return download_store_.get();
-  } else if (list_id == safe_browsing_util::CSDWHITELIST) {
+  } else if (list_id == safe_browsing::CSDWHITELIST) {
     return csd_whitelist_store_.get();
-  } else if (list_id == safe_browsing_util::DOWNLOADWHITELIST) {
+  } else if (list_id == safe_browsing::DOWNLOADWHITELIST) {
     return download_whitelist_store_.get();
-  } else if (list_id == safe_browsing_util::INCLUSIONWHITELIST) {
+  } else if (list_id == safe_browsing::INCLUSIONWHITELIST) {
     return inclusion_whitelist_store_.get();
-  } else if (list_id == safe_browsing_util::EXTENSIONBLACKLIST) {
+  } else if (list_id == safe_browsing::EXTENSIONBLACKLIST) {
     return extension_blacklist_store_.get();
-  } else if (list_id == safe_browsing_util::IPBLACKLIST) {
+  } else if (list_id == safe_browsing::IPBLACKLIST) {
     return ip_blacklist_store_.get();
-  } else if (list_id == safe_browsing_util::UNWANTEDURL) {
+  } else if (list_id == safe_browsing::UNWANTEDURL) {
     return unwanted_software_store_.get();
   }
   return NULL;
@@ -915,7 +917,7 @@ bool SafeBrowsingDatabaseNew::ContainsDownloadUrlPrefixes(
     return false;
 
   return MatchAddPrefixes(download_store_.get(),
-                          safe_browsing_util::BINURL % 2,
+                          safe_browsing::BINURL % 2,
                           prefixes,
                           prefix_hits);
 }
@@ -947,7 +949,7 @@ bool SafeBrowsingDatabaseNew::ContainsExtensionPrefixes(
     return false;
 
   return MatchAddPrefixes(extension_blacklist_store_.get(),
-                          safe_browsing_util::EXTENSIONBLACKLIST % 2,
+                          safe_browsing::EXTENSIONBLACKLIST % 2,
                           prefixes,
                           prefix_hits);
 }
@@ -987,7 +989,7 @@ bool SafeBrowsingDatabaseNew::ContainsMalwareIP(const std::string& ip_address) {
 bool SafeBrowsingDatabaseNew::ContainsDownloadWhitelistedString(
     const std::string& str) {
   std::vector<SBFullHash> hashes;
-  hashes.push_back(SBFullHashForString(str));
+  hashes.push_back(safe_browsing::SBFullHashForString(str));
   return ContainsWhitelistedHashes(SBWhitelistId::DOWNLOAD, hashes);
 }
 
@@ -1001,7 +1003,7 @@ bool SafeBrowsingDatabaseNew::ContainsWhitelistedHashes(
   for (std::vector<SBFullHash>::const_iterator it = hashes.begin();
        it != hashes.end(); ++it) {
     if (std::binary_search(whitelist->first.begin(), whitelist->first.end(),
-                           *it, SBFullHashLess)) {
+                           *it, safe_browsing::SBFullHashLess)) {
       return true;
     }
   }
@@ -1011,7 +1013,7 @@ bool SafeBrowsingDatabaseNew::ContainsWhitelistedHashes(
 // Helper to insert add-chunk entries.
 void SafeBrowsingDatabaseNew::InsertAddChunk(
     SafeBrowsingStore* store,
-    const safe_browsing_util::ListType list_id,
+    const safe_browsing::ListType list_id,
     const SBChunkData& chunk_data) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(store);
@@ -1040,7 +1042,7 @@ void SafeBrowsingDatabaseNew::InsertAddChunk(
 // Helper to insert sub-chunk entries.
 void SafeBrowsingDatabaseNew::InsertSubChunk(
     SafeBrowsingStore* store,
-    const safe_browsing_util::ListType list_id,
+    const safe_browsing::ListType list_id,
     const SBChunkData& chunk_data) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(store);
@@ -1083,8 +1085,8 @@ void SafeBrowsingDatabaseNew::InsertChunks(
   const base::TimeTicks before = base::TimeTicks::Now();
 
   // TODO(shess): The caller should just pass list_id.
-  const safe_browsing_util::ListType list_id =
-      safe_browsing_util::GetListId(list_name);
+  const safe_browsing::ListType list_id =
+      safe_browsing::GetListId(list_name);
 
   SafeBrowsingStore* store = GetStore(list_id);
   if (!store) return;
@@ -1116,8 +1118,8 @@ void SafeBrowsingDatabaseNew::DeleteChunks(
     return;
 
   const std::string& list_name = chunk_deletes.front().list_name;
-  const safe_browsing_util::ListType list_id =
-      safe_browsing_util::GetListId(list_name);
+  const safe_browsing::ListType list_id =
+      safe_browsing::GetListId(list_name);
 
   SafeBrowsingStore* store = GetStore(list_id);
   if (!store) return;
@@ -1221,8 +1223,8 @@ bool SafeBrowsingDatabaseNew::UpdateStarted(
   state_manager_.BeginWriteTransaction()->clear_prefix_gethash_cache();
 
   UpdateChunkRangesForLists(browse_store_.get(),
-                            safe_browsing_util::kMalwareList,
-                            safe_browsing_util::kPhishingList,
+                            safe_browsing::kMalwareList,
+                            safe_browsing::kPhishingList,
                             lists);
 
   // NOTE(shess): |download_store_| used to contain kBinHashList, which has been
@@ -1230,25 +1232,25 @@ bool SafeBrowsingDatabaseNew::UpdateStarted(
   // of Feb 2014, so it has been removed.  Everything _should_ be resilient to
   // extra data of that sort.
   UpdateChunkRangesForList(download_store_.get(),
-                           safe_browsing_util::kBinUrlList, lists);
+                           safe_browsing::kBinUrlList, lists);
 
   UpdateChunkRangesForList(csd_whitelist_store_.get(),
-                           safe_browsing_util::kCsdWhiteList, lists);
+                           safe_browsing::kCsdWhiteList, lists);
 
   UpdateChunkRangesForList(download_whitelist_store_.get(),
-                           safe_browsing_util::kDownloadWhiteList, lists);
+                           safe_browsing::kDownloadWhiteList, lists);
 
   UpdateChunkRangesForList(inclusion_whitelist_store_.get(),
-                           safe_browsing_util::kInclusionWhitelist, lists);
+                           safe_browsing::kInclusionWhitelist, lists);
 
   UpdateChunkRangesForList(extension_blacklist_store_.get(),
-                           safe_browsing_util::kExtensionBlacklist, lists);
+                           safe_browsing::kExtensionBlacklist, lists);
 
   UpdateChunkRangesForList(ip_blacklist_store_.get(),
-                           safe_browsing_util::kIPBlacklist, lists);
+                           safe_browsing::kIPBlacklist, lists);
 
   UpdateChunkRangesForList(unwanted_software_store_.get(),
-                           safe_browsing_util::kUnwantedUrlList,
+                           safe_browsing::kUnwantedUrlList,
                            lists);
 
   db_state_manager_.reset_corruption_detected();
@@ -1702,11 +1704,13 @@ void SafeBrowsingDatabaseNew::LoadWhitelist(
        it != full_hashes.end(); ++it) {
     new_whitelist.push_back(it->full_hash);
   }
-  std::sort(new_whitelist.begin(), new_whitelist.end(), SBFullHashLess);
+  std::sort(new_whitelist.begin(), new_whitelist.end(),
+            safe_browsing::SBFullHashLess);
 
-  SBFullHash kill_switch = SBFullHashForString(kWhitelistKillSwitchUrl);
+  SBFullHash kill_switch = safe_browsing::SBFullHashForString(
+      kWhitelistKillSwitchUrl);
   if (std::binary_search(new_whitelist.begin(), new_whitelist.end(),
-                         kill_switch, SBFullHashLess)) {
+                         kill_switch, safe_browsing::SBFullHashLess)) {
     // The kill switch is whitelisted hence we whitelist all URLs.
     state_manager_.BeginWriteTransaction()->WhitelistEverything(whitelist_id);
   } else {
@@ -1756,7 +1760,8 @@ void SafeBrowsingDatabaseNew::LoadIpBlacklist(
 }
 
 bool SafeBrowsingDatabaseNew::IsMalwareIPMatchKillSwitchOn() {
-  SBFullHash malware_kill_switch = SBFullHashForString(kMalwareIPKillSwitchUrl);
+  SBFullHash malware_kill_switch = safe_browsing::SBFullHashForString(
+      kMalwareIPKillSwitchUrl);
   std::vector<SBFullHash> full_hashes;
   full_hashes.push_back(malware_kill_switch);
   return ContainsWhitelistedHashes(SBWhitelistId::CSD, full_hashes);
diff --git a/chrome/browser/safe_browsing/safe_browsing_database.h b/chrome/browser/safe_browsing/safe_browsing_database.h
index 4d57ea3..22642a2 100644
--- a/chrome/browser/safe_browsing/safe_browsing_database.h
+++ b/chrome/browser/safe_browsing/safe_browsing_database.h
@@ -19,6 +19,7 @@
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/safe_browsing_store.h"
+#include "components/safe_browsing_db/util.h"
 
 namespace safe_browsing {
 class PrefixSet;
@@ -590,10 +591,10 @@ class SafeBrowsingDatabaseNew : public SafeBrowsingDatabase {
 
   // Helpers for InsertChunks().
   void InsertAddChunk(SafeBrowsingStore* store,
-                      safe_browsing_util::ListType list_id,
+                      safe_browsing::ListType list_id,
                       const SBChunkData& chunk);
   void InsertSubChunk(SafeBrowsingStore* store,
-                      safe_browsing_util::ListType list_id,
+                      safe_browsing::ListType list_id,
                       const SBChunkData& chunk);
 
   // Updates the |store| and stores the result on disk under |store_filename|.
diff --git a/chrome/browser/safe_browsing/safe_browsing_database_unittest.cc b/chrome/browser/safe_browsing/safe_browsing_database_unittest.cc
index 75e4030..33328129 100644
--- a/chrome/browser/safe_browsing/safe_browsing_database_unittest.cc
+++ b/chrome/browser/safe_browsing/safe_browsing_database_unittest.cc
@@ -32,7 +32,7 @@ namespace {
 const TimeDelta kCacheLifetime = TimeDelta::FromMinutes(45);
 
 SBPrefix SBPrefixForString(const std::string& str) {
-  return SBFullHashForString(str).prefix;
+  return safe_browsing::SBFullHashForString(str).prefix;
 }
 
 // Construct a full hash which has the given prefix, with the given
@@ -135,7 +135,8 @@ SBChunkData* AddChunkFullHash(int chunk_number, SBFullHash full_hash) {
 // Generate an add chunk with a full hash generated from |value|.
 SBChunkData* AddChunkFullHashValue(int chunk_number,
                                    const std::string& value) {
-  return AddChunkFullHash(chunk_number, SBFullHashForString(value));
+  return AddChunkFullHash(chunk_number,
+                          safe_browsing::SBFullHashForString(value));
 }
 
 // Generate an add chunk with two full hashes.
@@ -143,8 +144,8 @@ SBChunkData* AddChunkFullHash2Value(int chunk_number,
                                    const std::string& value1,
                                    const std::string& value2) {
   const SBFullHash full_hashes[2] = {
-    SBFullHashForString(value1),
-    SBFullHashForString(value2),
+    safe_browsing::SBFullHashForString(value1),
+    safe_browsing::SBFullHashForString(value2),
   };
   return BuildChunk(chunk_number, safe_browsing::ChunkData::ADD,
                     safe_browsing::ChunkData::FULL_32B,
@@ -197,7 +198,7 @@ SBChunkData* SubChunkFullHashValue(int chunk_number,
                                    const std::string& value,
                                    int add_chunk_number) {
   return SubChunkFullHash(chunk_number,
-                          SBFullHashForString(value),
+                          safe_browsing::SBFullHashForString(value),
                           add_chunk_number);
 }
 
@@ -351,12 +352,12 @@ TEST_F(SafeBrowsingDatabaseTest, BrowseListsInfo) {
   chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/malware.html"));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
+  EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
   EXPECT_EQ("1-3", lists[0].adds);
   EXPECT_TRUE(lists[0].subs.empty());
 
@@ -365,19 +366,19 @@ TEST_F(SafeBrowsingDatabaseTest, BrowseListsInfo) {
   chunks.push_back(SubChunkPrefixValue(7, "www.subbed.com/noteveil1.html", 19));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
+  EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
   EXPECT_EQ("1-3", lists[0].adds);
   EXPECT_EQ("7", lists[0].subs);
   if (lists.size() == 2) {
     // Old style database won't have the second entry since it creates the lists
     // when it receives an update containing that list. The filter-based
     // database has these values hard coded.
-    EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name);
+    EXPECT_EQ(safe_browsing::kPhishingList, lists[1].name);
     EXPECT_TRUE(lists[1].adds.empty());
     EXPECT_TRUE(lists[1].subs.empty());
   }
@@ -391,15 +392,15 @@ TEST_F(SafeBrowsingDatabaseTest, BrowseListsInfo) {
       SubChunkPrefixValue(201, "www.phishy2.com/notevil1.html", 1999));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get());
+  database_->InsertChunks(safe_browsing::kPhishingList, chunks.get());
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   ASSERT_LE(2U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
+  EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
   EXPECT_EQ("1-3", lists[0].adds);
   EXPECT_EQ("7", lists[0].subs);
-  EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name);
+  EXPECT_EQ(safe_browsing::kPhishingList, lists[1].name);
   EXPECT_EQ("47", lists[1].adds);
   EXPECT_EQ("200-201", lists[1].subs);
 }
@@ -412,73 +413,73 @@ TEST_F(SafeBrowsingDatabaseTest, ListNames) {
 
   // Insert malware, phish, binurl and bindownload add chunks.
   chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html"));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
 
   chunks.clear();
   chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html"));
-  database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get());
+  database_->InsertChunks(safe_browsing::kPhishingList, chunks.get());
 
   chunks.clear();
   chunks.push_back(AddChunkPrefixValue(3, "www.whatever.com/download.html"));
-  database_->InsertChunks(safe_browsing_util::kBinUrlList, chunks.get());
+  database_->InsertChunks(safe_browsing::kBinUrlList, chunks.get());
 
   chunks.clear();
   chunks.push_back(AddChunkFullHashValue(5, "www.forwhitelist.com/a.html"));
-  database_->InsertChunks(safe_browsing_util::kCsdWhiteList, chunks.get());
+  database_->InsertChunks(safe_browsing::kCsdWhiteList, chunks.get());
 
   chunks.clear();
   chunks.push_back(AddChunkFullHashValue(6, "www.download.com/"));
-  database_->InsertChunks(safe_browsing_util::kDownloadWhiteList, chunks.get());
+  database_->InsertChunks(safe_browsing::kDownloadWhiteList, chunks.get());
 
   chunks.clear();
   chunks.push_back(AddChunkFullHashValue(7, "www.inclusion.com/"));
-  database_->InsertChunks(safe_browsing_util::kInclusionWhitelist,
+  database_->InsertChunks(safe_browsing::kInclusionWhitelist,
                           chunks.get());
 
   chunks.clear();
   chunks.push_back(AddChunkFullHashValue(8,
                                          "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                                          "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
-  database_->InsertChunks(safe_browsing_util::kExtensionBlacklist,
+  database_->InsertChunks(safe_browsing::kExtensionBlacklist,
                           chunks.get());
 
   chunks.clear();
   chunks.push_back(AddChunkHashedIpValue(10, "::ffff:192.168.1.0", 120));
-  database_->InsertChunks(safe_browsing_util::kIPBlacklist, chunks.get());
+  database_->InsertChunks(safe_browsing::kIPBlacklist, chunks.get());
 
   chunks.clear();
   chunks.push_back(AddChunkPrefixValue(11, "www.unwanted.com/software.html"));
-  database_->InsertChunks(safe_browsing_util::kUnwantedUrlList, chunks.get());
+  database_->InsertChunks(safe_browsing::kUnwantedUrlList, chunks.get());
 
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   ASSERT_EQ(9U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
+  EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
   EXPECT_EQ("1", lists[0].adds);
   EXPECT_TRUE(lists[0].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name);
+  EXPECT_EQ(safe_browsing::kPhishingList, lists[1].name);
   EXPECT_EQ("2", lists[1].adds);
   EXPECT_TRUE(lists[1].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kBinUrlList, lists[2].name);
+  EXPECT_EQ(safe_browsing::kBinUrlList, lists[2].name);
   EXPECT_EQ("3", lists[2].adds);
   EXPECT_TRUE(lists[2].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kCsdWhiteList, lists[3].name);
+  EXPECT_EQ(safe_browsing::kCsdWhiteList, lists[3].name);
   EXPECT_EQ("5", lists[3].adds);
   EXPECT_TRUE(lists[3].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kDownloadWhiteList, lists[4].name);
+  EXPECT_EQ(safe_browsing::kDownloadWhiteList, lists[4].name);
   EXPECT_EQ("6", lists[4].adds);
   EXPECT_TRUE(lists[4].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kInclusionWhitelist, lists[5].name);
+  EXPECT_EQ(safe_browsing::kInclusionWhitelist, lists[5].name);
   EXPECT_EQ("7", lists[5].adds);
   EXPECT_TRUE(lists[5].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kExtensionBlacklist, lists[6].name);
+  EXPECT_EQ(safe_browsing::kExtensionBlacklist, lists[6].name);
   EXPECT_EQ("8", lists[6].adds);
   EXPECT_TRUE(lists[6].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kIPBlacklist, lists[7].name);
+  EXPECT_EQ(safe_browsing::kIPBlacklist, lists[7].name);
   EXPECT_EQ("10", lists[7].adds);
   EXPECT_TRUE(lists[7].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kUnwantedUrlList, lists[8].name);
+  EXPECT_EQ(safe_browsing::kUnwantedUrlList, lists[8].name);
   EXPECT_EQ("11", lists[8].adds);
   EXPECT_TRUE(lists[8].subs.empty());
 
@@ -497,11 +498,11 @@ TEST_F(SafeBrowsingDatabaseTest, BrowseAndUnwantedDatabasesAndPrefixSets) {
     size_t expected_list_index;
     TestListContainsBadUrl test_list_contains_bad_url;
   } const kTestCases[] {
-    { safe_browsing_util::kMalwareList, 0U,
+    { safe_browsing::kMalwareList, 0U,
       &SafeBrowsingDatabase::ContainsBrowseUrl },
-    { safe_browsing_util::kPhishingList, 1U,
+    { safe_browsing::kPhishingList, 1U,
       &SafeBrowsingDatabase::ContainsBrowseUrl },
-    { safe_browsing_util::kUnwantedUrlList, 8U,
+    { safe_browsing::kUnwantedUrlList, 8U,
       &SafeBrowsingDatabase::ContainsUnwantedSoftwareUrl },
   };
 
@@ -757,13 +758,13 @@ TEST_F(SafeBrowsingDatabaseTest, ZeroSizeChunk) {
                                         "www.random.com/random2.html"));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   // Add an empty ADD and SUB chunk.
   GetListsInfo(&lists);
   ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
+  EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
   EXPECT_EQ("1,10", lists[0].adds);
   EXPECT_TRUE(lists[0].subs.empty());
 
@@ -776,12 +777,12 @@ TEST_F(SafeBrowsingDatabaseTest, ZeroSizeChunk) {
                               NULL, 0, std::vector<int>()));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
+  EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
   EXPECT_EQ("1,10,19", lists[0].adds);
   EXPECT_EQ("7", lists[0].subs);
 
@@ -795,7 +796,7 @@ TEST_F(SafeBrowsingDatabaseTest, ZeroSizeChunk) {
   chunks.push_back(AddChunkPrefixValue(22, "www.notempty.com/full2.html"));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   std::vector<SBPrefix> prefix_hits;
@@ -807,28 +808,28 @@ TEST_F(SafeBrowsingDatabaseTest, ZeroSizeChunk) {
 
   GetListsInfo(&lists);
   ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
+  EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
   EXPECT_EQ("1,10,19-22", lists[0].adds);
   EXPECT_EQ("7", lists[0].subs);
 
   // Handle AddDel and SubDel commands for empty chunks.
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  AddDelChunk(safe_browsing_util::kMalwareList, 21);
+  AddDelChunk(safe_browsing::kMalwareList, 21);
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
+  EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
   EXPECT_EQ("1,10,19-20,22", lists[0].adds);
   EXPECT_EQ("7", lists[0].subs);
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  SubDelChunk(safe_browsing_util::kMalwareList, 7);
+  SubDelChunk(safe_browsing::kMalwareList, 7);
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
+  EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
   EXPECT_EQ("1,10,19-20,22", lists[0].adds);
   EXPECT_TRUE(lists[0].subs.empty());
 }
@@ -843,7 +844,7 @@ void SafeBrowsingDatabaseTest::PopulateDatabaseForCacheTest() {
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   // Cache should be cleared after updating.
@@ -851,17 +852,19 @@ void SafeBrowsingDatabaseTest::PopulateDatabaseForCacheTest() {
       database_->GetUnsynchronizedPrefixGetHashCacheForTesting()->empty());
 
   SBFullHashResult full_hash;
-  full_hash.list_id = safe_browsing_util::MALWARE;
+  full_hash.list_id = safe_browsing::MALWARE;
 
   std::vector<SBFullHashResult> results;
   std::vector<SBPrefix> prefixes;
 
   // Add a fullhash result for each prefix.
-  full_hash.hash = SBFullHashForString("www.evil.com/phishing.html");
+  full_hash.hash =
+      safe_browsing::SBFullHashForString("www.evil.com/phishing.html");
   results.push_back(full_hash);
   prefixes.push_back(full_hash.hash.prefix);
 
-  full_hash.hash = SBFullHashForString("www.evil.com/malware.html");
+  full_hash.hash =
+      safe_browsing::SBFullHashForString("www.evil.com/malware.html");
   results.push_back(full_hash);
   prefixes.push_back(full_hash.hash.prefix);
 
@@ -882,8 +885,9 @@ TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
       GURL("http://www.evil.com/phishing.html"), &prefix_hits, &cache_hits));
   EXPECT_TRUE(prefix_hits.empty());
   ASSERT_EQ(1U, cache_hits.size());
-  EXPECT_TRUE(SBFullHashEqual(
-      cache_hits[0].hash, SBFullHashForString("www.evil.com/phishing.html")));
+  EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+      cache_hits[0].hash,
+      safe_browsing::SBFullHashForString("www.evil.com/phishing.html")));
 
   prefix_hits.clear();
   cache_hits.clear();
@@ -893,8 +897,9 @@ TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
       GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
   EXPECT_TRUE(prefix_hits.empty());
   ASSERT_EQ(1U, cache_hits.size());
-  EXPECT_TRUE(SBFullHashEqual(
-      cache_hits[0].hash, SBFullHashForString("www.evil.com/malware.html")));
+  EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+      cache_hits[0].hash,
+      safe_browsing::SBFullHashForString("www.evil.com/malware.html")));
 
   prefix_hits.clear();
   cache_hits.clear();
@@ -905,7 +910,7 @@ TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   // This prefix should still be there, but cached fullhash should be gone.
@@ -925,7 +930,7 @@ TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
 
   // Test that an AddDel for the original chunk removes the last cached entry.
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  AddDelChunk(safe_browsing_util::kMalwareList, 1);
+  AddDelChunk(safe_browsing::kMalwareList, 1);
   database_->UpdateFinished(true);
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL("http://www.evil.com/malware.html"), &prefix_hits, &cache_hits));
@@ -967,7 +972,7 @@ TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
   // Since PopulateDatabaseForCacheTest() doesn't handle adding duplicate
   // chunks.
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  AddDelChunk(safe_browsing_util::kMalwareList, 1);
+  AddDelChunk(safe_browsing::kMalwareList, 1);
   database_->UpdateFinished(true);
 
   // Cache should be cleared after updating.
@@ -1016,7 +1021,7 @@ TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
                                           "www.fullevil.com/bad1.html",
                                           "www.fullevil.com/bad2.html"));
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   EXPECT_TRUE(database_->ContainsBrowseUrl(
@@ -1041,7 +1046,7 @@ TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
                                          "www.fullevil.com/bad1.html",
                                          20));
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
@@ -1058,7 +1063,7 @@ TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
 
   // Now test an AddDel for the remaining full add.
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  AddDelChunk(safe_browsing_util::kMalwareList, 20);
+  AddDelChunk(safe_browsing::kMalwareList, 20);
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsBrowseUrl(
@@ -1076,7 +1081,7 @@ TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
   {
     ScopedVector<SBChunkData> chunks;
     chunks.push_back(AddChunkPrefixValue(21, kExampleCollision));
-    database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+    database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   }
   database_->UpdateFinished(true);
 
@@ -1091,8 +1096,8 @@ TEST_F(SafeBrowsingDatabaseTest, HashCaching) {
   // Cache gethash response for |kExampleCollision|.
   {
     SBFullHashResult result;
-    result.hash = SBFullHashForString(kExampleCollision);
-    result.list_id = safe_browsing_util::MALWARE;
+    result.hash = safe_browsing::SBFullHashForString(kExampleCollision);
+    result.list_id = safe_browsing::MALWARE;
     database_->CacheHashResults(std::vector<SBPrefix>(1, result.hash.prefix),
                                 std::vector<SBFullHashResult>(1, result),
                                 kCacheLifetime);
@@ -1145,7 +1150,7 @@ TEST_F(SafeBrowsingDatabaseTest, DISABLED_FileCorruptionHandling) {
 
     // Start an update.  The insert will fail due to corruption.
     ASSERT_TRUE(database_->UpdateStarted(&lists));
-    database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+    database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
     database_->UpdateFinished(true);
 
     // Database file still exists until the corruption handler has run.
@@ -1161,7 +1166,7 @@ TEST_F(SafeBrowsingDatabaseTest, DISABLED_FileCorruptionHandling) {
 
   // Run the update again successfully.
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
   EXPECT_TRUE(base::PathExists(database_filename_));
 
@@ -1179,7 +1184,7 @@ TEST_F(SafeBrowsingDatabaseTest, ContainsDownloadUrlPrefixes) {
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kBinUrlList, chunks.get());
+  database_->InsertChunks(safe_browsing::kBinUrlList, chunks.get());
   database_->UpdateFinished(true);
 
   std::vector<SBPrefix> prefix_hits;
@@ -1276,13 +1281,13 @@ TEST_F(SafeBrowsingDatabaseTest, Whitelists) {
     // for strings.
     TestListContainsWhitelistedString test_list_contains_whitelisted_string;
   } const kTestCases[]{
-      {safe_browsing_util::kCsdWhiteList,
+      {safe_browsing::kCsdWhiteList,
        &SafeBrowsingDatabase::ContainsCsdWhitelistedUrl,
        nullptr},
-      {safe_browsing_util::kDownloadWhiteList,
+      {safe_browsing::kDownloadWhiteList,
        &SafeBrowsingDatabase::ContainsDownloadWhitelistedUrl,
        &SafeBrowsingDatabase::ContainsDownloadWhitelistedString},
-      {safe_browsing_util::kInclusionWhitelist,
+      {safe_browsing::kInclusionWhitelist,
        &SafeBrowsingDatabase::ContainsInclusionWhitelistedUrl,
        nullptr},
   };
@@ -1417,7 +1422,7 @@ TEST_F(SafeBrowsingDatabaseTest, Whitelists) {
             GURL(std::string("http://www.google.com/"))));
 
     // The malware kill switch is for the CSD whitelist only.
-    if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) {
+    if (test_case.test_list_name == safe_browsing::kCsdWhiteList) {
       // The CSD whitelist killswitch is not present.
       EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn());
 
@@ -1427,7 +1432,7 @@ TEST_F(SafeBrowsingDatabaseTest, Whitelists) {
           15, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware"));
 
       ASSERT_TRUE(database_->UpdateStarted(&lists));
-      database_->InsertChunks(safe_browsing_util::kCsdWhiteList, chunks.get());
+      database_->InsertChunks(safe_browsing::kCsdWhiteList, chunks.get());
       database_->UpdateFinished(true);
 
       EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn());
@@ -1446,7 +1451,7 @@ TEST_F(SafeBrowsingDatabaseTest, Whitelists) {
     database_->UpdateFinished(true);
 
     // Test CSD whitelist specific methods.
-    if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) {
+    if (test_case.test_list_name == safe_browsing::kCsdWhiteList) {
       // The CSD whitelist killswitch is present.
       EXPECT_TRUE(database_->IsCsdWhitelistKillSwitchOn());
       EXPECT_TRUE(database_->IsMalwareIPMatchKillSwitchOn());
@@ -1476,7 +1481,7 @@ TEST_F(SafeBrowsingDatabaseTest, Whitelists) {
     lists.clear();
     chunks.push_back(SubChunkFullHashValue(
         1, "sb-ssl.google.com/safebrowsing/csd/killswitch", 5));
-    if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) {
+    if (test_case.test_list_name == safe_browsing::kCsdWhiteList) {
       chunks.push_back(SubChunkFullHashValue(
           10, "sb-ssl.google.com/safebrowsing/csd/killswitch_malware", 15));
     }
@@ -1485,7 +1490,7 @@ TEST_F(SafeBrowsingDatabaseTest, Whitelists) {
     database_->InsertChunks(test_case.test_list_name, chunks.get());
     database_->UpdateFinished(true);
 
-    if (test_case.test_list_name == safe_browsing_util::kCsdWhiteList) {
+    if (test_case.test_list_name == safe_browsing::kCsdWhiteList) {
       EXPECT_FALSE(database_->IsMalwareIPMatchKillSwitchOn());
       EXPECT_FALSE(database_->IsCsdWhitelistKillSwitchOn());
     }
@@ -1528,12 +1533,12 @@ TEST_F(SafeBrowsingDatabaseTest, SameHostEntriesOkay) {
   // Insert the testing chunks into database.
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   ASSERT_LE(1U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
+  EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
   EXPECT_EQ("1", lists[0].adds);
   EXPECT_TRUE(lists[0].subs.empty());
 
@@ -1544,15 +1549,15 @@ TEST_F(SafeBrowsingDatabaseTest, SameHostEntriesOkay) {
                                         "www.evil.com/phishing2.html"));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get());
+  database_->InsertChunks(safe_browsing::kPhishingList, chunks.get());
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
   ASSERT_LE(2U, lists.size());
-  EXPECT_EQ(safe_browsing_util::kMalwareList, lists[0].name);
+  EXPECT_EQ(safe_browsing::kMalwareList, lists[0].name);
   EXPECT_EQ("1", lists[0].adds);
   EXPECT_TRUE(lists[0].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kPhishingList, lists[1].name);
+  EXPECT_EQ(safe_browsing::kPhishingList, lists[1].name);
   EXPECT_EQ("47", lists[1].adds);
   EXPECT_TRUE(lists[1].subs.empty());
 
@@ -1573,14 +1578,14 @@ TEST_F(SafeBrowsingDatabaseTest, SameHostEntriesOkay) {
   chunks.clear();
   chunks.push_back(SubChunkPrefixValue(4, "www.evil.com/malware1.html", 1));
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   // Remove the prefix that added last.
   chunks.clear();
   chunks.push_back(SubChunkPrefixValue(5, "www.evil.com/phishing2.html", 47));
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kPhishingList, chunks.get());
+  database_->InsertChunks(safe_browsing::kPhishingList, chunks.get());
   database_->UpdateFinished(true);
 
   // Verify that the database contains urls expected.
@@ -1606,7 +1611,7 @@ TEST_F(SafeBrowsingDatabaseTest, EmptyUpdate) {
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html"));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   // Get an older time to reset the lastmod time for detecting whether
@@ -1623,7 +1628,7 @@ TEST_F(SafeBrowsingDatabaseTest, EmptyUpdate) {
   ASSERT_TRUE(base::GetFileInfo(filename, &before_info));
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   chunks.push_back(AddChunkPrefixValue(2, "www.foo.com/malware.html"));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
   ASSERT_TRUE(base::GetFileInfo(filename, &after_info));
   EXPECT_LT(before_info.last_modified, after_info.last_modified);
@@ -1632,7 +1637,7 @@ TEST_F(SafeBrowsingDatabaseTest, EmptyUpdate) {
   ASSERT_TRUE(base::TouchFile(filename, old_last_modified, old_last_modified));
   ASSERT_TRUE(base::GetFileInfo(filename, &before_info));
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  AddDelChunk(safe_browsing_util::kMalwareList, 2);
+  AddDelChunk(safe_browsing::kMalwareList, 2);
   database_->UpdateFinished(true);
   ASSERT_TRUE(base::GetFileInfo(filename, &after_info));
   EXPECT_LT(before_info.last_modified, after_info.last_modified);
@@ -1658,7 +1663,7 @@ TEST_F(SafeBrowsingDatabaseTest, FilterFile) {
 
     ScopedVector<SBChunkData> chunks;
     chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/malware.html"));
-    database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+    database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
     database_->UpdateFinished(true);
   }
 
@@ -1708,7 +1713,7 @@ TEST_F(SafeBrowsingDatabaseTest, CachedFullMiss) {
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   {
@@ -1763,7 +1768,7 @@ TEST_F(SafeBrowsingDatabaseTest, CachedPrefixHitFullMiss) {
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   {
@@ -1807,7 +1812,7 @@ TEST_F(SafeBrowsingDatabaseTest, CachedPrefixHitFullMiss) {
     std::vector<SBFullHashResult> cache_results;
 
     SBFullHashResult full_hash_result;
-    full_hash_result.list_id = safe_browsing_util::MALWARE;
+    full_hash_result.list_id = safe_browsing::MALWARE;
 
     full_hash_result.hash = kFullHash1_1;
     cache_results.push_back(full_hash_result);
@@ -1827,7 +1832,8 @@ TEST_F(SafeBrowsingDatabaseTest, CachedPrefixHitFullMiss) {
         full_hashes, &prefix_hits, &cache_hits));
     EXPECT_TRUE(prefix_hits.empty());
     ASSERT_EQ(1U, cache_hits.size());
-    EXPECT_TRUE(SBFullHashEqual(kFullHash1_1, cache_hits[0].hash));
+    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+        kFullHash1_1, cache_hits[0].hash));
 
     // Adding kFullHash2_1 will see the existing cache hit plus the prefix hit
     // for kPrefix2.
@@ -1839,7 +1845,8 @@ TEST_F(SafeBrowsingDatabaseTest, CachedPrefixHitFullMiss) {
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(kPrefix2, prefix_hits[0]);
     ASSERT_EQ(1U, cache_hits.size());
-    EXPECT_TRUE(SBFullHashEqual(kFullHash1_1, cache_hits[0].hash));
+    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+        kFullHash1_1, cache_hits[0].hash));
 
     // kFullHash1_3 also gets a cache hit.
     full_hashes.push_back(kFullHash1_3);
@@ -1850,8 +1857,10 @@ TEST_F(SafeBrowsingDatabaseTest, CachedPrefixHitFullMiss) {
     ASSERT_EQ(1U, prefix_hits.size());
     EXPECT_EQ(kPrefix2, prefix_hits[0]);
     ASSERT_EQ(2U, cache_hits.size());
-    EXPECT_TRUE(SBFullHashEqual(kFullHash1_1, cache_hits[0].hash));
-    EXPECT_TRUE(SBFullHashEqual(kFullHash1_3, cache_hits[1].hash));
+    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+        kFullHash1_1, cache_hits[0].hash));
+    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+        kFullHash1_3, cache_hits[1].hash));
   }
 
   {
@@ -1863,7 +1872,8 @@ TEST_F(SafeBrowsingDatabaseTest, CachedPrefixHitFullMiss) {
         full_hashes, &prefix_hits, &cache_hits));
     EXPECT_TRUE(prefix_hits.empty());
     ASSERT_EQ(1U, cache_hits.size());
-    EXPECT_TRUE(SBFullHashEqual(kFullHash1_3, cache_hits[0].hash));
+    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+        kFullHash1_3, cache_hits[0].hash));
   }
 
   {
@@ -1903,7 +1913,7 @@ TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashMatching) {
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   {
@@ -1938,7 +1948,7 @@ TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashMatching) {
   {
     // Cache a gethash result for kFullHash1_2.
     SBFullHashResult full_hash_result;
-    full_hash_result.list_id = safe_browsing_util::MALWARE;
+    full_hash_result.list_id = safe_browsing::MALWARE;
     full_hash_result.hash = kFullHash1_2;
 
     std::vector<SBPrefix> prefixes(1, kPrefix1);
@@ -1972,7 +1982,8 @@ TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashMatching) {
         full_hashes, &prefix_hits, &cache_hits));
     EXPECT_TRUE(prefix_hits.empty());
     ASSERT_EQ(1U, cache_hits.size());
-    EXPECT_TRUE(SBFullHashEqual(kFullHash1_2, cache_hits[0].hash));
+    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+        kFullHash1_2, cache_hits[0].hash));
   }
 
   // Remove kFullHash1_1 from the database.
@@ -1980,7 +1991,7 @@ TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashMatching) {
   chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   // Cache should be cleared after updating.
@@ -2018,7 +2029,7 @@ TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashMatching) {
   chunks.push_back(SubChunkFullHash(12, kFullHash1_2, 2));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   // Cache should be cleared after updating.
@@ -2050,7 +2061,7 @@ TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashAndPrefixMatching) {
 
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   {
@@ -2067,7 +2078,7 @@ TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashAndPrefixMatching) {
   chunks.push_back(AddChunkPrefix(2, kPrefix1));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   {
@@ -2087,7 +2098,7 @@ TEST_F(SafeBrowsingDatabaseTest, BrowseFullHashAndPrefixMatching) {
   chunks.push_back(SubChunkFullHash(11, kFullHash1_1, 1));
 
   ASSERT_TRUE(database_->UpdateStarted(&lists));
-  database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+  database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   database_->UpdateFinished(true);
 
   {
@@ -2127,7 +2138,7 @@ TEST_F(SafeBrowsingDatabaseTest, MalwareIpBlacklist) {
   // IPv4 prefix match for ::ffff:192.1.128.0/113.
   chunks.push_back(AddChunkHashedIpValue(6, "::ffff:192.1.128.0", 113));
 
-  database_->InsertChunks(safe_browsing_util::kIPBlacklist, chunks.get());
+  database_->InsertChunks(safe_browsing::kIPBlacklist, chunks.get());
   database_->UpdateFinished(true);
 
   EXPECT_FALSE(database_->ContainsMalwareIP("192.168.0.255"));
@@ -2177,7 +2188,7 @@ TEST_F(SafeBrowsingDatabaseTest, ContainsBrowseURL) {
   {
     ScopedVector<SBChunkData> chunks;
     chunks.push_back(AddChunkPrefixValue(1, "www.evil.com/"));
-    database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+    database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   }
 
   // Add a specific fullhash.
@@ -2185,7 +2196,7 @@ TEST_F(SafeBrowsingDatabaseTest, ContainsBrowseURL) {
   {
     ScopedVector<SBChunkData> chunks;
     chunks.push_back(AddChunkFullHashValue(2, kWhateverMalware));
-    database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+    database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   }
 
   // Add a fullhash which has a prefix collision for a known url.
@@ -2197,7 +2208,7 @@ TEST_F(SafeBrowsingDatabaseTest, ContainsBrowseURL) {
   {
     ScopedVector<SBChunkData> chunks;
     chunks.push_back(AddChunkFullHashValue(3, kExampleCollision));
-    database_->InsertChunks(safe_browsing_util::kMalwareList, chunks.get());
+    database_->InsertChunks(safe_browsing::kMalwareList, chunks.get());
   }
 
   database_->UpdateFinished(true);
diff --git a/chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc b/chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc
index f1d3971..222cb7b 100644
--- a/chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc
+++ b/chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc
@@ -138,8 +138,8 @@ class TestSafeBrowsingDatabase :  public SafeBrowsingDatabase {
                          std::vector<SBPrefix>* prefix_hits,
                          std::vector<SBFullHashResult>* cache_hits) override {
     cache_hits->clear();
-    return ContainsUrl(safe_browsing_util::MALWARE,
-                       safe_browsing_util::PHISH,
+    return ContainsUrl(safe_browsing::MALWARE,
+                       safe_browsing::PHISH,
                        std::vector<GURL>(1, url),
                        prefix_hits);
   }
@@ -148,8 +148,8 @@ class TestSafeBrowsingDatabase :  public SafeBrowsingDatabase {
       std::vector<SBPrefix>* prefix_hits,
       std::vector<SBFullHashResult>* cache_hits) override {
     cache_hits->clear();
-    return ContainsUrl(safe_browsing_util::UNWANTEDURL,
-                       safe_browsing_util::UNWANTEDURL,
+    return ContainsUrl(safe_browsing::UNWANTEDURL,
+                       safe_browsing::UNWANTEDURL,
                        std::vector<GURL>(1, url),
                        prefix_hits);
   }
@@ -157,8 +157,8 @@ class TestSafeBrowsingDatabase :  public SafeBrowsingDatabase {
       const std::vector<SBPrefix>& prefixes,
       std::vector<SBPrefix>* prefix_hits) override {
     bool found =
-        ContainsUrlPrefixes(safe_browsing_util::BINURL,
-                            safe_browsing_util::BINURL, prefixes, prefix_hits);
+        ContainsUrlPrefixes(safe_browsing::BINURL,
+                            safe_browsing::BINURL, prefixes, prefix_hits);
     if (!found)
       return false;
     DCHECK_LE(1U, prefix_hits->size());
@@ -424,8 +424,8 @@ class SafeBrowsingServiceTest : public InProcessBrowserTest {
                                    SBFullHashResult* full_hash) {
     std::string host;
     std::string path;
-    safe_browsing_util::CanonicalizeUrl(url, &host, &path, NULL);
-    full_hash->hash = SBFullHashForString(host + path);
+    safe_browsing::CanonicalizeUrl(url, &host, &path, NULL);
+    full_hash->hash = safe_browsing::SBFullHashForString(host + path);
     full_hash->list_id = list_id;
   }
 
@@ -601,7 +601,7 @@ class SafeBrowsingServiceMetadataTest
 
   void GenUrlFullhashResultWithMetadata(const GURL& url,
                                         SBFullHashResult* full_hash) {
-    GenUrlFullhashResult(url, safe_browsing_util::MALWARE, full_hash);
+    GenUrlFullhashResult(url, safe_browsing::MALWARE, full_hash);
 
     safe_browsing::MalwarePatternType proto;
     switch (GetParam()) {
@@ -712,7 +712,7 @@ IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, UnwantedImgIgnored) {
   // Add the img url as coming from a site serving UwS and then load the parent
   // page.
   SBFullHashResult uws_full_hash;
-  GenUrlFullhashResult(img_url, safe_browsing_util::UNWANTEDURL,
+  GenUrlFullhashResult(img_url, safe_browsing::UNWANTEDURL,
                        &uws_full_hash);
   SetupResponseForUrl(img_url, uws_full_hash);
 
@@ -727,7 +727,7 @@ IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, DISABLED_MalwareWithWhitelist) {
   // After adding the url to safebrowsing database and getfullhash result,
   // we should see the interstitial page.
   SBFullHashResult malware_full_hash;
-  GenUrlFullhashResult(url, safe_browsing_util::MALWARE, &malware_full_hash);
+  GenUrlFullhashResult(url, safe_browsing::MALWARE, &malware_full_hash);
   EXPECT_CALL(observer_,
               OnSafeBrowsingMatch(IsUnsafeResourceFor(url))).Times(1);
   EXPECT_CALL(observer_, OnSafeBrowsingHit(IsUnsafeResourceFor(url))).Times(1)
@@ -781,7 +781,7 @@ IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, Prefetch) {
   // getfullhash result, we should not see the interstitial page since the
   // only malware was a prefetch target.
   SBFullHashResult malware_full_hash;
-  GenUrlFullhashResult(malware_url, safe_browsing_util::MALWARE,
+  GenUrlFullhashResult(malware_url, safe_browsing::MALWARE,
                        &malware_full_hash);
   SetupResponseForUrl(malware_url, malware_full_hash);
   ui_test_utils::NavigateToURL(browser(), url);
@@ -896,7 +896,7 @@ IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckDownloadUrl) {
   EXPECT_EQ(SB_THREAT_TYPE_SAFE, client->GetThreatType());
 
   SBFullHashResult full_hash_result;
-  GenUrlFullhashResult(badbin_url, safe_browsing_util::BINURL,
+  GenUrlFullhashResult(badbin_url, safe_browsing::BINURL,
                        &full_hash_result);
   SetupResponseForUrl(badbin_url, full_hash_result);
 
@@ -918,7 +918,7 @@ IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckUnwantedSoftwareUrl) {
 
     SBFullHashResult full_hash_result;
     GenUrlFullhashResult(
-        bad_url, safe_browsing_util::UNWANTEDURL, &full_hash_result);
+        bad_url, safe_browsing::UNWANTEDURL, &full_hash_result);
     SetupResponseForUrl(bad_url, full_hash_result);
 
     // Now, the bad_url is not safe since it is added to download
@@ -940,7 +940,7 @@ IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckUnwantedSoftwareUrl) {
 
     SBFullHashResult full_hash_result;
     GenUrlFullhashResult(
-        bad_url, safe_browsing_util::MALWARE, &full_hash_result);
+        bad_url, safe_browsing::MALWARE, &full_hash_result);
     SetupResponseForUrl(bad_url, full_hash_result);
 
     client->CheckBrowseUrl(bad_url);
@@ -960,7 +960,7 @@ IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckBrowseUrl) {
 
     SBFullHashResult full_hash_result;
     GenUrlFullhashResult(
-        bad_url, safe_browsing_util::MALWARE, &full_hash_result);
+        bad_url, safe_browsing::MALWARE, &full_hash_result);
     SetupResponseForUrl(bad_url, full_hash_result);
 
     // Now, the bad_url is not safe since it is added to download
@@ -983,7 +983,7 @@ IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckBrowseUrl) {
 
     SBFullHashResult full_hash_result;
     GenUrlFullhashResult(
-        bad_url, safe_browsing_util::UNWANTEDURL, &full_hash_result);
+        bad_url, safe_browsing::UNWANTEDURL, &full_hash_result);
     SetupResponseForUrl(bad_url, full_hash_result);
 
     client->CheckBrowseUrl(bad_url);
@@ -1007,7 +1007,7 @@ IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, CheckDownloadUrlRedirects) {
   EXPECT_EQ(SB_THREAT_TYPE_SAFE, client->GetThreatType());
 
   SBFullHashResult full_hash_result;
-  GenUrlFullhashResult(badbin_url, safe_browsing_util::BINURL,
+  GenUrlFullhashResult(badbin_url, safe_browsing::BINURL,
                        &full_hash_result);
   SetupResponseForUrl(badbin_url, full_hash_result);
 
@@ -1030,7 +1030,7 @@ IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest,
 
   scoped_refptr<TestSBClient> client(new TestSBClient);
   SBFullHashResult full_hash_result;
-  GenUrlFullhashResult(badbin_url, safe_browsing_util::BINURL,
+  GenUrlFullhashResult(badbin_url, safe_browsing::BINURL,
                        &full_hash_result);
   SetupResponseForUrl(badbin_url, full_hash_result);
   client->CheckDownloadUrl(badbin_urls);
diff --git a/chrome/browser/safe_browsing/safe_browsing_store_file_unittest.cc b/chrome/browser/safe_browsing/safe_browsing_store_file_unittest.cc
index 768b90b..91e6fb3 100644
--- a/chrome/browser/safe_browsing/safe_browsing_store_file_unittest.cc
+++ b/chrome/browser/safe_browsing/safe_browsing_store_file_unittest.cc
@@ -13,6 +13,7 @@
 #include "base/test/test_simple_task_runner.h"
 #include "chrome/common/chrome_paths.h"
 #include "components/safe_browsing_db/prefix_set.h"
+#include "components/safe_browsing_db/util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
@@ -26,12 +27,12 @@ const int kAddChunk4 = 7;
 const int kSubChunk1 = 2;
 const int kSubChunk2 = 4;
 
-const SBFullHash kHash1 = SBFullHashForString("one");
-const SBFullHash kHash2 = SBFullHashForString("two");
-const SBFullHash kHash3 = SBFullHashForString("three");
-const SBFullHash kHash4 = SBFullHashForString("four");
-const SBFullHash kHash5 = SBFullHashForString("five");
-const SBFullHash kHash6 = SBFullHashForString("six");
+const SBFullHash kHash1 = safe_browsing::SBFullHashForString("one");
+const SBFullHash kHash2 = safe_browsing::SBFullHashForString("two");
+const SBFullHash kHash3 = safe_browsing::SBFullHashForString("three");
+const SBFullHash kHash4 = safe_browsing::SBFullHashForString("four");
+const SBFullHash kHash5 = safe_browsing::SBFullHashForString("five");
+const SBFullHash kHash6 = safe_browsing::SBFullHashForString("six");
 
 const SBPrefix kMinSBPrefix = 0u;
 const SBPrefix kMaxSBPrefix = ~kMinSBPrefix;
@@ -194,7 +195,8 @@ TEST_F(SafeBrowsingStoreFileTest, BasicStore) {
 
     ASSERT_EQ(1U, add_full_hashes_result.size());
     EXPECT_EQ(kAddChunk2, add_full_hashes_result[0].chunk_id);
-    EXPECT_TRUE(SBFullHashEqual(kHash4, add_full_hashes_result[0].full_hash));
+    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+        kHash4, add_full_hashes_result[0].full_hash));
   }
 }
 
@@ -279,7 +281,8 @@ TEST_F(SafeBrowsingStoreFileTest, SubKnockout) {
 
     ASSERT_EQ(1U, add_full_hashes_result.size());
     EXPECT_EQ(kAddChunk2, add_full_hashes_result[0].chunk_id);
-    EXPECT_TRUE(SBFullHashEqual(kHash4, add_full_hashes_result[0].full_hash));
+    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+        kHash4, add_full_hashes_result[0].full_hash));
   }
 
   ASSERT_TRUE(store_->BeginUpdate());
@@ -302,7 +305,8 @@ TEST_F(SafeBrowsingStoreFileTest, SubKnockout) {
 
     ASSERT_EQ(1U, add_full_hashes_result.size());
     EXPECT_EQ(kAddChunk2, add_full_hashes_result[0].chunk_id);
-    EXPECT_TRUE(SBFullHashEqual(kHash4, add_full_hashes_result[0].full_hash));
+    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+        kHash4, add_full_hashes_result[0].full_hash));
   }
 
   ASSERT_TRUE(store_->BeginUpdate());
@@ -326,7 +330,8 @@ TEST_F(SafeBrowsingStoreFileTest, SubKnockout) {
 
     ASSERT_EQ(1U, add_full_hashes_result.size());
     EXPECT_EQ(kAddChunk2, add_full_hashes_result[0].chunk_id);
-    EXPECT_TRUE(SBFullHashEqual(kHash4, add_full_hashes_result[0].full_hash));
+    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+        kHash4, add_full_hashes_result[0].full_hash));
   }
 }
 
@@ -392,7 +397,8 @@ TEST_F(SafeBrowsingStoreFileTest, DeleteChunks) {
 
     ASSERT_EQ(1U, add_full_hashes_result.size());
     EXPECT_EQ(kAddChunk3, add_full_hashes_result[0].chunk_id);
-    EXPECT_TRUE(SBFullHashEqual(kHash6, add_full_hashes_result[0].full_hash));
+    EXPECT_TRUE(safe_browsing::SBFullHashEqual(
+        kHash6, add_full_hashes_result[0].full_hash));
   }
 
   // Expected chunks are there in another update.
@@ -665,7 +671,7 @@ TEST_F(SafeBrowsingStoreFileTest, GetAddPrefixesAndHashes) {
   EXPECT_TRUE(store_->GetAddFullHashes(&add_hashes));
   ASSERT_EQ(1U, add_hashes.size());
   EXPECT_EQ(kAddChunk2, add_hashes[0].chunk_id);
-  EXPECT_TRUE(SBFullHashEqual(kHash4, add_hashes[0].full_hash));
+  EXPECT_TRUE(safe_browsing::SBFullHashEqual(kHash4, add_hashes[0].full_hash));
 }
 
 // Test that the database handles resharding correctly, both when growing and
@@ -807,7 +813,7 @@ TEST_F(SafeBrowsingStoreFileTest, Version8) {
   EXPECT_TRUE(store_->GetAddFullHashes(&add_hashes));
   ASSERT_EQ(1U, add_hashes.size());
   EXPECT_EQ(kAddChunk1, add_hashes[0].chunk_id);
-  EXPECT_TRUE(SBFullHashEqual(kHash2, add_hashes[0].full_hash));
+  EXPECT_TRUE(safe_browsing::SBFullHashEqual(kHash2, add_hashes[0].full_hash));
 
   // Attempt an update to make sure things work end-to-end.
   EXPECT_TRUE(store_->BeginUpdate());
diff --git a/chrome/browser/safe_browsing/safe_browsing_store_unittest.cc b/chrome/browser/safe_browsing/safe_browsing_store_unittest.cc
index 0475105..fb8ab17 100644
--- a/chrome/browser/safe_browsing/safe_browsing_store_unittest.cc
+++ b/chrome/browser/safe_browsing/safe_browsing_store_unittest.cc
@@ -3,18 +3,19 @@
 // found in the LICENSE file.
 
 #include "chrome/browser/safe_browsing/safe_browsing_store.h"
+#include "components/safe_browsing_db/util.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
-const SBFullHash kHash1 = SBFullHashForString("one");
-const SBFullHash kHash2 = SBFullHashForString("two");
-const SBFullHash kHash3 = SBFullHashForString("three");
-const SBFullHash kHash4 = SBFullHashForString("four");
-const SBFullHash kHash5 = SBFullHashForString("five");
-const SBFullHash kHash6 = SBFullHashForString("six");
-const SBFullHash kHash7 = SBFullHashForString("seven");
+const SBFullHash kHash1 = safe_browsing::SBFullHashForString("one");
+const SBFullHash kHash2 = safe_browsing::SBFullHashForString("two");
+const SBFullHash kHash3 = safe_browsing::SBFullHashForString("three");
+const SBFullHash kHash4 = safe_browsing::SBFullHashForString("four");
+const SBFullHash kHash5 = safe_browsing::SBFullHashForString("five");
+const SBFullHash kHash6 = safe_browsing::SBFullHashForString("six");
+const SBFullHash kHash7 = safe_browsing::SBFullHashForString("seven");
 
 const int kAddChunk1 = 1;  // Use different chunk numbers just in case.
 const int kSubChunk1 = 2;
@@ -217,9 +218,9 @@ TEST(SafeBrowsingStoreTest, SBProcessSubsKnockout) {
 
   ASSERT_EQ(2U, add_hashes.size());
   EXPECT_EQ(kAddChunk5, add_hashes[0].chunk_id);
-  EXPECT_TRUE(SBFullHashEqual(kHash4, add_hashes[0].full_hash));
+  EXPECT_TRUE(safe_browsing::SBFullHashEqual(kHash4, add_hashes[0].full_hash));
   EXPECT_EQ(kAddChunk6, add_hashes[1].chunk_id);
-  EXPECT_TRUE(SBFullHashEqual(kHash6, add_hashes[1].full_hash));
+  EXPECT_TRUE(safe_browsing::SBFullHashEqual(kHash6, add_hashes[1].full_hash));
 
   ASSERT_EQ(1U, sub_prefixes.size());
   EXPECT_EQ(kSubChunk4, sub_prefixes[0].chunk_id);
@@ -229,7 +230,7 @@ TEST(SafeBrowsingStoreTest, SBProcessSubsKnockout) {
   ASSERT_EQ(1U, sub_hashes.size());
   EXPECT_EQ(kSubChunk3, sub_hashes[0].chunk_id);
   EXPECT_EQ(kAddChunk3, sub_hashes[0].add_chunk_id);
-  EXPECT_TRUE(SBFullHashEqual(kHash7, sub_hashes[0].full_hash));
+  EXPECT_TRUE(safe_browsing::SBFullHashEqual(kHash7, sub_hashes[0].full_hash));
 }
 
 // Test chunk deletions, and ordering of deletions WRT subs knocking
@@ -274,7 +275,7 @@ TEST(SafeBrowsingStoreTest, SBProcessSubsDeleteChunk) {
 
   ASSERT_EQ(1U, add_hashes.size());
   EXPECT_EQ(kAddChunk1, add_hashes[0].chunk_id);
-  EXPECT_TRUE(SBFullHashEqual(kHash6, add_hashes[0].full_hash));
+  EXPECT_TRUE(safe_browsing::SBFullHashEqual(kHash6, add_hashes[0].full_hash));
 
   EXPECT_TRUE(sub_prefixes.empty());
   EXPECT_TRUE(sub_hashes.empty());
diff --git a/chrome/browser/safe_browsing/safe_browsing_util.cc b/chrome/browser/safe_browsing/safe_browsing_util.cc
index 3a5ba42..867c1aa 100644
--- a/chrome/browser/safe_browsing/safe_browsing_util.cc
+++ b/chrome/browser/safe_browsing/safe_browsing_util.cc
@@ -4,25 +4,10 @@
 
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 
-#include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/safe_browsing/chunk.pb.h"
 #include "components/google/core/browser/google_util.h"
-#include "crypto/sha2.h"
-#include "net/base/escape.h"
-#include "url/gurl.h"
-#include "url/url_util.h"
-
-// SBCachedFullHashResult ------------------------------------------------------
-
-SBCachedFullHashResult::SBCachedFullHashResult() {}
-
-SBCachedFullHashResult::SBCachedFullHashResult(
-    const base::Time& in_expire_after)
-    : expire_after(in_expire_after) {}
-
-SBCachedFullHashResult::~SBCachedFullHashResult() {}
 
 // SBChunkData -----------------------------------------------------------------
 
@@ -143,343 +128,3 @@ SBListChunkRanges::SBListChunkRanges(const std::string& n)
 SBChunkDelete::SBChunkDelete() : is_sub_del(false) {}
 
 SBChunkDelete::~SBChunkDelete() {}
-
-// Utility functions -----------------------------------------------------------
-
-namespace {
-bool IsKnownList(const std::string& name) {
-  for (size_t i = 0; i < arraysize(safe_browsing_util::kAllLists); ++i) {
-    if (!strcmp(safe_browsing_util::kAllLists[i], name.c_str())) {
-      return true;
-    }
-  }
-  return false;
-}
-}  // namespace
-
-namespace safe_browsing_util {
-
-// Listnames that browser can process.
-const char kMalwareList[] = "goog-malware-shavar";
-const char kPhishingList[] = "goog-phish-shavar";
-const char kBinUrlList[] = "goog-badbinurl-shavar";
-const char kCsdWhiteList[] = "goog-csdwhite-sha256";
-const char kDownloadWhiteList[] = "goog-downloadwhite-digest256";
-const char kExtensionBlacklist[] = "goog-badcrxids-digestvar";
-const char kIPBlacklist[] = "goog-badip-digest256";
-const char kUnwantedUrlList[] = "goog-unwanted-shavar";
-const char kInclusionWhitelist[] = "goog-csdinclusionwhite-sha256";
-
-const char* kAllLists[9] = {
-    kMalwareList,
-    kPhishingList,
-    kBinUrlList,
-    kCsdWhiteList,
-    kDownloadWhiteList,
-    kExtensionBlacklist,
-    kIPBlacklist,
-    kUnwantedUrlList,
-    kInclusionWhitelist,
-};
-
-ListType GetListId(const base::StringPiece& name) {
-  ListType id;
-  if (name == safe_browsing_util::kMalwareList) {
-    id = MALWARE;
-  } else if (name == safe_browsing_util::kPhishingList) {
-    id = PHISH;
-  } else if (name == safe_browsing_util::kBinUrlList) {
-    id = BINURL;
-  } else if (name == safe_browsing_util::kCsdWhiteList) {
-    id = CSDWHITELIST;
-  } else if (name == safe_browsing_util::kDownloadWhiteList) {
-    id = DOWNLOADWHITELIST;
-  } else if (name == safe_browsing_util::kExtensionBlacklist) {
-    id = EXTENSIONBLACKLIST;
-  } else if (name == safe_browsing_util::kIPBlacklist) {
-    id = IPBLACKLIST;
-  } else if (name == safe_browsing_util::kUnwantedUrlList) {
-    id = UNWANTEDURL;
-  } else if (name == safe_browsing_util::kInclusionWhitelist) {
-    id = INCLUSIONWHITELIST;
-  } else {
-    id = INVALID;
-  }
-  return id;
-}
-
-bool GetListName(ListType list_id, std::string* list) {
-  switch (list_id) {
-    case MALWARE:
-      *list = safe_browsing_util::kMalwareList;
-      break;
-    case PHISH:
-      *list = safe_browsing_util::kPhishingList;
-      break;
-    case BINURL:
-      *list = safe_browsing_util::kBinUrlList;
-      break;
-    case CSDWHITELIST:
-      *list = safe_browsing_util::kCsdWhiteList;
-      break;
-    case DOWNLOADWHITELIST:
-      *list = safe_browsing_util::kDownloadWhiteList;
-      break;
-    case EXTENSIONBLACKLIST:
-      *list = safe_browsing_util::kExtensionBlacklist;
-      break;
-    case IPBLACKLIST:
-      *list = safe_browsing_util::kIPBlacklist;
-      break;
-    case UNWANTEDURL:
-      *list = safe_browsing_util::kUnwantedUrlList;
-      break;
-    case INCLUSIONWHITELIST:
-      *list = safe_browsing_util::kInclusionWhitelist;
-      break;
-    default:
-      return false;
-  }
-  DCHECK(IsKnownList(*list));
-  return true;
-}
-
-std::string Unescape(const std::string& url) {
-  std::string unescaped_str(url);
-  std::string old_unescaped_str;
-  const int kMaxLoopIterations = 1024;
-  int loop_var = 0;
-  do {
-    old_unescaped_str = unescaped_str;
-    unescaped_str = net::UnescapeURLComponent(
-        old_unescaped_str, net::UnescapeRule::SPOOFING_AND_CONTROL_CHARS |
-                               net::UnescapeRule::SPACES |
-                               net::UnescapeRule::URL_SPECIAL_CHARS);
-  } while (unescaped_str != old_unescaped_str && ++loop_var <=
-           kMaxLoopIterations);
-
-  return unescaped_str;
-}
-
-std::string Escape(const std::string& url) {
-  std::string escaped_str;
-  const char* kHexString = "0123456789ABCDEF";
-  for (size_t i = 0; i < url.length(); i++) {
-    unsigned char c = static_cast<unsigned char>(url[i]);
-    if (c <= ' ' || c > '~' || c == '#' || c == '%') {
-      escaped_str.push_back('%');
-      escaped_str.push_back(kHexString[c >> 4]);
-      escaped_str.push_back(kHexString[c & 0xf]);
-    } else {
-      escaped_str.push_back(c);
-    }
-  }
-
-  return escaped_str;
-}
-
-std::string RemoveConsecutiveChars(const std::string& str, const char c) {
-  std::string output(str);
-  std::string string_to_find;
-  std::string::size_type loc = 0;
-  string_to_find.append(2, c);
-  while ((loc = output.find(string_to_find, loc)) != std::string::npos) {
-    output.erase(loc, 1);
-  }
-
-  return output;
-}
-
-// Canonicalizes url as per Google Safe Browsing Specification.
-// See section 6.1 in
-// http://code.google.com/p/google-safe-browsing/wiki/Protocolv2Spec.
-void CanonicalizeUrl(const GURL& url,
-                     std::string* canonicalized_hostname,
-                     std::string* canonicalized_path,
-                     std::string* canonicalized_query) {
-  DCHECK(url.is_valid());
-
-  // We only canonicalize "normal" URLs.
-  if (!url.IsStandard())
-    return;
-
-  // Following canonicalization steps are excluded since url parsing takes care
-  // of those :-
-  // 1. Remove any tab (0x09), CR (0x0d), and LF (0x0a) chars from url.
-  //    (Exclude escaped version of these chars).
-  // 2. Normalize hostname to 4 dot-seperated decimal values.
-  // 3. Lowercase hostname.
-  // 4. Resolve path sequences "/../" and "/./".
-
-  // That leaves us with the following :-
-  // 1. Remove fragment in URL.
-  GURL url_without_fragment;
-  GURL::Replacements f_replacements;
-  f_replacements.ClearRef();
-  f_replacements.ClearUsername();
-  f_replacements.ClearPassword();
-  url_without_fragment = url.ReplaceComponents(f_replacements);
-
-  // 2. Do URL unescaping until no more hex encoded characters exist.
-  std::string url_unescaped_str(Unescape(url_without_fragment.spec()));
-  url::Parsed parsed;
-  url::ParseStandardURL(url_unescaped_str.data(), url_unescaped_str.length(),
-                        &parsed);
-
-  // 3. In hostname, remove all leading and trailing dots.
-  const std::string host =
-      (parsed.host.len > 0)
-          ? url_unescaped_str.substr(parsed.host.begin, parsed.host.len)
-          : std::string();
-  std::string host_without_end_dots;
-  base::TrimString(host, ".", &host_without_end_dots);
-
-  // 4. In hostname, replace consecutive dots with a single dot.
-  std::string host_without_consecutive_dots(RemoveConsecutiveChars(
-      host_without_end_dots, '.'));
-
-  // 5. In path, replace runs of consecutive slashes with a single slash.
-  std::string path =
-      (parsed.path.len > 0)
-          ? url_unescaped_str.substr(parsed.path.begin, parsed.path.len)
-          : std::string();
-  std::string path_without_consecutive_slash(RemoveConsecutiveChars(path, '/'));
-
-  url::Replacements<char> hp_replacements;
-  hp_replacements.SetHost(
-      host_without_consecutive_dots.data(),
-      url::Component(0, host_without_consecutive_dots.length()));
-  hp_replacements.SetPath(
-      path_without_consecutive_slash.data(),
-      url::Component(0, path_without_consecutive_slash.length()));
-
-  std::string url_unescaped_with_can_hostpath;
-  url::StdStringCanonOutput output(&url_unescaped_with_can_hostpath);
-  url::Parsed temp_parsed;
-  url::ReplaceComponents(url_unescaped_str.data(),
-                         url_unescaped_str.length(),
-                         parsed,
-                         hp_replacements,
-                         NULL,
-                         &output,
-                         &temp_parsed);
-  output.Complete();
-
-  // 6. Step needed to revert escaping done in url::ReplaceComponents.
-  url_unescaped_with_can_hostpath = Unescape(url_unescaped_with_can_hostpath);
-
-  // 7. After performing all above steps, percent-escape all chars in url which
-  // are <= ASCII 32, >= 127, #, %. Escapes must be uppercase hex characters.
-  std::string escaped_canon_url_str(Escape(url_unescaped_with_can_hostpath));
-  url::Parsed final_parsed;
-  url::ParseStandardURL(escaped_canon_url_str.data(),
-                        escaped_canon_url_str.length(),
-                        &final_parsed);
-
-  if (canonicalized_hostname && final_parsed.host.len > 0) {
-    *canonicalized_hostname =
-        escaped_canon_url_str.substr(final_parsed.host.begin,
-                                     final_parsed.host.len);
-  }
-  if (canonicalized_path && final_parsed.path.len > 0) {
-    *canonicalized_path = escaped_canon_url_str.substr(final_parsed.path.begin,
-                                                       final_parsed.path.len);
-  }
-  if (canonicalized_query && final_parsed.query.len > 0) {
-    *canonicalized_query = escaped_canon_url_str.substr(
-        final_parsed.query.begin, final_parsed.query.len);
-  }
-}
-
-void GenerateHostsToCheck(const GURL& url, std::vector<std::string>* hosts) {
-  hosts->clear();
-
-  std::string canon_host;
-  CanonicalizeUrl(url, &canon_host, NULL, NULL);
-
-  const std::string host = canon_host;  // const sidesteps GCC bugs below!
-  if (host.empty())
-    return;
-
-  // Per the Safe Browsing Protocol v2 spec, we try the host, and also up to 4
-  // hostnames formed by starting with the last 5 components and successively
-  // removing the leading component.  The last component isn't examined alone,
-  // since it's the TLD or a subcomponent thereof.
-  //
-  // Note that we don't need to be clever about stopping at the "real" eTLD --
-  // the data on the server side has been filtered to ensure it will not
-  // blacklist a whole TLD, and it's not significantly slower on our side to
-  // just check too much.
-  //
-  // Also note that because we have a simple blacklist, not some sort of complex
-  // whitelist-in-blacklist or vice versa, it doesn't matter what order we check
-  // these in.
-  const size_t kMaxHostsToCheck = 4;
-  bool skipped_last_component = false;
-  for (std::string::const_reverse_iterator i(host.rbegin());
-       i != host.rend() && hosts->size() < kMaxHostsToCheck; ++i) {
-    if (*i == '.') {
-      if (skipped_last_component)
-        hosts->push_back(std::string(i.base(), host.end()));
-      else
-        skipped_last_component = true;
-    }
-  }
-  hosts->push_back(host);
-}
-
-void GeneratePathsToCheck(const GURL& url, std::vector<std::string>* paths) {
-  paths->clear();
-
-  std::string canon_path;
-  std::string canon_query;
-  CanonicalizeUrl(url, NULL, &canon_path, &canon_query);
-
-  const std::string path = canon_path;   // const sidesteps GCC bugs below!
-  const std::string query = canon_query;
-  if (path.empty())
-    return;
-
-  // Per the Safe Browsing Protocol v2 spec, we try the exact path with/without
-  // the query parameters, and also up to 4 paths formed by starting at the root
-  // and adding more path components.
-  //
-  // As with the hosts above, it doesn't matter what order we check these in.
-  const size_t kMaxPathsToCheck = 4;
-  for (std::string::const_iterator i(path.begin());
-       i != path.end() && paths->size() < kMaxPathsToCheck; ++i) {
-    if (*i == '/')
-      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]);
-    }
-  }
-}
-
-SBFullHash StringToSBFullHash(const std::string& hash_in) {
-  DCHECK_EQ(crypto::kSHA256Length, hash_in.size());
-  SBFullHash hash_out;
-  memcpy(hash_out.full_hash, hash_in.data(), crypto::kSHA256Length);
-  return hash_out;
-}
-
-std::string SBFullHashToString(const SBFullHash& hash) {
-  DCHECK_EQ(crypto::kSHA256Length, sizeof(hash.full_hash));
-  return std::string(hash.full_hash, sizeof(hash.full_hash));
-}
-
-}  // namespace safe_browsing_util
diff --git a/chrome/browser/safe_browsing/safe_browsing_util.h b/chrome/browser/safe_browsing/safe_browsing_util.h
index b01f6a3..9cbb3cd 100644
--- a/chrome/browser/safe_browsing/safe_browsing_util.h
+++ b/chrome/browser/safe_browsing/safe_browsing_util.h
@@ -16,14 +16,12 @@
 #include "base/strings/string_piece.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/chunk_range.h"
-#include "components/safe_browsing_db/safe_browsing_db_util.h"
+#include "components/safe_browsing_db/util.h"
 
 namespace safe_browsing {
 class ChunkData;
 };
 
-class GURL;
-
 // Container for holding a chunk URL and the list it belongs to.
 struct ChunkUrl {
   std::string url;
@@ -65,24 +63,6 @@ class SBChunkData {
   DISALLOW_COPY_AND_ASSIGN(SBChunkData);
 };
 
-// Used when we get a gethash response.
-struct SBFullHashResult {
-  SBFullHash hash;
-  // TODO(shess): Refactor to allow ListType here.
-  int list_id;
-  std::string metadata;
-};
-
-// Caches individual response from GETHASH request.
-struct SBCachedFullHashResult {
-  SBCachedFullHashResult();
-  explicit SBCachedFullHashResult(const base::Time& in_expire_after);
-  ~SBCachedFullHashResult();
-
-  base::Time expire_after;
-  std::vector<SBFullHashResult> full_hashes;
-};
-
 // Contains information about a list in the database.
 struct SBListChunkRanges {
   explicit SBListChunkRanges(const std::string& n);
@@ -102,81 +82,4 @@ struct SBChunkDelete {
   std::vector<ChunkRange> chunk_del;
 };
 
-// Utility functions -----------------------------------------------------------
-
-namespace safe_browsing_util {
-
-// SafeBrowsing list names.
-extern const char kMalwareList[];
-extern const char kPhishingList[];
-// Binary Download list name.
-extern const char kBinUrlList[];
-// SafeBrowsing client-side detection whitelist list name.
-extern const char kCsdWhiteList[];
-// SafeBrowsing download whitelist list name.
-extern const char kDownloadWhiteList[];
-// SafeBrowsing extension list name.
-extern const char kExtensionBlacklist[];
-// SafeBrowsing csd malware IP blacklist name.
-extern const char kIPBlacklist[];
-// SafeBrowsing unwanted URL list.
-extern const char kUnwantedUrlList[];
-// SafeBrowsing off-domain inclusion whitelist list name.
-extern const char kInclusionWhitelist[];
-
-// This array must contain all Safe Browsing lists.
-extern const char* kAllLists[9];
-
-enum ListType {
-  INVALID = -1,
-  MALWARE = 0,
-  PHISH = 1,
-  BINURL = 2,
-  // Obsolete BINHASH = 3,
-  CSDWHITELIST = 4,
-  // SafeBrowsing lists are stored in pairs.  Keep ListType 5
-  // available for a potential second list that we would store in the
-  // csd-whitelist store file.
-  DOWNLOADWHITELIST = 6,
-  // See above comment. Leave 7 available.
-  EXTENSIONBLACKLIST = 8,
-  // See above comment. Leave 9 available.
-  // Obsolete SIDEEFFECTFREEWHITELIST = 10,
-  // See above comment. Leave 11 available.
-  IPBLACKLIST = 12,
-  // See above comment.  Leave 13 available.
-  UNWANTEDURL = 14,
-  // See above comment.  Leave 15 available.
-  INCLUSIONWHITELIST = 16,
-  // See above comment.  Leave 17 available.
-};
-
-// Maps a list name to ListType.
-ListType GetListId(const base::StringPiece& name);
-
-// Maps a ListId to list name. Return false if fails.
-bool GetListName(ListType list_id, std::string* list);
-
-// Canonicalizes url as per Google Safe Browsing Specification.
-// See section 6.1 in
-// http://code.google.com/p/google-safe-browsing/wiki/Protocolv2Spec.
-void CanonicalizeUrl(const GURL& url, std::string* canonicalized_hostname,
-                     std::string* canonicalized_path,
-                     std::string* canonicalized_query);
-
-// Given a URL, returns all the hosts we need to check.  They are returned
-// in order of size (i.e. b.c is first, then a.b.c).
-void GenerateHostsToCheck(const GURL& url, std::vector<std::string>* hosts);
-
-// Given a URL, returns all the paths we need to check.
-void GeneratePathsToCheck(const GURL& url, std::vector<std::string>* paths);
-
-// Given a URL, returns all the patterns we need to check.
-void GeneratePatternsToCheck(const GURL& url, std::vector<std::string>* urls);
-
-SBFullHash StringToSBFullHash(const std::string& hash_in);
-std::string SBFullHashToString(const SBFullHash& hash_out);
-
-}  // namespace safe_browsing_util
-
 #endif  // CHROME_BROWSER_SAFE_BROWSING_SAFE_BROWSING_UTIL_H_
diff --git a/chrome/chrome_tests_unit.gypi b/chrome/chrome_tests_unit.gypi
index e7701d0..dd63d07 100644
--- a/chrome/chrome_tests_unit.gypi
+++ b/chrome/chrome_tests_unit.gypi
@@ -995,7 +995,6 @@
       'browser/safe_browsing/safe_browsing_database_unittest.cc',
       'browser/safe_browsing/safe_browsing_store_file_unittest.cc',
       'browser/safe_browsing/safe_browsing_store_unittest.cc',
-      'browser/safe_browsing/safe_browsing_util_unittest.cc',
       'browser/safe_browsing/sandboxed_dmg_analyzer_mac_unittest.cc',
       'browser/safe_browsing/sandboxed_zip_analyzer_unittest.cc',
       'browser/safe_browsing/signature_evaluator_mac_unittest.cc',
diff --git a/components/components_tests.gyp b/components/components_tests.gyp
index a925c6b..027ccfe 100644
--- a/components/components_tests.gyp
+++ b/components/components_tests.gyp
@@ -578,7 +578,7 @@
     ],
     'safe_browsing_db_unittest_sources': [
       'safe_browsing_db/prefix_set_unittest.cc',
-      'safe_browsing_db/safe_browsing_db_util_unittest.cc',
+      'safe_browsing_db/util_unittest.cc',
     ],
     'safe_json_unittest_sources': [
       'safe_json/json_sanitizer_unittest.cc',
diff --git a/components/safe_browsing_db.gypi b/components/safe_browsing_db.gypi
index c5cec12..a874bfa 100644
--- a/components/safe_browsing_db.gypi
+++ b/components/safe_browsing_db.gypi
@@ -16,8 +16,8 @@
         # Note: sources list duplicated in GN build.
         'safe_browsing_db/prefix_set.h',
         'safe_browsing_db/prefix_set.cc',
-        'safe_browsing_db/safe_browsing_db_util.h',
-        'safe_browsing_db/safe_browsing_db_util.cc',
+        'safe_browsing_db/util.h',
+        'safe_browsing_db/util.cc',
       ],
       'include_dirs': [
         '..',
diff --git a/components/safe_browsing_db/BUILD.gn b/components/safe_browsing_db/BUILD.gn
index 4147fe9..bc82f79 100644
--- a/components/safe_browsing_db/BUILD.gn
+++ b/components/safe_browsing_db/BUILD.gn
@@ -5,7 +5,7 @@
 group("safe_browsing_db") {
   deps = [
     ":prefix_set",
-    ":safe_browsing_db_util",
+    ":util",
   ]
 }
 
@@ -19,10 +19,10 @@ source_set("prefix_set") {
   ]
 }
 
-source_set("safe_browsing_db_util") {
+source_set("util") {
   sources = [
-    "safe_browsing_db_util.cc",
-    "safe_browsing_db_util.h",
+    "util.cc",
+    "util.h",
   ]
   deps = [
     "//base",
@@ -34,11 +34,11 @@ source_set("unit_tests") {
   testonly = true
   sources = [
     "prefix_set_unittest.cc",
-    "safe_browsing_db_util_unittest.cc",
+    "util_unittest.cc",
   ]
   deps = [
     ":prefix_set",
-    ":safe_browsing_db_util",
+    ":util",
     "//base",
     "//testing/gtest",
   ]
diff --git a/components/safe_browsing_db/DEPS b/components/safe_browsing_db/DEPS
index 4ef4138..12af900 100644
--- a/components/safe_browsing_db/DEPS
+++ b/components/safe_browsing_db/DEPS
@@ -1,3 +1,4 @@
 include_rules = [
   "+crypto",
+  "+net",
 ]
diff --git a/components/safe_browsing_db/prefix_set.h b/components/safe_browsing_db/prefix_set.h
index 433da66..5517105 100644
--- a/components/safe_browsing_db/prefix_set.h
+++ b/components/safe_browsing_db/prefix_set.h
@@ -55,7 +55,7 @@
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
-#include "components/safe_browsing_db/safe_browsing_db_util.h"
+#include "components/safe_browsing_db/util.h"
 
 namespace base {
 class FilePath;
diff --git a/components/safe_browsing_db/prefix_set_unittest.cc b/components/safe_browsing_db/prefix_set_unittest.cc
index b980e71..08f639a9 100644
--- a/components/safe_browsing_db/prefix_set_unittest.cc
+++ b/components/safe_browsing_db/prefix_set_unittest.cc
@@ -19,7 +19,7 @@
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
-#include "components/safe_browsing_db/safe_browsing_db_util.h"
+#include "components/safe_browsing_db/util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
diff --git a/components/safe_browsing_db/util.cc b/components/safe_browsing_db/util.cc
new file mode 100644
index 0000000..8d95b9c
--- /dev/null
+++ b/components/safe_browsing_db/util.cc
@@ -0,0 +1,371 @@
+// Copyright (c) 2015 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_db/util.h"
+
+#include "base/strings/string_util.h"
+#include "crypto/sha2.h"
+#include "net/base/escape.h"
+#include "url/gurl.h"
+#include "url/url_util.h"
+
+// Utility functions -----------------------------------------------------------
+
+namespace {
+bool IsKnownList(const std::string& name) {
+  for (size_t i = 0; i < arraysize(safe_browsing::kAllLists); ++i) {
+    if (!strcmp(safe_browsing::kAllLists[i], name.c_str())) {
+      return true;
+    }
+  }
+  return false;
+}
+}  // namespace
+
+
+// SBCachedFullHashResult ------------------------------------------------------
+
+SBCachedFullHashResult::SBCachedFullHashResult() {}
+
+SBCachedFullHashResult::SBCachedFullHashResult(
+    const base::Time& in_expire_after)
+    : expire_after(in_expire_after) {}
+
+SBCachedFullHashResult::~SBCachedFullHashResult() {}
+
+
+namespace safe_browsing {
+
+// Listnames that browser can process.
+const char kMalwareList[] = "goog-malware-shavar";
+const char kPhishingList[] = "goog-phish-shavar";
+const char kBinUrlList[] = "goog-badbinurl-shavar";
+const char kCsdWhiteList[] = "goog-csdwhite-sha256";
+const char kDownloadWhiteList[] = "goog-downloadwhite-digest256";
+const char kExtensionBlacklist[] = "goog-badcrxids-digestvar";
+const char kIPBlacklist[] = "goog-badip-digest256";
+const char kUnwantedUrlList[] = "goog-unwanted-shavar";
+const char kInclusionWhitelist[] = "goog-csdinclusionwhite-sha256";
+
+const char* kAllLists[9] = {
+    kMalwareList,
+    kPhishingList,
+    kBinUrlList,
+    kCsdWhiteList,
+    kDownloadWhiteList,
+    kExtensionBlacklist,
+    kIPBlacklist,
+    kUnwantedUrlList,
+    kInclusionWhitelist,
+};
+
+ListType GetListId(const base::StringPiece& name) {
+  ListType id;
+  if (name == kMalwareList) {
+    id = MALWARE;
+  } else if (name == kPhishingList) {
+    id = PHISH;
+  } else if (name == kBinUrlList) {
+    id = BINURL;
+  } else if (name == kCsdWhiteList) {
+    id = CSDWHITELIST;
+  } else if (name == kDownloadWhiteList) {
+    id = DOWNLOADWHITELIST;
+  } else if (name == kExtensionBlacklist) {
+    id = EXTENSIONBLACKLIST;
+  } else if (name == kIPBlacklist) {
+    id = IPBLACKLIST;
+  } else if (name == kUnwantedUrlList) {
+    id = UNWANTEDURL;
+  } else if (name == kInclusionWhitelist) {
+    id = INCLUSIONWHITELIST;
+  } else {
+    id = INVALID;
+  }
+  return id;
+}
+
+bool GetListName(ListType list_id, std::string* list) {
+  switch (list_id) {
+    case MALWARE:
+      *list = kMalwareList;
+      break;
+    case PHISH:
+      *list = kPhishingList;
+      break;
+    case BINURL:
+      *list = kBinUrlList;
+      break;
+    case CSDWHITELIST:
+      *list = kCsdWhiteList;
+      break;
+    case DOWNLOADWHITELIST:
+      *list = kDownloadWhiteList;
+      break;
+    case EXTENSIONBLACKLIST:
+      *list = kExtensionBlacklist;
+      break;
+    case IPBLACKLIST:
+      *list = kIPBlacklist;
+      break;
+    case UNWANTEDURL:
+      *list = kUnwantedUrlList;
+      break;
+    case INCLUSIONWHITELIST:
+      *list = kInclusionWhitelist;
+      break;
+    default:
+      return false;
+  }
+  DCHECK(IsKnownList(*list));
+  return true;
+}
+
+
+SBFullHash SBFullHashForString(const base::StringPiece& str) {
+  SBFullHash h;
+  crypto::SHA256HashString(str, &h.full_hash, sizeof(h.full_hash));
+  return h;
+}
+
+SBFullHash StringToSBFullHash(const std::string& hash_in) {
+  DCHECK_EQ(crypto::kSHA256Length, hash_in.size());
+  SBFullHash hash_out;
+  memcpy(hash_out.full_hash, hash_in.data(), crypto::kSHA256Length);
+  return hash_out;
+}
+
+std::string SBFullHashToString(const SBFullHash& hash) {
+  DCHECK_EQ(crypto::kSHA256Length, sizeof(hash.full_hash));
+  return std::string(hash.full_hash, sizeof(hash.full_hash));
+}
+
+
+std::string Unescape(const std::string& url) {
+  std::string unescaped_str(url);
+  std::string old_unescaped_str;
+  const int kMaxLoopIterations = 1024;
+  int loop_var = 0;
+  do {
+    old_unescaped_str = unescaped_str;
+    unescaped_str = net::UnescapeURLComponent(
+        old_unescaped_str, net::UnescapeRule::SPOOFING_AND_CONTROL_CHARS |
+                               net::UnescapeRule::SPACES |
+                               net::UnescapeRule::URL_SPECIAL_CHARS);
+  } while (unescaped_str != old_unescaped_str && ++loop_var <=
+           kMaxLoopIterations);
+
+  return unescaped_str;
+}
+
+std::string Escape(const std::string& url) {
+  std::string escaped_str;
+  const char* kHexString = "0123456789ABCDEF";
+  for (size_t i = 0; i < url.length(); i++) {
+    unsigned char c = static_cast<unsigned char>(url[i]);
+    if (c <= ' ' || c > '~' || c == '#' || c == '%') {
+      escaped_str.push_back('%');
+      escaped_str.push_back(kHexString[c >> 4]);
+      escaped_str.push_back(kHexString[c & 0xf]);
+    } else {
+      escaped_str.push_back(c);
+    }
+  }
+
+  return escaped_str;
+}
+
+std::string RemoveConsecutiveChars(const std::string& str, const char c) {
+  std::string output(str);
+  std::string string_to_find;
+  std::string::size_type loc = 0;
+  string_to_find.append(2, c);
+  while ((loc = output.find(string_to_find, loc)) != std::string::npos) {
+    output.erase(loc, 1);
+  }
+
+  return output;
+}
+
+// Canonicalizes url as per Google Safe Browsing Specification.
+// See section 6.1 in
+// http://code.google.com/p/google-safe-browsing/wiki/Protocolv2Spec.
+void CanonicalizeUrl(const GURL& url,
+                     std::string* canonicalized_hostname,
+                     std::string* canonicalized_path,
+                     std::string* canonicalized_query) {
+  DCHECK(url.is_valid());
+
+  // We only canonicalize "normal" URLs.
+  if (!url.IsStandard())
+    return;
+
+  // Following canonicalization steps are excluded since url parsing takes care
+  // of those :-
+  // 1. Remove any tab (0x09), CR (0x0d), and LF (0x0a) chars from url.
+  //    (Exclude escaped version of these chars).
+  // 2. Normalize hostname to 4 dot-seperated decimal values.
+  // 3. Lowercase hostname.
+  // 4. Resolve path sequences "/../" and "/./".
+
+  // That leaves us with the following :-
+  // 1. Remove fragment in URL.
+  GURL url_without_fragment;
+  GURL::Replacements f_replacements;
+  f_replacements.ClearRef();
+  f_replacements.ClearUsername();
+  f_replacements.ClearPassword();
+  url_without_fragment = url.ReplaceComponents(f_replacements);
+
+  // 2. Do URL unescaping until no more hex encoded characters exist.
+  std::string url_unescaped_str(Unescape(url_without_fragment.spec()));
+  url::Parsed parsed;
+  url::ParseStandardURL(url_unescaped_str.data(), url_unescaped_str.length(),
+                        &parsed);
+
+  // 3. In hostname, remove all leading and trailing dots.
+  const std::string host =
+      (parsed.host.len > 0)
+          ? url_unescaped_str.substr(parsed.host.begin, parsed.host.len)
+          : std::string();
+  std::string host_without_end_dots;
+  base::TrimString(host, ".", &host_without_end_dots);
+
+  // 4. In hostname, replace consecutive dots with a single dot.
+  std::string host_without_consecutive_dots(RemoveConsecutiveChars(
+      host_without_end_dots, '.'));
+
+  // 5. In path, replace runs of consecutive slashes with a single slash.
+  std::string path =
+      (parsed.path.len > 0)
+          ? url_unescaped_str.substr(parsed.path.begin, parsed.path.len)
+          : std::string();
+  std::string path_without_consecutive_slash(RemoveConsecutiveChars(path, '/'));
+
+  url::Replacements<char> hp_replacements;
+  hp_replacements.SetHost(
+      host_without_consecutive_dots.data(),
+      url::Component(0, host_without_consecutive_dots.length()));
+  hp_replacements.SetPath(
+      path_without_consecutive_slash.data(),
+      url::Component(0, path_without_consecutive_slash.length()));
+
+  std::string url_unescaped_with_can_hostpath;
+  url::StdStringCanonOutput output(&url_unescaped_with_can_hostpath);
+  url::Parsed temp_parsed;
+  url::ReplaceComponents(url_unescaped_str.data(),
+                         url_unescaped_str.length(),
+                         parsed,
+                         hp_replacements,
+                         NULL,
+                         &output,
+                         &temp_parsed);
+  output.Complete();
+
+  // 6. Step needed to revert escaping done in url::ReplaceComponents.
+  url_unescaped_with_can_hostpath = Unescape(url_unescaped_with_can_hostpath);
+
+  // 7. After performing all above steps, percent-escape all chars in url which
+  // are <= ASCII 32, >= 127, #, %. Escapes must be uppercase hex characters.
+  std::string escaped_canon_url_str(Escape(url_unescaped_with_can_hostpath));
+  url::Parsed final_parsed;
+  url::ParseStandardURL(escaped_canon_url_str.data(),
+                        escaped_canon_url_str.length(),
+                        &final_parsed);
+
+  if (canonicalized_hostname && final_parsed.host.len > 0) {
+    *canonicalized_hostname =
+        escaped_canon_url_str.substr(final_parsed.host.begin,
+                                     final_parsed.host.len);
+  }
+  if (canonicalized_path && final_parsed.path.len > 0) {
+    *canonicalized_path = escaped_canon_url_str.substr(final_parsed.path.begin,
+                                                       final_parsed.path.len);
+  }
+  if (canonicalized_query && final_parsed.query.len > 0) {
+    *canonicalized_query = escaped_canon_url_str.substr(
+        final_parsed.query.begin, final_parsed.query.len);
+  }
+}
+
+void GenerateHostsToCheck(const GURL& url, std::vector<std::string>* hosts) {
+  hosts->clear();
+
+  std::string canon_host;
+  CanonicalizeUrl(url, &canon_host, NULL, NULL);
+
+  const std::string host = canon_host;  // const sidesteps GCC bugs below!
+  if (host.empty())
+    return;
+
+  // Per the Safe Browsing Protocol v2 spec, we try the host, and also up to 4
+  // hostnames formed by starting with the last 5 components and successively
+  // removing the leading component.  The last component isn't examined alone,
+  // since it's the TLD or a subcomponent thereof.
+  //
+  // Note that we don't need to be clever about stopping at the "real" eTLD --
+  // the data on the server side has been filtered to ensure it will not
+  // blacklist a whole TLD, and it's not significantly slower on our side to
+  // just check too much.
+  //
+  // Also note that because we have a simple blacklist, not some sort of complex
+  // whitelist-in-blacklist or vice versa, it doesn't matter what order we check
+  // these in.
+  const size_t kMaxHostsToCheck = 4;
+  bool skipped_last_component = false;
+  for (std::string::const_reverse_iterator i(host.rbegin());
+       i != host.rend() && hosts->size() < kMaxHostsToCheck; ++i) {
+    if (*i == '.') {
+      if (skipped_last_component)
+        hosts->push_back(std::string(i.base(), host.end()));
+      else
+        skipped_last_component = true;
+    }
+  }
+  hosts->push_back(host);
+}
+
+void GeneratePathsToCheck(const GURL& url, std::vector<std::string>* paths) {
+  paths->clear();
+
+  std::string canon_path;
+  std::string canon_query;
+  CanonicalizeUrl(url, NULL, &canon_path, &canon_query);
+
+  const std::string path = canon_path;   // const sidesteps GCC bugs below!
+  const std::string query = canon_query;
+  if (path.empty())
+    return;
+
+  // Per the Safe Browsing Protocol v2 spec, we try the exact path with/without
+  // the query parameters, and also up to 4 paths formed by starting at the root
+  // and adding more path components.
+  //
+  // As with the hosts above, it doesn't matter what order we check these in.
+  const size_t kMaxPathsToCheck = 4;
+  for (std::string::const_iterator i(path.begin());
+       i != path.end() && paths->size() < kMaxPathsToCheck; ++i) {
+    if (*i == '/')
+      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]);
+    }
+  }
+}
+
+}  // namespace safe_browsing
diff --git a/components/safe_browsing_db/util.h b/components/safe_browsing_db/util.h
new file mode 100644
index 0000000..666e081
--- /dev/null
+++ b/components/safe_browsing_db/util.h
@@ -0,0 +1,167 @@
+// Copyright (c) 2015 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.
+//
+// Utilities for the SafeBrowsing DB code.
+
+#ifndef COMPONENTS_SAFE_BROWSING_DB_UTIL_H_
+#define COMPONENTS_SAFE_BROWSING_DB_UTIL_H_
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/strings/string_piece.h"
+#include "base/time/time.h"
+
+
+class GURL;
+
+// Different types of threats that SafeBrowsing protects against.
+enum SBThreatType {
+  // No threat at all.
+  SB_THREAT_TYPE_SAFE,
+
+  // The URL is being used for phishing.
+  SB_THREAT_TYPE_URL_PHISHING,
+
+  // The URL hosts malware.
+  SB_THREAT_TYPE_URL_MALWARE,
+
+  // The URL hosts unwanted programs.
+  SB_THREAT_TYPE_URL_UNWANTED,
+
+  // The download URL is malware.
+  SB_THREAT_TYPE_BINARY_MALWARE_URL,
+
+  // Url detected by the client-side phishing model.  Note that unlike the
+  // above values, this does not correspond to a downloaded list.
+  SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL,
+
+  // The Chrome extension or app (given by its ID) is malware.
+  SB_THREAT_TYPE_EXTENSION,
+
+  // Url detected by the client-side malware IP list. This IP list is part
+  // of the client side detection model.
+  SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL,
+};
+
+
+// TODO(vakh): Move all these declarations under safe_browsing namespace.
+// A truncated hash's type.
+typedef uint32 SBPrefix;
+
+// A full hash.
+union SBFullHash {
+  char full_hash[32];
+  SBPrefix prefix;
+};
+
+// Used when we get a gethash response.
+struct SBFullHashResult {
+  SBFullHash hash;
+  // TODO(shess): Refactor to allow ListType here.
+  int list_id;
+  std::string metadata;
+};
+
+// Caches individual response from GETHASH request.
+struct SBCachedFullHashResult {
+  SBCachedFullHashResult();
+  explicit SBCachedFullHashResult(const base::Time& in_expire_after);
+  ~SBCachedFullHashResult();
+
+  base::Time expire_after;
+  std::vector<SBFullHashResult> full_hashes;
+};
+
+
+namespace safe_browsing {
+
+// SafeBrowsing list names.
+extern const char kMalwareList[];
+extern const char kPhishingList[];
+// Binary Download list name.
+extern const char kBinUrlList[];
+// SafeBrowsing client-side detection whitelist list name.
+extern const char kCsdWhiteList[];
+// SafeBrowsing download whitelist list name.
+extern const char kDownloadWhiteList[];
+// SafeBrowsing extension list name.
+extern const char kExtensionBlacklist[];
+// SafeBrowsing csd malware IP blacklist name.
+extern const char kIPBlacklist[];
+// SafeBrowsing unwanted URL list.
+extern const char kUnwantedUrlList[];
+// SafeBrowsing off-domain inclusion whitelist list name.
+extern const char kInclusionWhitelist[];
+// This array must contain all Safe Browsing lists.
+extern const char* kAllLists[9];
+
+
+enum ListType {
+  INVALID = -1,
+  MALWARE = 0,
+  PHISH = 1,
+  BINURL = 2,
+  // Obsolete BINHASH = 3,
+  CSDWHITELIST = 4,
+  // SafeBrowsing lists are stored in pairs.  Keep ListType 5
+  // available for a potential second list that we would store in the
+  // csd-whitelist store file.
+  DOWNLOADWHITELIST = 6,
+  // See above comment. Leave 7 available.
+  EXTENSIONBLACKLIST = 8,
+  // See above comment. Leave 9 available.
+  // Obsolete SIDEEFFECTFREEWHITELIST = 10,
+  // See above comment. Leave 11 available.
+  IPBLACKLIST = 12,
+  // See above comment.  Leave 13 available.
+  UNWANTEDURL = 14,
+  // See above comment.  Leave 15 available.
+  INCLUSIONWHITELIST = 16,
+  // See above comment.  Leave 17 available.
+};
+
+
+inline bool SBFullHashEqual(const SBFullHash& a, const SBFullHash& b) {
+  return !memcmp(a.full_hash, b.full_hash, sizeof(a.full_hash));
+}
+
+inline bool SBFullHashLess(const SBFullHash& a, const SBFullHash& b) {
+  return memcmp(a.full_hash, b.full_hash, sizeof(a.full_hash)) < 0;
+}
+
+// Generate full hash for the given string.
+SBFullHash SBFullHashForString(const base::StringPiece& str);
+SBFullHash StringToSBFullHash(const std::string& hash_in);
+std::string SBFullHashToString(const SBFullHash& hash_out);
+
+
+// Maps a list name to ListType.
+ListType GetListId(const base::StringPiece& name);
+
+// Maps a ListId to list name. Return false if fails.
+bool GetListName(ListType list_id, std::string* list);
+
+// Canonicalizes url as per Google Safe Browsing Specification.
+// See section 6.1 in
+// http://code.google.com/p/google-safe-browsing/wiki/Protocolv2Spec.
+void CanonicalizeUrl(const GURL& url, std::string* canonicalized_hostname,
+                     std::string* canonicalized_path,
+                     std::string* canonicalized_query);
+
+// Given a URL, returns all the hosts we need to check.  They are returned
+// in order of size (i.e. b.c is first, then a.b.c).
+void GenerateHostsToCheck(const GURL& url, std::vector<std::string>* hosts);
+
+// Given a URL, returns all the paths we need to check.
+void GeneratePathsToCheck(const GURL& url, std::vector<std::string>* paths);
+
+// Given a URL, returns all the patterns we need to check.
+void GeneratePatternsToCheck(const GURL& url, std::vector<std::string>* urls);
+
+}  // namespace safe_browsing
+
+#endif  // COMPONENTS_SAFE_BROWSING_DB_UTIL_H_
diff --git a/chrome/browser/safe_browsing/safe_browsing_util_unittest.cc b/components/safe_browsing_db/util_unittest.cc
index 3c875bb..d29bd3f 100644
--- a/chrome/browser/safe_browsing/safe_browsing_util_unittest.cc
+++ b/components/safe_browsing_db/util_unittest.cc
@@ -1,11 +1,11 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2015 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 <algorithm>
 
 #include "base/strings/stringprintf.h"
-#include "chrome/browser/safe_browsing/safe_browsing_util.h"
+#include "components/safe_browsing_db/util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
@@ -20,12 +20,12 @@ bool VectorContains(const std::vector<std::string>& data,
 // according to the Safe Browsing spec.
 // See section 6.2 in
 // http://code.google.com/p/google-safe-browsing/wiki/Protocolv2Spec.
-TEST(SafeBrowsingUtilTest, UrlParsing) {
+TEST(SafeBrowsingDbUtilTest, UrlParsing) {
   std::vector<std::string> hosts, paths;
 
   GURL url("http://a.b.c/1/2.html?param=1");
-  safe_browsing_util::GenerateHostsToCheck(url, &hosts);
-  safe_browsing_util::GeneratePathsToCheck(url, &paths);
+  safe_browsing::GenerateHostsToCheck(url, &hosts);
+  safe_browsing::GeneratePathsToCheck(url, &paths);
   EXPECT_EQ(hosts.size(), static_cast<size_t>(2));
   EXPECT_EQ(paths.size(), static_cast<size_t>(4));
   EXPECT_EQ(hosts[0], "b.c");
@@ -37,8 +37,8 @@ TEST(SafeBrowsingUtilTest, UrlParsing) {
   EXPECT_TRUE(VectorContains(paths, "/"));
 
   url = GURL("http://a.b.c.d.e.f.g/1.html");
-  safe_browsing_util::GenerateHostsToCheck(url, &hosts);
-  safe_browsing_util::GeneratePathsToCheck(url, &paths);
+  safe_browsing::GenerateHostsToCheck(url, &hosts);
+  safe_browsing::GeneratePathsToCheck(url, &paths);
   EXPECT_EQ(hosts.size(), static_cast<size_t>(5));
   EXPECT_EQ(paths.size(), static_cast<size_t>(2));
   EXPECT_EQ(hosts[0], "f.g");
@@ -50,7 +50,7 @@ TEST(SafeBrowsingUtilTest, UrlParsing) {
   EXPECT_TRUE(VectorContains(paths, "/"));
 
   url = GURL("http://a.b/saw-cgi/eBayISAPI.dll/");
-  safe_browsing_util::GeneratePathsToCheck(url, &paths);
+  safe_browsing::GeneratePathsToCheck(url, &paths);
   EXPECT_EQ(paths.size(), static_cast<size_t>(3));
   EXPECT_TRUE(VectorContains(paths, "/saw-cgi/eBayISAPI.dll/"));
   EXPECT_TRUE(VectorContains(paths, "/saw-cgi/"));
@@ -60,7 +60,7 @@ TEST(SafeBrowsingUtilTest, UrlParsing) {
 // Tests the url canonicalization according to the Safe Browsing spec.
 // See section 6.1 in
 // http://code.google.com/p/google-safe-browsing/wiki/Protocolv2Spec.
-TEST(SafeBrowsingUtilTest, CanonicalizeUrl) {
+TEST(SafeBrowsingDbUtilTest, CanonicalizeUrl) {
   struct {
     const char* input_url;
     const char* expected_canonicalized_hostname;
@@ -265,7 +265,7 @@ TEST(SafeBrowsingUtilTest, CanonicalizeUrl) {
     std::string canonicalized_hostname;
     std::string canonicalized_path;
     std::string canonicalized_query;
-    safe_browsing_util::CanonicalizeUrl(url, &canonicalized_hostname,
+    safe_browsing::CanonicalizeUrl(url, &canonicalized_hostname,
         &canonicalized_path, &canonicalized_query);
 
     EXPECT_EQ(tests[i].expected_canonicalized_hostname,
@@ -277,47 +277,63 @@ TEST(SafeBrowsingUtilTest, CanonicalizeUrl) {
   }
 }
 
-TEST(SafeBrowsingUtilTest, ListIdListNameConversion) {
+TEST(SafeBrowsingDbUtilTest, ListIdListNameConversion) {
   std::string list_name;
-  EXPECT_FALSE(safe_browsing_util::GetListName(safe_browsing_util::INVALID,
+  EXPECT_FALSE(safe_browsing::GetListName(safe_browsing::INVALID,
                                                &list_name));
-  EXPECT_TRUE(safe_browsing_util::GetListName(safe_browsing_util::MALWARE,
+  EXPECT_TRUE(safe_browsing::GetListName(safe_browsing::MALWARE,
                                               &list_name));
-  EXPECT_EQ(list_name, std::string(safe_browsing_util::kMalwareList));
-  EXPECT_EQ(safe_browsing_util::MALWARE,
-            safe_browsing_util::GetListId(list_name));
+  EXPECT_EQ(list_name, std::string(safe_browsing::kMalwareList));
+  EXPECT_EQ(safe_browsing::MALWARE,
+            safe_browsing::GetListId(list_name));
 
-  EXPECT_TRUE(safe_browsing_util::GetListName(safe_browsing_util::PHISH,
+  EXPECT_TRUE(safe_browsing::GetListName(safe_browsing::PHISH,
                                               &list_name));
-  EXPECT_EQ(list_name, std::string(safe_browsing_util::kPhishingList));
-  EXPECT_EQ(safe_browsing_util::PHISH,
-            safe_browsing_util::GetListId(list_name));
+  EXPECT_EQ(list_name, std::string(safe_browsing::kPhishingList));
+  EXPECT_EQ(safe_browsing::PHISH,
+            safe_browsing::GetListId(list_name));
 
-  EXPECT_TRUE(safe_browsing_util::GetListName(safe_browsing_util::BINURL,
+  EXPECT_TRUE(safe_browsing::GetListName(safe_browsing::BINURL,
                                               &list_name));
-  EXPECT_EQ(list_name, std::string(safe_browsing_util::kBinUrlList));
-  EXPECT_EQ(safe_browsing_util::BINURL,
-            safe_browsing_util::GetListId(list_name));
+  EXPECT_EQ(list_name, std::string(safe_browsing::kBinUrlList));
+  EXPECT_EQ(safe_browsing::BINURL,
+            safe_browsing::GetListId(list_name));
 }
 
 // Since the ids are saved in file, we need to make sure they don't change.
 // Since only the last bit of each id is saved in file together with
 // chunkids, this checks only last bit.
-TEST(SafeBrowsingUtilTest, ListIdVerification) {
-  EXPECT_EQ(0, safe_browsing_util::MALWARE % 2);
-  EXPECT_EQ(1, safe_browsing_util::PHISH % 2);
-  EXPECT_EQ(0, safe_browsing_util::BINURL %2);
+TEST(SafeBrowsingDbUtilTest, ListIdVerification) {
+  EXPECT_EQ(0, safe_browsing::MALWARE % 2);
+  EXPECT_EQ(1, safe_browsing::PHISH % 2);
+  EXPECT_EQ(0, safe_browsing::BINURL %2);
 }
 
-TEST(SafeBrowsingUtilTest, StringToSBFullHashAndSBFullHashToString) {
+TEST(SafeBrowsingDbUtilTest, StringToSBFullHashAndSBFullHashToString) {
   // 31 chars plus the last \0 as full_hash.
   const std::string hash_in = "12345678902234567890323456789012";
-  SBFullHash hash_out = safe_browsing_util::StringToSBFullHash(hash_in);
+  SBFullHash hash_out = safe_browsing::StringToSBFullHash(hash_in);
   EXPECT_EQ(0x34333231U, hash_out.prefix);
   EXPECT_EQ(0, memcmp(hash_in.data(), hash_out.full_hash, sizeof(SBFullHash)));
 
-  std::string hash_final = safe_browsing_util::SBFullHashToString(hash_out);
+  std::string hash_final = safe_browsing::SBFullHashToString(hash_out);
   EXPECT_EQ(hash_in, hash_final);
 }
 
+TEST(SafeBrowsingDbUtilTest, FullHashOperators) {
+  const SBFullHash kHash1 = safe_browsing::SBFullHashForString("one");
+  const SBFullHash kHash2 = safe_browsing::SBFullHashForString("two");
+
+  EXPECT_TRUE(safe_browsing::SBFullHashEqual(kHash1, kHash1));
+  EXPECT_TRUE(safe_browsing::SBFullHashEqual(kHash2, kHash2));
+  EXPECT_FALSE(safe_browsing::SBFullHashEqual(kHash1, kHash2));
+  EXPECT_FALSE(safe_browsing::SBFullHashEqual(kHash2, kHash1));
+
+  EXPECT_FALSE(safe_browsing::SBFullHashLess(kHash1, kHash2));
+  EXPECT_TRUE(safe_browsing::SBFullHashLess(kHash2, kHash1));
+
+  EXPECT_FALSE(safe_browsing::SBFullHashLess(kHash1, kHash1));
+  EXPECT_FALSE(safe_browsing::SBFullHashLess(kHash2, kHash2));
+}
+
 }  // namespace