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 268 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));
   database_->InsertChunks(safe_browsing_util::kIPBlacklist, chunks.get());
 
   chunks.clear();
   chunks.push_back(AddChunkPrefixValue(11, "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("9", lists[7].adds);
+  EXPECT_EQ(safe_browsing_util::kIPBlacklist, lists[7].name);
+  EXPECT_EQ("10", lists[7].adds);
   EXPECT_TRUE(lists[7].subs.empty());
-  EXPECT_EQ(safe_browsing_util::kIPBlacklist, lists[8].name);
-  EXPECT_EQ("10", lists[8].adds);
+  EXPECT_EQ(safe_browsing_util::kUnwantedUrlList, lists[8].name);
+  EXPECT_EQ("11", 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));
 }