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/logging.h"
 #include "base/message_loop.h"
@@ skipping 352 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)));
     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(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
 }
 
 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)));
     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)));
 }
 
 void FakeDriveService::GetAppList(const GetAppListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(app_info_value_);
 
   if (offline_) {
     scoped_ptr<AppList> null;
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    GDATA_NO_CONNECTION,
                    base::Passed(&null)));
     return;
   }
 
   scoped_ptr<AppList> app_list(AppList::CreateFrom(*app_info_value_));
-  MessageLoop::current()->PostTask(
+  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(
+  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()));
     return;
   }
 
   // The field content.src is the URL to download the file.
   base::DictionaryValue* entry = FindEntryByContentUrl(download_url);
   if (!entry) {
@@ skipping 60 matching lines @@
 void FakeDriveService::CopyResource(
     const std::string& resource_id,
     const std::string& in_parent_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)));
     return;
   }
 
   const std::string& parent_resource_id = in_parent_resource_id.empty() ?
       GetRootResourceId() : in_parent_resource_id;
 
@@ skipping 29 matching lines @@
         links->Append(link);
 
         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)));
         return;
       }
     }
   }
 
   scoped_ptr<ResourceEntry> null;
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
 }
 
 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());
 
   CopyResource(resource_id, std::string(), new_name, callback);
 }
 
 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(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_SUCCESS));
     return;
   }
 
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(callback, HTTP_NOT_FOUND));
 }
 
 void FakeDriveService::TouchResource(
     const std::string& resource_id,
     const base::Time& modified_date,
     const base::Time& last_viewed_by_me_date,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!modified_date.is_null());
   DCHECK(!last_viewed_by_me_date.is_null());
   DCHECK(!callback.is_null());
 
   if (offline_) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, GDATA_NO_CONNECTION,
                    base::Passed(scoped_ptr<ResourceEntry>())));
     return;
   }
 
   base::DictionaryValue* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND,
                    base::Passed(scoped_ptr<ResourceEntry>())));
     return;
   }
 
   entry->SetString("updated.$t",
                    util::FormatTimeAsString(modified_date));
   entry->SetString("gd$lastViewed.$t",
                    util::FormatTimeAsString(last_viewed_by_me_date));
   AddNewChangestamp(entry);
 
   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)));
 }
 
 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(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, HTTP_SUCCESS));
     return;
   }
 
-  MessageLoop::current()->PostTask(
+  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(
+  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)));
     return;
   }
 
   const char kContentType[] = "application/atom+xml;type=feed";
   const base::DictionaryValue* new_entry = AddNewEntry(kContentType,
                                                        "",  // content_data
                                                        parent_resource_id,
                                                        directory_name,
                                                        false,  // shared_with_me
                                                        "folder");
   if (!new_entry) {
     scoped_ptr<ResourceEntry> null;
-    MessageLoop::current()->PostTask(
+    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(
+    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,
                                                        "",  // content_data
                                                        parent_resource_id,
                                                        title,
                                                        false,  // shared_with_me
                                                        "file");
   if (!new_entry) {
-    MessageLoop::current()->PostTask(
+    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(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS,
                  net::AppendQueryParameter(upload_url, "mode", "newfile")));
 
 }
 
 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(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, GDATA_NO_CONNECTION, GURL()));
     return;
   }
 
   DictionaryValue* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
-    MessageLoop::current()->PostTask(
+    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(
+    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(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS,
                  net::AppendQueryParameter(upload_url, "mode", "existing")));
 }
 
 void FakeDriveService::GetUploadStatus(
     const base::FilePath& drive_file_path,
     const GURL& upload_url,
     int64 content_length,
     const UploadRangeCallback& callback) {
@@ skipping 10 matching lines @@
       const std::string& content_type,
       const base::FilePath& local_file_path,
       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),
                    base::Passed(&result_entry)));
     return;
   }
 
   DictionaryValue* entry = NULL;
   entry = FindEntryByUploadUrl(RemoveQueryParameter(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)));
     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)));
     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)));
     return;
   }
 
   AddNewChangestamp(entry);
   result_entry = ResourceEntry::CreateFrom(*entry).Pass();
 
   std::string upload_mode;
   bool upload_mode_found =
       net::GetValueForKeyInQuery(upload_url, "mode", &upload_mode);
   DCHECK(upload_mode_found &&
          (upload_mode == "newfile" || upload_mode == "existing"));
 
   GDataErrorCode return_code =
       upload_mode == "newfile" ? HTTP_CREATED : HTTP_SUCCESS;
 
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  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,
                                   const std::string& content_data,
                                   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)));
     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_data,
                                                        parent_resource_id,
                                                        title,
                                                        shared_with_me,
                                                        entry_kind);
   if (!new_entry) {
     scoped_ptr<ResourceEntry> null;
-    MessageLoop::current()->PostTask(
+    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)));
     return;
   }
 
   base::DictionaryValue* entry = FindEntryByResourceId(resource_id);
   if (!entry) {
     scoped_ptr<ResourceEntry> null;
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, HTTP_NOT_FOUND, base::Passed(&null)));
     return;
   }
 
   if (last_modified_time.is_null()) {
     entry->Remove("updated.$t", NULL);
   } else {
     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 185 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,
     int* load_counter,
     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)));
     return;
   }
 
   scoped_ptr<ResourceList> resource_list =
       ResourceList::CreateFrom(*resource_list_value_);
 
@@ skipping 79 matching lines @@
     }
 
     Link* link = new Link;
     link->set_type(Link::LINK_NEXT);
     link->set_href(next_url);
     resource_list->mutable_links()->push_back(link);
   }
 
   if (load_counter)
     *load_counter += 1;
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  HTTP_SUCCESS,
                  base::Passed(&resource_list)));
 }
 
 }  // namespace google_apis