Delay virtual keyboard hiding for 100ms

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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/aura_test_helper.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/base/ime/input_method.h"
@@ skipping 136 matching lines @@
   virtual bool ChangeTextDirectionAndLayoutAlignment(
       base::i18n::TextDirection direction) OVERRIDE { return false; }
   virtual void ExtendSelectionAndDelete(size_t before, size_t after) OVERRIDE {}
   virtual void EnsureCaretInRect(const gfx::Rect& rect) OVERRIDE {}
 
   ui::TextInputType type_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTextInputClient);
 };
 
+class KeyboardContainerObserver : public aura::WindowObserver {
+ public:
+  explicit KeyboardContainerObserver(aura::Window* window) : window_(window) {
+    window_->AddObserver(this);
+  }
+  virtual ~KeyboardContainerObserver() {
+    window_->RemoveObserver(this);
+  }
+
+ private:
+  virtual void OnWindowVisibilityChanged(aura::Window* window,
+                                    bool visible) OVERRIDE {

[sadrul, 2013/08/29 23:43:54]

Fix indent

[bshe, 2013/08/30 15:54:19]

Done.

+    if (!visible)
+      base::MessageLoop::current()->Quit();
+  }
+
+  aura::Window* window_;
+
+  DISALLOW_COPY_AND_ASSIGN(KeyboardContainerObserver);
+};
+
 }  // namespace
 
 class KeyboardControllerTest : public testing::Test {
  public:
   KeyboardControllerTest() {}
   virtual ~KeyboardControllerTest() {}
 
   virtual void SetUp() OVERRIDE {
     aura_test_helper_.reset(new aura::test::AuraTestHelper(&message_loop_));
     aura_test_helper_->SetUp();
     ui::SetUpInputMethodFactoryForTesting();
     focus_controller_.reset(new TestFocusController(root_window()));
+    proxy_ = new TestKeyboardControllerProxy();
+    controller_.reset(new KeyboardController(proxy_));
   }
 
   virtual void TearDown() OVERRIDE {
     focus_controller_.reset();
     aura_test_helper_->TearDown();
   }
 
   aura::RootWindow* root_window() { return aura_test_helper_->root_window(); }
+  KeyboardControllerProxy* proxy() { return proxy_; }
+  KeyboardController* controller() { return controller_.get(); }
 
-  void ShowKeyboard(KeyboardController* controller) {
+  void ShowKeyboard() {
     TestTextInputClient test_text_input_client(ui::TEXT_INPUT_TYPE_TEXT);
-    controller->OnTextInputStateChanged(&test_text_input_client);
+    controller_->OnTextInputStateChanged(&test_text_input_client);
   }
 
  protected:
+  bool WillHideKeyboard() {
+    return controller_->WillHideKeyboard();
+  }
+
   base::MessageLoopForUI message_loop_;
   scoped_ptr<aura::test::AuraTestHelper> aura_test_helper_;
   scoped_ptr<TestFocusController> focus_controller_;
 
  private:
+  KeyboardControllerProxy* proxy_;
+  scoped_ptr<KeyboardController> controller_;
+
   DISALLOW_COPY_AND_ASSIGN(KeyboardControllerTest);
 };
 
 TEST_F(KeyboardControllerTest, KeyboardSize) {
-  KeyboardControllerProxy* proxy = new TestKeyboardControllerProxy();
-  KeyboardController controller(proxy);
-
-  scoped_ptr<aura::Window> container(controller.GetContainerWindow());
+  scoped_ptr<aura::Window> container(controller()->GetContainerWindow());
   gfx::Rect bounds(0, 0, 100, 100);
   container->SetBounds(bounds);
 
-  const gfx::Rect& before_bounds = proxy->GetKeyboardWindow()->bounds();
+  const gfx::Rect& before_bounds = proxy()->GetKeyboardWindow()->bounds();
   gfx::Rect new_bounds(
       before_bounds.x(), before_bounds.y(),
       before_bounds.width() / 2, before_bounds.height() / 2);
 
   // The KeyboardController's LayoutManager shouldn't let this happen
-  proxy->GetKeyboardWindow()->SetBounds(new_bounds);
-  ASSERT_EQ(before_bounds, proxy->GetKeyboardWindow()->bounds());
+  proxy()->GetKeyboardWindow()->SetBounds(new_bounds);
+  ASSERT_EQ(before_bounds, proxy()->GetKeyboardWindow()->bounds());
 }
 
 // Tests that tapping/clicking inside the keyboard does not give it focus.
 TEST_F(KeyboardControllerTest, ClickDoesNotFocusKeyboard) {
   const gfx::Rect& root_bounds = root_window()->bounds();
   aura::test::EventCountDelegate delegate;
   scoped_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();
 
-  KeyboardControllerProxy* proxy = new TestKeyboardControllerProxy();
-  KeyboardController controller(proxy);
-
-  scoped_ptr<aura::Window> keyboard_container(controller.GetContainerWindow());
+  scoped_ptr<aura::Window> keyboard_container(
+      controller()->GetContainerWindow());
   keyboard_container->SetBounds(root_bounds);
 
   root_window()->AddChild(keyboard_container.get());
   keyboard_container->Show();
 
-  ShowKeyboard(&controller);
+  ShowKeyboard();
 
   EXPECT_TRUE(window->IsVisible());
   EXPECT_TRUE(keyboard_container->IsVisible());
   EXPECT_TRUE(window->HasFocus());
   EXPECT_FALSE(keyboard_container->HasFocus());
 
   // Click on the keyboard. Make sure the keyboard receives the event, but does
   // not get focus.
   EventObserver observer;
   keyboard_container->AddPreTargetHandler(&observer);
 
   aura::test::EventGenerator generator(root_window());
-  generator.MoveMouseTo(proxy->GetKeyboardWindow()->bounds().CenterPoint());
+  generator.MoveMouseTo(proxy()->GetKeyboardWindow()->bounds().CenterPoint());
   generator.ClickLeftButton();
   EXPECT_TRUE(window->HasFocus());
   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());
 }
 
 TEST_F(KeyboardControllerTest, VisibilityChangeWithTextInputTypeChange) {
   const gfx::Rect& root_bounds = root_window()->bounds();
-  aura::test::EventCountDelegate delegate;
-  scoped_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();
 
-  KeyboardControllerProxy* proxy = new TestKeyboardControllerProxy();
-  ui::InputMethod* input_method = proxy->GetInputMethod();
-  TestTextInputClient input_client(ui::TEXT_INPUT_TYPE_TEXT);
-  TestTextInputClient no_input_client(ui::TEXT_INPUT_TYPE_NONE);
-  input_method->SetFocusedTextInputClient(&input_client);
+  ui::InputMethod* input_method = proxy()->GetInputMethod();
+  TestTextInputClient input_client_0(ui::TEXT_INPUT_TYPE_TEXT);
+  TestTextInputClient input_client_1(ui::TEXT_INPUT_TYPE_TEXT);
+  TestTextInputClient input_client_2(ui::TEXT_INPUT_TYPE_TEXT);
+  TestTextInputClient no_input_client_0(ui::TEXT_INPUT_TYPE_NONE);
+  TestTextInputClient no_input_client_1(ui::TEXT_INPUT_TYPE_NONE);
+  input_method->SetFocusedTextInputClient(&input_client_0);
 
-  KeyboardController controller(proxy);
-
-  scoped_ptr<aura::Window> keyboard_container(controller.GetContainerWindow());
+  scoped_ptr<aura::Window> keyboard_container(
+      controller()->GetContainerWindow());
+  scoped_ptr<KeyboardContainerObserver> keyboard_container_observer(
+      new KeyboardContainerObserver(keyboard_container.get()));
   keyboard_container->SetBounds(root_bounds);
   root_window()->AddChild(keyboard_container.get());
 
   EXPECT_TRUE(keyboard_container->IsVisible());
 
-  input_method->SetFocusedTextInputClient(&no_input_client);
+  input_method->SetFocusedTextInputClient(&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());

[sadrul, 2013/08/29 23:43:54]

Also, EXPECT_TRUE(WillHideKeyboard());

[bshe, 2013/08/30 15:54:19]

Done.

+  // Wait for hide keyboard to finish.
+  base::MessageLoop::current()->Run();
   EXPECT_FALSE(keyboard_container->IsVisible());
 
-  input_method->SetFocusedTextInputClient(&input_client);
+  input_method->SetFocusedTextInputClient(&input_client_1);
+  EXPECT_TRUE(keyboard_container->IsVisible());
+
+  // Schedule to hide keyboard.
+  input_method->SetFocusedTextInputClient(&no_input_client_1);

[sadrul, 2013/08/29 23:43:54]

EXPECT_TRUE(WillHideKeyboard());

[bshe, 2013/08/30 15:54:19]

Done.

+  // Cancel keyboard hide.
+  input_method->SetFocusedTextInputClient(&input_client_2);
+
+  EXPECT_FALSE(WillHideKeyboard());
   EXPECT_TRUE(keyboard_container->IsVisible());
 }
 
 }  // namespace keyboard