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"
 #include "ui/base/ime/input_method_factory.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/compositor/layer_type.h"
 #include "ui/gfx/rect.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_controller_proxy.h"
 
 namespace keyboard {
 namespace {
 
+void StopWait() {
+  base::MessageLoop::current()->Quit();
+}
+
+void WaitKeyboardHideToFinish() {
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&StopWait),
+      base::TimeDelta::FromMilliseconds(kHideKeyboardDelayMs));

[sadrul, 2013/08/29 17:06:33]

Don't post a delayed task. Instead, create an aura::WindowObserver for
keyboard_container, which starts a nested-loop, and terminates it when the
Window is shown/hidden. That would be cleaner, and make the test easier to
follow.

[bshe, 2013/08/29 18:19:02]

I did try to add an observer. But then I found that it is hard to test this case
show -> hide -> show -> cancel hide.

I want to verify if hide is indeed canceled. There are two options:
1. check if weak_ptr is invalidated in KeyboardController(this is probably hacky
and unreliable)
2. check if keyboard is still visible after the delayed time. If it is not
visible, it probably means the hide is not correctly canceled.
I found a similar pattern in the unit test for PostDelayTask.
https://code.google.com/p/chromium/codesearch/#chromium/src/base/message_loop...
So I assumed that this is probably acceptable?

I might miss something, in that case, please feel free to point out.

On 2013/08/29 17:06:33, sadrul wrote:

[sadrul, 2013/08/29 20:32:07]

KeyboardControllerTest is already friends with KeyboardController. So it'd be OK
to check that the KC is going to hide the keyboard. I agree that checking the
weak_ptr from here would be ugly, so I would add a private 'bool
WillHideWindow() const { return weak_ptr_.HasWeakPtrs(); }' function to KC and
use that here.
We should normally avoid tests that depend on timing. It's of course expected
that the code that tests PostDelayedTask() uses the function. But in most other
cases, we should avoid it in tests.

[bshe, 2013/08/29 23:05:03]

Done.

+  base::MessageLoop::current()->Run();
+}
+
 // 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::RootWindow* root)
       : root_(root) {
     root_->AddPreTargetHandler(this);
   }
 
   virtual ~TestFocusController() {
@@ skipping 228 matching lines @@
   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);
+  TestTextInputClient input_client_0(ui::TEXT_INPUT_TYPE_TEXT);
+  TestTextInputClient input_client_1(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());
   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());
+  WaitKeyboardHideToFinish();
   EXPECT_FALSE(keyboard_container->IsVisible());
 
-  input_method->SetFocusedTextInputClient(&input_client);
+  input_method->SetFocusedTextInputClient(&input_client_0);
+  EXPECT_TRUE(keyboard_container->IsVisible());
+
+  // Schedule to hide keyboard.
+  input_method->SetFocusedTextInputClient(&no_input_client_1);
+  // Cancel keyboard hide.
+  input_method->SetFocusedTextInputClient(&input_client_1);
+
+  WaitKeyboardHideToFinish();
   EXPECT_TRUE(keyboard_container->IsVisible());
 }
 
 }  // namespace keyboard