webkit: Use base::MessageLoop.

webkit/appcache/appcache_response_unittest.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 <stack>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 45 matching lines @@
   // Helper callback to run a test on our io_thread. The io_thread is spun up
   // once and reused for all tests.
   template <class Method>
   void MethodWrapper(Method method) {
     SetUpTest();
     (this->*method)();
   }
 
   static void SetUpTestCase() {
     io_thread_.reset(new base::Thread("AppCacheResponseTest Thread"));
-    base::Thread::Options options(MessageLoop::TYPE_IO, 0);
+    base::Thread::Options options(base::MessageLoop::TYPE_IO, 0);
     io_thread_->StartWithOptions(options);
   }
 
   static void TearDownTestCase() {
     io_thread_.reset(NULL);
   }
 
   AppCacheResponseTest() {}
 
   template <class Method>
   void RunTestOnIOThread(Method method) {
     test_finished_event_ .reset(new base::WaitableEvent(false, false));
     io_thread_->message_loop()->PostTask(
         FROM_HERE, base::Bind(&AppCacheResponseTest::MethodWrapper<Method>,
                               base::Unretained(this), method));
     test_finished_event_->Wait();
   }
 
   void SetUpTest() {
-    DCHECK(MessageLoop::current() == io_thread_->message_loop());
+    DCHECK(base::MessageLoop::current() == io_thread_->message_loop());
     DCHECK(task_stack_.empty());
     storage_delegate_.reset(new MockStorageDelegate(this));
     service_.reset(new MockAppCacheService());
     expected_read_result_ = 0;
     expected_write_result_ = 0;
     written_response_id_ = 0;
     should_delete_reader_in_completion_callback_ = false;
     should_delete_writer_in_completion_callback_ = false;
     reader_deletion_count_down_ = 0;
     writer_deletion_count_down_ = 0;
     read_callback_was_called_ = false;
     write_callback_was_called_ = false;
   }
 
   void TearDownTest() {
-    DCHECK(MessageLoop::current() == io_thread_->message_loop());
+    DCHECK(base::MessageLoop::current() == io_thread_->message_loop());
     while (!task_stack_.empty())
       task_stack_.pop();
 
     reader_.reset();
     read_buffer_ = NULL;
     read_info_buffer_ = NULL;
     writer_.reset();
     write_buffer_ = NULL;
     write_info_buffer_ = NULL;
     storage_delegate_.reset();
     service_.reset();
   }
 
   void TestFinished() {
     // We unwind the stack prior to finishing up to let stack
     // based objects get deleted.
-    DCHECK(MessageLoop::current() == io_thread_->message_loop());
-    MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&AppCacheResponseTest::TestFinishedUnwound,
-                              base::Unretained(this)));
+    DCHECK(base::MessageLoop::current() == io_thread_->message_loop());
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,

[brettw, 2013/04/30 21:56:47]

"

[xhwang, 2013/05/06 16:33:12]

Done.

+        base::Bind(&AppCacheResponseTest::TestFinishedUnwound,
+                   base::Unretained(this)));
   }
 
   void TestFinishedUnwound() {
     TearDownTest();
     test_finished_event_->Signal();
   }
 
   void PushNextTask(const base::Closure& task) {
     task_stack_.push(std::pair<base::Closure, bool>(task, false));
   }
 
   void PushNextTaskAsImmediate(const base::Closure& task) {
     task_stack_.push(std::pair<base::Closure, bool>(task, true));
   }
 
   void ScheduleNextTask() {
-    DCHECK(MessageLoop::current() == io_thread_->message_loop());
+    DCHECK(base::MessageLoop::current() == io_thread_->message_loop());
     if (task_stack_.empty()) {
       TestFinished();
       return;
     }
     base::Closure task = task_stack_.top().first;
     bool immediate = task_stack_.top().second;
     task_stack_.pop();
     if (immediate)
       task.Run();
     else
-      MessageLoop::current()->PostTask(FROM_HERE, task);
+      base::MessageLoop::current()->PostTask(FROM_HERE, task);
   }
 
   // Wrappers to call AppCacheResponseReader/Writer Read and Write methods
 
   void WriteBasicResponse() {
     static const char kHttpHeaders[] =
         "HTTP/1.0 200 OK\0Content-Length: 5\0\0";
     static const char* kHttpBody = "Hello";
     scoped_refptr<IOBuffer> body(new WrappedIOBuffer(kHttpBody));
     std::string raw_headers(kHttpHeaders, arraysize(kHttpHeaders));
@@ skipping 473 matching lines @@
 
   void ReadThenDelete() {
     read_callback_was_called_ = false;
     reader_.reset(service_->storage()->CreateResponseReader(
         GURL(), 0, written_response_id_));
     ReadResponseBody(new IOBuffer(kBlockSize), kBlockSize);
     EXPECT_TRUE(reader_->IsReadPending());
     reader_.reset();
 
     // Wait a moment to verify no callbacks.
-    MessageLoop::current()->PostDelayedTask(
-        FROM_HERE, base::Bind(&AppCacheResponseTest::VerifyNoCallbacks,
-                              base::Unretained(this)),
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,

[brettw, 2013/04/30 21:56:47]

"

[xhwang, 2013/05/06 16:33:12]

Done.

+        base::Bind(&AppCacheResponseTest::VerifyNoCallbacks,
+                   base::Unretained(this)),
         base::TimeDelta::FromMilliseconds(10));
   }
 
   void VerifyNoCallbacks() {
     EXPECT_TRUE(!write_callback_was_called_);
     EXPECT_TRUE(!read_callback_was_called_);
     TestFinished();
   }
 
   // Data members
@@ skipping 52 matching lines @@
 
 TEST_F(AppCacheResponseTest, DeleteWithinCallbacks) {
   RunTestOnIOThread(&AppCacheResponseTest::DeleteWithinCallbacks);
 }
 
 TEST_F(AppCacheResponseTest, DeleteWithIOPending) {
   RunTestOnIOThread(&AppCacheResponseTest::DeleteWithIOPending);
 }
 
 }  // namespace appcache