Replace MessageLoop::current()->task_runner() with ThreadTaskRunnerHandle::Get().

ui/views/controls/menu/menu_controller_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/views/controls/menu/menu_controller.h"
 
 #include "base/callback.h"
+#include "base/logging.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "ui/aura/scoped_window_targeter.h"
 #include "ui/aura/window.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_handler.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/null_event_targeter.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/geometry/point.h"
@@ skipping 243 matching lines @@
  public:
   MenuControllerTest() : menu_controller_(nullptr) {
   }
 
   ~MenuControllerTest() override {}
 
   // ViewsTestBase:
   void SetUp() override {
     ViewsTestBase::SetUp();
     Init();
+    ASSERT_TRUE(base::MessageLoopForUI::IsCurrent());
   }
 
   void TearDown() override {
     owner_->CloseNow();
     DestroyMenuController();
     ViewsTestBase::TearDown();
   }
 
   void ReleaseTouchId(int id) {
     event_generator_->ReleaseTouchId(id);
@@ skipping 321 matching lines @@
   MenuController* menu_controller_;
   TestMenuMessageLoop* test_message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuControllerTest);
 };
 
 #if defined(OS_LINUX) && defined(USE_X11)
 // Tests that an event targeter which blocks events will be honored by the menu
 // event dispatcher.
 TEST_F(MenuControllerTest, EventTargeter) {
-  base::MessageLoopForUI::current()->task_runner()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&MenuControllerTest::TestEventTargeter,
                             base::Unretained(this)));
   RunMenu();
 }
 #endif  // defined(OS_LINUX) && defined(USE_X11)
 
 #if defined(USE_X11)
 // Tests that touch event ids are released correctly. See crbug.com/439051 for
 // details. When the ids aren't managed correctly, we get stuck down touches.
 TEST_F(MenuControllerTest, TouchIdsReleasedCorrectly) {
   TestEventHandler test_event_handler;
   owner()->GetNativeWindow()->GetRootWindow()->AddPreTargetHandler(
       &test_event_handler);
 
   std::vector<int> devices;
   devices.push_back(1);
   ui::SetUpTouchDevicesForTest(devices);
 
   event_generator()->PressTouchId(0);
   event_generator()->PressTouchId(1);
   event_generator()->ReleaseTouchId(0);
 
-  base::MessageLoopForUI::current()->task_runner()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&MenuControllerTest::ReleaseTouchId,
                             base::Unretained(this), 1));
 
-  base::MessageLoopForUI::current()->task_runner()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&MenuControllerTest::PressKey,
                             base::Unretained(this), ui::VKEY_ESCAPE));
 
   RunMenu();
 
   EXPECT_EQ(MenuController::EXIT_OUTERMOST, menu_exit_type());
   EXPECT_EQ(0, test_event_handler.outstanding_touches());
 
   owner()->GetNativeWindow()->GetRootWindow()->RemovePreTargetHandler(
       &test_event_handler);
@@ skipping 561 matching lines @@
   EXPECT_EQ(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
             delegate->on_menu_closed_notify_type());
   EXPECT_EQ(MenuController::EXIT_ALL, controller->exit_type());
 }
 
 // Tests that if you exit all menus when an asynchrnous menu is nested within a
 // synchronous menu, the message loop for the parent menu finishes running.
 TEST_F(MenuControllerTest, AsynchronousNestedExitAll) {
   InstallTestMenuMessageLoop();
 
-  base::MessageLoopForUI::current()->task_runner()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&MenuControllerTest::TestAsynchronousNestedExitAll,
                             base::Unretained(this)));
 
   RunMenu();
 }
 
 // Tests that if you exit the nested menu when an asynchrnous menu is nested
 // within a synchronous menu, the message loop for the parent menu remains
 // running.
 TEST_F(MenuControllerTest, AsynchronousNestedExitOutermost) {
   InstallTestMenuMessageLoop();
 
-  base::MessageLoopForUI::current()->task_runner()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&MenuControllerTest::TestAsynchronousNestedExitOutermost,
                  base::Unretained(this)));
 
   RunMenu();
 }
 
 // Tests that having the MenuController deleted during RepostEvent does not
 // cause a crash. ASAN bots should not detect use-after-free in MenuController.
 TEST_F(MenuControllerTest, AsynchronousRepostEventDeletesController) {
@@ skipping 78 matching lines @@
 
 // Tests that when an asynchronous menu is nested, and the nested message loop
 // is kill not by the MenuController, that the nested menu is notified of
 // destruction.
 TEST_F(MenuControllerTest, NestedMessageLoopDiesWithNestedMenu) {
   menu_controller()->CancelAll();
   InstallTestMenuMessageLoop();
   std::unique_ptr<TestMenuControllerDelegate> nested_delegate(
       new TestMenuControllerDelegate());
   // This will nest an asynchronous menu, and then kill the nested message loop.
-  base::MessageLoopForUI::current()->task_runner()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&MenuControllerTest::TestNestedMessageLoopKillsItself,
                  base::Unretained(this), nested_delegate.get()));
 
   int result_event_flags = 0;
   // This creates a nested message loop.
   EXPECT_EQ(nullptr, menu_controller()->Run(owner(), nullptr, menu_item(),
                                             gfx::Rect(), MENU_ANCHOR_TOPLEFT,
                                             false, false, &result_event_flags));
   EXPECT_FALSE(menu_controller_delegate()->on_menu_closed_called());
   EXPECT_TRUE(nested_delegate->on_menu_closed_called());
 }
 
 #if defined(USE_AURA)
 // Tests that when a synchronous menu receives a cancel event, that it closes.
 TEST_F(MenuControllerTest, SynchronousCancelEvent) {
   ExitMenuRun();
   // Post actual test to run once the menu has created a nested message loop.
-  base::MessageLoopForUI::current()->task_runner()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&MenuControllerTest::TestCancelEvent, base::Unretained(this)));
   int mouse_event_flags = 0;
   MenuItemView* run_result = menu_controller()->Run(
       owner(), nullptr, menu_item(), gfx::Rect(), MENU_ANCHOR_TOPLEFT, false,
       false, &mouse_event_flags);
   EXPECT_EQ(run_result, nullptr);
 }
 
 // Tests that when an asynchronous menu receives a cancel event, that it closes.
@@ skipping 39 matching lines @@
   aura::client::SetDragDropClient(owner()->GetNativeWindow()->GetRootWindow(),
                                   &drag_drop_client);
   AddButtonMenuItems();
   StartDrag();
 }
 
 #endif  // defined(USE_AURA)
 
 }  // namespace test
 }  // namespace views