Remove calls to deprecated MessageLoop methods in ui.

ui/events/platform/platform_event_source_unittest.cc

 // Copyright 2014 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 "ui/events/platform/platform_event_source.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_observer.h"
 #include "ui/events/platform/scoped_event_dispatcher.h"
 
 namespace ui {
 
 namespace {
 
 std::unique_ptr<PlatformEvent> CreatePlatformEvent() {
@@ skipping 463 matching lines @@
   EXPECT_EQ(30, list[3]);
 }
 
 // Provides mechanism for running tests from inside an active message-loop.
 class PlatformEventTestWithMessageLoop : public PlatformEventTest {
  public:
   PlatformEventTestWithMessageLoop() {}
   ~PlatformEventTestWithMessageLoop() override {}
 
   void Run() {
-    message_loop_.PostTask(
-        FROM_HERE,
-        base::Bind(&PlatformEventTestWithMessageLoop::RunTest,
-                   base::Unretained(this)));
+    message_loop_.task_runner()->PostTask(
+        FROM_HERE, base::Bind(&PlatformEventTestWithMessageLoop::RunTest,
+                              base::Unretained(this)));
     message_loop_.Run();
   }
 
  protected:
   void RunTest() {
     RunTestImpl();
     message_loop_.QuitWhenIdle();
   }
 
   virtual void RunTestImpl() = 0;
@@ skipping 135 matching lines @@
     source()->Dispatch(*event);
     ASSERT_EQ(2u, list.size());
     EXPECT_EQ(15, list[0]);
     EXPECT_EQ(20, list[1]);
     list.clear();
 
     overriding.SetScopedHandle(std::move(override_handle));
     base::RunLoop run_loop;
     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
     base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
-    loop->PostTask(
+    loop->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(
             &DestroyedNestedOverriddenDispatcherQuitsNestedLoopIteration::
                 NestedTask,
-            base::Unretained(this),
-            base::Unretained(&list),
+            base::Unretained(this), base::Unretained(&list),
             base::Unretained(&overriding)));
     run_loop.Run();
 
     // Dispatching the event should now reach the default dispatcher.
     source()->Dispatch(*event);
     ASSERT_EQ(2u, list.size());
     EXPECT_EQ(15, list[0]);
     EXPECT_EQ(10, list[1]);
   }
 };
@@ skipping 36 matching lines @@
     EXPECT_EQ(15, (*list)[0]);
     EXPECT_EQ(70, (*list)[1]);
     list->clear();
 
     second_overriding.SetScopedHandle(std::move(second_override_handle));
     second_overriding.set_post_dispatch_action(POST_DISPATCH_NONE);
     base::RunLoop run_loop;
     second_overriding.set_callback(run_loop.QuitClosure());
     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
     base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
-    loop->PostTask(
+    loop->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&TestPlatformEventSource::Dispatch),
-                   base::Unretained(source()),
-                   *event));
+                   base::Unretained(source()), *event));
     run_loop.Run();
     ASSERT_EQ(2u, list->size());
     EXPECT_EQ(15, (*list)[0]);
     EXPECT_EQ(70, (*list)[1]);
     list->clear();
 
     // Terminate the message-loop.
     base::MessageLoopForUI::current()->QuitNow();
   }
 
@@ skipping 14 matching lines @@
     EXPECT_EQ(15, list[0]);
     EXPECT_EQ(20, list[1]);
     list.clear();
 
     // Start a nested message-loop, and destroy |override_handle| in the nested
     // loop. That should terminate the nested loop, restore the previous
     // dispatchers, and return control to this function.
     base::RunLoop run_loop;
     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
     base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
-    loop->PostTask(
+    loop->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(
             &ConsecutiveOverriddenDispatcherInTheSameMessageLoopIteration::
                 NestedTask,
-            base::Unretained(this),
-            base::Passed(&override_handle),
+            base::Unretained(this), base::Passed(&override_handle),
             base::Unretained(&list)));
     run_loop.Run();
 
     // Dispatching the event should now reach the default dispatcher.
     source()->Dispatch(*event);
     ASSERT_EQ(2u, list.size());
     EXPECT_EQ(15, list[0]);
     EXPECT_EQ(10, list[1]);
   }
 };
 
 RUN_TEST_IN_MESSAGE_LOOP(
     ConsecutiveOverriddenDispatcherInTheSameMessageLoopIteration)
 
 }  // namespace ui