[chrome/browser/drive] Avoid use of MessageLoopProxy by TTRH

chrome/browser/drive/fake_drive_service.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/drive/fake_drive_service.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/md5.h"
-#include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/drive/drive_api_util.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/test_util.h"
 #include "net/base/escape.h"
 #include "net/base/url_util.h"
 
 using google_apis::AboutResource;
 using google_apis::AboutResourceCallback;
 using google_apis::AppList;
@@ skipping 68 matching lines @@
       return false;
   }
   return true;
 }
 
 void ScheduleUploadRangeCallback(const UploadRangeCallback& callback,
                                  int64 start_position,
                                  int64 end_position,
                                  DriveApiErrorCode error,
                                  scoped_ptr<FileResource> entry) {
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  UploadRangeResponse(error,
                                      start_position,
                                      end_position),
                  base::Passed(&entry)));
 }
 
 void FileListCallbackAdapter(const FileListCallback& callback,
                              DriveApiErrorCode error,
@@ skipping 408 matching lines @@
       next_link, base::Bind(&FileListCallbackAdapter, callback));
 }
 
 CancelCallback FakeDriveService::GetFileResource(
     const std::string& resource_id,
     const FileResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    DRIVE_NO_CONNECTION,
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (entry && entry->change_resource.file()) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, base::Passed(make_scoped_ptr(
             new FileResource(*entry->change_resource.file())))));
     return CancelCallback();
   }
 
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_NOT_FOUND,
                  base::Passed(scoped_ptr<FileResource>())));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetShareUrl(
     const std::string& resource_id,
     const GURL& /* embed_origin */,
     const GetShareUrlCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    DRIVE_NO_CONNECTION,
                    GURL()));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (entry) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, entry->share_url));
     return CancelCallback();
   }
 
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_NOT_FOUND, GURL()));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetAboutResource(
     const AboutResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     scoped_ptr<AboutResource> null;
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    DRIVE_NO_CONNECTION, base::Passed(&null)));
     return CancelCallback();
   }
 
   ++about_resource_load_count_;
   scoped_ptr<AboutResource> about_resource(new AboutResource(*about_resource_));
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  HTTP_SUCCESS, base::Passed(&about_resource)));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetAppList(const AppListCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
   DCHECK(app_info_value_);
 
   if (offline_) {
     scoped_ptr<AppList> null;
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    DRIVE_NO_CONNECTION,
                    base::Passed(&null)));
     return CancelCallback();
   }
 
   ++app_list_load_count_;
   scoped_ptr<AppList> app_list(AppList::CreateFrom(*app_info_value_));
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS, base::Passed(&app_list)));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::DeleteResource(
     const std::string& resource_id,
     const std::string& etag,
     const EntryActionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, DRIVE_NO_CONNECTION));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
     return CancelCallback();
   }
 
   ChangeResource* change = &entry->change_resource;
   const FileResource* file = change->file();
   if (change->is_deleted()) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
     return CancelCallback();
   }
 
   if (!etag.empty() && etag != file->etag()) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_PRECONDITION));
     return CancelCallback();
   }
 
   if (entry->user_permission != google_apis::drive::PERMISSION_ROLE_OWNER) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_FORBIDDEN));
     return CancelCallback();
   }
 
   change->set_deleted(true);
   AddNewChangestamp(change);
   change->set_file(scoped_ptr<FileResource>());
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, HTTP_NO_CONTENT));
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::TrashResource(
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, DRIVE_NO_CONNECTION));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
     return CancelCallback();
   }
 
   ChangeResource* change = &entry->change_resource;
   FileResource* file = change->mutable_file();
   if (change->is_deleted() || file->labels().is_trashed()) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
     return CancelCallback();
   }
 
   if (entry->user_permission != google_apis::drive::PERMISSION_ROLE_OWNER) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_FORBIDDEN));
     return CancelCallback();
   }
 
   file->mutable_labels()->set_trashed(true);
   AddNewChangestamp(change);
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, HTTP_SUCCESS));
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::DownloadFile(
     const base::FilePath& local_cache_path,
     const std::string& resource_id,
     const DownloadActionCallback& download_action_callback,
     const GetContentCallback& get_content_callback,
     const ProgressCallback& progress_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!download_action_callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(download_action_callback,
                    DRIVE_NO_CONNECTION,
                    base::FilePath()));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry || entry->change_resource.file()->IsHostedDocument()) {
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(download_action_callback, HTTP_NOT_FOUND, base::FilePath()));
     return CancelCallback();
   }
 
   const FileResource* file = entry->change_resource.file();
   const std::string& content_data = entry->content_data;
   int64 file_size = file->file_size();
   DCHECK_EQ(static_cast<size_t>(file_size), content_data.size());
 
   if (!get_content_callback.is_null()) {
     const int64 kBlockSize = 5;
     for (int64 i = 0; i < file_size; i += kBlockSize) {
       const int64 size = std::min(kBlockSize, file_size - i);
       scoped_ptr<std::string> content_for_callback(
           new std::string(content_data.substr(i, size)));
-      base::MessageLoopProxy::current()->PostTask(
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(get_content_callback, HTTP_SUCCESS,
                      base::Passed(&content_for_callback)));
     }
   }
 
   if (!test_util::WriteStringToFile(local_cache_path, content_data)) {
     // Failed to write the content.
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(download_action_callback,
                    DRIVE_FILE_ERROR, base::FilePath()));
     return CancelCallback();
   }
 
   if (!progress_callback.is_null()) {
     // See also the comment in ResumeUpload(). For testing that clients
     // can handle the case progress_callback is called multiple times,
     // here we invoke the callback twice.
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(progress_callback, file_size / 2, file_size));
-    base::MessageLoopProxy::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(progress_callback, file_size, file_size));
   }
