Remove calls to deprecated MessageLoop methods in sync.

sync/internal_api/public/util/weak_handle_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 "sync/internal_api/public/util/weak_handle.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 using ::testing::_;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
@@ skipping 31 matching lines @@
   }
 
   void PumpLoop() {
     base::RunLoop().RunUntilIdle();
   }
 
   static void CallTestFromOtherThread(tracked_objects::Location from_here,
                                       const WeakHandle<Base>& h) {
     base::Thread t("Test thread");
     ASSERT_TRUE(t.Start());
-    t.message_loop()->PostTask(
+    t.task_runner()->PostTask(
         from_here, base::Bind(&WeakHandleTest::CallTest, from_here, h));
   }
 
  private:
   static void CallTest(tracked_objects::Location from_here,
                        const WeakHandle<Base>& h) {
     h.Call(from_here, &Base::Test);
   }
 
   base::MessageLoop message_loop_;
@@ skipping 119 matching lines @@
 
 TEST_F(WeakHandleTest, DeleteOnOtherThread) {
   StrictMock<Base> b;
   EXPECT_CALL(b, Test()).Times(0);
 
   WeakHandle<Base>* h = new WeakHandle<Base>(b.AsWeakHandle());
 
   {
     base::Thread t("Test thread");
     ASSERT_TRUE(t.Start());
-    t.message_loop()->DeleteSoon(FROM_HERE, h);
+    t.task_runner()->DeleteSoon(FROM_HERE, h);
   }
 
   PumpLoop();
 }
 
 void CallTestWithSelf(const WeakHandle<Base>& b1) {
   StrictMock<Base> b2;
   b1.Call(FROM_HERE, &Base::TestWithSelf, b2.AsWeakHandle());
 }
 
 TEST_F(WeakHandleTest, WithDestroyedThread) {
   StrictMock<Base> b1;
   WeakHandle<Base> b2;
   EXPECT_CALL(b1, TestWithSelf(_)).WillOnce(SaveArg<0>(&b2));
 
   {
     base::Thread t("Test thread");
     ASSERT_TRUE(t.Start());
-    t.message_loop()->PostTask(FROM_HERE,
-                               base::Bind(&CallTestWithSelf,
-                                          b1.AsWeakHandle()));
+    t.task_runner()->PostTask(FROM_HERE,
+                              base::Bind(&CallTestWithSelf, b1.AsWeakHandle()));
   }
 
   // Calls b1.TestWithSelf().
   PumpLoop();
 
   // Shouldn't do anything, since the thread is gone.
   b2.Call(FROM_HERE, &Base::Test);
 
   // |b2| shouldn't leak when it's destroyed, even if the original
   // thread is gone.
@@ skipping 82 matching lines @@
   EXPECT_FALSE(base_weak_handle.IsInitialized());
 }
 
 TEST_F(WeakHandleTest, TypeConversionConstructorUninitializedAssignment) {
   WeakHandle<Base> base_weak_handle;
   base_weak_handle = WeakHandle<Derived>();
   EXPECT_FALSE(base_weak_handle.IsInitialized());
 }
 
 }  // namespace syncer