Upstream RunBlockingPoolTask().

chrome/browser/chromeos/drive/file_system_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/chromeos/drive/file_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 133 matching lines @@
     // Disable delaying so that the sync starts immediately.
     file_system_->sync_client_for_testing()->set_delay_for_testing(
         base::TimeDelta::FromSeconds(0));
   }
 
   // Loads the full resource list via FakeDriveService.
   bool LoadFullResourceList() {
     FileError error = FILE_ERROR_FAILED;
     file_system_->change_list_loader_for_testing()->LoadIfNeeded(
         google_apis::test_util::CreateCopyResultCallback(&error));
-    test_util::RunBlockingPoolTask();
+    content::RunAllBlockingPoolTasksUntilIdle();
     return error == FILE_ERROR_OK;
   }
 
   // Gets resource entry by path synchronously.
   scoped_ptr<ResourceEntry> GetResourceEntrySync(
       const base::FilePath& file_path) {
     FileError error = FILE_ERROR_FAILED;
     scoped_ptr<ResourceEntry> entry;
     file_system_->GetResourceEntry(
         file_path,
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
-    test_util::RunBlockingPoolTask();
+    content::RunAllBlockingPoolTasksUntilIdle();
 
     return entry.Pass();
   }
 
   // Gets directory info by path synchronously.
   scoped_ptr<ResourceEntryVector> ReadDirectorySync(
       const base::FilePath& file_path) {
     FileError error = FILE_ERROR_FAILED;
     scoped_ptr<ResourceEntryVector> entries(new ResourceEntryVector);
     file_system_->ReadDirectory(
         file_path,
         base::Bind(&AccumulateReadDirectoryResult, entries.get()),
         google_apis::test_util::CreateCopyResultCallback(&error));
-    test_util::RunBlockingPoolTask();
+    content::RunAllBlockingPoolTasksUntilIdle();
     if (error != FILE_ERROR_OK)
       entries.reset();
     return entries.Pass();
   }
 
   // Used to implement ReadDirectorySync().
   static void AccumulateReadDirectoryResult(
       ResourceEntryVector* out_entries,
       scoped_ptr<ResourceEntryVector> entries) {
     ASSERT_TRUE(entries);
@@ skipping 131 matching lines @@
   base::FilePath src_file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/root/Copied.txt"));
   EXPECT_TRUE(GetResourceEntrySync(src_file_path));
   EXPECT_FALSE(GetResourceEntrySync(dest_file_path));
 
   FileError error = FILE_ERROR_FAILED;
   file_system_->Copy(src_file_path,
                      dest_file_path,
                      false,  // preserve_last_modified,
                      google_apis::test_util::CreateCopyResultCallback(&error));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // Entry is added on the server.
   scoped_ptr<ResourceEntry> entry = GetResourceEntrySync(dest_file_path);
   ASSERT_TRUE(entry);
 
   google_apis::GDataErrorCode status = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> server_entry;
   fake_drive_service_->GetFileResource(
       entry->resource_id(),
       google_apis::test_util::CreateCopyResultCallback(&status, &server_entry));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(google_apis::HTTP_SUCCESS, status);
   ASSERT_TRUE(server_entry);
   EXPECT_EQ(entry->title(), server_entry->title());
   EXPECT_FALSE(server_entry->IsDirectory());
 }
 
 TEST_F(FileSystemTest, Move) {
   base::FilePath src_file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   base::FilePath dest_file_path(
       FILE_PATH_LITERAL("drive/root/Directory 1/Moved.txt"));
   EXPECT_TRUE(GetResourceEntrySync(src_file_path));
   EXPECT_FALSE(GetResourceEntrySync(dest_file_path));
   scoped_ptr<ResourceEntry> parent =
       GetResourceEntrySync(dest_file_path.DirName());
   ASSERT_TRUE(parent);
 
   FileError error = FILE_ERROR_FAILED;
   file_system_->Move(src_file_path,
                      dest_file_path,
                      google_apis::test_util::CreateCopyResultCallback(&error));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // Entry is moved on the server.
   scoped_ptr<ResourceEntry> entry = GetResourceEntrySync(dest_file_path);
   ASSERT_TRUE(entry);
 
   google_apis::GDataErrorCode status = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> server_entry;
   fake_drive_service_->GetFileResource(
       entry->resource_id(),
       google_apis::test_util::CreateCopyResultCallback(&status, &server_entry));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(google_apis::HTTP_SUCCESS, status);
   ASSERT_TRUE(server_entry);
   EXPECT_EQ(entry->title(), server_entry->title());
 
   ASSERT_FALSE(server_entry->parents().empty());
   EXPECT_EQ(parent->resource_id(), server_entry->parents()[0].file_id());
 }
 
 TEST_F(FileSystemTest, Remove) {
   base::FilePath file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntrySync(file_path);
   ASSERT_TRUE(entry);
 
   FileError error = FILE_ERROR_FAILED;
   file_system_->Remove(
       file_path,
       false,  // is_resursive
       google_apis::test_util::CreateCopyResultCallback(&error));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // Entry is removed on the server.
   google_apis::GDataErrorCode status = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> server_entry;
   fake_drive_service_->GetFileResource(
       entry->resource_id(),
       google_apis::test_util::CreateCopyResultCallback(&status, &server_entry));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(google_apis::HTTP_SUCCESS, status);
   ASSERT_TRUE(server_entry);
   EXPECT_TRUE(server_entry->labels().is_trashed());
 }
 
 TEST_F(FileSystemTest, CreateDirectory) {
   base::FilePath directory_path(FILE_PATH_LITERAL("drive/root/New Directory"));
   EXPECT_FALSE(GetResourceEntrySync(directory_path));
 
   FileError error = FILE_ERROR_FAILED;
   file_system_->CreateDirectory(
       directory_path,
       true,  // is_exclusive
       false,  // is_recursive
       google_apis::test_util::CreateCopyResultCallback(&error));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // Directory is created on the server.
   scoped_ptr<ResourceEntry> entry = GetResourceEntrySync(directory_path);
   ASSERT_TRUE(entry);
 
   google_apis::GDataErrorCode status = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> server_entry;
   fake_drive_service_->GetFileResource(
       entry->resource_id(),
       google_apis::test_util::CreateCopyResultCallback(&status, &server_entry));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(google_apis::HTTP_SUCCESS, status);
   ASSERT_TRUE(server_entry);
   EXPECT_EQ(entry->title(), server_entry->title());
   EXPECT_TRUE(server_entry->IsDirectory());
 }
 
 TEST_F(FileSystemTest, CreateFile) {
   base::FilePath file_path(FILE_PATH_LITERAL("drive/root/New File.txt"));
   EXPECT_FALSE(GetResourceEntrySync(file_path));
 
   FileError error = FILE_ERROR_FAILED;
   file_system_->CreateFile(
       file_path,
       true,  // is_exclusive
       "text/plain",
       google_apis::test_util::CreateCopyResultCallback(&error));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // File is created on the server.
   scoped_ptr<ResourceEntry> entry = GetResourceEntrySync(file_path);
   ASSERT_TRUE(entry);
 
   google_apis::GDataErrorCode status = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> server_entry;
   fake_drive_service_->GetFileResource(
       entry->resource_id(),
       google_apis::test_util::CreateCopyResultCallback(&status, &server_entry));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(google_apis::HTTP_SUCCESS, status);
   ASSERT_TRUE(server_entry);
   EXPECT_EQ(entry->title(), server_entry->title());
   EXPECT_FALSE(server_entry->IsDirectory());
 }
 
 TEST_F(FileSystemTest, TouchFile) {
   base::FilePath file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntrySync(file_path);
   ASSERT_TRUE(entry);
 
   base::Time last_accessed =
       base::Time::FromInternalValue(entry->file_info().last_accessed()) +
       base::TimeDelta::FromSeconds(1);
   base::Time last_modified =
       base::Time::FromInternalValue(entry->file_info().last_modified()) +
       base::TimeDelta::FromSeconds(1);
 
   FileError error = FILE_ERROR_FAILED;
   file_system_->TouchFile(
       file_path,
       last_accessed,
       last_modified,
       google_apis::test_util::CreateCopyResultCallback(&error));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // File is touched on the server.
   google_apis::GDataErrorCode status = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> server_entry;
   fake_drive_service_->GetFileResource(
       entry->resource_id(),
       google_apis::test_util::CreateCopyResultCallback(&status, &server_entry));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(google_apis::HTTP_SUCCESS, status);
   ASSERT_TRUE(server_entry);
   EXPECT_EQ(last_accessed, server_entry->last_viewed_by_me_date());
   EXPECT_EQ(last_modified, server_entry->modified_date());
 }
 
 TEST_F(FileSystemTest, TruncateFile) {
   base::FilePath file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntrySync(file_path);
   ASSERT_TRUE(entry);
 
   const int64 kLength = entry->file_info().size() + 100;
 
   FileError error = FILE_ERROR_FAILED;
   file_system_->TruncateFile(
       file_path,
       kLength,
       google_apis::test_util::CreateCopyResultCallback(&error));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // File is touched on the server.
   google_apis::GDataErrorCode status = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::FileResource> server_entry;
   fake_drive_service_->GetFileResource(
       entry->resource_id(),
       google_apis::test_util::CreateCopyResultCallback(&status, &server_entry));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(google_apis::HTTP_SUCCESS, status);
   ASSERT_TRUE(server_entry);
   EXPECT_EQ(kLength, server_entry->file_size());
 }
 
 TEST_F(FileSystemTest, DuplicatedAsyncInitialization) {
   base::RunLoop loop;
 
   int counter = 0;
   const GetResourceEntryCallback& callback = base::Bind(
@@ skipping 125 matching lines @@
   // changestamp (i.e. the local metadata is up-to-date), so no request for
   // new resource list (i.e., call to GetResourceList) should happen.
   EXPECT_EQ(0, fake_drive_service_->file_list_load_count());
 
   // Since the file system has verified that it holds the latest snapshot,
   // it should change its state to "loaded", which admits periodic refresh.
   // To test it, call CheckForUpdates and verify it does try to check updates.
   const int about_resource_load_count_before =
       fake_drive_service_->about_resource_load_count();
   file_system_->CheckForUpdates();
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_LT(about_resource_load_count_before,
             fake_drive_service_->about_resource_load_count());
 }
 
 TEST_F(FileSystemTest, LoadFileSystemFromCacheWhileOffline) {
   ASSERT_NO_FATAL_FAILURE(SetUpTestFileSystem(USE_OLD_TIMESTAMP));
 
   // Make GetResourceList fail for simulating offline situation. This will
   // leave the file system "loaded from cache, but not synced with server"
   // state.
@@ skipping 21 matching lines @@
       FILE_PATH_LITERAL("drive/root/Dir1/SubDir2/File3"))));
 
   // Since the file system has at least succeeded to load cached snapshot,
   // the file system should be able to start periodic refresh.
   // To test it, call CheckForUpdates and verify it does try to check
   // updates, which will cause directory changes.
   fake_drive_service_->set_offline(false);
 
   file_system_->CheckForUpdates();
 
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(1, fake_drive_service_->about_resource_load_count());
   EXPECT_EQ(1, fake_drive_service_->change_list_load_count());
 
   ASSERT_LE(0u, mock_directory_observer_->changed_directories().size());
   ASSERT_LE(1u, mock_directory_observer_->changed_files().size());
 }
 
 TEST_F(FileSystemTest, ReadDirectoryWhileRefreshing) {
   // Use old timestamp so the fast fetch will be performed.
   ASSERT_NO_FATAL_FAILURE(SetUpTestFileSystem(USE_OLD_TIMESTAMP));
@@ skipping 23 matching lines @@
   // CreateDirectory ensures the resource list is loaded before it runs.
 
   base::FilePath existing_directory(
       FILE_PATH_LITERAL("drive/root/Directory 1"));
   FileError error = FILE_ERROR_FAILED;
   file_system_->CreateDirectory(
       existing_directory,
       true,  // is_exclusive
       false,  // is_recursive
       google_apis::test_util::CreateCopyResultCallback(&error));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
 
   // It should fail because is_exclusive is set to true.
   EXPECT_EQ(FILE_ERROR_EXISTS, error);
 }
 
 TEST_F(FileSystemTest, CreateDirectoryRecursively) {
   // Intentionally *not* calling LoadFullResourceList(), for testing that
   // CreateDirectory ensures the resource list is loaded before it runs.
 
   base::FilePath new_directory(
       FILE_PATH_LITERAL("drive/root/Directory 1/a/b/c/d"));
   FileError error = FILE_ERROR_FAILED;
   file_system_->CreateDirectory(
       new_directory,
       true,  // is_exclusive
       true,  // is_recursive
       google_apis::test_util::CreateCopyResultCallback(&error));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
 
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   scoped_ptr<ResourceEntry> entry(GetResourceEntrySync(new_directory));
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->file_info().is_directory());
 }
 
 TEST_F(FileSystemTest, PinAndUnpin) {
   ASSERT_TRUE(LoadFullResourceList());
 
   base::FilePath file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
 
   // Get the file info.
   scoped_ptr<ResourceEntry> entry(GetResourceEntrySync(file_path));
   ASSERT_TRUE(entry);
 
   // Pin the file.
   FileError error = FILE_ERROR_FAILED;
   file_system_->Pin(file_path,
                     google_apis::test_util::CreateCopyResultCallback(&error));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   entry = GetResourceEntrySync(file_path);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->file_specific_info().cache_state().is_pinned());
   EXPECT_TRUE(entry->file_specific_info().cache_state().is_present());
 
   // Unpin the file.
   error = FILE_ERROR_FAILED;
   file_system_->Unpin(file_path,
                       google_apis::test_util::CreateCopyResultCallback(&error));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   entry = GetResourceEntrySync(file_path);
   ASSERT_TRUE(entry);
   EXPECT_FALSE(entry->file_specific_info().cache_state().is_pinned());
 
   // Pinned file gets synced and it results in entry state changes.
   ASSERT_EQ(0u, mock_directory_observer_->changed_directories().size());
   ASSERT_EQ(1u, mock_directory_observer_->changed_files().size());
   EXPECT_EQ(1u,
@@ skipping 14 matching lines @@
   FileError error_pin = FILE_ERROR_FAILED;
   file_system_->Pin(
       file_path,
       google_apis::test_util::CreateCopyResultCallback(&error_pin));
 
   FileError error_unpin = FILE_ERROR_FAILED;
   file_system_->Unpin(
       file_path,
       google_apis::test_util::CreateCopyResultCallback(&error_unpin));
 
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error_pin);
   EXPECT_EQ(FILE_ERROR_OK, error_unpin);
 
   // No cache file available because the sync was cancelled by Unpin().
   entry = GetResourceEntrySync(file_path);
   ASSERT_TRUE(entry);
   EXPECT_FALSE(entry->file_specific_info().cache_state().is_present());
 }
 
 TEST_F(FileSystemTest, GetAvailableSpace) {
   FileError error = FILE_ERROR_OK;
   int64 bytes_total;
   int64 bytes_used;
   file_system_->GetAvailableSpace(
       google_apis::test_util::CreateCopyResultCallback(
           &error, &bytes_total, &bytes_used));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(6789012345LL, bytes_used);
   EXPECT_EQ(9876543210LL, bytes_total);
 }
 
 TEST_F(FileSystemTest, MarkCacheFileAsMountedAndUnmounted) {
   ASSERT_TRUE(LoadFullResourceList());
 
   base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
 
   // Make the file cached.
   FileError error = FILE_ERROR_FAILED;
   base::FilePath file_path;
   scoped_ptr<ResourceEntry> entry;
   file_system_->GetFile(
       file_in_root,
       google_apis::test_util::CreateCopyResultCallback(
           &error, &file_path, &entry));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // Test for mounting.
   error = FILE_ERROR_FAILED;
   file_path.clear();
   file_system_->MarkCacheFileAsMounted(
       file_in_root,
       google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // Cannot remove a cache entry while it's being mounted.
   EXPECT_EQ(FILE_ERROR_IN_USE, cache_->Remove(entry->local_id()));
 
   // Test for unmounting.
   error = FILE_ERROR_FAILED;
   file_system_->MarkCacheFileAsUnmounted(
       file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // Now able to remove the cache entry.
   EXPECT_EQ(FILE_ERROR_OK, cache_->Remove(entry->local_id()));
 }
 
 TEST_F(FileSystemTest, GetShareUrl) {
   ASSERT_TRUE(LoadFullResourceList());
 
   const base::FilePath kFileInRoot(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   const GURL kEmbedOrigin("chrome-extension://test-id");
 
   // Try to fetch the URL for the sharing dialog.
   FileError error = FILE_ERROR_FAILED;
   GURL share_url;
   file_system_->GetShareUrl(
       kFileInRoot,
       kEmbedOrigin,
       google_apis::test_util::CreateCopyResultCallback(&error, &share_url));
-  test_util::RunBlockingPoolTask();
+  content::RunAllBlockingPoolTasksUntilIdle();
 
   // Verify the share url to the sharing dialog.
   EXPECT_EQ(FILE_ERROR_OK, error);
   EXPECT_TRUE(share_url.is_valid());
 }
 
 }   // namespace drive