chrome: Use base::MessageLoop. (Part 3)

chrome/browser/google_apis/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/google_apis/fake_drive_service.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 321 matching lines @@
 }
 
 void FakeDriveService::GetResourceEntry(
     const std::string& resource_id,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
     scoped_ptr<ResourceEntry> null;
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback,
-                   GDATA_NO_CONNECTION,
-                   base::Passed(&null)));
+        base::Bind(callback, GDATA_NO_CONNECTION, base::Passed(&null)));
     return;
   }
 
   base::DictionaryValue* entry = FindEntryByResourceId(resource_id);
   if (entry) {
     scoped_ptr<ResourceEntry> resource_entry =
         ResourceEntry::CreateFrom(*entry);
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, base::Passed(&resource_entry)));
     return;
   }
 
   scoped_ptr<ResourceEntry> null;
-  MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
 }
 
 void FakeDriveService::GetAccountMetadata(
     const GetAccountMetadataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
     scoped_ptr<AccountMetadata> null;
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback,
-                   GDATA_NO_CONNECTION,
-                   base::Passed(&null)));
+        base::Bind(callback, GDATA_NO_CONNECTION, base::Passed(&null)));
     return;
   }
 
   ++account_metadata_load_count_;
   scoped_ptr<AccountMetadata> account_metadata =
       AccountMetadata::CreateFrom(*account_metadata_value_);
   // Overwrite the change stamp.
   account_metadata->set_largest_changestamp(largest_changestamp_);
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(callback,
-                 HTTP_SUCCESS,
-                 base::Passed(&account_metadata)));
+      base::Bind(callback, HTTP_SUCCESS, base::Passed(&account_metadata)));
 }
 
 void FakeDriveService::GetAboutResource(
     const GetAboutResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
     scoped_ptr<AboutResource> null;
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback,
-                   GDATA_NO_CONNECTION, base::Passed(&null)));
+        base::Bind(callback, GDATA_NO_CONNECTION, base::Passed(&null)));
     return;
   }
 
   ++about_resource_load_count_;
   scoped_ptr<AboutResource> about_resource(
       AboutResource::CreateFromAccountMetadata(
           *AccountMetadata::CreateFrom(*account_metadata_value_),
           GetRootResourceId()));
   // Overwrite the change id.
   about_resource->set_largest_change_id(largest_changestamp_);
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(callback,
-                 HTTP_SUCCESS, base::Passed(&about_resource)));
+      base::Bind(callback, HTTP_SUCCESS, base::Passed(&about_resource)));
 }
 
 void FakeDriveService::GetAppList(const GetAppListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
     scoped_ptr<AppList> null;
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback,
-                   GDATA_NO_CONNECTION,
-                   base::Passed(&null)));
+        base::Bind(callback, GDATA_NO_CONNECTION, base::Passed(&null)));
     return;
   }
 
   scoped_ptr<AppList> app_list(AppList::CreateFrom(*app_info_value_));
-  MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(callback, HTTP_SUCCESS, base::Passed(&app_list)));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, HTTP_SUCCESS, base::Passed(&app_list)));
 }
 
 void FakeDriveService::DeleteResource(
     const std::string& resource_id,
     const std::string& etag,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
     return;
   }
 
   base::DictionaryValue* resource_list_dict = NULL;
   base::ListValue* entries = NULL;
   // Go through entries and remove the one that matches |resource_id|.
   if (resource_list_value_->GetAsDictionary(&resource_list_dict) &&
       resource_list_dict->GetList("entry", &entries)) {
     for (size_t i = 0; i < entries->GetSize(); ++i) {
       base::DictionaryValue* entry = NULL;
       std::string current_resource_id;
       if (entries->GetDictionary(i, &entry) &&
           entry->GetString("gd$resourceId.$t", &current_resource_id) &&
           resource_id == current_resource_id) {
         entries->Remove(i, NULL);
-        MessageLoop::current()->PostTask(
+        base::MessageLoop::current()->PostTask(
             FROM_HERE, base::Bind(callback, HTTP_SUCCESS));
         return;
       }
     }
   }
 
   // TODO(satorux): Add support for returning "deleted" entries in
   // changelists from GetResourceList().
-  MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+                                         base::Bind(callback, HTTP_NOT_FOUND));
 }
 
 void FakeDriveService::DownloadFile(
     const base::FilePath& virtual_path,
     const base::FilePath& local_cache_path,
     const GURL& download_url,
     const DownloadActionCallback& download_action_callback,
     const GetContentCallback& get_content_callback,
     const ProgressCallback& progress_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!download_action_callback.is_null());
 
   if (offline_) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(download_action_callback,
-                   GDATA_NO_CONNECTION,
-                   base::FilePath()));
+        base::Bind(
+            download_action_callback, GDATA_NO_CONNECTION, base::FilePath()));
     return;
   }
 
   // The field content.src is the URL to download the file.
   base::DictionaryValue* entry = FindEntryByContentUrl(download_url);
   if (!entry) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(download_action_callback, HTTP_NOT_FOUND, base::FilePath()));
     return;
