Make the virtual keyboard show up on the display with input focus.

ash/root_window_controller_unittest.cc

 // Copyright (c) 2012 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 "ash/root_window_controller.h"
 
 #include <memory>
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/material_design/material_design_controller.h"
@@ skipping 19 matching lines @@
 #include "ui/aura/env.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/base/ime/dummy_text_input_client.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/display/manager/display_manager.h"
+#include "ui/display/test/display_manager_test_api.h"
+#include "ui/events/devices/device_data_manager.h"
+#include "ui/events/devices/touchscreen_device.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/events/test/test_event_handler.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_switches.h"
 #include "ui/keyboard/keyboard_ui.h"
 #include "ui/keyboard/keyboard_util.h"
 #include "ui/views/controls/menu/menu_controller.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
@@ skipping 646 matching lines @@
 class VirtualKeyboardRootWindowControllerTest
     : public RootWindowControllerTest {
  public:
   VirtualKeyboardRootWindowControllerTest() {}
   ~VirtualKeyboardRootWindowControllerTest() override {}
 
   void SetUp() override {
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         keyboard::switches::kEnableVirtualKeyboard);
     test::AshTestBase::SetUp();
-    Shell::GetPrimaryRootWindowController()->ActivateKeyboard(
-        keyboard::KeyboardController::GetInstance());
+    keyboard::SetTouchKeyboardEnabled(true);
+    Shell::GetInstance()->CreateKeyboard();
+  }
+
+  void TearDown() override {
+    keyboard::SetTouchKeyboardEnabled(false);
+    test::AshTestBase::TearDown();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VirtualKeyboardRootWindowControllerTest);
 };
 
 class MockTextInputClient : public ui::DummyTextInputClient {
  public:
   MockTextInputClient() : ui::DummyTextInputClient(ui::TEXT_INPUT_TYPE_TEXT) {}
 
@@ skipping 18 matching lines @@
     if (event->type() == ui::ET_MOUSE_PRESSED)
       ui::test::TestEventHandler::OnMouseEvent(event);
     event->StopPropagation();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TargetHitTestEventHandler);
 };
 
 // Test for http://crbug.com/297858. Virtual keyboard container should only show
-// on primary root window.
+// on primary root window if no window has a focus.

[oshima, 2016/11/08 17:26:04]

I assume you meant touch capability?

[yhanada, 2016/11/14 22:48:47]

Done.

 TEST_F(VirtualKeyboardRootWindowControllerTest,
-       VirtualKeyboardOnPrimaryRootWindowOnly) {
+       VirtualKeyboardOnPrimaryRootWindowDefault) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("500x500,500x500");
 
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   aura::Window* primary_root_window = Shell::GetPrimaryRootWindow();
+  aura::Window* secondary_root_window = root_windows[0] == primary_root_window
+                                            ? root_windows[1]
+                                            : root_windows[0];
+
+  ASSERT_TRUE(Shell::GetContainer(primary_root_window,
+                                  kShellWindowId_VirtualKeyboardContainer));
+  ASSERT_FALSE(Shell::GetContainer(secondary_root_window,
+                                   kShellWindowId_VirtualKeyboardContainer));
+}
+
+// Test for http://crbug.com/303429. Virtual keyboard container should show on
+// a display which has touch capability.
+TEST_F(VirtualKeyboardRootWindowControllerTest,
+       VirtualKeyboardOnTouchableDisplayOnly) {
+  if (!SupportsMultipleDisplays())
+    return;
+
+  UpdateDisplay("500x500,500x500");
+  display::Display secondary_display =
+      Shell::GetInstance()->display_manager()->GetSecondaryDisplay();
+  display::test::DisplayManagerTestApi(Shell::GetInstance()->display_manager())
+      .SetTouchSupport(secondary_display.id(),
+                       display::Display::TouchSupport::TOUCH_SUPPORT_AVAILABLE);
+
+  // The primary display doesn't have touch capability and the secondary display
+  // does.
+  ASSERT_NE(display::Display::TouchSupport::TOUCH_SUPPORT_AVAILABLE,
+            display::Screen::GetScreen()->GetPrimaryDisplay().touch_support());
+  ASSERT_EQ(display::Display::TouchSupport::TOUCH_SUPPORT_AVAILABLE,
+            Shell::GetInstance()
+                ->display_manager()
+                ->GetSecondaryDisplay()
+                .touch_support());
+
+  aura::Window::Windows root_windows = Shell::GetAllRootWindows();
+  aura::Window* primary_root_window = Shell::GetPrimaryRootWindow();
+  aura::Window* secondary_root_window = root_windows[0] == primary_root_window
+                                            ? root_windows[1]
+                                            : root_windows[0];
+
+  keyboard::KeyboardController::GetInstance()->ShowKeyboard(false);
+  ASSERT_FALSE(Shell::GetContainer(primary_root_window,
+                                   kShellWindowId_VirtualKeyboardContainer));
+  ASSERT_TRUE(Shell::GetContainer(secondary_root_window,
+                                  kShellWindowId_VirtualKeyboardContainer));
+}

