jingle: Use base::MessageLoop.

jingle/glue/thread_wrapper_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 "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 68 matching lines @@
   ThreadWrapperTest()
       : thread_(NULL) {
   }
 
   virtual void SetUp() OVERRIDE {
     JingleThreadWrapper::EnsureForCurrentMessageLoop();
     thread_ = talk_base::Thread::Current();
   }
 
   // ThreadWrapper destroyes itself when |message_loop_| is destroyed.
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
   talk_base::Thread* thread_;
   MockMessageHandler handler1_;
   MockMessageHandler handler2_;
 };
 
 TEST_F(ThreadWrapperTest, Post) {
   talk_base::MessageData* data1 = new talk_base::MessageData();
   talk_base::MessageData* data2 = new talk_base::MessageData();
   talk_base::MessageData* data3 = new talk_base::MessageData();
   talk_base::MessageData* data4 = new talk_base::MessageData();
@@ skipping 41 matching lines @@
       MatchMessage(&handler1_, kTestMessage2, data2)))
       .WillOnce(DeleteMessageData());
   EXPECT_CALL(handler2_, OnMessage(
       MatchMessage(&handler2_, kTestMessage1, data3)))
       .WillOnce(DeleteMessageData());
   EXPECT_CALL(handler2_, OnMessage(
       MatchMessage(&handler2_, kTestMessage1, data4)))
       .WillOnce(DeleteMessageData());
 
   message_loop_.PostDelayedTask(
-      FROM_HERE, MessageLoop::QuitClosure(),
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
       base::TimeDelta::FromMilliseconds(kMaxTestDelay));
   message_loop_.Run();

[awong, 2013/04/27 00:35:04]

Use a RunLoop?

 }
 
 TEST_F(ThreadWrapperTest, Clear) {
   thread_->Post(&handler1_, kTestMessage1, NULL);
   thread_->Post(&handler1_, kTestMessage2, NULL);
   thread_->Post(&handler2_, kTestMessage1, NULL);
   thread_->Post(&handler2_, kTestMessage2, NULL);
 
   thread_->Clear(&handler1_, kTestMessage2);
 
@@ skipping 28 matching lines @@
       MatchMessage(&handler1_, kTestMessage1, null_data)))
       .WillOnce(DeleteMessageData());
   EXPECT_CALL(handler2_, OnMessage(
       MatchMessage(&handler2_, kTestMessage1, null_data)))
       .WillOnce(DeleteMessageData());
   EXPECT_CALL(handler2_, OnMessage(
       MatchMessage(&handler2_, kTestMessage1, null_data)))
       .WillOnce(DeleteMessageData());
 
   message_loop_.PostDelayedTask(
-      FROM_HERE, MessageLoop::QuitClosure(),
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
       base::TimeDelta::FromMilliseconds(kMaxTestDelay));
   message_loop_.Run();
 }
 
 // Verify that the queue is cleared when a handler is destroyed.
 TEST_F(ThreadWrapperTest, ClearDestoroyed) {
   MockMessageHandler* handler_ptr;
   {
     MockMessageHandler handler;
     handler_ptr = &handler;
@@ skipping 84 matching lines @@
 
 TEST_F(ThreadWrapperTest, Dispose) {
   bool deleted_;
   thread_->Dispose(new DeletableObject(&deleted_));
   EXPECT_FALSE(deleted_);
   message_loop_.RunUntilIdle();
   EXPECT_TRUE(deleted_);
 }
 
 }  // namespace jingle_glue