Move SafeBrowsing to the blocking pool via an experiment.

chrome/browser/safe_browsing/safe_browsing_store_file_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 "chrome/browser/safe_browsing/safe_browsing_store_file.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/md5.h"
 #include "base/path_service.h"
+#include "base/test/test_simple_task_runner.h"
 #include "chrome/common/chrome_paths.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace {
 
 const int kAddChunk1 = 1;
 const int kAddChunk2 = 3;
 const int kAddChunk3 = 5;
 const int kAddChunk4 = 7;
@@ skipping 10 matching lines @@
 
 const SBPrefix kMinSBPrefix = 0u;
 const SBPrefix kMaxSBPrefix = ~kMinSBPrefix;
 
 }  // namespace
 
 namespace safe_browsing {
 
 class SafeBrowsingStoreFileTest : public PlatformTest {
  public:
+  SafeBrowsingStoreFileTest()
+      : task_runner_(new base::TestSimpleTaskRunner),
+        corruption_detected_(false) {}
+
   void SetUp() override {
     PlatformTest::SetUp();
 
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     filename_ = temp_dir_.path();
     filename_ = filename_.AppendASCII("SafeBrowsingTestStore");
 
-    store_.reset(new SafeBrowsingStoreFile());
+    store_.reset(new SafeBrowsingStoreFile(task_runner_));
     store_->Init(filename_,
                  base::Bind(&SafeBrowsingStoreFileTest::OnCorruptionDetected,
                             base::Unretained(this)));
     corruption_detected_ = false;

[gab, 2015/02/19 14:38:23]

Remove this line now that it's properly taken care of in the constructor.

[Alexei Svitkine (slow), 2015/02/20 15:42:45]

Done.

   }
   void TearDown() override {
     if (store_.get())
       store_->Delete();
     store_.reset();
 
     PlatformTest::TearDown();
   }
 
   void OnCorruptionDetected() {
@@ skipping 39 matching lines @@
   // Manually read the shard stride info from the file.
   uint32 ReadStride() {
     base::ScopedFILE file(base::OpenFile(filename_, "rb"));
     const long kOffset = 4 * sizeof(uint32);
     EXPECT_EQ(fseek(file.get(), kOffset, SEEK_SET), 0);
     uint32 shard_stride = 0;
     EXPECT_EQ(fread(&shard_stride, sizeof(shard_stride), 1, file.get()), 1U);
     return shard_stride;
   }
 
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ScopedTempDir temp_dir_;
   base::FilePath filename_;
   scoped_ptr<SafeBrowsingStoreFile> store_;
   bool corruption_detected_;
 };
 
 // Test that the empty store looks empty.
 TEST_F(SafeBrowsingStoreFileTest, Empty) {
   ASSERT_TRUE(store_->BeginUpdate());
 
@@ skipping 329 matching lines @@
 
   EXPECT_FALSE(base::PathExists(filename_));
   EXPECT_FALSE(base::PathExists(temp_file));
 
   // Starting a transaction creates a temporary file.
   ASSERT_TRUE(store_->BeginUpdate());
   EXPECT_TRUE(base::PathExists(temp_file));
 
   // Pull the rug out from under the existing store, simulating a
   // crash.
-  store_.reset(new SafeBrowsingStoreFile());
+  store_.reset(new SafeBrowsingStoreFile(task_runner_));
   store_->Init(filename_, base::Closure());
   EXPECT_FALSE(base::PathExists(filename_));
   EXPECT_TRUE(base::PathExists(temp_file));
 
   // Make sure the temporary file is deleted.
   EXPECT_TRUE(store_->Delete());
   EXPECT_FALSE(base::PathExists(filename_));
   EXPECT_FALSE(base::PathExists(temp_file));
 }
 
@@ skipping 266 matching lines @@
   // - Add chunk kAddChunk1 containing kHash1.prefix and kHash2.
   // - Sub chunk kSubChunk1 containing kHash3.
   const char kBasename[] = "FileStoreVersion7";
   base::FilePath golden_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &golden_path));
   golden_path = golden_path.AppendASCII("SafeBrowsing");
   golden_path = golden_path.AppendASCII(kBasename);
   ASSERT_TRUE(base::CopyFile(golden_path, filename_));
 
   // Reset the store to make sure it re-reads the file.
-  store_.reset(new SafeBrowsingStoreFile());
+  store_.reset(new SafeBrowsingStoreFile(task_runner_));

[gab, 2015/02/19 14:38:23]

ASSERT_TRUE(!task_runner_->HasPendingTasks());

before this line maybe? Otherwise this doesn't really simulate a "crash" as the
task_runner_ is not empty.

Same on 290.

[Alexei Svitkine (slow), 2015/02/20 15:42:44]

Done.

   store_->Init(filename_,
                base::Bind(&SafeBrowsingStoreFileTest::OnCorruptionDetected,
                           base::Unretained(this)));
   EXPECT_FALSE(corruption_detected_);
 
   // The unknown version should be encountered on the first read.
   EXPECT_FALSE(store_->BeginUpdate());
   EXPECT_TRUE(corruption_detected_);
 
   // No more to test because corrupt file stores are cleaned up by the database
@@ skipping 12 matching lines @@
   // - Add chunk kAddChunk1 containing kHash1.prefix and kHash2.
   // - Sub chunk kSubChunk1 containing kHash3.
   const char kBasename[] = "FileStoreVersion8";
   base::FilePath golden_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &golden_path));
   golden_path = golden_path.AppendASCII("SafeBrowsing");
   golden_path = golden_path.AppendASCII(kBasename);
   ASSERT_TRUE(base::CopyFile(golden_path, filename_));
 
   // Reset the store to make sure it re-reads the file.
-  store_.reset(new SafeBrowsingStoreFile());
+  store_.reset(new SafeBrowsingStoreFile(task_runner_));
   store_->Init(filename_,
                base::Bind(&SafeBrowsingStoreFileTest::OnCorruptionDetected,
                           base::Unretained(this)));
 
   // Check that the expected prefixes and hashes are in place.
   SBAddPrefixes add_prefixes;
   EXPECT_TRUE(store_->GetAddPrefixes(&add_prefixes));
   ASSERT_EQ(2U, add_prefixes.size());
   EXPECT_EQ(kAddChunk1, add_prefixes[0].chunk_id);
   EXPECT_EQ(kHash1.prefix, add_prefixes[0].prefix);
@@ skipping 40 matching lines @@
     std::vector<SBPrefix> prefixes_result;
     builder.GetPrefixSetNoHashes()->GetPrefixes(&prefixes_result);
     ASSERT_EQ(1U, prefixes_result.size());
     EXPECT_EQ(kHash1.prefix, prefixes_result[0]);
     EXPECT_TRUE(add_full_hashes_result.empty());
   }
 }
 #endif
 
 }  // namespace safe_browsing