Remove PrerenderLocalPredictor, part 2.

chrome/browser/safe_browsing/safe_browsing_database_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.
 //
 // Unit tests for the SafeBrowsing storage system.
 
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 270 matching lines @@
     SafeBrowsingStoreFile* download_store =
         new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* csd_whitelist_store =
         new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* download_whitelist_store =
         new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* inclusion_whitelist_store =
         new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* extension_blacklist_store =
         new SafeBrowsingStoreFile(task_runner_);
-    SafeBrowsingStoreFile* side_effect_free_whitelist_store =
-        new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* ip_blacklist_store =
         new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* unwanted_software_store =
         new SafeBrowsingStoreFile(task_runner_);
     database_.reset(new SafeBrowsingDatabaseNew(
         task_runner_, browse_store, download_store, csd_whitelist_store,
         download_whitelist_store, inclusion_whitelist_store,
-        extension_blacklist_store, side_effect_free_whitelist_store,
-        ip_blacklist_store, unwanted_software_store));
+        extension_blacklist_store, ip_blacklist_store,
+        unwanted_software_store));
     database_->Init(database_filename_);
   }
 
   bool ContainsDownloadUrl(const std::vector<GURL>& urls,
                            std::vector<SBPrefix>* prefix_hits) {
     std::vector<SBPrefix> prefixes;
     SafeBrowsingDatabase::GetDownloadUrlPrefixes(urls, &prefixes);
     return database_->ContainsDownloadUrlPrefixes(prefixes, prefix_hits);
   }
 