-  base::MessageLoopProxy::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(download_action_callback,
                  HTTP_SUCCESS,
                  local_cache_path));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::CopyResource(
     const std::string& resource_id,
     const std::string& in_parent_resource_id,
     const std::string& new_title,
     const base::Time& last_modified,
     const FileResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    DRIVE_NO_CONNECTION,
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 
   const std::string& parent_resource_id = in_parent_resource_id.empty() ?
       GetRootResourceId() : in_parent_resource_id;
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND,
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 
   // Make a copy and set the new resource ID and the new title.
   scoped_ptr<EntryInfo> copied_entry(new EntryInfo);
   copied_entry->content_data = entry->content_data;
   copied_entry->share_url = entry->share_url;
@@ skipping 16 matching lines @@
 
   if (!last_modified.is_null())
     new_file->set_modified_date(last_modified);
 
   AddNewChangestamp(new_change);
   UpdateETag(new_file);
 
   // Add the new entry to the map.
   entries_[new_resource_id] = copied_entry.release();
 
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  HTTP_SUCCESS,
                  base::Passed(make_scoped_ptr(new FileResource(*new_file)))));
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::UpdateResource(
     const std::string& resource_id,
     const std::string& parent_resource_id,
     const std::string& new_title,
     const base::Time& last_modified,
     const base::Time& last_viewed_by_me,
     const google_apis::drive::Properties& properties,
     const google_apis::FileResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, DRIVE_NO_CONNECTION,
                               base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND,
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 
   if (!UserHasWriteAccess(entry->user_permission)) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_FORBIDDEN,
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 
   ChangeResource* change = &entry->change_resource;
   FileResource* file = change->mutable_file();
 
   if (!new_title.empty())
@@ skipping 12 matching lines @@
 
   if (!last_modified.is_null())
     file->set_modified_date(last_modified);
 
   if (!last_viewed_by_me.is_null())
     file->set_last_viewed_by_me_date(last_viewed_by_me);
 
   AddNewChangestamp(change);
   UpdateETag(file);
 
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS,
                  base::Passed(make_scoped_ptr(new FileResource(*file)))));
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::AddResourceToDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, DRIVE_NO_CONNECTION));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
     return CancelCallback();
   }
 
   ChangeResource* change = &entry->change_resource;
   // On the real Drive server, resources do not necessary shape a tree
   // structure. That is, each resource can have multiple parent.
   // We mimic the behavior here; AddResourceToDirectoy just adds
   // one more parent, not overwriting old ones.
   ParentReference parent;
   parent.set_file_id(parent_resource_id);
   parent.set_parent_link(GetFakeLinkUrl(parent_resource_id));
   change->mutable_file()->mutable_parents()->push_back(parent);
 
   AddNewChangestamp(change);
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, HTTP_SUCCESS));
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::RemoveResourceFromDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, DRIVE_NO_CONNECTION));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
     return CancelCallback();
   }
 
   ChangeResource* change = &entry->change_resource;
   FileResource* file = change->mutable_file();
   std::vector<ParentReference>* parents = file->mutable_parents();
   for (size_t i = 0; i < parents->size(); ++i) {
     if ((*parents)[i].file_id() == parent_resource_id) {
       parents->erase(parents->begin() + i);
       AddNewChangestamp(change);
-      base::MessageLoop::current()->PostTask(
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(callback, HTTP_NO_CONTENT));
-      base::MessageLoop::current()->PostTask(
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(&FakeDriveService::NotifyObservers,
                      weak_ptr_factory_.GetWeakPtr()));
       return CancelCallback();
     }
   }
 
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::AddNewDirectory(
     const std::string& parent_resource_id,
     const std::string& directory_title,
     const AddNewDirectoryOptions& options,
     const FileResourceCallback& callback) {
   return AddNewDirectoryWithResourceId(
       "",
       parent_resource_id.empty() ? GetRootResourceId() : parent_resource_id,
       directory_title,
       options,
       callback);
 }
 
 CancelCallback FakeDriveService::InitiateUploadNewFile(
     const std::string& content_type,
     int64 content_length,
     const std::string& parent_resource_id,
     const std::string& title,
     const UploadNewFileOptions& options,
     const InitiateUploadCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, DRIVE_NO_CONNECTION, GURL()));
     return CancelCallback();
   }
 
   if (parent_resource_id != GetRootResourceId() &&
       !entries_.count(parent_resource_id)) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND, GURL()));
     return CancelCallback();
   }
 
   GURL session_url = GetNewUploadSessionUrl();
   upload_sessions_[session_url] =
       UploadSession(content_type, content_length,
                     parent_resource_id,
                     "",  // resource_id
                     "",  // etag
                     title);
 
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS, session_url));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::InitiateUploadExistingFile(
     const std::string& content_type,
     int64 content_length,
     const std::string& resource_id,
     const UploadExistingFileOptions& options,
     const InitiateUploadCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, DRIVE_NO_CONNECTION, GURL()));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND, GURL()));
     return CancelCallback();
   }
 
   if (!UserHasWriteAccess(entry->user_permission)) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_FORBIDDEN, GURL()));
     return CancelCallback();
   }
 
   FileResource* file = entry->change_resource.mutable_file();
   if (!options.etag.empty() && options.etag != file->etag()) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_PRECONDITION, GURL()));
     return CancelCallback();
   }
   // TODO(hashimoto): Update |file|'s metadata with |options|.
 
   GURL session_url = GetNewUploadSessionUrl();
   upload_sessions_[session_url] =
       UploadSession(content_type, content_length,
                     "",  // parent_resource_id
                     resource_id,
                     file->etag(),
                     "" /* title */);
 
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS, session_url));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetUploadStatus(
     const GURL& upload_url,
     int64 content_length,
     const UploadRangeCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 37 matching lines @@
   }
 
   if (!progress_callback.is_null()) {
     // In the real GDataWapi/Drive DriveService, progress is reported in
     // nondeterministic timing. In this fake implementation, we choose to call
     // it twice per one ResumeUpload. This is for making sure that client code
     // works fine even if the callback is invoked more than once; it is the
     // crucial difference of the progress callback from others.
     // Note that progress is notified in the relative offset in each chunk.
     const int64 chunk_size = end_position - start_position;
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(progress_callback, chunk_size / 2, chunk_size));
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(progress_callback, chunk_size, chunk_size));
   }
 
   if (content_length != end_position) {
     session->uploaded_size = end_position;
     completion_callback.Run(HTTP_RESUME_INCOMPLETE, scoped_ptr<FileResource>());
     return CancelCallback();
   }
 
   std::string content_data;
