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

chrome/browser/safe_browsing/protocol_parser.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.
 //
 // Parse the data returned from the SafeBrowsing v2.1 protocol response.
 
 // TODOv3(shess): Review these changes carefully.
 
 #include <stdlib.h>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/safe_browsing/protocol_parser.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 
+namespace safe_browsing {
+
 namespace {
 
 // Helper class for scanning a buffer.
 class BufferReader {
  public:
   BufferReader(const char* data, size_t length)
       : data_(data),
         length_(length) {
   }
 
@@ skipping 92 matching lines @@
     return true;
   }
 
  private:
   const char* data_;
   size_t length_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferReader);
 };
 
-bool ParseGetHashMetadata(size_t hash_count,
-                          BufferReader* reader,
-                          std::vector<SBFullHashResult>* full_hashes) {
+bool ParseGetHashMetadata(
+    size_t hash_count,
+    BufferReader* reader,
+    std::vector<SBFullHashResult>* full_hashes) {
   for (size_t i = 0; i < hash_count; ++i) {
     base::StringPiece line;
     if (!reader->GetLine(&line))
       return false;
 
     size_t meta_data_len;
     if (!base::StringToSizeT(line, &meta_data_len))
       return false;
 
     const void* meta_data;
     if (!reader->RefData(&meta_data, meta_data_len))
       return false;
 
     if (full_hashes) {
       (*full_hashes)[full_hashes->size() - hash_count + i].metadata.assign(
           reinterpret_cast<const char*>(meta_data), meta_data_len);
     }
   }
   return true;
 }
 
 }  // namespace
 
-namespace safe_browsing {
-
 // BODY          = CACHELIFETIME LF HASHENTRY* EOF
 // CACHELIFETIME = DIGIT+
 // HASHENTRY     = LISTNAME ":" HASHSIZE ":" NUMRESPONSES [":m"] LF
 //                 HASHDATA (METADATALEN LF METADATA)*
 // HASHSIZE      = DIGIT+                  # Length of each full hash
 // NUMRESPONSES  = DIGIT+                  # Number of full hashes in HASHDATA
 // HASHDATA      = <HASHSIZE*NUMRESPONSES number of unsigned bytes>
 // METADATALEN   = DIGIT+
 // METADATA      = <METADATALEN number of unsigned bytes>
 bool ParseGetHash(const char* chunk_data,
@@ skipping 20 matching lines @@
 
     *cache_lifetime = base::TimeDelta::FromSeconds(cache_lifetime_seconds);
   }
 
   while (!reader.empty()) {
     std::vector<base::StringPiece> cmd_parts;
     if (!reader.GetPieces(3, &cmd_parts))
       return false;
 
     SBFullHashResult full_hash;
-    full_hash.list_id = safe_browsing::GetListId(cmd_parts[0]);
+    full_hash.list_id = GetListId(cmd_parts[0]);
 
     size_t hash_len;
     if (!base::StringToSizeT(cmd_parts[1], &hash_len))
       return false;
 
     // TODO(shess): Is this possible?  If not, why the length present?
     if (hash_len != sizeof(SBFullHash))
       return false;
 
     // Metadata is indicated by an optional ":m" at the end of the line.
@@ skipping 174 matching lines @@
   if (!list.adds.empty() && !list.subs.empty())
     formatted_results.append(":");
   if (!list.subs.empty())
     formatted_results.append("s:").append(list.subs);
   formatted_results.append("\n");
 
   return formatted_results;
 }
 
 }  // namespace safe_browsing