[safe browsing] Remove stale BINHASH code.

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.
 //
 // Program to test the SafeBrowsing protocol parsing v2.1.
 
 #include <map>
 #include <string>
 
 #include "base/strings/stringprintf.h"
@@ skipping 162 matching lines @@
 
   const SBChunkHost& host0 = chunks[0].hosts[0];
   EXPECT_EQ(host0.host, 0x61616161);
   EXPECT_EQ(host0.entry->prefix_count(), 255);
 
   const SBChunkHost& host1 = chunks[0].hosts[1];
   EXPECT_EQ(host1.host, 0x61616161);
   EXPECT_EQ(host1.entry->prefix_count(), 5);
 }
 
-// Test to make sure we could deal with truncated bin hash chunk.
-TEST(SafeBrowsingProtocolParsingTest, TestTruncatedBinHashChunk) {
+// Test to make sure we could deal with truncated goog-*-digestvar chunk.
+TEST(SafeBrowsingProtocolParsingTest, TestTruncatedHashChunk) {
   // This chunk delares there are 4 prefixes but actually only contains 2.
   const char add_chunk[] = "a:1:4:16\n11112222";
   SafeBrowsingProtocolParser parser;
   SBChunkList chunks;
-  bool result = parser.ParseChunk(safe_browsing_util::kBinHashList,
+  bool result = parser.ParseChunk(safe_browsing_util::kExtensionBlacklist,
                                   add_chunk,
                                   static_cast<int>(sizeof(add_chunk)),
                                   &chunks);
   EXPECT_FALSE(result);
   EXPECT_EQ(chunks.size(), 0U);
 }
 
 // Test to make sure we could deal with truncated malwarelist chunk.
 TEST(SafeBrowsingProtocolParsingTest, TestTruncatedUrlHashChunk) {
   // This chunk delares there are 4 prefixes but actually only contains 2.
@@ skipping 434 matching lines @@
   EXPECT_EQ(chunks[2].hosts[1].entry->ChunkIdAtPrefix(0), 0x35363738);
 }
 
 TEST(SafeBrowsingProtocolParsingTest, TestAddBinHashChunks) {
   std::string add_chunk("a:1:4:16\naaaabbbbccccdddd"
                         "a:2:4:8\n11112222");
   // Run the parse.
   SafeBrowsingProtocolParser parser;
   SBChunkList chunks;
   bool result = parser.ParseChunk(
-      safe_browsing_util::kBinHashList,
+      safe_browsing_util::kExtensionBlacklist,
       add_chunk.data(),
       static_cast<int>(add_chunk.length()),
       &chunks);
   EXPECT_TRUE(result);
   EXPECT_EQ(chunks.size(), 2U);
   EXPECT_EQ(chunks[0].chunk_number, 1);
   EXPECT_EQ(chunks[0].hosts.size(), 1U);
 
   EXPECT_EQ(chunks[0].hosts[0].host, 0);
   SBEntry* entry = chunks[0].hosts[0].entry;
@@ skipping 15 matching lines @@
 
 // Test parsing one add chunk where a hostkey spans several entries.
 TEST(SafeBrowsingProtocolParsingTest, TestAddBigBinHashChunk) {
   std::string add_chunk("a:1:4:1028\n");
   for (int i = 0; i < 257; ++i)
     add_chunk.append(base::StringPrintf("%04d", i));
 
   SafeBrowsingProtocolParser parser;
   SBChunkList chunks;
   bool result = parser.ParseChunk(
-      safe_browsing_util::kBinHashList,
+      safe_browsing_util::kExtensionBlacklist,
       add_chunk.data(),
       static_cast<int>(add_chunk.length()),
       &chunks);
   EXPECT_TRUE(result);
   EXPECT_EQ(chunks.size(), 1U);
   EXPECT_EQ(chunks[0].chunk_number, 1);
 
   EXPECT_EQ(chunks[0].hosts.size(), 1U);
 
   const SBChunkHost& host0 = chunks[0].hosts[0];
   EXPECT_EQ(host0.host, 0);
   EXPECT_EQ(host0.entry->prefix_count(), 257);
 }
 
 // Test parsing one sub chunk.
 TEST(SafeBrowsingProtocolParsingTest, TestSubBinHashChunk) {
   std::string sub_chunk("s:9:4:16\n1111mmmm2222nnnn");
 
   // Run the parser.
   SafeBrowsingProtocolParser parser;
   SBChunkList chunks;
   bool result = parser.ParseChunk(
-      safe_browsing_util::kBinHashList,
+      safe_browsing_util::kExtensionBlacklist,
       sub_chunk.data(),
       static_cast<int>(sub_chunk.length()),
       &chunks);
   EXPECT_TRUE(result);
   EXPECT_EQ(chunks.size(), 1U);
   EXPECT_EQ(chunks[0].chunk_number, 9);
   EXPECT_EQ(chunks[0].hosts.size(), 1U);
 
   EXPECT_EQ(chunks[0].hosts[0].host, 0);
   SBEntry* entry = chunks[0].hosts[0].entry;
@@ skipping 82 matching lines @@
       "{\xd7\x01\xad\xa6\xb5""X\xbb\xcf""F\xcf\x00\xf7""A\xbd"
       "p\x00\xab\xd7\x89\xd3\x00", 48);
   add_testdata[safe_browsing_util::kPhishingList] = std::string(
       "a:301377:4:9\n\xdb\xe0\xaa\x8e\x01\x85\xba\xb2\x9e", 22);
   add_testdata[safe_browsing_util::kBinUrlList] = std::string(
       "a:19420:4:18\n_\x92\x9e\xcd\x01\x03""}I\xa2\\3\xe6""h\x01\xee"
       "H\xf6\xe4", 31);
   add_testdata[safe_browsing_util::kSideEffectFreeWhitelist] = std::string(
       "a:1818:4:9\n\x85\xd0\xfe""i\x01""}\x98\xb1\xe5", 20);
   // goog-*-digestvar lists have no host-key data.
-  add_testdata[safe_browsing_util::kBinHashList] = std::string(
-      "a:5:4:4\nBBBB", 12);
   add_testdata[safe_browsing_util::kExtensionBlacklist] = std::string(
       "a:81:4:8\nhleedfcc", 17);
   // goog-*-sha256 lists have host-keys but they only contains
   // full-length entires.
   add_testdata[safe_browsing_util::kCsdWhiteList] = std::string(
       "a:35:32:37\n\x06\xf9\xb1\xaf\x01\x06\xf9\xb1\xaf""5\xc""9!\x17\x1e"
       "*-\xc9"",*>YSl6\xf9""B\xb8\x96""O\x98""r\xf2\xd5\x8d\xe3""T\x99", 48);
   // goog-*-digest256 has no host-keys and contains only full-length
   // hashes.
   add_testdata[safe_browsing_util::kDownloadWhiteList] = std::string(
       "a:42:32:32\n\xc8\xec\x9f\x9c\x9b\x9a"",\x82""G:F(\xe9\xad\x9c""b$\x8a"
       "\xba""%\x19\xae""c\x03\x87""~\xd1\xd3""bvC\xfd", 43);
   add_testdata[safe_browsing_util::kIPBlacklist] = std::string(
       "a:12:32:32\n8\x99\x17\xda\xec""+i`\x1a\xb3""8pVh\n$\x01\xd1\x12"
       ":\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 43);
 
   std::map<std::string, std::string> sub_testdata;
   // goog-*-shavar lists have a host-key, add number followed by zero or more
   // prefixes.
   sub_testdata[safe_browsing_util::kMalwareList] = std::string(
       "s:122930:4:9\n\x85""!_\x13\x00\x00\x01\xf1\xa2", 22);
   sub_testdata[safe_browsing_util::kPhishingList] = std::string(
       "s:150181:4:9\nr\x90""zt\x00\x00\x04\x9f""@", 22);
   sub_testdata[safe_browsing_util::kBinUrlList] = std::string(
       "s:3:4:13\nHOST\x01""####BBBB", 22);
   sub_testdata[safe_browsing_util::kSideEffectFreeWhitelist] = std::string(
       "s:4:4:9\nHOST\x00""####", 17);
   // goog-*-digestvar lists have no host-key data.
-  sub_testdata[safe_browsing_util::kBinHashList] = std::string(
-      "s:5:4:8\n####BBBB", 16);
   sub_testdata[safe_browsing_util::kExtensionBlacklist] = std::string(
       "s:3:4:8\n\x00\x00\x00""%pgkc", 16);
   // goog-*-sha256 lists have host-keys but they only contains
   // full-length entires.
   sub_testdata[safe_browsing_util::kCsdWhiteList] = std::string(
       "s:1:32:41\n\x1a""\"[\n\x01\x00\x00\x00\x15\x1""a\"[\n\xe9\x81""P\x11"
       "LR\xcb""3\x00""B\x90\xb3\x15""K\xf5\xdc\xd0""V\xc2""aI\x1e""-\xc8"
       "\xce"":\t\x01", 51);
   // goog-*-digest256 has no host-keys and contains only full-length
   // hashes.
@@ skipping 36 matching lines @@
                                     chunk_data.data(),
                                     static_cast<int>(chunk_data.length()),
                                     &chunks))
           << "Unable to parse sub chunk data for listname: "
           << listname;
       ASSERT_EQ(chunks.size(), 1U);
       EXPECT_FALSE(chunks[0].is_add);
     }
   }
 }