Replace MessageLoopProxy::current() with ThreadTaskRunnerHandle::Get()

chrome/browser/sync_file_system/drive_backend_v1/fake_api_util.cc

 // Copyright 2013 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/sync_file_system/drive_backend_v1/fake_api_util.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"

[peria, 2014/07/04 05:31:05]

Can we drop this #include?

[peria, 2014/07/04 05:36:43]

Please ignore this comment.

+#include "base/thread_task_runner_handle.h"
 #include "google_apis/drive/drive_entry_kinds.h"
 #include "webkit/common/blob/scoped_file.h"
 
 namespace sync_file_system {
 namespace drive_backend {
 
 bool FakeAPIUtil::RemoteResourceComparator::operator()(
     const RemoteResource& left,
     const RemoteResource& right) {
   if (left.parent_resource_id != right.parent_resource_id)
@@ skipping 47 matching lines @@
           GURL(google_apis::GDataWapiUrlGenerator::kBaseUrlForProduction)) {}
 
 FakeAPIUtil::~FakeAPIUtil() {}
 
 void FakeAPIUtil::AddObserver(APIUtilObserver* observer) {}
 
 void FakeAPIUtil::RemoveObserver(APIUtilObserver* observer) {}
 
 void FakeAPIUtil::GetDriveDirectoryForSyncRoot(
     const ResourceIdCallback& callback) {
-  base::MessageLoopProxy::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  google_apis::HTTP_SUCCESS,
                  "folder: sync_root_resource_id"));
 }
 
 void FakeAPIUtil::GetDriveDirectoryForOrigin(
     const std::string& sync_root_resource_id,
     const GURL& origin,
     const ResourceIdCallback& callback) {
-  base::MessageLoopProxy::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  google_apis::HTTP_SUCCESS,
                  "folder resource_id for " + origin.host()));
 }
 
 void FakeAPIUtil::GetLargestChangeStamp(const ChangeStampCallback& callback) {
-  base::MessageLoopProxy::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, google_apis::HTTP_SUCCESS, largest_changestamp_));
 }
 
 void FakeAPIUtil::GetResourceEntry(const std::string& resource_id,
                                    const ResourceEntryCallback& callback) {
   NOTREACHED();
 }
 
 void FakeAPIUtil::ListFiles(const std::string& directory_resource_id,
@@ skipping 15 matching lines @@
     scoped_ptr<google_apis::ResourceEntry> entry(
         CreateResourceEntry(itr->second));
     entries.push_back(entry.release());
   }
 
   std::sort(entries.begin(), entries.end(), ChangeStampComparator());
 
   change_feed->set_entries(entries.Pass());
   change_feed->set_largest_changestamp(largest_changestamp_);
 
-  base::MessageLoopProxy::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(
           callback, google_apis::HTTP_SUCCESS, base::Passed(&change_feed)));
 }
 
 void FakeAPIUtil::ContinueListing(const GURL& next_link,
                                   const ResourceListCallback& callback) {
   NOTREACHED();
 }
 
@@ skipping 10 matching lines @@
   if (found != remote_resources_.end() && !found->second.deleted) {
     scoped_ptr<google_apis::ResourceEntry> entry(
         CreateResourceEntry(found->second));
     file_md5 = entry->file_md5();
     file_size = entry->file_size();
     updated_time = entry->updated_time();
     error = google_apis::HTTP_SUCCESS;
   }
 
   webkit_blob::ScopedFile dummy;
-  base::MessageLoopProxy::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, error, file_md5, file_size, updated_time,
                  base::Passed(&dummy)));
 }
 
 void FakeAPIUtil::UploadNewFile(const std::string& directory_resource_id,
                                 const base::FilePath& local_file_path,
                                 const std::string& title,
                                 const UploadFileCallback& callback) {
   NOTREACHED();
@@ skipping 11 matching lines @@
                                   const ResourceIdCallback& callback) {
   NOTREACHED();
 }
 
 bool FakeAPIUtil::IsAuthenticated() const { return true; }
 
 void FakeAPIUtil::DeleteFile(const std::string& resource_id,
                              const std::string& remote_file_md5,
                              const GDataErrorCallback& callback) {
   if (!ContainsKey(remote_resources_, resource_id)) {
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, google_apis::HTTP_NOT_FOUND));
     return;
   }
 
   const RemoteResource& deleted_directory = remote_resources_[resource_id];
   PushRemoteChange(deleted_directory.parent_resource_id,
                    deleted_directory.parent_title,
                    deleted_directory.title,
                    deleted_directory.resource_id,
                    deleted_directory.md5_checksum,
                    SYNC_FILE_TYPE_UNKNOWN,
                    true /* deleted */);
 
-  base::MessageLoopProxy::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, google_apis::HTTP_SUCCESS));
 }
 
 void FakeAPIUtil::EnsureSyncRootIsNotInMyDrive(
     const std::string& sync_root_resource_id) {
   // Nothing to do.
 }
 
 void FakeAPIUtil::PushRemoteChange(const std::string& parent_resource_id,
@@ skipping 42 matching lines @@
   return entry.Pass();
 }
 
 GURL FakeAPIUtil::ResourceIdToResourceLink(
     const std::string& resource_id) const {
   return url_generator_.GenerateEditUrl(resource_id);
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system