Move SafeBrowsing to the blocking pool via an experiment.

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"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
+#include "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/chunk.pb.h"
 #include "chrome/browser/safe_browsing/safe_browsing_store_file.h"
 #include "crypto/sha2.h"
 #include "net/base/net_util.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "url/gurl.h"
@@ skipping 219 matching lines @@
     }
 
     return false;
   }
 };
 
 }  // namespace
 
 class SafeBrowsingDatabaseTest : public PlatformTest {
  public:
+  SafeBrowsingDatabaseTest() : task_runner_(new base::TestSimpleTaskRunner) {}
+
   void SetUp() override {
     PlatformTest::SetUp();
 
     // Setup a database in a temporary directory.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     database_filename_ =
         temp_dir_.path().AppendASCII("SafeBrowsingTestDatabase");
 
     ResetAndReloadFullDatabase();
   }
 
   void TearDown() override {
     database_.reset();
 
     PlatformTest::TearDown();
   }
 
   // Reloads the |database_| in a new SafeBrowsingDatabaseNew object with all
   // stores enabled.
   void ResetAndReloadFullDatabase() {
-    SafeBrowsingStoreFile* browse_store = new SafeBrowsingStoreFile();
-    SafeBrowsingStoreFile* download_store = new SafeBrowsingStoreFile();
-    SafeBrowsingStoreFile* csd_whitelist_store = new SafeBrowsingStoreFile();
+    SafeBrowsingStoreFile* browse_store =
+        new SafeBrowsingStoreFile(task_runner_);
+    SafeBrowsingStoreFile* download_store =
+        new SafeBrowsingStoreFile(task_runner_);
+    SafeBrowsingStoreFile* csd_whitelist_store =
+        new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* download_whitelist_store =
-        new SafeBrowsingStoreFile();
+        new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* inclusion_whitelist_store =
-        new SafeBrowsingStoreFile();
+        new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* extension_blacklist_store =
-        new SafeBrowsingStoreFile();
+        new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* side_effect_free_whitelist_store =
-        new SafeBrowsingStoreFile();
-    SafeBrowsingStoreFile* ip_blacklist_store = new SafeBrowsingStoreFile();
+        new SafeBrowsingStoreFile(task_runner_);
+    SafeBrowsingStoreFile* ip_blacklist_store =
+        new SafeBrowsingStoreFile(task_runner_);
     SafeBrowsingStoreFile* unwanted_software_store =
-        new SafeBrowsingStoreFile();
-    database_.reset(
-        new SafeBrowsingDatabaseNew(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));
+        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));
     database_->Init(database_filename_);
   }
 
   void GetListsInfo(std::vector<SBListChunkRanges>* lists) {
     lists->clear();
     ASSERT_TRUE(database_->UpdateStarted(lists));
     database_->UpdateFinished(true);
   }
 
   // Helper function to do an AddDel or SubDel command.
@@ skipping 13 matching lines @@
     DelChunk(list, chunk_id, false);
   }
 
   void SubDelChunk(const std::string& list, int chunk_id) {
     DelChunk(list, chunk_id, true);
   }
 
   // Utility function for setting up the database for the caching test.
   void PopulateDatabaseForCacheTest();
 
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   scoped_ptr<SafeBrowsingDatabaseNew> database_;
   base::FilePath database_filename_;
   base::ScopedTempDir temp_dir_;
 };
 
 // Tests retrieving list name information.
 TEST_F(SafeBrowsingDatabaseTest, BrowseListsInfo) {
   std::vector<SBListChunkRanges> lists;
   ScopedVector<SBChunkData> chunks;
 
@@ skipping 765 matching lines @@
 // Test that corrupt databases are appropriately handled, even if the
 // corruption is detected in the midst of the update.
 // 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();
-  database_.reset(new SafeBrowsingDatabaseNew(store, NULL, NULL, NULL, NULL,
-                                              NULL, NULL, NULL, NULL));
+  SafeBrowsingStoreFile* store = new SafeBrowsingStoreFile(task_runner_);
+  database_.reset(new SafeBrowsingDatabaseNew(
+      task_runner_, store, NULL, 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 152 matching lines @@
        nullptr},
       {safe_browsing_util::kDownloadWhiteList,
        &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(new SafeBrowsingStoreFile(), NULL,
-                                              NULL, NULL, NULL, NULL, NULL,
-                                              NULL, NULL));
+  database_.reset(new SafeBrowsingDatabaseNew(
+      task_runner_, new SafeBrowsingStoreFile(task_runner_), 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));
 }