[oshima, 2016/11/08 17:26:05]

can you also test that it opens on the secondary display even if the focused
window is on the primary?

[yhanada, 2016/11/14 22:48:47]

Done.

+
+// Test for http://crbug.com/303429. If both of displays have touch capability,
+// virtual keyboard follows the input focus.
+TEST_F(VirtualKeyboardRootWindowControllerTest, FollowInputFocus) {
+  if (!SupportsMultipleDisplays())
+    return;
+
+  UpdateDisplay("500x500,500x500");
+  const int64_t primary_display_id =
+      display::Screen::GetScreen()->GetPrimaryDisplay().id();
+  display::test::DisplayManagerTestApi(Shell::GetInstance()->display_manager())
+      .SetTouchSupport(primary_display_id,
+                       display::Display::TouchSupport::TOUCH_SUPPORT_AVAILABLE);
+  const int64_t secondary_display_id =
+      Shell::GetInstance()->display_manager()->GetSecondaryDisplay().id();
+  display::test::DisplayManagerTestApi(Shell::GetInstance()->display_manager())
+      .SetTouchSupport(secondary_display_id,
+                       display::Display::TouchSupport::TOUCH_SUPPORT_AVAILABLE);
+
+  // Both of displays have touch capability.
+  ASSERT_EQ(display::Display::TouchSupport::TOUCH_SUPPORT_AVAILABLE,
+            display::Screen::GetScreen()->GetPrimaryDisplay().touch_support());
+  ASSERT_EQ(display::Display::TouchSupport::TOUCH_SUPPORT_AVAILABLE,
+            Shell::GetInstance()
+                ->display_manager()
+                ->GetSecondaryDisplay()
+                .touch_support());
+
+  aura::Window::Windows root_windows = Shell::GetAllRootWindows();
+  aura::Window* primary_root_window = Shell::GetPrimaryRootWindow();
+  aura::Window* secondary_root_window = root_windows[0] == primary_root_window
+                                            ? root_windows[1]
+                                            : root_windows[0];
+  aura::Window* focusable_window_in_primary_display =
+      CreateTestWindowInShellWithBounds(
+          primary_root_window->GetBoundsInScreen());
+  ASSERT_EQ(primary_root_window,
+            focusable_window_in_primary_display->GetRootWindow());
+  aura::Window* focusable_window_in_secondary_display =
+      CreateTestWindowInShellWithBounds(
+          secondary_root_window->GetBoundsInScreen());
+  ASSERT_EQ(secondary_root_window,
+            focusable_window_in_secondary_display->GetRootWindow());
+
+  keyboard::KeyboardController::GetInstance()->ShowKeyboard(false);
+  ASSERT_TRUE(Shell::GetContainer(primary_root_window,
+                                  kShellWindowId_VirtualKeyboardContainer));
+  ASSERT_FALSE(Shell::GetContainer(secondary_root_window,
+                                   kShellWindowId_VirtualKeyboardContainer));
+
+  // Move the focus to the secondary display.
+  focusable_window_in_secondary_display->Focus();
+  ASSERT_TRUE(focusable_window_in_secondary_display->HasFocus());
+
+  keyboard::KeyboardController::GetInstance()->ShowKeyboard(false);
+  ASSERT_FALSE(Shell::GetContainer(primary_root_window,
+                                   kShellWindowId_VirtualKeyboardContainer));
+  ASSERT_TRUE(Shell::GetContainer(secondary_root_window,
+                                  kShellWindowId_VirtualKeyboardContainer));
+
+  // Move back focus to the primary display.
+  focusable_window_in_primary_display->Focus();
+  ASSERT_TRUE(focusable_window_in_primary_display->HasFocus());
+
+  keyboard::KeyboardController::GetInstance()->ShowKeyboard(false);
+  ASSERT_TRUE(Shell::GetContainer(primary_root_window,
+                                  kShellWindowId_VirtualKeyboardContainer));
+  ASSERT_FALSE(Shell::GetContainer(secondary_root_window,
+                                   kShellWindowId_VirtualKeyboardContainer));
+}
+
+// Test for http://crbug.com/303429. Even if both of display don't have touch
+// capability, the virtual keyboard shows up on the specified display.
+TEST_F(VirtualKeyboardRootWindowControllerTest,
+       VirtualKeyboardShowOnSpecifiedDisplay) {
+  if (!SupportsMultipleDisplays())
+    return;
+
+  UpdateDisplay("500x500,500x500");
+  display::Display secondary_display =
+      Shell::GetInstance()->display_manager()->GetSecondaryDisplay();
+
+  aura::Window::Windows root_windows = Shell::GetAllRootWindows();
+  aura::Window* primary_root_window = Shell::GetPrimaryRootWindow();
   aura::Window* secondary_root_window = root_windows[0] == primary_root_window
                                             ? root_windows[1]
                                             : root_windows[0];
 
   ASSERT_TRUE(Shell::GetContainer(primary_root_window,
                                   kShellWindowId_VirtualKeyboardContainer));
   ASSERT_FALSE(Shell::GetContainer(secondary_root_window,
                                    kShellWindowId_VirtualKeyboardContainer));
+
+  const int64_t secondary_display_id = secondary_display.id();
+  keyboard::KeyboardController::GetInstance()->ShowKeyboardInSpecificDisplay(
+      secondary_display_id);
+
+  ASSERT_FALSE(Shell::GetContainer(primary_root_window,
+                                   kShellWindowId_VirtualKeyboardContainer));
+  ASSERT_TRUE(Shell::GetContainer(secondary_root_window,
+                                  kShellWindowId_VirtualKeyboardContainer));
 }
 
 // Test for http://crbug.com/263599. Virtual keyboard should be able to receive
 // events at blocked user session.
 TEST_F(VirtualKeyboardRootWindowControllerTest,
        ClickVirtualKeyboardInBlockedWindow) {
   aura::Window* root_window = Shell::GetPrimaryRootWindow();
   aura::Window* keyboard_container =
       Shell::GetContainer(root_window, kShellWindowId_VirtualKeyboardContainer);
   ASSERT_TRUE(keyboard_container);
@@ skipping 257 matching lines @@
   keyboard_controller->ui()->GetKeyboardWindow()->SetBounds(
       gfx::Rect(0, 400, 800, 200));
   EXPECT_EQ("0,400 800x200", keyboard_container->bounds().ToString());
 
   UpdateDisplay("600x800");
   EXPECT_EQ("0,600 600x200", keyboard_container->bounds().ToString());
 }
 
 }  // namespace test
 }  // namespace ash