Move more declarations from c/b/sb/sb_util.h to components.

chrome/browser/safe_browsing/protocol_parser_unittest.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 <string>
 
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/protocol_parser.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
@@ skipping 75 matching lines @@
   EXPECT_TRUE(safe_browsing::ParseChunk(kRawAddChunk, sizeof(kRawAddChunk),
                                         &chunks));
   ASSERT_EQ(1U, chunks.size());
   EXPECT_EQ(1, chunks[0]->ChunkNumber());
   EXPECT_TRUE(chunks[0]->IsAdd());
   EXPECT_FALSE(chunks[0]->IsSub());
   EXPECT_FALSE(chunks[0]->IsPrefix());
   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
 // one more after it.
 TEST(SafeBrowsingProtocolParsingTest, TestAddChunks) {
   const char kRawAddChunk[] = {
     '\0', '\0', '\0', '\x1C',  // 32-bit payload length in network byte order.
     '\x08',                    // field 1, wire format varint
     '\x01',                    // chunk_number varint 1
     '\x22',                    // field 4, wire format length-delimited
@@ skipping 172 matching lines @@
   EXPECT_TRUE(safe_browsing::ParseChunk(kRawSubChunk, sizeof(kRawSubChunk),
                                         &chunks));
   ASSERT_EQ(1U, chunks.size());
   EXPECT_EQ(2, chunks[0]->ChunkNumber());
   EXPECT_FALSE(chunks[0]->IsAdd());
   EXPECT_TRUE(chunks[0]->IsSub());
   EXPECT_FALSE(chunks[0]->IsPrefix());
   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));
 }
 
 // Test parsing the SafeBrowsing update response.
 TEST(SafeBrowsingProtocolParsingTest, TestChunkDelete) {
   std::string add_del("n:1700\ni:phishy\nad:1-7,43-597,44444,99999\n"
                       "i:malware\nsd:21-27,42,171717\n");
 
   size_t next_query_sec = 0;
   bool reset = false;
@@ skipping 91 matching lines @@
       kDefaultPhishList));
   std::vector<SBFullHashResult> full_hashes;
   base::TimeDelta cache_lifetime;
   EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash.data(), get_hash.length(),
                                           &cache_lifetime, &full_hashes));
 
   ASSERT_EQ(3U, full_hashes.size());
   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(
       "45\n"
       "%s:32:1\n"
       "00112233445566778899aabbccddeeff"
       "%s:32:2\n"
       "cafebeefcafebeefdeaddeaddeaddead"
       "zzzzyyyyxxxxwwwwvvvvuuuuttttssss",
       kDefaultPhishList,
       kDefaultMalwareList));
   EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash2.data(), get_hash2.length(),
                                           &cache_lifetime, &full_hashes));
 
   ASSERT_EQ(3U, full_hashes.size());
   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(
       "45\n"
       "%s:32:2:m\n"
       "zzzzyyyyxxxxwwwwvvvvuuuuttttssss"
       "00112233445566778899aabbccddeeff"
       "2\nab2\nxy"
       "%s:32:1\n"
       "cafebeefcafebeefdeaddeaddeaddead",
       kDefaultMalwareList,
       kDefaultPhishList));
   EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash3.data(), get_hash3.length(),
                                           &cache_lifetime, &full_hashes));
 
   ASSERT_EQ(3U, full_hashes.size());
   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);
 }
 
 TEST(SafeBrowsingProtocolParsingTest, TestGetHashWithUnknownList) {
   std::string hash_response(base::StringPrintf(
       "45\n"
       "%s:32:1\n"
       "12345678901234567890123456789012"
       "googpub-phish-shavar:32:1\n"
       "09876543210987654321098765432109",
       kDefaultPhishList));
   std::vector<SBFullHashResult> full_hashes;
   base::TimeDelta cache_lifetime;
   EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(),
                                           hash_response.size(),
                                           &cache_lifetime,
                                           &full_hashes));
 
   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"
       "abcdefghijklmnopqrstuvwxyz123457",
       kDefaultMalwareList);
   full_hashes.clear();
   EXPECT_TRUE(safe_browsing::ParseGetHash(hash_response.data(),
                                           hash_response.size(),
                                           &cache_lifetime,
                                           &full_hashes));
 
   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) {
   std::vector<SBFullHashResult> full_hashes;
   base::TimeDelta cache_lifetime;
   // Test skipping over a hashentry with an unrecognized listname that also has
   // metadata.
   const std::string get_hash3(base::StringPrintf(
       "600\n"
       "BADLISTNAME:32:1:m\n"
       "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
       "8\nMETADATA"
       "%s:32:1\n"
       "0123456789hashhashhashhashhashha",
       kDefaultMalwareList));
   EXPECT_TRUE(safe_browsing::ParseGetHash(get_hash3.data(), get_hash3.length(),
                                           &cache_lifetime, &full_hashes));
   ASSERT_EQ(1U, full_hashes.size());
   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);
 }
 
 TEST(SafeBrowsingProtocolParsingTest, TestFormatHash) {
   std::vector<SBPrefix> prefixes;
   prefixes.push_back(0x34333231);
   prefixes.push_back(0x64636261);
   prefixes.push_back(0x73727170);
 
   EXPECT_EQ("4:12\n1234abcdpqrs", safe_browsing::FormatGetHash(prefixes));
@@ skipping 167 matching lines @@
   EXPECT_FALSE(chunks[0]->IsAdd());
   EXPECT_TRUE(chunks[0]->IsSub());
   EXPECT_TRUE(chunks[2]->IsPrefix());
   EXPECT_FALSE(chunks[2]->IsFullHash());
   ASSERT_EQ(1U, chunks[2]->PrefixCount());
   EXPECT_EQ(0x70707070U, chunks[2]->PrefixAt(0));  // pppp
   EXPECT_EQ(11, chunks[2]->AddChunkNumberAt(0));
 }
 
 }  // namespace