@@ skipping 15 matching lines @@
         session->parent_resource_id,
         session->title,
         false);  // shared_with_me
     if (!new_entry) {
       completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<FileResource>());
       return CancelCallback();
     }
 
     completion_callback.Run(HTTP_CREATED, make_scoped_ptr(
         new FileResource(*new_entry->change_resource.file())));
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&FakeDriveService::NotifyObservers,
                    weak_ptr_factory_.GetWeakPtr()));
     return CancelCallback();
   }
 
   EntryInfo* entry = FindEntryByResourceId(session->resource_id);
   if (!entry) {
     completion_callback.Run(HTTP_NOT_FOUND, scoped_ptr<FileResource>());
     return CancelCallback();
   }
 
   ChangeResource* change = &entry->change_resource;
   FileResource* file = change->mutable_file();
   if (file->etag().empty() || session->etag != file->etag()) {
     completion_callback.Run(HTTP_PRECONDITION, scoped_ptr<FileResource>());
     return CancelCallback();
   }
 
   file->set_md5_checksum(base::MD5String(content_data));
   entry->content_data = content_data;
   file->set_file_size(end_position);
   AddNewChangestamp(change);
   UpdateETag(file);
 
   completion_callback.Run(HTTP_SUCCESS, make_scoped_ptr(
       new FileResource(*file)));
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::MultipartUploadNewFile(
     const std::string& content_type,
     int64 content_length,
     const std::string& parent_resource_id,
@@ skipping 62 matching lines @@
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::UninstallApp(
     const std::string& app_id,
     const google_apis::EntryActionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, google_apis::DRIVE_NO_CONNECTION));
     return CancelCallback();
   }
 
   // Find app_id from app_info_value_ and delete.
   base::ListValue* items = NULL;
   if (!app_info_value_->GetList("items", &items)) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, google_apis::HTTP_NOT_FOUND));
     return CancelCallback();
   }
 
   for (size_t i = 0; i < items->GetSize(); ++i) {
     base::DictionaryValue* item = NULL;
     std::string id;
     if (items->GetDictionary(i, &item) && item->GetString("id", &id) &&
         id == app_id) {
-      base::MessageLoop::current()->PostTask(
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(callback,
                      items->Remove(i, NULL) ? google_apis::HTTP_NO_CONTENT
                                             : google_apis::HTTP_NOT_FOUND));
       return CancelCallback();
     }
   }
 
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, google_apis::HTTP_NOT_FOUND));
   return CancelCallback();
 }
 
 void FakeDriveService::AddNewFile(const std::string& content_type,
                                   const std::string& content_data,
                                   const std::string& parent_resource_id,
                                   const std::string& title,
                                   bool shared_with_me,
                                   const FileResourceCallback& callback) {
   AddNewFileWithResourceId("", content_type, content_data, parent_resource_id,
                            title, shared_with_me, callback);
 }
 
 void FakeDriveService::AddNewFileWithResourceId(
     const std::string& resource_id,
     const std::string& content_type,
     const std::string& content_data,
     const std::string& parent_resource_id,
     const std::string& title,
     bool shared_with_me,
     const FileResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    DRIVE_NO_CONNECTION,
                    base::Passed(scoped_ptr<FileResource>())));
     return;
   }
 
   const EntryInfo* new_entry = AddNewEntry(resource_id,
                                            content_type,
                                            content_data,
                                            parent_resource_id,
                                            title,
                                            shared_with_me);
   if (!new_entry) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND,
                    base::Passed(scoped_ptr<FileResource>())));
     return;
   }
 
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_CREATED,
                  base::Passed(make_scoped_ptr(
                      new FileResource(*new_entry->change_resource.file())))));
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 CancelCallback FakeDriveService::AddNewDirectoryWithResourceId(
     const std::string& resource_id,
     const std::string& parent_resource_id,
     const std::string& directory_title,
     const AddNewDirectoryOptions& options,
     const FileResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    DRIVE_NO_CONNECTION,
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 
   const EntryInfo* new_entry = AddNewEntry(resource_id,
                                            util::kDriveFolderMimeType,
                                            "",  // content_data
                                            parent_resource_id,
                                            directory_title,
                                            false);  // shared_with_me
   if (!new_entry) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND,
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_CREATED,
                  base::Passed(make_scoped_ptr(
                      new FileResource(*new_entry->change_resource.file())))));
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
   return CancelCallback();
 }
 
 void FakeDriveService::SetLastModifiedTime(
     const std::string& resource_id,
     const base::Time& last_modified_time,
     const FileResourceCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    DRIVE_NO_CONNECTION,
                    base::Passed(scoped_ptr<FileResource>())));
     return;
   }
 
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND,
                    base::Passed(scoped_ptr<FileResource>())));
     return;
   }
 
   ChangeResource* change = &entry->change_resource;
   FileResource* file = change->mutable_file();
   file->set_modified_date(last_modified_time);
 
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS,
                  base::Passed(make_scoped_ptr(new FileResource(*file)))));
 }
 
 google_apis::DriveApiErrorCode FakeDriveService::SetUserPermission(
     const std::string& resource_id,
     google_apis::drive::PermissionRole user_permission) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 120 matching lines @@
 
 void FakeDriveService::GetChangeListInternal(
     int64 start_changestamp,
     const std::string& search_query,
     const std::string& directory_resource_id,
     int start_offset,
     int max_results,
     int* load_counter,
     const ChangeListCallback& callback) {
   if (offline_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    DRIVE_NO_CONNECTION,
                    base::Passed(scoped_ptr<ChangeList>())));
     return;
   }
 
   // Filter out entries per parameters like |directory_resource_id| and
   // |search_query|.
   ScopedVector<ChangeResource> entries;
@@ skipping 90 matching lines @@
       next_url = net::AppendOrReplaceQueryParameter(
           next_url, "parent", directory_resource_id);
     }
 
     change_list->set_next_link(next_url);
   }
   *change_list->mutable_items() = entries.Pass();
 
   if (load_counter)
     *load_counter += 1;
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS, base::Passed(&change_list)));
 }
 
 GURL FakeDriveService::GetNewUploadSessionUrl() {
   return GURL("https://upload_session_url/" +
               base::Int64ToString(next_upload_sequence_number_++));
 }
 
 google_apis::CancelCallback FakeDriveService::AddPermission(
@@ skipping 14 matching lines @@
 
   NOTREACHED();
   return scoped_ptr<BatchRequestConfiguratorInterface>();
 }
 
 void FakeDriveService::NotifyObservers() {
   FOR_EACH_OBSERVER(ChangeObserver, change_observers_, OnNewChangeAvailable());
 }
 
 }  // namespace drive