Remove calls to deprecated MessageLoop methods in jingle.

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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::InvokeWithoutArgs;
 using ::testing::Mock;
 
@@ skipping 93 matching lines @@
   EXPECT_CALL(handler1_, OnMessage(
       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_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ThreadWrapperTest, PostDelayed) {
   rtc::MessageData* data1 = new rtc::MessageData();
   rtc::MessageData* data2 = new rtc::MessageData();
   rtc::MessageData* data3 = new rtc::MessageData();
   rtc::MessageData* data4 = new rtc::MessageData();
 
   thread_->PostDelayed(RTC_FROM_HERE, kTestDelayMs1, &handler1_, kTestMessage1,
                        data1);
@@ skipping 12 matching lines @@
   EXPECT_CALL(handler1_, OnMessage(
       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(
+  message_loop_.task_runner()->PostDelayedTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
       base::TimeDelta::FromMilliseconds(kMaxTestDelay));
-  message_loop_.Run();
+  base::RunLoop().Run();
 }
 
 TEST_F(ThreadWrapperTest, Clear) {
   thread_->Post(RTC_FROM_HERE, &handler1_, kTestMessage1, NULL);
   thread_->Post(RTC_FROM_HERE, &handler1_, kTestMessage2, NULL);
   thread_->Post(RTC_FROM_HERE, &handler2_, kTestMessage1, NULL);
   thread_->Post(RTC_FROM_HERE, &handler2_, kTestMessage2, NULL);
 
   thread_->Clear(&handler1_, kTestMessage2);
 
   InSequence in_seq;
 
   rtc::MessageData* null_data = NULL;
   EXPECT_CALL(handler1_, OnMessage(
       MatchMessage(&handler1_, kTestMessage1, null_data)))
       .WillOnce(DeleteMessageData());
   EXPECT_CALL(handler2_, OnMessage(
       MatchMessage(&handler2_, kTestMessage1, null_data)))
       .WillOnce(DeleteMessageData());
   EXPECT_CALL(handler2_, OnMessage(
       MatchMessage(&handler2_, kTestMessage2, null_data)))
       .WillOnce(DeleteMessageData());
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ThreadWrapperTest, ClearDelayed) {
   thread_->PostDelayed(RTC_FROM_HERE, kTestDelayMs1, &handler1_, kTestMessage1,
                        NULL);
   thread_->PostDelayed(RTC_FROM_HERE, kTestDelayMs2, &handler1_, kTestMessage2,
                        NULL);
   thread_->PostDelayed(RTC_FROM_HERE, kTestDelayMs3, &handler2_, kTestMessage1,
                        NULL);
   thread_->PostDelayed(RTC_FROM_HERE, kTestDelayMs4, &handler2_, kTestMessage1,
                        NULL);
 
   thread_->Clear(&handler1_, kTestMessage2);
 
   InSequence in_seq;
 
   rtc::MessageData* null_data = NULL;
   EXPECT_CALL(handler1_, OnMessage(
       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(
+  message_loop_.task_runner()->PostDelayedTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
       base::TimeDelta::FromMilliseconds(kMaxTestDelay));
-  message_loop_.Run();
+  base::RunLoop().Run();
 }
 
 // Verify that the queue is cleared when a handler is destroyed.
 TEST_F(ThreadWrapperTest, ClearDestroyed) {
   MockMessageHandler* handler_ptr;
   {
     MockMessageHandler handler;
     handler_ptr = &handler;
     thread_->Post(RTC_FROM_HERE, &handler, kTestMessage1, NULL);
   }
@@ skipping 26 matching lines @@
 TEST_F(ThreadWrapperTest, SendToOtherThread) {
   JingleThreadWrapper::current()->set_send_allowed(true);
 
   base::Thread second_thread("JingleThreadWrapperTest");
   second_thread.Start();
 
   base::WaitableEvent initialized_event(
       base::WaitableEvent::ResetPolicy::MANUAL,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   rtc::Thread* target;
-  second_thread.message_loop()->PostTask(
-      FROM_HERE, base::Bind(&InitializeWrapperForNewThread,
-                            &target, &initialized_event));
+  second_thread.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&InitializeWrapperForNewThread, &target, &initialized_event));
   initialized_event.Wait();
 
   ASSERT_TRUE(target != NULL);
 
   rtc::MessageData* data = new rtc::MessageData();
 
   EXPECT_CALL(handler1_, OnMessage(
       MatchMessage(&handler1_, kTestMessage1, data)))
       .WillOnce(DeleteMessageData());
   target->Send(RTC_FROM_HERE, &handler1_, kTestMessage1, data);
 
   Mock::VerifyAndClearExpectations(&handler1_);
 }
 
 // Verify that thread handles Send() while another Send() is
 // pending. The test creates second thread and Send()s kTestMessage1
 // to that thread. kTestMessage1 handler calls PingMainThread() which
 // tries to Send() kTestMessage2 to the main thread.
 TEST_F(ThreadWrapperTest, SendDuringSend) {
   JingleThreadWrapper::current()->set_send_allowed(true);
 
   base::Thread second_thread("JingleThreadWrapperTest");
   second_thread.Start();
 
   base::WaitableEvent initialized_event(
       base::WaitableEvent::ResetPolicy::MANUAL,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   rtc::Thread* target;
-  second_thread.message_loop()->PostTask(
-      FROM_HERE, base::Bind(&InitializeWrapperForNewThread,
-                            &target, &initialized_event));
+  second_thread.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&InitializeWrapperForNewThread, &target, &initialized_event));
   initialized_event.Wait();
 
   ASSERT_TRUE(target != NULL);
 
   rtc::MessageData* data = new rtc::MessageData();
 
   EXPECT_CALL(handler1_, OnMessage(
       MatchMessage(&handler1_, kTestMessage1, data)))
       .WillOnce(DoAll(
           InvokeWithoutArgs(
               this, &ThreadWrapperTest::PingMainThread),
           DeleteMessageData()));
   target->Send(RTC_FROM_HERE, &handler1_, kTestMessage1, data);
 
   Mock::VerifyAndClearExpectations(&handler1_);
 }
 
 TEST_F(ThreadWrapperTest, Dispose) {
   bool deleted_ = false;
   thread_->Dispose(new DeletableObject(&deleted_));
   EXPECT_FALSE(deleted_);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(deleted_);
 }
 
 }  // namespace jingle_glue