Move code in components/safe_browsing_db and chrome/browser/s_b/ under the safe_browsing namespace.

chrome/browser/safe_browsing/safe_browsing_database.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "crypto/sha2.h"
 #include "net/base/ip_address_number.h"
 #include "url/gurl.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #endif
 
 using content::BrowserThread;
-using safe_browsing::PrefixSet;
-using safe_browsing::PrefixSetBuilder;
 
 namespace {
 
+using safe_browsing::SafeBrowsingStore;
+using safe_browsing::SBCachedFullHashResult;
+using safe_browsing::SBPrefix;
+
 // Filename suffix for the bloom filter.
 const base::FilePath::CharType kBloomFilterFileSuffix[] =
     FILE_PATH_LITERAL(" Filter 2");
 // Filename suffix for the prefix set.
 const base::FilePath::CharType kPrefixSetFileSuffix[] =
     FILE_PATH_LITERAL(" Prefix Set");
 // Filename suffix for download store.
 const base::FilePath::CharType kDownloadDBFile[] =
     FILE_PATH_LITERAL(" Download");
 // Filename suffix for client-side phishing detection whitelist store.
@@ skipping 67 matching lines @@
 // to match against the csd whitelist.  E.g., if the path-prefix /foo is on the
 // whitelist it should also match /foo/bar which is not the case for all the
 // other lists.  We'll also always add a pattern for the empty path.
 // TODO(shess): This function is almost the same as
 // |CompareFullHashes()| in safe_browsing_util.cc, except that code
 // does an early exit on match.  Since match should be the infrequent
 // case (phishing or malware found), consider combining this function
 // with that one.
 void UrlToFullHashes(const GURL& url,
                      bool include_whitelist_hashes,
-                     std::vector<SBFullHash>* full_hashes) {
+                     std::vector<safe_browsing::SBFullHash>* full_hashes) {
   std::vector<std::string> hosts;
   if (url.HostIsIPAddress()) {
     hosts.push_back(url.host());
   } else {
     safe_browsing::GenerateHostsToCheck(url, &hosts);
   }
 
   std::vector<std::string> 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(safe_browsing::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
       // that ends in '/' we also add the path without the slash.
-      if (include_whitelist_hashes &&
-          path.size() > 1 &&
+      if (include_whitelist_hashes && path.size() > 1 &&
           path[path.size() - 1] == '/') {
-        full_hashes->push_back(
-            safe_browsing::SBFullHashForString(
-                hosts[i] + path.substr(0, path.size() - 1)));
+        full_hashes->push_back(safe_browsing::SBFullHashForString(
+            hosts[i] + path.substr(0, path.size() - 1)));
       }
     }
   }
 }
 
 // Helper function to compare addprefixes in |store| with |prefixes|.
 // The |list_bit| indicates which list (url or hash) to compare.
 //
 // Returns true if there is a match, |*prefix_hits| (if non-NULL) will contain
 // the actual matching prefixes.
 bool MatchAddPrefixes(SafeBrowsingStore* store,
                       int list_bit,
                       const std::vector<SBPrefix>& prefixes,
                       std::vector<SBPrefix>* prefix_hits) {
   prefix_hits->clear();
   bool found_match = false;
 
-  SBAddPrefixes add_prefixes;
+  safe_browsing::SBAddPrefixes add_prefixes;
   store->GetAddPrefixes(&add_prefixes);
-  for (SBAddPrefixes::const_iterator iter = add_prefixes.begin();
+  for (safe_browsing::SBAddPrefixes::const_iterator iter = add_prefixes.begin();
        iter != add_prefixes.end(); ++iter) {
     for (size_t j = 0; j < prefixes.size(); ++j) {
       const SBPrefix& prefix = prefixes[j];
-      if (prefix == iter->prefix &&
-          GetListIdBit(iter->chunk_id) == list_bit) {
+      if (prefix == iter->prefix && GetListIdBit(iter->chunk_id) == list_bit) {
         prefix_hits->push_back(prefix);
         found_match = true;
       }
     }
   }
   return found_match;
 }
 
 // This function generates a chunk range string for |chunks|. It
 // outputs one chunk range string per list and writes it to the
 // |list_ranges| vector.  We expect |list_ranges| to already be of the
 // right size.  E.g., if |chunks| contains chunks with two different
 // list ids then |list_ranges| must contain two elements.
 void GetChunkRanges(const std::vector<int>& chunks,
                     std::vector<std::string>* list_ranges) {
   // Since there are 2 possible list ids, there must be exactly two
   // list ranges.  Even if the chunk data should only contain one
   // line, this code has to somehow handle corruption.
   DCHECK_EQ(2U, list_ranges->size());
 
-  std::vector<std::vector<int> > decoded_chunks(list_ranges->size());
+  std::vector<std::vector<int>> decoded_chunks(list_ranges->size());
   for (std::vector<int>::const_iterator iter = chunks.begin();
        iter != chunks.end(); ++iter) {
     int mod_list_id = GetListIdBit(*iter);
     DCHECK_GE(mod_list_id, 0);
     DCHECK_LT(static_cast<size_t>(mod_list_id), decoded_chunks.size());
     decoded_chunks[mod_list_id].push_back(DecodeChunkId(*iter));
   }
   for (size_t i = 0; i < decoded_chunks.size(); ++i) {
-    ChunksToRangeString(decoded_chunks[i], &((*list_ranges)[i]));
+    safe_browsing::ChunksToRangeString(decoded_chunks[i], &((*list_ranges)[i]));
   }
 }
 
 // Helper function to create chunk range lists for Browse related
 // lists.
 void UpdateChunkRanges(SafeBrowsingStore* store,
                        const std::vector<std::string>& listnames,
-                       std::vector<SBListChunkRanges>* lists) {
+                       std::vector<safe_browsing::SBListChunkRanges>* lists) {
   if (!store)
     return;
 
   DCHECK_GT(listnames.size(), 0U);
   DCHECK_LE(listnames.size(), 2U);
   std::vector<int> add_chunks;
   std::vector<int> sub_chunks;
   store->GetAddChunks(&add_chunks);
   store->GetSubChunks(&sub_chunks);
 
   // Always decode 2 ranges, even if only the first one is expected.
   // The loop below will only load as many into |lists| as |listnames|
   // indicates.
   std::vector<std::string> adds(2);
   std::vector<std::string> subs(2);
   GetChunkRanges(add_chunks, &adds);
   GetChunkRanges(sub_chunks, &subs);
 
   for (size_t i = 0; i < listnames.size(); ++i) {
     const std::string& listname = listnames[i];
-    DCHECK_EQ(safe_browsing::GetListId(listname) % 2,
-              static_cast<int>(i % 2));
-    DCHECK_NE(safe_browsing::GetListId(listname),
-              safe_browsing::INVALID);
-    lists->push_back(SBListChunkRanges(listname));
+    DCHECK_EQ(safe_browsing::GetListId(listname) % 2, static_cast<int>(i % 2));
+    DCHECK_NE(safe_browsing::GetListId(listname), safe_browsing::INVALID);
+    lists->push_back(safe_browsing::SBListChunkRanges(listname));
     lists->back().adds.swap(adds[i]);
     lists->back().subs.swap(subs[i]);
   }
 }
 
-void UpdateChunkRangesForLists(SafeBrowsingStore* store,
-                               const std::string& listname0,
-                               const std::string& listname1,
-                               std::vector<SBListChunkRanges>* lists) {
+void UpdateChunkRangesForLists(
+    SafeBrowsingStore* store,
+    const std::string& listname0,
+    const std::string& listname1,
+    std::vector<safe_browsing::SBListChunkRanges>* lists) {
   std::vector<std::string> listnames;
   listnames.push_back(listname0);
   listnames.push_back(listname1);
   UpdateChunkRanges(store, listnames, lists);
 }
 
-void UpdateChunkRangesForList(SafeBrowsingStore* store,
-                              const std::string& listname,
-                              std::vector<SBListChunkRanges>* lists) {
+void UpdateChunkRangesForList(
+    SafeBrowsingStore* store,
+    const std::string& listname,
+    std::vector<safe_browsing::SBListChunkRanges>* lists) {
   UpdateChunkRanges(store, std::vector<std::string>(1, listname), lists);
 }
 
 // This code always checks for non-zero file size.  This helper makes
 // that less verbose.
 int64 GetFileSizeOrZero(const base::FilePath& file_path) {
   int64 size_64;
   if (!base::GetFileSize(file_path, &size_64))
     return 0;
   return size_64;
 }
 
 // Helper for PrefixSetContainsUrlHashes().  Returns true if an un-expired match
 // for |full_hash| is found in |cache|, with any matches appended to |results|
 // (true can be returned with zero matches).  |expire_base| is used to check the
 // cache lifetime of matches, expired matches will be discarded from |cache|.
 bool GetCachedFullHash(std::map<SBPrefix, SBCachedFullHashResult>* cache,
-                       const SBFullHash& full_hash,
+                       const safe_browsing::SBFullHash& full_hash,
                        const base::Time& expire_base,
-                       std::vector<SBFullHashResult>* results) {
+                       std::vector<safe_browsing::SBFullHashResult>* results) {
   // First check if there is a valid cached result for this prefix.
-  std::map<SBPrefix, SBCachedFullHashResult>::iterator
-      citer = cache->find(full_hash.prefix);
+  std::map<SBPrefix, SBCachedFullHashResult>::iterator citer =
+      cache->find(full_hash.prefix);
   if (citer == cache->end())
     return false;
 
   // Remove expired entries.
   SBCachedFullHashResult& cached_result = citer->second;
   if (cached_result.expire_after <= expire_base) {
     cache->erase(citer);
     return false;
   }
 
   // Find full-hash matches.
-  std::vector<SBFullHashResult>& cached_hashes = cached_result.full_hashes;
+  std::vector<safe_browsing::SBFullHashResult>& cached_hashes =
+      cached_result.full_hashes;
   for (size_t i = 0; i < cached_hashes.size(); ++i) {
-    if (safe_browsing::SBFullHashEqual(full_hash, cached_hashes[i].hash))
+    if (SBFullHashEqual(full_hash, cached_hashes[i].hash))
       results->push_back(cached_hashes[i]);
   }
 
   return true;
 }
 
-SafeBrowsingStoreFile* CreateStore(
+safe_browsing::SafeBrowsingStoreFile* CreateStore(
     bool enable,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
   if (!enable)
     return nullptr;
-  return new SafeBrowsingStoreFile(task_runner);
+  return new safe_browsing::SafeBrowsingStoreFile(task_runner);
 }
 
 }  // namespace
 
+namespace safe_browsing {

[Nathan Parker, 2015/11/07 01:15:13]

Similar here: this can encompase the whole file, w/ a anon-namespace within it.

[vakh (old account. dont use), 2015/11/11 18:59:53]

Done.

+
 // The default SafeBrowsingDatabaseFactory.
 class SafeBrowsingDatabaseFactoryImpl : public SafeBrowsingDatabaseFactory {
  public:
   SafeBrowsingDatabase* CreateSafeBrowsingDatabase(
       const scoped_refptr<base::SequencedTaskRunner>& db_task_runner,
       bool enable_download_protection,
       bool enable_client_side_whitelist,
       bool enable_download_whitelist,
       bool enable_extension_blacklist,
       bool enable_ip_blacklist,
       bool enable_unwanted_software_list) override {
     return new SafeBrowsingDatabaseNew(
         db_task_runner, CreateStore(true, db_task_runner),  // browse_store
         CreateStore(enable_download_protection, db_task_runner),
         CreateStore(enable_client_side_whitelist, db_task_runner),
         CreateStore(enable_download_whitelist, db_task_runner),
         CreateStore(true, db_task_runner),  // inclusion_whitelist_store
         CreateStore(enable_extension_blacklist, db_task_runner),
         CreateStore(enable_ip_blacklist, db_task_runner),
         CreateStore(enable_unwanted_software_list, db_task_runner));
   }
 
-  SafeBrowsingDatabaseFactoryImpl() { }
+  SafeBrowsingDatabaseFactoryImpl() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingDatabaseFactoryImpl);
 };
 
 // static
 SafeBrowsingDatabaseFactory* SafeBrowsingDatabase::factory_ = NULL;
 
 // Factory method, should be called on the Safe Browsing sequenced task runner,
 // which is also passed to the function as |current_task_runner|.
@@ skipping 11 matching lines @@
   DCHECK(current_task_runner->RunsTasksOnCurrentThread());
   if (!factory_)
     factory_ = new SafeBrowsingDatabaseFactoryImpl();
   return factory_->CreateSafeBrowsingDatabase(
       current_task_runner, enable_download_protection,
       enable_client_side_whitelist, enable_download_whitelist,
       enable_extension_blacklist, enable_ip_blacklist,
       enable_unwanted_software_list);
 }
 
-SafeBrowsingDatabase::~SafeBrowsingDatabase() {
-}
+SafeBrowsingDatabase::~SafeBrowsingDatabase() {}
 
 // static
 base::FilePath SafeBrowsingDatabase::BrowseDBFilename(
     const base::FilePath& db_base_filename) {
   return base::FilePath(db_base_filename.value() + kBrowseDBFile);
 }
 
 // static
 base::FilePath SafeBrowsingDatabase::DownloadDBFilename(
     const base::FilePath& db_base_filename) {
@@ skipping 63 matching lines @@
     UrlToFullHashes(urls[i], false, &full_hashes);
 
   for (size_t i = 0; i < full_hashes.size(); ++i)
     prefixes->push_back(full_hashes[i].prefix);
 }
 
 SafeBrowsingStore* SafeBrowsingDatabaseNew::GetStore(const int list_id) {
   // Stores are not thread safe.
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
-  if (list_id == safe_browsing::PHISH ||
-      list_id == safe_browsing::MALWARE) {
+  if (list_id == PHISH || list_id == MALWARE) {
     return browse_store_.get();
-  } else if (list_id == safe_browsing::BINURL) {
+  } else if (list_id == BINURL) {
     return download_store_.get();
-  } else if (list_id == safe_browsing::CSDWHITELIST) {
+  } else if (list_id == CSDWHITELIST) {
     return csd_whitelist_store_.get();
-  } else if (list_id == safe_browsing::DOWNLOADWHITELIST) {
+  } else if (list_id == DOWNLOADWHITELIST) {
     return download_whitelist_store_.get();
-  } else if (list_id == safe_browsing::INCLUSIONWHITELIST) {
+  } else if (list_id == INCLUSIONWHITELIST) {
     return inclusion_whitelist_store_.get();
-  } else if (list_id == safe_browsing::EXTENSIONBLACKLIST) {
+  } else if (list_id == EXTENSIONBLACKLIST) {
     return extension_blacklist_store_.get();
-  } else if (list_id == safe_browsing::IPBLACKLIST) {
+  } else if (list_id == IPBLACKLIST) {
     return ip_blacklist_store_.get();
-  } else if (list_id == safe_browsing::UNWANTEDURL) {
+  } else if (list_id == UNWANTEDURL) {
     return unwanted_software_store_.get();
   }
   return NULL;
 }
 
 // static
 void SafeBrowsingDatabase::RecordFailure(FailureType failure_type) {
   UMA_HISTOGRAM_ENUMERATION("SB2.DatabaseFailure", failure_type,
                             FAILURE_DATABASE_MAX);
 }
@@ skipping 124 matching lines @@
   }
 
   ThreadSafeStateManager* outer_;
   base::AutoLock transaction_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(WriteTransaction);
 };
 
 SafeBrowsingDatabaseNew::ThreadSafeStateManager::ThreadSafeStateManager(
     const scoped_refptr<const base::SequencedTaskRunner>& db_task_runner)
-    : db_task_runner_(db_task_runner) {
-}
+    : db_task_runner_(db_task_runner) {}
 
-SafeBrowsingDatabaseNew::ThreadSafeStateManager::~ThreadSafeStateManager() {
-}
+SafeBrowsingDatabaseNew::ThreadSafeStateManager::~ThreadSafeStateManager() {}
 
 SafeBrowsingDatabaseNew::DatabaseStateManager::DatabaseStateManager(
     const scoped_refptr<const base::SequencedTaskRunner>& db_task_runner)
     : db_task_runner_(db_task_runner),
       corruption_detected_(false),
-      change_detected_(false) {
-}
+      change_detected_(false) {}
 
-SafeBrowsingDatabaseNew::DatabaseStateManager::~DatabaseStateManager() {
-}
+SafeBrowsingDatabaseNew::DatabaseStateManager::~DatabaseStateManager() {}
 
 scoped_ptr<SafeBrowsingDatabaseNew::ReadTransaction>
 SafeBrowsingDatabaseNew::ThreadSafeStateManager::BeginReadTransaction() {
   return make_scoped_ptr(
       new ReadTransaction(this, ReadTransaction::AutoLockRequirement::LOCK));
 }
 
 scoped_ptr<SafeBrowsingDatabaseNew::ReadTransaction> SafeBrowsingDatabaseNew::
     ThreadSafeStateManager::BeginReadTransactionNoLockOnMainTaskRunner() {
   return make_scoped_ptr(new ReadTransaction(
@@ skipping 274 matching lines @@
 
 bool SafeBrowsingDatabaseNew::ContainsDownloadUrlPrefixes(
     const std::vector<SBPrefix>& prefixes,
     std::vector<SBPrefix>* prefix_hits) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
   // Ignore this check when download checking is not enabled.
   if (!download_store_.get())
     return false;
 
-  return MatchAddPrefixes(download_store_.get(),
-                          safe_browsing::BINURL % 2,
-                          prefixes,
+  return MatchAddPrefixes(download_store_.get(), BINURL % 2, prefixes,
                           prefix_hits);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsCsdWhitelistedUrl(const GURL& url) {
   std::vector<SBFullHash> full_hashes;
   UrlToFullHashes(url, true, &full_hashes);
   return ContainsWhitelistedHashes(SBWhitelistId::CSD, full_hashes);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsDownloadWhitelistedUrl(const GURL& url) {
@@ skipping 10 matching lines @@
 
 bool SafeBrowsingDatabaseNew::ContainsExtensionPrefixes(
     const std::vector<SBPrefix>& prefixes,
     std::vector<SBPrefix>* prefix_hits) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
   if (!extension_blacklist_store_)
     return false;
 
   return MatchAddPrefixes(extension_blacklist_store_.get(),
-                          safe_browsing::EXTENSIONBLACKLIST % 2,
-                          prefixes,
-                          prefix_hits);
+                          EXTENSIONBLACKLIST % 2, prefixes, prefix_hits);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsMalwareIP(const std::string& ip_address) {
   net::IPAddressNumber ip_number;
   if (!net::ParseIPLiteralToNumber(ip_address, &ip_number))
     return false;
   if (ip_number.size() == net::kIPv4AddressSize)
     ip_number = net::ConvertIPv4NumberToIPv6Number(ip_number);
   if (ip_number.size() != net::kIPv6AddressSize)
     return false;  // better safe than sorry.
@@ skipping 17 matching lines @@
     if (it->second.count(hash) > 0) {
       return true;
     }
   }
   return false;
 }
 
 bool SafeBrowsingDatabaseNew::ContainsDownloadWhitelistedString(
     const std::string& str) {
   std::vector<SBFullHash> hashes;
-  hashes.push_back(safe_browsing::SBFullHashForString(str));
+  hashes.push_back(SBFullHashForString(str));
   return ContainsWhitelistedHashes(SBWhitelistId::DOWNLOAD, hashes);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsWhitelistedHashes(
     SBWhitelistId whitelist_id,
     const std::vector<SBFullHash>& hashes) {
   scoped_ptr<ReadTransaction> txn = state_manager_.BeginReadTransaction();
   const SBWhitelist* whitelist = txn->GetSBWhitelist(whitelist_id);
   if (whitelist->second)
     return true;
   for (std::vector<SBFullHash>::const_iterator it = hashes.begin();
        it != hashes.end(); ++it) {
     if (std::binary_search(whitelist->first.begin(), whitelist->first.end(),
-                           *it, safe_browsing::SBFullHashLess)) {
+                           *it, SBFullHashLess)) {
       return true;
     }
   }
   return false;
 }
 
 // Helper to insert add-chunk entries.
-void SafeBrowsingDatabaseNew::InsertAddChunk(
-    SafeBrowsingStore* store,
-    const safe_browsing::ListType list_id,
-    const SBChunkData& chunk_data) {
+void SafeBrowsingDatabaseNew::InsertAddChunk(SafeBrowsingStore* store,
+                                             const ListType list_id,
+                                             const SBChunkData& chunk_data) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(store);
 
   // The server can give us a chunk that we already have because
   // it's part of a range.  Don't add it again.
   const int chunk_id = chunk_data.ChunkNumber();
   const int encoded_chunk_id = EncodeChunkId(chunk_id, list_id);
   if (store->CheckAddChunk(encoded_chunk_id))
     return;
 
   store->SetAddChunk(encoded_chunk_id);
   if (chunk_data.IsPrefix()) {
     const size_t c = chunk_data.PrefixCount();
     for (size_t i = 0; i < c; ++i) {
       store->WriteAddPrefix(encoded_chunk_id, chunk_data.PrefixAt(i));
     }
   } else {
     const size_t c = chunk_data.FullHashCount();
     for (size_t i = 0; i < c; ++i) {
       store->WriteAddHash(encoded_chunk_id, chunk_data.FullHashAt(i));
     }
   }
 }
 
 // Helper to insert sub-chunk entries.
-void SafeBrowsingDatabaseNew::InsertSubChunk(
-    SafeBrowsingStore* store,
-    const safe_browsing::ListType list_id,
-    const SBChunkData& chunk_data) {
+void SafeBrowsingDatabaseNew::InsertSubChunk(SafeBrowsingStore* store,
+                                             const ListType list_id,
+                                             const SBChunkData& chunk_data) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(store);
 
   // The server can give us a chunk that we already have because
   // it's part of a range.  Don't add it again.
   const int chunk_id = chunk_data.ChunkNumber();
   const int encoded_chunk_id = EncodeChunkId(chunk_id, list_id);
   if (store->CheckSubChunk(encoded_chunk_id))
     return;
 
@@ skipping 21 matching lines @@
     const std::string& list_name,
     const std::vector<SBChunkData*>& chunks) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
   if (db_state_manager_.corruption_detected() || chunks.empty())
     return;
 
   const base::TimeTicks before = base::TimeTicks::Now();
 
   // TODO(shess): The caller should just pass list_id.
-  const safe_browsing::ListType list_id =
-      safe_browsing::GetListId(list_name);
+  const ListType list_id = GetListId(list_name);
 
   SafeBrowsingStore* store = GetStore(list_id);
-  if (!store) return;
+  if (!store)
+    return;
 
   db_state_manager_.set_change_detected();
 
   // TODO(shess): I believe that the list is always add or sub.  Can this use
   // that productively?
   store->BeginChunk();
   for (size_t i = 0; i < chunks.size(); ++i) {
     if (chunks[i]->IsAdd()) {
       InsertAddChunk(store, list_id, *chunks[i]);
     } else if (chunks[i]->IsSub()) {
       InsertSubChunk(store, list_id, *chunks[i]);
     } else {
       NOTREACHED();
     }
   }
   store->FinishChunk();
 
   UMA_HISTOGRAM_TIMES("SB2.ChunkInsert", base::TimeTicks::Now() - before);
 }
 
 void SafeBrowsingDatabaseNew::DeleteChunks(
     const std::vector<SBChunkDelete>& chunk_deletes) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
   if (db_state_manager_.corruption_detected() || chunk_deletes.empty())
     return;
 
   const std::string& list_name = chunk_deletes.front().list_name;
-  const safe_browsing::ListType list_id =
-      safe_browsing::GetListId(list_name);
+  const ListType list_id = GetListId(list_name);
 
   SafeBrowsingStore* store = GetStore(list_id);
-  if (!store) return;
+  if (!store)
+    return;
 
   db_state_manager_.set_change_detected();
 
   for (size_t i = 0; i < chunk_deletes.size(); ++i) {
     std::vector<int> chunk_numbers;
     RangesToChunks(chunk_deletes[i].chunk_del, &chunk_numbers);
     for (size_t j = 0; j < chunk_numbers.size(); ++j) {
       const int encoded_chunk_id = EncodeChunkId(chunk_numbers[j], list_id);
       if (chunk_deletes[i].is_sub_del)
         store->DeleteSubChunk(encoded_chunk_id);
@@ skipping 79 matching lines @@
   if (unwanted_software_store_ && !unwanted_software_store_->BeginUpdate()) {
     RecordFailure(FAILURE_UNWANTED_SOFTWARE_DATABASE_UPDATE_BEGIN);
     HandleCorruptDatabase();
     return false;
   }
 
   // Cached fullhash results must be cleared on every database update (whether
   // successful or not).
   state_manager_.BeginWriteTransaction()->clear_prefix_gethash_cache();
 
-  UpdateChunkRangesForLists(browse_store_.get(),
-                            safe_browsing::kMalwareList,
-                            safe_browsing::kPhishingList,
+  UpdateChunkRangesForLists(browse_store_.get(), kMalwareList, kPhishingList,
                             lists);
 
   // NOTE(shess): |download_store_| used to contain kBinHashList, which has been
   // deprecated.  Code to delete the list from the store shows ~15k hits/day as
   // of Feb 2014, so it has been removed.  Everything _should_ be resilient to
   // extra data of that sort.
-  UpdateChunkRangesForList(download_store_.get(),
-                           safe_browsing::kBinUrlList, lists);
+  UpdateChunkRangesForList(download_store_.get(), kBinUrlList, lists);
 
-  UpdateChunkRangesForList(csd_whitelist_store_.get(),
-                           safe_browsing::kCsdWhiteList, lists);
+  UpdateChunkRangesForList(csd_whitelist_store_.get(), kCsdWhiteList, lists);
 
-  UpdateChunkRangesForList(download_whitelist_store_.get(),
-                           safe_browsing::kDownloadWhiteList, lists);
+  UpdateChunkRangesForList(download_whitelist_store_.get(), kDownloadWhiteList,
+                           lists);
 
   UpdateChunkRangesForList(inclusion_whitelist_store_.get(),
-                           safe_browsing::kInclusionWhitelist, lists);
+                           kInclusionWhitelist, lists);
 
   UpdateChunkRangesForList(extension_blacklist_store_.get(),
-                           safe_browsing::kExtensionBlacklist, lists);
+                           kExtensionBlacklist, lists);
 
-  UpdateChunkRangesForList(ip_blacklist_store_.get(),
-                           safe_browsing::kIPBlacklist, lists);
+  UpdateChunkRangesForList(ip_blacklist_store_.get(), kIPBlacklist, lists);
 
-  UpdateChunkRangesForList(unwanted_software_store_.get(),
-                           safe_browsing::kUnwantedUrlList,
+  UpdateChunkRangesForList(unwanted_software_store_.get(), kUnwantedUrlList,
                            lists);
 
   db_state_manager_.reset_corruption_detected();
   db_state_manager_.reset_change_detected();
   return true;
 }
 
 void SafeBrowsingDatabaseNew::UpdateFinished(bool update_succeeded) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
@@ skipping 168 matching lines @@
   // Measure the amount of IO during the filter build.
   base::IoCounters io_before, io_after;
   base::ProcessHandle handle = base::GetCurrentProcessHandle();
   scoped_ptr<base::ProcessMetrics> metric(
 #if !defined(OS_MACOSX)
       base::ProcessMetrics::CreateProcessMetrics(handle)
 #else
       // Getting stats only for the current process is enough, so NULL is fine.
       base::ProcessMetrics::CreateProcessMetrics(handle, NULL)
 #endif
-  );
+          );
 
   // IoCounters are currently not supported on Mac, and may not be
   // available for Linux, so we check the result and only show IO
   // stats if they are available.
   const bool got_counters = metric->GetIOCounters(&io_before);
 
   const base::TimeTicks before = base::TimeTicks::Now();
 
   // TODO(shess): Perhaps refactor to let builder accumulate full hashes on the
   // fly?  Other clients use the SBAddFullHash vector, but AFAICT they only use
@@ skipping 26 matching lines @@
                                                         new_prefix_set.Pass());
 
   UMA_HISTOGRAM_LONG_TIMES("SB2.BuildFilter", base::TimeTicks::Now() - before);
 
   WritePrefixSet(db_filename, prefix_set_id, write_failure_type);
 
   // Gather statistics.
   if (got_counters && metric->GetIOCounters(&io_after)) {
     UMA_HISTOGRAM_COUNTS("SB2.BuildReadKilobytes",
                          static_cast<int>(io_after.ReadTransferCount -
-                                          io_before.ReadTransferCount) / 1024);
+                                          io_before.ReadTransferCount) /
+                             1024);
     UMA_HISTOGRAM_COUNTS("SB2.BuildWriteKilobytes",
                          static_cast<int>(io_after.WriteTransferCount -
-                                          io_before.WriteTransferCount) / 1024);
+                                          io_before.WriteTransferCount) /
+                             1024);
     UMA_HISTOGRAM_COUNTS("SB2.BuildReadOperations",
                          static_cast<int>(io_after.ReadOperationCount -
                                           io_before.ReadOperationCount));
     UMA_HISTOGRAM_COUNTS("SB2.BuildWriteOperations",
                          static_cast<int>(io_after.WriteOperationCount -
                                           io_before.WriteOperationCount));
   }
 
   RecordFileSizeHistogram(db_filename);
 
@@ skipping 99 matching lines @@
   // if something looks wrong.
 
   const bool r1 = browse_store_->Delete();
   if (!r1)
     RecordFailure(FAILURE_DATABASE_STORE_DELETE);
 
   const bool r2 = download_store_.get() ? download_store_->Delete() : true;
   if (!r2)
     RecordFailure(FAILURE_DATABASE_STORE_DELETE);
 
-  const bool r3 = csd_whitelist_store_.get() ?
-      csd_whitelist_store_->Delete() : true;
+  const bool r3 =
+      csd_whitelist_store_.get() ? csd_whitelist_store_->Delete() : true;
   if (!r3)
     RecordFailure(FAILURE_DATABASE_STORE_DELETE);
 
-  const bool r4 = download_whitelist_store_.get() ?
-      download_whitelist_store_->Delete() : true;
+  const bool r4 = download_whitelist_store_.get()
+                      ? download_whitelist_store_->Delete()
+                      : true;
   if (!r4)
     RecordFailure(FAILURE_DATABASE_STORE_DELETE);
 
-  const bool r5 = inclusion_whitelist_store_.get() ?
-      inclusion_whitelist_store_->Delete() : true;
+  const bool r5 = inclusion_whitelist_store_.get()
+                      ? inclusion_whitelist_store_->Delete()
+                      : true;
   if (!r5)
     RecordFailure(FAILURE_DATABASE_STORE_DELETE);
 
   const base::FilePath browse_filename =
       BrowseDBFilename(db_state_manager_.filename_base());
   const base::FilePath bloom_filter_filename =
       BloomFilterForFilename(browse_filename);
   const bool r6 = base::DeleteFile(bloom_filter_filename, false);
   if (!r6)
     RecordFailure(FAILURE_DATABASE_FILTER_DELETE);
@@ skipping 63 matching lines @@
     state_manager_.BeginWriteTransaction()->WhitelistEverything(whitelist_id);
     return;
   }
 
   std::vector<SBFullHash> new_whitelist;
   new_whitelist.reserve(full_hashes.size());
   for (std::vector<SBAddFullHash>::const_iterator it = full_hashes.begin();
        it != full_hashes.end(); ++it) {
     new_whitelist.push_back(it->full_hash);
   }
