google_apis: Remove PostBlockingPoolSequencedTask () and friends

chrome/browser/chromeos/drive/drive_file_system.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/drive_file_system.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop_proxy.h"
@@ skipping 830 matching lines @@
   }
 
   // For a hosted document, we create a special JSON file to represent the
   // document instead of fetching the document content in one of the exported
   // formats. The JSON file contains the edit URL and resource ID of the
   // document.
   if (entry_proto->file_specific_info().is_hosted_document()) {
     FilePath* temp_file_path = new FilePath;
     const std::string mime_type = kMimeTypeJson;
     const DriveFileType file_type = HOSTED_DOCUMENT;
-    google_apis::util::PostBlockingPoolSequencedTaskAndReplyWithResult(
+    base::PostTaskAndReplyWithResult(
+        blocking_task_runner_,
         FROM_HERE,
-        blocking_task_runner_,
         base::Bind(&CreateDocumentJsonFileOnBlockingPool,
                    cache_->GetCacheDirectoryPath(
                        DriveCache::CACHE_TYPE_TMP_DOCUMENTS),
                    GURL(entry_proto->file_specific_info().alternate_url()),
                    entry_proto->resource_id(),
                    temp_file_path),
         base::Bind(&RunGetFileCallbackHelper,
                    get_file_callback,
                    base::Owned(temp_file_path),
                    mime_type,
@@ skipping 170 matching lines @@
   DCHECK(!params.get_file_callback.is_null());
 
   if (error != DRIVE_FILE_OK) {
     params.get_file_callback.Run(error,
                                  params.cache_file_path,
                                  params.mime_type,
                                  REGULAR_FILE);
     return;
   }
 
-  google_apis::util::PostBlockingPoolSequencedTaskAndReplyWithResult(
+  base::PostTaskAndReplyWithResult(
+      blocking_task_runner_,
       FROM_HERE,
-      blocking_task_runner_,
       base::Bind(&DriveCache::FreeDiskSpaceOnBlockingPoolIfNeededFor,
                  base::Unretained(cache_),
                  file_size),
       base::Bind(&DriveFileSystem::StartDownloadFileIfEnoughSpace,
                  ui_weak_ptr_,
                  params,
                  content_url,
                  params.cache_file_path));
 }
 
@@ skipping 286 matching lines @@
   DCHECK(!callback.is_null());
 
   if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   // Gets the size of the cache file. Since the file is locally modified, the
   // file size information stored in DriveEntry is not correct.
   int64* file_size = new int64(0);
-  google_apis::util::PostBlockingPoolSequencedTaskAndReplyWithResult(
+  base::PostTaskAndReplyWithResult(
+      blocking_task_runner_,
       FROM_HERE,
-      blocking_task_runner_,
       base::Bind(&file_util::GetFileSize,
                  cache_file_path,
                  file_size),
       base::Bind(&DriveFileSystem::OnGetFileSizeCompleteForUpdateFile,
                  ui_weak_ptr_,
                  callback,
                  drive_file_path,
                  base::Passed(&entry_proto),
                  cache_file_path,
                  base::Owned(file_size)));
@@ skipping 363 matching lines @@
   }
 
   // At this point, the disk can be full or nearly full for several reasons:
   // - The expected file size was incorrect and the file was larger
   // - There was an in-flight download operation and it used up space
   // - The disk became full for some user actions we cannot control
   //   (ex. the user might have downloaded a large file from a regular web site)
   //
   // If we don't have enough space, we return PLATFORM_FILE_ERROR_NO_SPACE,
   // and try to free up space, even if the file was downloaded successfully.
-  google_apis::util::PostBlockingPoolSequencedTaskAndReplyWithResult(
+  base::PostTaskAndReplyWithResult(
+      blocking_task_runner_,
       FROM_HERE,
-      blocking_task_runner_,
       base::Bind(&DriveCache::FreeDiskSpaceOnBlockingPoolIfNeededFor,
                  base::Unretained(cache_),
                  0),
       base::Bind(&DriveFileSystem::OnFileDownloadedAndSpaceChecked,
                  ui_weak_ptr_,
                  params,
                  status,
                  content_url,
                  downloaded_file_path));
 }
@@ skipping 28 matching lines @@
     if (has_enough_space) {
       cache_->Store(params.resource_id,
                     params.md5,
                     downloaded_file_path,
                     DriveCache::FILE_OPERATION_MOVE,
                     base::Bind(&DriveFileSystem::OnDownloadStoredToCache,
                                ui_weak_ptr_));
     } else {
       // If we don't have enough space, remove the downloaded file, and
       // report "no space" error.
-      google_apis::util::PostBlockingPoolSequencedTask(
+      blocking_task_runner_->PostTask(
           FROM_HERE,
-          blocking_task_runner_,
           base::Bind(base::IgnoreResult(&file_util::Delete),
                      downloaded_file_path,
                      false /* recursive*/));
       error = DRIVE_FILE_ERROR_NO_SPACE;
     }
   }
 
   params.get_file_callback.Run(error,
                                downloaded_file_path,
                                params.mime_type,
@@ skipping 570 matching lines @@
   DCHECK(!callback.is_null());
 
   // When no dirty cache is found, use the original entry info as is.
   if (error != DRIVE_FILE_OK) {
     callback.Run(DRIVE_FILE_OK, entry_proto.Pass());
     return;
   }
 
   // If the cache is dirty, obtain the file info from the cache file itself.
   base::PlatformFileInfo* file_info = new base::PlatformFileInfo;
-  google_apis::util::PostBlockingPoolSequencedTaskAndReplyWithResult(
+  base::PostTaskAndReplyWithResult(
+      blocking_task_runner_,
       FROM_HERE,
-      blocking_task_runner_,
       base::Bind(&file_util::GetFileInfo,
                  local_cache_path,
                  base::Unretained(file_info)),
       base::Bind(&DriveFileSystem::CheckLocalModificationAndRunAfterGetFileInfo,
                  ui_weak_ptr_,
                  base::Passed(&entry_proto),
                  callback,
                  base::Owned(file_info)));
 }
 
@@ skipping 10 matching lines @@
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   DriveEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   callback.Run(DRIVE_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace drive