@@ skipping 53 matching lines @@
 
 void FakeDriveService::CopyHostedDocument(
     const std::string& resource_id,
     const std::string& new_name,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
     scoped_ptr<ResourceEntry> null;
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback,
-                   GDATA_NO_CONNECTION,
-                   base::Passed(&null)));
+        base::Bind(callback, GDATA_NO_CONNECTION, base::Passed(&null)));
     return;
   }
 
   base::DictionaryValue* resource_list_dict = NULL;
   base::ListValue* entries = NULL;
   // Go through entries and copy the one that matches |resource_id|.
   if (resource_list_value_->GetAsDictionary(&resource_list_dict) &&
       resource_list_dict->GetList("entry", &entries)) {
     for (size_t i = 0; i < entries->GetSize(); ++i) {
       base::DictionaryValue* entry = NULL;
@@ skipping 21 matching lines @@
             copied_entry->SetString("title.$t", new_name);
 
             AddNewChangestamp(copied_entry.get());
 
             // Parse the new entry.
             scoped_ptr<ResourceEntry> resource_entry =
                 ResourceEntry::CreateFrom(*copied_entry);
             // Add it to the resource list.
             entries->Append(copied_entry.release());
 
-            MessageLoop::current()->PostTask(
+            base::MessageLoop::current()->PostTask(
                 FROM_HERE,
-                base::Bind(callback,
-                           HTTP_SUCCESS,
-                           base::Passed(&resource_entry)));
+                base::Bind(
+                    callback, HTTP_SUCCESS, base::Passed(&resource_entry)));
             return;
           }
         }
       }
     }
   }
 
   scoped_ptr<ResourceEntry> null;
-  MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
 }
 
 void FakeDriveService::RenameResource(
     const std::string& resource_id,
     const std::string& new_name,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
     return;
   }
 
   base::DictionaryValue* entry = FindEntryByResourceId(resource_id);
   if (entry) {
     entry->SetString("title.$t", new_name);
     AddNewChangestamp(entry);
-    MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, HTTP_SUCCESS));
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::Bind(callback, HTTP_SUCCESS));
     return;
   }
 
-  MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+                                         base::Bind(callback, HTTP_NOT_FOUND));
 }
 
 void FakeDriveService::AddResourceToDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
     return;
   }
 
   base::DictionaryValue* entry = FindEntryByResourceId(resource_id);
   if (entry) {
     base::ListValue* links = NULL;
     if (!entry->GetList("link", &links)) {
       links = new base::ListValue;
       entry->Set("link", links);
     }
 
     // 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 link, not overwriting old links.
     base::DictionaryValue* link = new base::DictionaryValue;
     link->SetString("rel", "http://schemas.google.com/docs/2007#parent");
     link->SetString(
         "href", GetFakeLinkUrl(parent_resource_id).spec());
     links->Append(link);
 
     AddNewChangestamp(entry);
-    MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, HTTP_SUCCESS));
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::Bind(callback, HTTP_SUCCESS));
     return;
   }
 
