Clean up keyboard_unittests.

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"
@@ skipping 46 matching lines @@
   // Multiple steps are required to complete complex animations.
   // TODO(vollick): This should not be necessary. crbug.com/154017
   while (controller.animator()->is_animating()) {
     controller.StartThreadedAnimationsIfNeeded();
     base::TimeTicks step_time = controller.animator()->last_step_time();
     controller.animator()->Step(step_time +
                                 base::TimeDelta::FromMilliseconds(1000));
   }
 }
 
+class ScopedTouchKeyboardEnabler {
+ public:
+  ScopedTouchKeyboardEnabler() : enabled_(keyboard::GetTouchKeyboardEnabled()) {
+    keyboard::SetTouchKeyboardEnabled(true);
+  }
+
+  ~ScopedTouchKeyboardEnabler() { keyboard::SetTouchKeyboardEnabled(enabled_); }
+
+ private:
+  const bool enabled_;
+};
+
+class ScopedAccessibilityKeyboardEnabler {
+ public:
+  ScopedAccessibilityKeyboardEnabler()
+      : enabled_(keyboard::GetAccessibilityKeyboardEnabled()) {
+    keyboard::SetAccessibilityKeyboardEnabled(true);
+  }
+
+  ~ScopedAccessibilityKeyboardEnabler() {
+    keyboard::SetAccessibilityKeyboardEnabled(enabled_);
+  }
+
+ private:
+  const bool enabled_;
+};
+
 // An event handler that focuses a window when it is clicked/touched on. This is
 // used to match the focus manger behaviour in ash and views.
 class TestFocusController : public ui::EventHandler {
  public:
   explicit TestFocusController(aura::Window* root)
       : root_(root) {
     root_->AddPreTargetHandler(this);
   }
 
   ~TestFocusController() override { root_->RemovePreTargetHandler(this); }
@@ skipping 291 matching lines @@
   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) {
-  keyboard::SetAccessibilityKeyboardEnabled(true);
+  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();
 
   aura::Window* keyboard_container(controller()->GetContainerWindow());
@@ skipping 20 matching lines @@
   EXPECT_FALSE(keyboard_container->HasFocus());
   EXPECT_EQ("0 0", delegate.GetMouseButtonCountsAndReset());
   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);
-  keyboard::SetAccessibilityKeyboardEnabled(false);
 }
 
 TEST_F(KeyboardControllerTest, VisibilityChangeWithTextInputTypeChange) {
-  keyboard::SetAccessibilityKeyboardEnabled(true);
+  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(
       new KeyboardContainerObserver(keyboard_container, &run_loop));
@@ skipping 16 matching lines @@
   EXPECT_TRUE(keyboard_container->IsVisible());
 
   // Schedule to hide keyboard.
   SetFocus(&no_input_client_1);
   EXPECT_TRUE(WillHideKeyboard());
   // Cancel keyboard hide.
   SetFocus(&input_client_2);
 
   EXPECT_FALSE(WillHideKeyboard());
   EXPECT_TRUE(keyboard_container->IsVisible());
-  keyboard::SetAccessibilityKeyboardEnabled(false);
 }
 
 // Test to prevent spurious overscroll boxes when changing tabs during keyboard
 // hide. Refer to crbug.com/401670 for more context.
 TEST_F(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.
-  keyboard::SetTouchKeyboardEnabled(true);
+  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) {
-  keyboard::SetAccessibilityKeyboardEnabled(true);
+  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();

[bshe, 2017/01/18 20:52:33]

ScopedTouchKeyboardEnabler scoped_keyboard_enabler; ?

[yhanada, 2017/01/18 23:16:02]

Done.

-  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);
   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
 // place and sets the correct overscroll.
 TEST_F(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();
-  keyboard::SetTouchKeyboardEnabled(true);
   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) {
-  keyboard::SetAccessibilityKeyboardEnabled(true);
+  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));
   root_window()->AddChild(keyboard_container);
@@ skipping 16 matching lines @@
   // Unlock keyboard.
   controller()->set_keyboard_locked(false);
 
   // 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());
-  keyboard::SetAccessibilityKeyboardEnabled(false);
 }
 
 // Tests that deactivates keyboard will get closed event.
 TEST_F(KeyboardControllerTest, CloseKeyboard) {
-  keyboard::SetAccessibilityKeyboardEnabled(true);
+  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);
   ResetController();
   EXPECT_TRUE(IsKeyboardClosed());
-  keyboard::SetAccessibilityKeyboardEnabled(false);
 }
 
 class KeyboardControllerAnimationTest : public KeyboardControllerTest {
  public:
   KeyboardControllerAnimationTest() {}
   ~KeyboardControllerAnimationTest() override {}
 
   void SetUp() override {
     // We cannot short-circuit animations for this test.
     ui::ScopedAnimationDurationScaleMode test_duration_mode(
@@ skipping 18 matching lines @@
   aura::Window* keyboard_window() {
     return ui()->GetKeyboardWindow();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(KeyboardControllerAnimationTest);
 };
 
 // Tests virtual keyboard has correct show and hide animation.
 TEST_F(KeyboardControllerAnimationTest, ContainerAnimation) {
+  ScopedAccessibilityKeyboardEnabler scoped_keyboard_enabler;
   ui::Layer* layer = keyboard_container()->layer();
-  keyboard::SetAccessibilityKeyboardEnabled(true);
   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;
   transform.Translate(0, kAnimationDistance);
   EXPECT_EQ(transform, layer->transform());
@@ skipping 20 matching lines @@
   EXPECT_EQ(gfx::Rect(), notified_bounds());
 
   RunAnimationForLayer(layer);
   EXPECT_FALSE(keyboard_container()->IsVisible());
   EXPECT_FALSE(keyboard_container()->layer()->visible());
   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());
-  keyboard::SetAccessibilityKeyboardEnabled(false);
 }
 
 // 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) {
-  keyboard::SetAccessibilityKeyboardEnabled(true);
+  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());
-  keyboard::SetAccessibilityKeyboardEnabled(false);
 }
 
 // Test for crbug.com/568274.
 TEST_F(KeyboardControllerTest, FloatingKeyboardShowOnFirstTap) {
+  ScopedTouchKeyboardEnabler scoped_keyboard_enabler;
   aura::Window* container(controller()->GetContainerWindow());
   aura::Window* keyboard(ui()->GetKeyboardWindow());
   root_window()->AddChild(container);
 
-  keyboard::SetTouchKeyboardEnabled(true);
   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) {
+  ScopedTouchKeyboardEnabler scoped_keyboard_enabler;
   ui::DummyTextInputClient input_client(ui::TEXT_INPUT_TYPE_TEXT);
 
   aura::Window* container(controller()->GetContainerWindow());
   root_window()->AddChild(container);
 
-  keyboard::SetTouchKeyboardEnabled(true);
   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