webkit: Use base::MessageLoop.

webkit/fileapi/syncable/canned_syncable_file_system.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/fileapi/syncable/canned_syncable_file_system.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
@@ skipping 22 matching lines @@
 using fileapi::FileSystemURL;
 using fileapi::FileSystemURLSet;
 using quota::QuotaManager;
 using webkit_blob::MockBlobURLRequestContext;
 using webkit_blob::ScopedTextBlob;
 
 namespace sync_file_system {
 
 namespace {
 
-void Quit() { MessageLoop::current()->Quit(); }
+void Quit() { base::MessageLoop::current()->Quit(); }
 
 template <typename R>
 void AssignAndQuit(base::TaskRunner* original_task_runner,
                    R* result_out, R result) {
   DCHECK(result_out);
   *result_out = result;
   original_task_runner->PostTask(FROM_HERE, base::Bind(&Quit));
 }
 
 template <typename R>
 R RunOnThread(
     base::SingleThreadTaskRunner* task_runner,
     const tracked_objects::Location& location,
     const base::Callback<void(const base::Callback<void(R)>& callback)>& task) {
   R result;
   task_runner->PostTask(
       location,
       base::Bind(task, base::Bind(&AssignAndQuit<R>,
                                   base::MessageLoopProxy::current(),
                                   &result)));
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
   return result;
 }
 
 void RunOnThread(base::SingleThreadTaskRunner* task_runner,
                  const tracked_objects::Location& location,
                  const base::Closure& task) {
   task_runner->PostTaskAndReply(
       location, task,
       base::Bind(base::IgnoreResult(
           base::Bind(&base::MessageLoopProxy::PostTask,
                      base::MessageLoopProxy::current(),
                      FROM_HERE, base::Bind(&Quit)))));
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 }
 
 void EnsureRunningOn(base::SingleThreadTaskRunner* runner) {
   EXPECT_TRUE(runner->RunsTasksOnCurrentThread());
 }
 
 void VerifySameTaskRunner(
     base::SingleThreadTaskRunner* runner1,
     base::SingleThreadTaskRunner* runner2) {
   ASSERT_TRUE(runner1 != NULL);
@@ skipping 38 matching lines @@
  public:
   WriteHelper() : bytes_written_(0) {}
   WriteHelper(MockBlobURLRequestContext* request_context,
               const GURL& blob_url,
               const std::string& blob_data)
       : bytes_written_(0),
         request_context_(request_context),
         blob_data_(new ScopedTextBlob(*request_context, blob_url, blob_data)) {}
 
   ~WriteHelper() {
     if (request_context_)

[brettw, 2013/05/06 17:43:33]

Can you add {} for this (since it's multi-line)?

[xhwang, 2013/05/07 00:11:07]

Done.

-      MessageLoop::current()->DeleteSoon(FROM_HERE, request_context_.release());
+      base::MessageLoop::current()->DeleteSoon(FROM_HERE,
+                                               request_context_.release());
   }
 
   void DidWrite(const base::Callback<void(int64 result)>& completion_callback,
                 PlatformFileError error, int64 bytes, bool complete) {
     if (error == base::PLATFORM_FILE_OK) {
       bytes_written_ += bytes;
       if (!complete)
         return;
     }
     completion_callback.Run(error == base::PLATFORM_FILE_OK
@@ skipping 95 matching lines @@
   return file_system_context_->CrackURL(url);
 }
 
 PlatformFileError CannedSyncableFileSystem::OpenFileSystem() {
   EXPECT_TRUE(is_filesystem_set_up_);
   EXPECT_FALSE(is_filesystem_opened_);
   file_system_context_->OpenSyncableFileSystem(
       service_name_, origin_, type_, true /* create */,
       base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
   if (file_system_context_->sync_context()) {
     // Register 'this' as a sync status observer.
     RunOnThread(io_task_runner_,
                 FROM_HERE,
                 base::Bind(
                     &CannedSyncableFileSystem::InitializeSyncStatusObserver,
                     base::Unretained(this)));
   }
   return result_;
 }
@@ skipping 10 matching lines @@
 
 SyncStatusCode CannedSyncableFileSystem::MaybeInitializeFileSystemContext(
     LocalFileSyncContext* sync_context) {
   DCHECK(sync_context);
   sync_status_ = sync_file_system::SYNC_STATUS_UNKNOWN;
   VerifySameTaskRunner(io_task_runner_, sync_context->io_task_runner_);
   sync_context->MaybeInitializeFileSystemContext(
       origin_, service_name_, file_system_context_,
       base::Bind(&CannedSyncableFileSystem::DidInitializeFileSystemContext,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
   return sync_status_;
 }
 
 PlatformFileError CannedSyncableFileSystem::CreateDirectory(
     const FileSystemURL& url) {
   return RunOnThread<PlatformFileError>(
       io_task_runner_,
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoCreateDirectory,
                  base::Unretained(this), url));
@@ skipping 285 matching lines @@
   quota_manager_->GetUsageAndQuota(
       origin_, storage_type(),
       base::Bind(&DidGetUsageAndQuota, callback, usage, quota));
 }
 
 void CannedSyncableFileSystem::DidOpenFileSystem(
     PlatformFileError result, const std::string& name, const GURL& root) {
   result_ = result;
   root_url_ = root;
   is_filesystem_opened_ = true;
-  MessageLoop::current()->Quit();
+  base::MessageLoop::current()->Quit();
 }
 
 void CannedSyncableFileSystem::DidInitializeFileSystemContext(
     SyncStatusCode status) {
   sync_status_ = status;
-  MessageLoop::current()->Quit();
+  base::MessageLoop::current()->Quit();
 }
 
 void CannedSyncableFileSystem::InitializeSyncStatusObserver() {
   ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   file_system_context_->sync_context()->sync_status()->AddObserver(this);
 }
 
 }  // namespace sync_file_system