Remove calls to deprecated MessageLoop methods on Windows and Linux.

ui/keyboard/keyboard_controller_unittest.cc

 // Copyright (c) 2013 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/keyboard/keyboard_controller.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/test/aura_test_helper.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/ime/dummy_text_input_client.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/input_method_factory.h"
@@ skipping 116 matching lines @@
     ui::EventHandler::OnEvent(event);
     event_counts_[event->type()]++;
   }
 
   std::map<ui::EventType, int> event_counts_;
   DISALLOW_COPY_AND_ASSIGN(EventObserver);
 };
 
 class KeyboardContainerObserver : public aura::WindowObserver {
  public:
-  explicit KeyboardContainerObserver(aura::Window* window) : window_(window) {
+  explicit KeyboardContainerObserver(aura::Window* window,
+                                     base::RunLoop* run_loop)
+      : window_(window), run_loop_(run_loop) {
     window_->AddObserver(this);
   }
   ~KeyboardContainerObserver() override { window_->RemoveObserver(this); }
 
  private:
   void OnWindowVisibilityChanged(aura::Window* window, bool visible) override {
     if (!visible)
-      base::MessageLoop::current()->QuitWhenIdle();
+      run_loop_->QuitWhenIdle();
   }
 
   aura::Window* window_;
+  base::RunLoop* const run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardContainerObserver);
 };
 
 }  // namespace
 
 class KeyboardControllerTest : public testing::Test,
                                public KeyboardControllerObserver {
  public:
   KeyboardControllerTest() : number_of_calls_(0), ui_(nullptr) {}
@@ skipping 186 matching lines @@
 }
 
 TEST_F(KeyboardControllerTest, VisibilityChangeWithTextInputTypeChange) {
   keyboard::SetAccessibilityKeyboardEnabled(true);
   ui::DummyTextInputClient input_client_0(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient input_client_1(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient input_client_2(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient no_input_client_0(ui::TEXT_INPUT_TYPE_NONE);
   ui::DummyTextInputClient no_input_client_1(ui::TEXT_INPUT_TYPE_NONE);
 
+  base::RunLoop run_loop;
   aura::Window* keyboard_container(controller()->GetContainerWindow());
   std::unique_ptr<KeyboardContainerObserver> keyboard_container_observer(
-      new KeyboardContainerObserver(keyboard_container));
+      new KeyboardContainerObserver(keyboard_container, &run_loop));
   root_window()->AddChild(keyboard_container);
 
   SetFocus(&input_client_0);
 
   EXPECT_TRUE(keyboard_container->IsVisible());
 
   SetFocus(&no_input_client_0);
   // Keyboard should not immediately hide itself. It is delayed to avoid layout
   // flicker when the focus of input field quickly change.
   EXPECT_TRUE(keyboard_container->IsVisible());
   EXPECT_TRUE(WillHideKeyboard());
   // Wait for hide keyboard to finish.
-  base::MessageLoop::current()->Run();
+  run_loop.Run();
   EXPECT_FALSE(keyboard_container->IsVisible());
 
   SetFocus(&input_client_1);
   EXPECT_TRUE(keyboard_container->IsVisible());
 
   // Schedule to hide keyboard.
   SetFocus(&no_input_client_1);
   EXPECT_TRUE(WillHideKeyboard());
   // Cancel keyboard hide.
   SetFocus(&input_client_2);
@@ skipping 27 matching lines @@
   EXPECT_TRUE(ShouldEnableInsets(ui()->GetKeyboardWindow()));
 }
 
 // Verify switch to FLOATING mode will reset the overscroll or resize and when
 // in FLOATING mode, overscroll or resize wont be triggered.
 TEST_F(KeyboardControllerTest, FloatingKeyboardDontOverscrollOrResize) {
   keyboard::SetAccessibilityKeyboardEnabled(true);
   ui::DummyTextInputClient input_client(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient no_input_client(ui::TEXT_INPUT_TYPE_NONE);
 
+  base::RunLoop run_loop;
   aura::Window* container(controller()->GetContainerWindow());
   root_window()->AddChild(container);
   std::unique_ptr<KeyboardContainerObserver> keyboard_container_observer(
-      new KeyboardContainerObserver(container));
+      new KeyboardContainerObserver(container, &run_loop));
   gfx::Rect screen_bounds = root_window()->bounds();
   keyboard::SetTouchKeyboardEnabled(true);
 
   SetFocus(&input_client);
   gfx::Rect expected_bounds(
       0, screen_bounds.height() - kDefaultVirtualKeyboardHeight,
       screen_bounds.width(), kDefaultVirtualKeyboardHeight);
   // Verify overscroll or resize is in effect.
   EXPECT_EQ(expected_bounds, notified_bounds());
   EXPECT_EQ(1, number_of_calls());
 
   controller()->SetKeyboardMode(FLOATING);
   // Switch to FLOATING should clear overscroll or resize.
   EXPECT_EQ(gfx::Rect(), notified_bounds());
   EXPECT_EQ(2, number_of_calls());
   SetFocus(&no_input_client);
-  base::MessageLoop::current()->Run();
+  run_loop.Run();
   EXPECT_EQ(gfx::Rect(), notified_bounds());
   EXPECT_EQ(3, number_of_calls());
   SetFocus(&input_client);
   // In FLOATING mode, no overscroll or resize should be triggered.
   EXPECT_EQ(3, number_of_calls());
   EXPECT_EQ(gfx::Rect(), controller()->current_keyboard_bounds());
   keyboard::SetAccessibilityKeyboardEnabled(false);
 }
 
 // Verify switch to FULL_WIDTH mode will move virtual keyboard to the right
@@ skipping 19 matching lines @@
   EXPECT_EQ(expected_bounds, controller()->current_keyboard_bounds());
 }
 
 TEST_F(KeyboardControllerTest, AlwaysVisibleWhenLocked) {
   keyboard::SetAccessibilityKeyboardEnabled(true);
   ui::DummyTextInputClient input_client_0(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient input_client_1(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient no_input_client_0(ui::TEXT_INPUT_TYPE_NONE);
   ui::DummyTextInputClient no_input_client_1(ui::TEXT_INPUT_TYPE_NONE);
 
+  base::RunLoop run_loop;
   aura::Window* keyboard_container(controller()->GetContainerWindow());
   std::unique_ptr<KeyboardContainerObserver> keyboard_container_observer(
-      new KeyboardContainerObserver(keyboard_container));
+      new KeyboardContainerObserver(keyboard_container, &run_loop));
   root_window()->AddChild(keyboard_container);
 
   SetFocus(&input_client_0);
 
   EXPECT_TRUE(keyboard_container->IsVisible());
 
   // Lock keyboard.
   controller()->set_lock_keyboard(true);
 
   SetFocus(&no_input_client_0);
   // Keyboard should not try to hide itself as it is locked.
   EXPECT_TRUE(keyboard_container->IsVisible());
   EXPECT_FALSE(WillHideKeyboard());
 
   SetFocus(&input_client_1);
   EXPECT_TRUE(keyboard_container->IsVisible());
 
   // Unlock keyboard.
   controller()->set_lock_keyboard(false);
 
   // Keyboard should hide when focus on no input client.
   SetFocus(&no_input_client_1);
   EXPECT_TRUE(WillHideKeyboard());
 
   // Wait for hide keyboard to finish.
-  base::MessageLoop::current()->Run();
+  run_loop.Run();
   EXPECT_FALSE(keyboard_container->IsVisible());
   keyboard::SetAccessibilityKeyboardEnabled(false);
 }
 
 class KeyboardControllerAnimationTest : public KeyboardControllerTest {
  public:
   KeyboardControllerAnimationTest() {}
   ~KeyboardControllerAnimationTest() override {}
 
   void SetUp() override {
@@ skipping 122 matching lines @@
   gfx::Rect new_bounds(0, 0, 1280, 800);
   ASSERT_NE(new_bounds, root_window()->bounds());
   EXPECT_EQ(1, number_of_calls());
   root_window()->SetBounds(new_bounds);
   EXPECT_EQ(2, number_of_calls());
   MockRotateScreen();
   EXPECT_EQ(3, number_of_calls());
 }
 
 }  // namespace keyboard