-  MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+                                         base::Bind(callback, HTTP_NOT_FOUND));
 }
 
 void FakeDriveService::RemoveResourceFromDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION));
     return;
   }
 
   base::DictionaryValue* entry = FindEntryByResourceId(resource_id);
   if (entry) {
     base::ListValue* links = NULL;
     if (entry->GetList("link", &links)) {
       GURL parent_content_url = GetFakeLinkUrl(parent_resource_id);
       for (size_t i = 0; i < links->GetSize(); ++i) {
         base::DictionaryValue* link = NULL;
         std::string rel;
         std::string href;
         if (links->GetDictionary(i, &link) &&
             link->GetString("rel", &rel) &&
             link->GetString("href", &href) &&
             rel == "http://schemas.google.com/docs/2007#parent" &&
             GURL(href) == parent_content_url) {
           links->Remove(i, NULL);
           AddNewChangestamp(entry);
-          MessageLoop::current()->PostTask(
+          base::MessageLoop::current()->PostTask(
               FROM_HERE, base::Bind(callback, HTTP_SUCCESS));
           return;
         }
       }
     }
   }
 
-  MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+                                         base::Bind(callback, HTTP_NOT_FOUND));
 }
 
 void FakeDriveService::AddNewDirectory(
     const std::string& parent_resource_id,
     const std::string& directory_name,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
     scoped_ptr<ResourceEntry> null;
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback,
-                   GDATA_NO_CONNECTION,
-                   base::Passed(&null)));
+        base::Bind(callback, GDATA_NO_CONNECTION, base::Passed(&null)));
     return;
   }
 
   const char kContentType[] = "application/atom+xml;type=feed";
   const base::DictionaryValue* new_entry = AddNewEntry(kContentType,
                                                        0,  // content_length
                                                        parent_resource_id,
                                                        directory_name,
                                                        false,  // shared_with_me
                                                        "folder");
   if (!new_entry) {
     scoped_ptr<ResourceEntry> null;
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
     return;
   }
 
   scoped_ptr<ResourceEntry> parsed_entry(ResourceEntry::CreateFrom(*new_entry));
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_CREATED, base::Passed(&parsed_entry)));
 }
 
 void FakeDriveService::InitiateUploadNewFile(
     const base::FilePath& drive_file_path,
     const std::string& content_type,
     int64 content_length,
     const std::string& parent_resource_id,
     const std::string& title,
     const InitiateUploadCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
     return;
   }
 
   // Content length should be zero, as we'll create an empty file first. The
   // content will be added in ResumeUpload().
   const base::DictionaryValue* new_entry = AddNewEntry(content_type,
                                                        0,  // content_length
                                                        parent_resource_id,
                                                        title,
                                                        false,  // shared_with_me
                                                        "file");
   if (!new_entry) {
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, HTTP_NOT_FOUND, GURL()));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND, GURL()));
     return;
   }
   const GURL upload_url = GetUploadUrl(*new_entry);
   DCHECK(upload_url.is_valid());
 
-  MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(callback, HTTP_SUCCESS, upload_url));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, HTTP_SUCCESS, upload_url));
 }
 
 void FakeDriveService::InitiateUploadExistingFile(
     const base::FilePath& drive_file_path,
     const std::string& content_type,
     int64 content_length,
     const std::string& resource_id,
     const std::string& etag,
     const InitiateUploadCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
     return;
   }
 
   DictionaryValue* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, HTTP_NOT_FOUND, GURL()));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND, GURL()));
     return;
   }
 
   std::string entry_etag;
   entry->GetString("gd$etag", &entry_etag);
   if (!etag.empty() && etag != entry_etag) {
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, HTTP_PRECONDITION, GURL()));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, HTTP_PRECONDITION, GURL()));
     return;
   }
   entry->SetString("docs$size.$t", "0");
 
   const GURL upload_url = GetUploadUrl(*entry);
   DCHECK(upload_url.is_valid());
 
-  MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(callback, HTTP_SUCCESS, upload_url));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, HTTP_SUCCESS, upload_url));
 }
 
 void FakeDriveService::GetUploadStatus(
     UploadMode upload_mode,
     const base::FilePath& drive_file_path,
     const GURL& upload_url,
     int64 content_length,
     const UploadRangeCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 }
 
 void FakeDriveService::ResumeUpload(
       UploadMode upload_mode,
       const base::FilePath& drive_file_path,
       const GURL& upload_url,
       int64 start_position,
       int64 end_position,
       int64 content_length,
       const std::string& content_type,
       const scoped_refptr<net::IOBuffer>& buf,
       const UploadRangeCallback& callback,
       const ProgressCallback& progress_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   scoped_ptr<ResourceEntry> result_entry;
 
   if (offline_) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
-                   UploadRangeResponse(GDATA_NO_CONNECTION,
-                                       start_position,
-                                       end_position),
+                   UploadRangeResponse(
+                       GDATA_NO_CONNECTION, start_position, end_position),
                    base::Passed(&result_entry)));
     return;
   }
 
   DictionaryValue* entry = NULL;
   entry = FindEntryByUploadUrl(upload_url);
   if (!entry) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback,
-                   UploadRangeResponse(HTTP_NOT_FOUND,
-                                       start_position,
-                                       end_position),
-                   base::Passed(&result_entry)));
+        base::Bind(
+            callback,
+            UploadRangeResponse(HTTP_NOT_FOUND, start_position, end_position),
+            base::Passed(&result_entry)));
     return;
   }
 
   // Chunks are required to be sent in such a ways that they fill from the start
   // of the not-yet-uploaded part with no gaps nor overlaps.
   std::string current_size_string;
   int64 current_size;
   if (!entry->GetString("docs$size.$t", &current_size_string) ||
       !base::StringToInt64(current_size_string, &current_size) ||
       current_size != start_position) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback,
-                   UploadRangeResponse(HTTP_BAD_REQUEST,
-                                       start_position,
-                                       end_position),
-                   base::Passed(&result_entry)));
+        base::Bind(
+            callback,
+            UploadRangeResponse(HTTP_BAD_REQUEST, start_position, end_position),
+            base::Passed(&result_entry)));
     return;
   }
 
   entry->SetString("docs$size.$t", base::Int64ToString(end_position));
 
   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;
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(progress_callback, chunk_size / 2, chunk_size));
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(progress_callback, chunk_size, chunk_size));
   }
 
   if (content_length != end_position) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
