Add --keyboard-usability-test flag and always show keyboard unless manually hide

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/command_line.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"
+#include "ui/keyboard/keyboard_switches.h"
 
 namespace keyboard {
 namespace {
 
 // 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) {
@@ skipping 148 matching lines @@
 
   aura::Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardContainerObserver);
 };
 
 }  // namespace
 
 class KeyboardControllerTest : public testing::Test {
  public:
-  KeyboardControllerTest() {}
+  KeyboardControllerTest() : command_line_(CommandLine::NO_PROGRAM) {}
   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 AppendSwitch(const std::string& switch_string) {
+    command_line_.AppendSwitch(switch_string);
+    controller_->set_command_line_for_testing(&command_line_);

[sadrul, 2013/10/24 01:21:01]

You don't do this.

For this kind of tests, where you are testing a feature behind a flag, you add
the flag to the Command::ForCurrentProcess() in the SetUp() override. So, for
this case, you would have:

class KeyboardControllerUsabilityTest : public KeyboardControllerTest {
  ...
  virtual void SetUp() OVERRIDE {
    CommandLine::ForCurrentProcess()->AppendSwitch(<switch>);
    KeyboardControllerTest::SetUp();
  }

  ...
};
...

TEST_F(KeyboardControllerUsabilityTest, ...)

There are various examples of this in ash/

[bshe, 2013/10/24 03:35:36]

eh. I followed the pattern that is used in desktop_background_controller.cc and
its unit tests, thought this is the preferred way. Anyway, changed to the
suggested way and I will clean up the code in desktop_background_controller in a
follow up CL. 

On 2013/10/24 01:21:01, sadrul wrote:

+  }
+
   void ShowKeyboard() {
     TestTextInputClient test_text_input_client(ui::TEXT_INPUT_TYPE_TEXT);
     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:
+  // Custom command line passed to KeyboardController by AppendSwitch().
+  CommandLine command_line_;
+
   KeyboardControllerProxy* proxy_;
   scoped_ptr<KeyboardController> controller_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardControllerTest);
 };
 
 TEST_F(KeyboardControllerTest, KeyboardSize) {
   aura::Window* container(controller()->GetContainerWindow());
   gfx::Rect bounds(0, 0, 100, 100);
   container->SetBounds(bounds);
@@ skipping 86 matching lines @@
   // Schedule to hide keyboard.
   input_method->SetFocusedTextInputClient(&no_input_client_1);
   EXPECT_TRUE(WillHideKeyboard());
   // Cancel keyboard hide.
   input_method->SetFocusedTextInputClient(&input_client_2);
 
   EXPECT_FALSE(WillHideKeyboard());
   EXPECT_TRUE(keyboard_container->IsVisible());
 }
 
+TEST_F(KeyboardControllerTest, KeyboardAlwaysVisibleInKeyboardUsabilityTest) {
+  const gfx::Rect& root_bounds = root_window()->bounds();
+
+  AppendSwitch(switches::kKeyboardUsabilityTest);
+  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);
+
+  aura::Window* keyboard_container(controller()->GetContainerWindow());
+  scoped_ptr<KeyboardContainerObserver> keyboard_container_observer(
+      new KeyboardContainerObserver(keyboard_container));
+  keyboard_container->SetBounds(root_bounds);
+  root_window()->AddChild(keyboard_container);
+
+  EXPECT_TRUE(keyboard_container->IsVisible());
+
+  input_method->SetFocusedTextInputClient(&no_input_client);
+  // Keyboard should not hide itself after lost focus.
+  EXPECT_TRUE(keyboard_container->IsVisible());
+  EXPECT_FALSE(WillHideKeyboard());
+}
+
 }  // namespace keyboard