Don't use KeyboardController::GetInstance() in KeyboardUI.

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/run_loop.h"
 #include "base/test/scoped_task_environment.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"
 #include "ui/base/ime/text_input_client.h"
+#include "ui/base/ui_base_switches.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer_type.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/compositor/test/context_factories_for_test.h"
 #include "ui/compositor/test/layer_animator_test_controller.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/keyboard/keyboard_controller_observer.h"
 #include "ui/keyboard/keyboard_ui.h"
@@ skipping 166 matching lines @@
   // Overridden from keyboard::KeyboardLayoutDelegate
   void MoveKeyboardToDisplay(int64_t /* display_id */) override {}
   void MoveKeyboardToTouchableDisplay() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestKeyboardLayoutDelegate);
 };
 
 }  // namespace
 
-class KeyboardControllerTest : public testing::Test,
+// Test parameter indicates if the new window behavior for the accessibility
+// keyboard should be used.
+class KeyboardControllerTest : public testing::TestWithParam<bool>,
                                public KeyboardControllerObserver {
  public:
   KeyboardControllerTest()
       : scoped_task_environment_(
             base::test::ScopedTaskEnvironment::MainThreadType::UI),
         number_of_calls_(0),
         ui_(nullptr),
         keyboard_closed_(false) {}
   ~KeyboardControllerTest() override {}
 
   void SetUp() override {
     // The ContextFactory must exist before any Compositors are created.
     bool enable_pixel_output = false;
     ui::ContextFactory* context_factory = nullptr;
     ui::ContextFactoryPrivate* context_factory_private = nullptr;
 
     ui::InitializeContextFactoryForTests(enable_pixel_output, &context_factory,
                                          &context_factory_private);
 
     ui::SetUpInputMethodFactoryForTesting();
     aura_test_helper_.reset(new aura::test::AuraTestHelper());
     aura_test_helper_->SetUp(context_factory, context_factory_private);
     new wm::DefaultActivationClient(aura_test_helper_->root_window());
     focus_controller_.reset(new TestFocusController(root_window()));
     ui_ = new TestKeyboardUI(aura_test_helper_->host()->GetInputMethod());
     layout_delegate_.reset(new TestKeyboardLayoutDelegate());
     controller_.reset(new KeyboardController(ui_, layout_delegate_.get()));
     controller()->AddObserver(this);
+
+    if (GetParam()) {
+      base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+      command_line->AppendSwitch(::switches::kUseNewVirtualKeyboardBehavior);
+    }
   }
 
   void TearDown() override {
     if (controller())
       controller()->RemoveObserver(this);
     controller_.reset();
     focus_controller_.reset();
     aura_test_helper_->TearDown();
     ui::TerminateContextFactoryForTests();
   }
@@ skipping 64 matching lines @@
   int number_of_calls_;
   gfx::Rect notified_bounds_;
   KeyboardUI* ui_;
   std::unique_ptr<KeyboardLayoutDelegate> layout_delegate_;
   std::unique_ptr<KeyboardController> controller_;
   std::unique_ptr<ui::TextInputClient> test_text_input_client_;
   bool keyboard_closed_;
   DISALLOW_COPY_AND_ASSIGN(KeyboardControllerTest);
 };
 