-                   UploadRangeResponse(HTTP_RESUME_INCOMPLETE,
-                                       start_position,
-                                       end_position),
-                    base::Passed(&result_entry)));
+                   UploadRangeResponse(
+                       HTTP_RESUME_INCOMPLETE, start_position, end_position),
+                   base::Passed(&result_entry)));
     return;
   }
 
   result_entry = ResourceEntry::CreateFrom(*entry).Pass();
 
   GDataErrorCode return_code = HTTP_SUCCESS;
   if (upload_mode == UPLOAD_NEW_FILE)
     return_code = HTTP_CREATED;
 
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
-                 UploadRangeResponse(return_code,
-                                     start_position,
-                                     end_position),
+                 UploadRangeResponse(return_code, start_position, end_position),
                  base::Passed(&result_entry)));
 }
 
 void FakeDriveService::AuthorizeApp(const std::string& resource_id,
                                     const std::string& app_id,
                                     const AuthorizeAppCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 }
 
 void FakeDriveService::AddNewFile(const std::string& content_type,
                                   int64 content_length,
                                   const std::string& parent_resource_id,
                                   const std::string& title,
                                   bool shared_with_me,
                                   const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
     scoped_ptr<ResourceEntry> null;
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback,
-                   GDATA_NO_CONNECTION,
-                   base::Passed(&null)));
+        base::Bind(callback, GDATA_NO_CONNECTION, base::Passed(&null)));
     return;
   }
 
   // Prepare "kind" for hosted documents. This only supports Google Document.
   std::string entry_kind;
   if (content_type == "application/vnd.google-apps.document")
     entry_kind = "document";
   else
     entry_kind = "file";
 
   const base::DictionaryValue* new_entry = AddNewEntry(content_type,
                                                        content_length,
                                                        parent_resource_id,
                                                        title,
                                                        shared_with_me,
                                                        entry_kind);
   if (!new_entry) {
     scoped_ptr<ResourceEntry> null;
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
     return;
   }
 
   scoped_ptr<ResourceEntry> parsed_entry(
       ResourceEntry::CreateFrom(*new_entry));
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_CREATED, base::Passed(&parsed_entry)));
 }
 
 void FakeDriveService::SetLastModifiedTime(
     const std::string& resource_id,
     const base::Time& last_modified_time,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (offline_) {
     scoped_ptr<ResourceEntry> null;
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback,
-                   GDATA_NO_CONNECTION,
-                   base::Passed(&null)));
+        base::Bind(callback, GDATA_NO_CONNECTION, base::Passed(&null)));
     return;
   }
 
   base::DictionaryValue* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
     scoped_ptr<ResourceEntry> null;
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
     return;
   }
 
   entry->SetString("updated.$t", util::FormatTimeAsString(last_modified_time));
 
   scoped_ptr<ResourceEntry> parsed_entry(
       ResourceEntry::CreateFrom(*entry));
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS, base::Passed(&parsed_entry)));
 }
 
 base::DictionaryValue* FakeDriveService::FindEntryByResourceId(
     const std::string& resource_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::DictionaryValue* resource_list_dict = NULL;
   base::ListValue* entries = NULL;
@@ skipping 180 matching lines @@
 
 void FakeDriveService::GetResourceListInternal(
     int64 start_changestamp,
     const std::string& search_query,
     const std::string& directory_resource_id,
     int start_offset,
     int max_results,
     const GetResourceListCallback& callback) {
   if (offline_) {
     scoped_ptr<ResourceList> null;
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback,
-                   GDATA_NO_CONNECTION,
-                   base::Passed(&null)));
+        base::Bind(callback, GDATA_NO_CONNECTION, base::Passed(&null)));
     return;
   }
 
   scoped_ptr<ResourceList> resource_list =
       ResourceList::CreateFrom(*resource_list_value_);
 
   // Filter out entries per parameters like |directory_resource_id| and
   // |search_query|.
   ScopedVector<ResourceEntry>* entries = resource_list->mutable_entries();
 
@@ skipping 74 matching lines @@
           next_url, "parent", directory_resource_id);
     }
 
     Link* link = new Link;
     link->set_type(Link::LINK_NEXT);
     link->set_href(next_url);
     resource_list->mutable_links()->push_back(link);
   }
 
   ++resource_list_load_count_;
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(callback,
-                 HTTP_SUCCESS,
-                 base::Passed(&resource_list)));
+      base::Bind(callback, HTTP_SUCCESS, base::Passed(&resource_list)));
 }
 
 }  // namespace google_apis