-  std::sort(new_whitelist.begin(), new_whitelist.end(),
-            safe_browsing::SBFullHashLess);
+  std::sort(new_whitelist.begin(), new_whitelist.end(), SBFullHashLess);
 
-  SBFullHash kill_switch = safe_browsing::SBFullHashForString(
-      kWhitelistKillSwitchUrl);
+  SBFullHash kill_switch = SBFullHashForString(kWhitelistKillSwitchUrl);
   if (std::binary_search(new_whitelist.begin(), new_whitelist.end(),
-                         kill_switch, safe_browsing::SBFullHashLess)) {
+                         kill_switch, SBFullHashLess)) {
     // The kill switch is whitelisted hence we whitelist all URLs.
     state_manager_.BeginWriteTransaction()->WhitelistEverything(whitelist_id);
   } else {
     state_manager_.BeginWriteTransaction()->SwapSBWhitelist(whitelist_id,
                                                             &new_whitelist);
   }
 }
 
 void SafeBrowsingDatabaseNew::LoadIpBlacklist(
     const std::vector<SBAddFullHash>& full_hashes) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
   IPBlacklist new_blacklist;
   for (std::vector<SBAddFullHash>::const_iterator it = full_hashes.begin();
-       it != full_hashes.end();
-       ++it) {
+       it != full_hashes.end(); ++it) {
     const char* full_hash = it->full_hash.full_hash;
     DCHECK_EQ(crypto::kSHA256Length, arraysize(it->full_hash.full_hash));
     // The format of the IP blacklist is:
     // SHA-1(IPv6 prefix) + uint8(prefix size) + 11 unused bytes.
     std::string hashed_ip_prefix(full_hash, base::kSHA1Length);
     size_t prefix_size = static_cast<uint8>(full_hash[base::kSHA1Length]);
     if (prefix_size > kMaxIpPrefixSize || prefix_size < kMinIpPrefixSize) {
       RecordFailure(FAILURE_IP_BLACKLIST_UPDATE_INVALID);
       new_blacklist.clear();  // Load empty blacklist.
       break;
@@ skipping 13 matching lines @@
              << " prefix_size:" << prefix_size
              << " hashed_ip:" << base::HexEncode(hashed_ip_prefix.data(),
                                                  hashed_ip_prefix.size());
     new_blacklist[mask].insert(hashed_ip_prefix);
   }
 
   state_manager_.BeginWriteTransaction()->swap_ip_blacklist(&new_blacklist);
 }
 
 bool SafeBrowsingDatabaseNew::IsMalwareIPMatchKillSwitchOn() {
-  SBFullHash malware_kill_switch = safe_browsing::SBFullHashForString(
-      kMalwareIPKillSwitchUrl);
+  SBFullHash malware_kill_switch = SBFullHashForString(kMalwareIPKillSwitchUrl);
   std::vector<SBFullHash> full_hashes;
   full_hashes.push_back(malware_kill_switch);
   return ContainsWhitelistedHashes(SBWhitelistId::CSD, full_hashes);
 }
 
 bool SafeBrowsingDatabaseNew::IsCsdWhitelistKillSwitchOn() {
   return state_manager_.BeginReadTransaction()
       ->GetSBWhitelist(SBWhitelistId::CSD)
       ->second;
 }
@@ skipping 52 matching lines @@
   else
     NOTREACHED();  // Add support for new lists above.
 
   // Histogram properties as in UMA_HISTOGRAM_COUNTS macro.
   base::HistogramBase* histogram_pointer = base::Histogram::FactoryGet(
       histogram_name, 1, 1000000, 50,
       base::HistogramBase::kUmaTargetedHistogramFlag);
 
   histogram_pointer->Add(file_size_kilobytes);
 }
+
+}  // namespace safe_browsing