Upstream RunBlockingPoolTask().

chrome/browser/chromeos/drive/fileapi/fileapi_worker_unittest.cc

 // Copyright 2014 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/chromeos/drive/fileapi/fileapi_worker.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/chromeos/drive/dummy_file_system.h"
-#include "chrome/browser/chromeos/drive/test_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "google_apis/drive/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace drive {
 namespace fileapi_internal {
 namespace {
 
 // Increments |num_called| for checking how many times the closure is called.
 void Increment(int* num_called) {
   ++*num_called;
@@ skipping 142 matching lines @@
   base::CreateTemporaryFile(&temp_path);
 
   // CREATE => CREATE (fails if file exists.)
   TestFileSystemForOpenFile file_system(temp_path, CREATE_FILE);
   const int64 kExpectedSize = 0;
 
   OpenFile(kDummyPath,
            base::File::FLAG_CREATE | base::File::FLAG_WRITE,
            base::Bind(&VerifyWrite, kExpectedSize, temp_path, kWriteData),
            &file_system);
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_TRUE(file_system.closed());
 }
 
 TEST_F(FileApiWorkerTest, OpenFileForOpenAlwaysWrite) {
   const base::FilePath kDummyPath = base::FilePath::FromUTF8Unsafe("whatever");
   const std::string kWriteData = "byebye";
   const std::string kInitialData = "hello";
 
   base::FilePath temp_path;
   base::CreateTemporaryFile(&temp_path);
   google_apis::test_util::WriteStringToFile(temp_path, kInitialData);
 
   // OPEN_ALWAYS => OPEN_OR_CREATE (success whether file exists or not.)
   // No truncation should take place.
   TestFileSystemForOpenFile file_system(temp_path, OPEN_OR_CREATE_FILE);
   const int64 kExpectedSize = static_cast<int64>(kInitialData.size());
 
   OpenFile(kDummyPath,
            base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE,
            base::Bind(&VerifyWrite, kExpectedSize, temp_path, kWriteData),
            &file_system);
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_TRUE(file_system.closed());
 }
 
 TEST_F(FileApiWorkerTest, OpenFileForOpenTruncatedWrite) {
   const base::FilePath kDummyPath = base::FilePath::FromUTF8Unsafe("whatever");
   const std::string kInitialData = "hello";
   const std::string kWriteData = "byebye";
 
   base::FilePath temp_path;
   base::CreateTemporaryFile(&temp_path);
   google_apis::test_util::WriteStringToFile(temp_path, kInitialData);
 
   // OPEN_TRUNCATED => OPEN (failure when the file did not exist.)
   // It should truncate the file before passing to the callback.
   TestFileSystemForOpenFile file_system(temp_path, OPEN_FILE);
   const int64 kExpectedSize = 0;
 
   OpenFile(kDummyPath,
            base::File::FLAG_OPEN_TRUNCATED | base::File::FLAG_WRITE,
            base::Bind(&VerifyWrite, kExpectedSize, temp_path, kWriteData),
            &file_system);
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_TRUE(file_system.closed());
 }
 
 TEST_F(FileApiWorkerTest, OpenFileForOpenCreateAlwaysWrite) {
   const base::FilePath kDummyPath = base::FilePath::FromUTF8Unsafe("whatever");
   const std::string kInitialData = "hello";
   const std::string kWriteData = "byebye";
 
   base::FilePath temp_path;
   base::CreateTemporaryFile(&temp_path);
   google_apis::test_util::WriteStringToFile(temp_path, kInitialData);
 
   // CREATE_ALWAYS => OPEN_OR_CREATE (success whether file exists or not.)
   // It should truncate the file before passing to the callback.
   TestFileSystemForOpenFile file_system(temp_path, OPEN_OR_CREATE_FILE);
   const int64 kExpectedSize = 0;
 
   OpenFile(kDummyPath,
            base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE,
            base::Bind(&VerifyWrite, kExpectedSize, temp_path, kWriteData),
            &file_system);
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_TRUE(file_system.closed());
 }
 
 TEST_F(FileApiWorkerTest, OpenFileForOpenRead) {
   const base::FilePath kDummyPath = base::FilePath::FromUTF8Unsafe("whatever");
   const std::string kInitialData = "hello";
 
   base::FilePath temp_path;
   base::CreateTemporaryFile(&temp_path);
   google_apis::test_util::WriteStringToFile(temp_path, kInitialData);
 
   // OPEN => OPEN (failure when the file did not exist.)
   TestFileSystemForOpenFile file_system(temp_path, OPEN_FILE);
 
   OpenFile(kDummyPath,
            base::File::FLAG_OPEN | base::File::FLAG_READ,
            base::Bind(&VerifyRead, kInitialData),
            &file_system);
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_TRUE(file_system.closed());
 }
 
 }  // namespace fileapi_internal
 }  // namespace drive