-TEST_F(KeyboardControllerTest, KeyboardSize) {
+// Run all KeyboardControllerTest with and without
+// "use-new-virtual-keyboard-behavior" flag.
+INSTANTIATE_TEST_CASE_P(NewAndOldBehavior,
+                        KeyboardControllerTest,
+                        testing::Bool());
+
+TEST_P(KeyboardControllerTest, KeyboardSize) {
   aura::Window* container(controller()->GetContainerWindow());
   aura::Window* keyboard(ui()->GetKeyboardWindow());
   gfx::Rect screen_bounds = root_window()->bounds();
   root_window()->AddChild(container);
   container->AddChild(keyboard);
   const gfx::Rect& initial_bounds = container->bounds();
   // The container should be positioned at the bottom of screen and has 0
   // height.
   ASSERT_EQ(0, initial_bounds.height());
   ASSERT_EQ(screen_bounds.height(), initial_bounds.y());
@@ skipping 18 matching lines @@
   // The above call should resize keyboard to new width while keeping the old
   // height.
   ASSERT_EQ(gfx::Rect(0,
                       screen_bounds.width() - 50,
                       screen_bounds.height(),
                       50),
             container->bounds());
   VerifyKeyboardWindowSize(container, keyboard);
 }
 
-TEST_F(KeyboardControllerTest, KeyboardSizeMultiRootWindow) {
+TEST_P(KeyboardControllerTest, KeyboardSizeMultiRootWindow) {
   aura::Window* container(controller()->GetContainerWindow());
   aura::Window* keyboard(ui()->GetKeyboardWindow());
   gfx::Rect screen_bounds = root_window()->bounds();
   root_window()->AddChild(container);
   container->AddChild(keyboard);
   const gfx::Rect& initial_bounds = container->bounds();
   // The container should be positioned at the bottom of screen and has 0
   // height.
   ASSERT_EQ(0, initial_bounds.height());
   ASSERT_EQ(screen_bounds.height(), initial_bounds.y());
@@ skipping 11 matching lines @@
   controller()->HideKeyboard(
       KeyboardController::HideReason::HIDE_REASON_AUTOMATIC);
   root_window()->RemoveChild(container);
   secondary_tree_host->window()->AddChild(container);
 
   const gfx::Rect& new_bounds = container->bounds();
   EXPECT_EQ(500, new_bounds.y());
   VerifyKeyboardWindowSize(container, keyboard);
 }
 
-TEST_F(KeyboardControllerTest, FloatingKeyboardSize) {
+TEST_P(KeyboardControllerTest, FloatingKeyboardSize) {
   aura::Window* container(controller()->GetContainerWindow());
   aura::Window* keyboard(ui()->GetKeyboardWindow());
   root_window()->AddChild(container);
   controller()->SetKeyboardMode(FLOATING);
   container->AddChild(keyboard);
   gfx::Rect new_bounds(0, 50, 50, 50);
   keyboard->SetBounds(new_bounds);
   ASSERT_EQ(new_bounds, container->bounds());
   VerifyKeyboardWindowSize(container, keyboard);
 }
 
 // Tests that tapping/clicking inside the keyboard does not give it focus.
-TEST_F(KeyboardControllerTest, ClickDoesNotFocusKeyboard) {
+TEST_P(KeyboardControllerTest, ClickDoesNotFocusKeyboard) {
   ScopedAccessibilityKeyboardEnabler scoped_keyboard_enabler;
   const gfx::Rect& root_bounds = root_window()->bounds();
   aura::test::EventCountDelegate delegate;
   std::unique_ptr<aura::Window> window(new aura::Window(&delegate));
   window->Init(ui::LAYER_NOT_DRAWN);
   window->SetBounds(root_bounds);
   root_window()->AddChild(window.get());
   window->Show();
   window->Focus();
 
@@ skipping 23 matching lines @@
   EXPECT_EQ(1, observer.GetEventCount(ui::ET_MOUSE_PRESSED));
   EXPECT_EQ(1, observer.GetEventCount(ui::ET_MOUSE_RELEASED));
 
   // Click outside of the keyboard. It should reach the window behind.
   generator.MoveMouseTo(gfx::Point());
   generator.ClickLeftButton();
   EXPECT_EQ("1 1", delegate.GetMouseButtonCountsAndReset());
   keyboard_container->RemovePreTargetHandler(&observer);
 }
 
-TEST_F(KeyboardControllerTest, VisibilityChangeWithTextInputTypeChange) {
+TEST_P(KeyboardControllerTest, VisibilityChangeWithTextInputTypeChange) {
   ScopedAccessibilityKeyboardEnabler scoped_keyboard_enabler;
   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(
@@ skipping 21 matching lines @@
   EXPECT_TRUE(WillHideKeyboard());
   // Cancel keyboard hide.
   SetFocus(&input_client_2);
 
   EXPECT_FALSE(WillHideKeyboard());
   EXPECT_TRUE(keyboard_container->IsVisible());
 }
 
 // Test to prevent spurious overscroll boxes when changing tabs during keyboard
 // hide. Refer to crbug.com/401670 for more context.
-TEST_F(KeyboardControllerTest, CheckOverscrollInsetDuringVisibilityChange) {
+TEST_P(KeyboardControllerTest, CheckOverscrollInsetDuringVisibilityChange) {
   ui::DummyTextInputClient input_client(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient no_input_client(ui::TEXT_INPUT_TYPE_NONE);
 
   aura::Window* keyboard_container(controller()->GetContainerWindow());
   root_window()->AddChild(keyboard_container);
 
   // Enable touch keyboard / overscroll mode to test insets.
   ScopedTouchKeyboardEnabler scoped_keyboard_enabler;
   EXPECT_TRUE(keyboard::IsKeyboardOverscrollEnabled());
 
   SetFocus(&input_client);
   SetFocus(&no_input_client);
   // Insets should not be enabled for new windows while keyboard is in the
   // process of hiding when overscroll is enabled.
   EXPECT_FALSE(ShouldEnableInsets(ui()->GetKeyboardWindow()));
   // Cancel keyboard hide.
   SetFocus(&input_client);
   // Insets should be enabled for new windows as hide was cancelled.
   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) {
+TEST_P(KeyboardControllerTest, FloatingKeyboardDontOverscrollOrResize) {
   ScopedAccessibilityKeyboardEnabler scoped_keyboard_enabler;
   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, &run_loop));
   gfx::Rect screen_bounds = root_window()->bounds();
@@ skipping 16 matching lines @@
   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());
 }
 
 // Verify switch to FULL_WIDTH mode will move virtual keyboard to the right
 // place and sets the correct overscroll.
-TEST_F(KeyboardControllerTest, SwitchToFullWidthVirtualKeyboard) {
+TEST_P(KeyboardControllerTest, SwitchToFullWidthVirtualKeyboard) {
   ScopedTouchKeyboardEnabler scoped_keyboard_enabler;
   ui::DummyTextInputClient input_client(ui::TEXT_INPUT_TYPE_TEXT);
 
   aura::Window* container(controller()->GetContainerWindow());
   root_window()->AddChild(container);
   gfx::Rect screen_bounds = root_window()->bounds();
   SetFocus(&input_client);
 
   controller()->SetKeyboardMode(FLOATING);
   EXPECT_EQ(gfx::Rect(), notified_bounds());
   EXPECT_EQ(gfx::Rect(), controller()->current_keyboard_bounds());
 
   controller()->SetKeyboardMode(FULL_WIDTH);
   gfx::Rect expected_bounds(
       0, screen_bounds.height() - kDefaultVirtualKeyboardHeight,
       screen_bounds.width(), kDefaultVirtualKeyboardHeight);
   EXPECT_EQ(expected_bounds, notified_bounds());
   EXPECT_EQ(expected_bounds, controller()->current_keyboard_bounds());
 }
 
-TEST_F(KeyboardControllerTest, AlwaysVisibleWhenLocked) {
+TEST_P(KeyboardControllerTest, AlwaysVisibleWhenLocked) {
   ScopedAccessibilityKeyboardEnabler scoped_keyboard_enabler;
   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, &run_loop));
@@ skipping 20 matching lines @@
   // Keyboard should hide when focus on no input client.
   SetFocus(&no_input_client_1);
   EXPECT_TRUE(WillHideKeyboard());
 
   // Wait for hide keyboard to finish.
   run_loop.Run();
   EXPECT_FALSE(keyboard_container->IsVisible());
 }
 
 // Tests that deactivates keyboard will get closed event.
-TEST_F(KeyboardControllerTest, CloseKeyboard) {
+TEST_P(KeyboardControllerTest, CloseKeyboard) {
   ScopedAccessibilityKeyboardEnabler scoped_keyboard_enabler;
   aura::Window* keyboard_container(controller()->GetContainerWindow());
   root_window()->AddChild(keyboard_container);
   keyboard_container->Show();
 
   ShowKeyboard();
   EXPECT_TRUE(keyboard_container->IsVisible());
   EXPECT_FALSE(IsKeyboardClosed());
 
   root_window()->RemoveChild(keyboard_container);
@@ skipping 28 matching lines @@
   }
 
   aura::Window* keyboard_window() {
     return ui()->GetKeyboardWindow();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(KeyboardControllerAnimationTest);
 };
 
+// Run all KeyboardControllerAnimationTest with and without
+// "use-new-virtual-keyboard-behavior flag.
+INSTANTIATE_TEST_CASE_P(NewAndOldBehavior,
+                        KeyboardControllerAnimationTest,
+                        testing::Bool());
+
 // Tests virtual keyboard has correct show and hide animation.
-TEST_F(KeyboardControllerAnimationTest, ContainerAnimation) {
+TEST_P(KeyboardControllerAnimationTest, ContainerAnimation) {
   ScopedAccessibilityKeyboardEnabler scoped_keyboard_enabler;
   ui::Layer* layer = keyboard_container()->layer();
   ShowKeyboard();
 
   // Keyboard container and window should immediately become visible before
   // animation starts.
   EXPECT_TRUE(keyboard_container()->IsVisible());
   EXPECT_TRUE(keyboard_window()->IsVisible());
   float show_start_opacity = layer->opacity();
   gfx::Transform transform;
@@ skipping 27 matching lines @@
   EXPECT_FALSE(keyboard_window()->IsVisible());
   float hide_end_opacity = layer->opacity();
   EXPECT_GT(hide_start_opacity, hide_end_opacity);
   EXPECT_EQ(transform, layer->transform());
   EXPECT_EQ(gfx::Rect(), notified_bounds());
 }
 
 // Show keyboard during keyboard hide animation should abort the hide animation
 // and the keyboard should animate in.
 // Test for crbug.com/333284.
-TEST_F(KeyboardControllerAnimationTest, ContainerShowWhileHide) {
+TEST_P(KeyboardControllerAnimationTest, ContainerShowWhileHide) {
   ScopedAccessibilityKeyboardEnabler scoped_keyboard_enabler;
   ui::Layer* layer = keyboard_container()->layer();
   ShowKeyboard();
   RunAnimationForLayer(layer);
 
   controller()->HideKeyboard(KeyboardController::HIDE_REASON_AUTOMATIC);
   // Before hide animation finishes, show keyboard again.
   ShowKeyboard();
   RunAnimationForLayer(layer);
   EXPECT_TRUE(keyboard_container()->IsVisible());
   EXPECT_TRUE(keyboard_window()->IsVisible());
   EXPECT_EQ(1.0, layer->opacity());
   EXPECT_EQ(gfx::Transform(), layer->transform());
 }
 
 // Test for crbug.com/568274.
-TEST_F(KeyboardControllerTest, FloatingKeyboardShowOnFirstTap) {
+TEST_P(KeyboardControllerTest, FloatingKeyboardShowOnFirstTap) {
   ScopedTouchKeyboardEnabler scoped_keyboard_enabler;
   aura::Window* container(controller()->GetContainerWindow());
   aura::Window* keyboard(ui()->GetKeyboardWindow());
   root_window()->AddChild(container);
 
   controller()->SetKeyboardMode(FLOATING);
   container->AddChild(keyboard);
   // Mock focus on an input field.
   ui()->GetInputMethod()->ShowImeIfNeeded();
   // Mock set keyboard size from javascript side. In floating mode, virtual
   // keyboard's size is decided by client.
   gfx::Rect new_bounds(0, 50, 50, 50);
   keyboard->SetBounds(new_bounds);
   ASSERT_EQ(new_bounds, container->bounds());
   EXPECT_TRUE(keyboard->IsVisible());
   EXPECT_TRUE(container->IsVisible());
 }
 
-TEST_F(KeyboardControllerTest, DisplayChangeShouldNotifyBoundsChange) {
+TEST_P(KeyboardControllerTest, DisplayChangeShouldNotifyBoundsChange) {
   ScopedTouchKeyboardEnabler scoped_keyboard_enabler;
   ui::DummyTextInputClient input_client(ui::TEXT_INPUT_TYPE_TEXT);
 
   aura::Window* container(controller()->GetContainerWindow());
   root_window()->AddChild(container);
 
   controller()->SetKeyboardMode(FULL_WIDTH);
   SetFocus(&input_client);
   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