@@ skipping 128 matching lines @@
                           chunks.get());
 
   chunks.clear();
   chunks.push_back(AddChunkFullHashValue(8,
                                          "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                                          "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
   database_->InsertChunks(safe_browsing_util::kExtensionBlacklist,
                           chunks.get());
 
   chunks.clear();
-  chunks.push_back(AddChunkFullHashValue(9, "www.sideeffectfree.com"));
-  database_->InsertChunks(safe_browsing_util::kSideEffectFreeWhitelist,
-                          chunks.get());
-
-  chunks.clear();
-  chunks.push_back(AddChunkHashedIpValue(10, "::ffff:192.168.1.0", 120));
+  chunks.push_back(AddChunkHashedIpValue(9, "::ffff:192.168.1.0", 120));

[Scott Hess - ex-Googler, 2015/04/08 22:32:26]

I don't think you need to renumber these.  Unless you do.  If not renumbering
works, I'd stick with that just to avoid changing other list tests.  It's not
like we're going to run out of chunk ids.

[davidben, 2015/04/09 21:54:38]

Done. (The index into lists has to change, but I kept the chunk IDs the same.)

   database_->InsertChunks(safe_browsing_util::kIPBlacklist, chunks.get());
 
   chunks.clear();
-  chunks.push_back(AddChunkPrefixValue(11, "www.unwanted.com/software.html"));
+  chunks.push_back(AddChunkPrefixValue(10, "www.unwanted.com/software.html"));
   database_->InsertChunks(safe_browsing_util::kUnwantedUrlList, chunks.get());
 
   database_->UpdateFinished(true);
 
   GetListsInfo(&lists);
-  ASSERT_EQ(10U, lists.size());
+  ASSERT_EQ(9U, lists.size());
   EXPECT_EQ(safe_browsing_util::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("2", lists[1].adds);
   EXPECT_TRUE(lists[1].subs.empty());
   EXPECT_EQ(safe_browsing_util::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("5", lists[3].adds);
   EXPECT_TRUE(lists[3].subs.empty());
   EXPECT_EQ(safe_browsing_util::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("7", lists[5].adds);
   EXPECT_TRUE(lists[5].subs.empty());
   EXPECT_EQ(safe_browsing_util::kExtensionBlacklist, lists[6].name);
   EXPECT_EQ("8", lists[6].adds);
   EXPECT_TRUE(lists[6].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kSideEffectFreeWhitelist, lists[7].name);
+  EXPECT_EQ(safe_browsing_util::kIPBlacklist, lists[7].name);
   EXPECT_EQ("9", lists[7].adds);
   EXPECT_TRUE(lists[7].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kIPBlacklist, lists[8].name);
+  EXPECT_EQ(safe_browsing_util::kUnwantedUrlList, lists[8].name);
   EXPECT_EQ("10", lists[8].adds);
   EXPECT_TRUE(lists[8].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kUnwantedUrlList, lists[9].name);
-  EXPECT_EQ("11", lists[9].adds);
-  EXPECT_TRUE(lists[9].subs.empty());
 
   database_.reset();
 }
 
 // Checks database reading and writing for browse and unwanted PrefixSets.
 TEST_F(SafeBrowsingDatabaseTest, BrowseAndUnwantedDatabasesAndPrefixSets) {
   struct TestCase {
     using TestListContainsBadUrl = bool (SafeBrowsingDatabase::*)(
         const GURL& url,
         std::vector<SBPrefix>* prefix_hits,
         std::vector<SBFullHashResult>* cache_hits);
 
     const char* test_list_name;
     size_t expected_list_index;
     TestListContainsBadUrl test_list_contains_bad_url;
   } const kTestCases[] {
     { safe_browsing_util::kMalwareList, 0U,
       &SafeBrowsingDatabase::ContainsBrowseUrl },
     { safe_browsing_util::kPhishingList, 1U,
       &SafeBrowsingDatabase::ContainsBrowseUrl },
-    { safe_browsing_util::kUnwantedUrlList, 9U,
+    { safe_browsing_util::kUnwantedUrlList, 8U,
       &SafeBrowsingDatabase::ContainsUnwantedSoftwareUrl },
   };
 
   for (const auto& test_case : kTestCases) {
     SCOPED_TRACE(std::string("Tested list at fault => ") +
                  test_case.test_list_name);
 
     std::vector<SBListChunkRanges> lists;
     ScopedVector<SBChunkData> chunks;
 
@@ skipping 593 matching lines @@
 // TODO(shess): Disabled until ScopedLogMessageIgnorer resolved.
 // http://crbug.com/56448
 TEST_F(SafeBrowsingDatabaseTest, DISABLED_FileCorruptionHandling) {
   // Re-create the database in a captive message loop so that we can
   // influence task-posting.  Database specifically needs to the
   // file-backed.
   database_.reset();
   base::MessageLoop loop;
   SafeBrowsingStoreFile* store = new SafeBrowsingStoreFile(task_runner_);
   database_.reset(new SafeBrowsingDatabaseNew(
-      task_runner_, store, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL));
+      task_runner_, store, NULL, NULL, NULL, NULL, NULL, NULL, NULL));
   database_->Init(database_filename_);
 
   // This will cause an empty database to be created.
   std::vector<SBListChunkRanges> lists;
   ASSERT_TRUE(database_->UpdateStarted(&lists));
   database_->UpdateFinished(true);
 
   // Create a sub chunk to insert.
   ScopedVector<SBChunkData> chunks;
   chunks.push_back(SubChunkPrefixValue(7,
@@ skipping 154 matching lines @@
        &SafeBrowsingDatabase::ContainsDownloadWhitelistedUrl,
        &SafeBrowsingDatabase::ContainsDownloadWhitelistedString},
       {safe_browsing_util::kInclusionWhitelist,
        &SafeBrowsingDatabase::ContainsInclusionWhitelistedUrl,
        nullptr},
   };
 
   // If the whitelist is disabled everything should match the whitelist.
   database_.reset(new SafeBrowsingDatabaseNew(
       task_runner_, new SafeBrowsingStoreFile(task_runner_), NULL, NULL, NULL,
-      NULL, NULL, NULL, NULL, NULL));
+      NULL, NULL, NULL, NULL));
   database_->Init(database_filename_);
   for (const auto& test_case : kTestCases) {
     SCOPED_TRACE(std::string("Tested list at fault => ") +
                  test_case.test_list_name);
 
     EXPECT_TRUE(
         (database_.get()->*test_case.test_list_contains_whitelisted_url)(
             GURL(std::string("http://www.phishing.com/"))));
     if (test_case.TestStrings()) {
       EXPECT_TRUE(
@@ skipping 927 matching lines @@
       GURL(std::string("http://") + kExampleCollision),
       &prefix_hits, &cache_hits));
   ASSERT_EQ(1U, prefix_hits.size());
   EXPECT_EQ(SBPrefixForString(kExampleCollision), prefix_hits[0]);
   EXPECT_TRUE(cache_hits.empty());
 
   // This prefix collides, but no full hash match.
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits));
 }