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

ui/keyboard/keyboard_controller.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 <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
+#include "ui/display/types/display_constants.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/keyboard/keyboard_controller_observer.h"
 #include "ui/keyboard/keyboard_layout_manager.h"
 #include "ui/keyboard/keyboard_ui.h"
 #include "ui/keyboard/keyboard_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/process/launch.h"
@@ skipping 123 matching lines @@
 }
 
 void CallbackAnimationObserver::OnLayerAnimationAborted(
     ui::LayerAnimationSequence* seq) {
   animator_->RemoveObserver(this);
 }
 
 // static
 KeyboardController* KeyboardController::instance_ = NULL;
 
-KeyboardController::KeyboardController(KeyboardUI* ui)
+KeyboardController::KeyboardController(KeyboardUI* ui,
+                                       KeyboardLayoutDelegate* delegate)
     : ui_(ui),
+      layout_delegate_(delegate),
       input_method_(NULL),
       keyboard_visible_(false),
       show_on_resize_(false),
-      lock_keyboard_(false),
+      keyboard_locked_(false),
       keyboard_mode_(FULL_WIDTH),
       type_(ui::TEXT_INPUT_TYPE_NONE),
       weak_factory_(this) {
   CHECK(ui);
   input_method_ = ui_->GetInputMethod();
   input_method_->AddObserver(this);
   ui_->SetController(this);
 }
 
 KeyboardController::~KeyboardController() {
@@ skipping 52 matching lines @@
   keyboard_visible_ = false;
   ToggleTouchEventLogging(true);
 
   keyboard::LogKeyboardControlEvent(
       reason == HIDE_REASON_AUTOMATIC ?
           keyboard::KEYBOARD_CONTROL_HIDE_AUTO :
           keyboard::KEYBOARD_CONTROL_HIDE_USER);
 
   NotifyKeyboardBoundsChanging(gfx::Rect());
 
-  set_lock_keyboard(false);
+  set_keyboard_locked(false);
 
   ui::LayerAnimator* container_animator = container_->layer()->GetAnimator();
   animation_observer_.reset(new CallbackAnimationObserver(
       container_animator,
       base::Bind(&KeyboardController::HideAnimationFinished,
                  base::Unretained(this))));
   container_animator->AddObserver(animation_observer_.get());
 
   ui::ScopedLayerAnimationSettings settings(container_animator);
   settings.SetTweenType(gfx::Tween::FAST_OUT_LINEAR_IN);
@@ skipping 30 matching lines @@
     gfx::Rect new_bounds = root_bounds;
     new_bounds.set_y(root_bounds.height() - keyboard_height);
     new_bounds.set_height(keyboard_height);
     GetContainerWindow()->SetBounds(new_bounds);
     // No animation added, so call ShowAnimationFinished immediately.
     ShowAnimationFinished();
   }
 }
 
 void KeyboardController::ShowKeyboard(bool lock) {
-  set_lock_keyboard(lock);
-  ShowKeyboardInternal();
+  set_keyboard_locked(lock);
+  ShowKeyboardInternal(display::kInvalidDisplayId);
+}
+
+void KeyboardController::ShowKeyboardInDisplay(int64_t display_id) {
+  set_keyboard_locked(true);
+  ShowKeyboardInternal(display_id);
 }
 
 void KeyboardController::OnWindowHierarchyChanged(
     const HierarchyChangeParams& params) {
   if (params.new_parent && params.target == container_.get())
     OnTextInputStateChanged(ui_->GetInputMethod()->GetTextInputClient());
 }
 
 void KeyboardController::OnWindowAddedToRootWindow(aura::Window* window) {
   if (!window->GetRootWindow()->HasObserver(this))
@@ skipping 43 matching lines @@
   }
 }
 
 void KeyboardController::OnTextInputStateChanged(
     const ui::TextInputClient* client) {
   if (!container_.get())
     return;
 
   type_ = client ? client->GetTextInputType() : ui::TEXT_INPUT_TYPE_NONE;
 
-  if (type_ == ui::TEXT_INPUT_TYPE_NONE && !lock_keyboard_) {
+  if (type_ == ui::TEXT_INPUT_TYPE_NONE && !keyboard_locked_) {
     if (keyboard_visible_) {
       // Set the visibility state here so that any queries for visibility
       // before the timer fires returns the correct future value.
       keyboard_visible_ = false;
       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&KeyboardController::HideKeyboard,
                      weak_factory_.GetWeakPtr(), HIDE_REASON_AUTOMATIC),
           base::TimeDelta::FromMilliseconds(kHideKeyboardDelayMs));
     }
@@ skipping 12 matching lines @@
   }
 }
 
 void KeyboardController::OnInputMethodDestroyed(
     const ui::InputMethod* input_method) {
   DCHECK_EQ(input_method_, input_method);
   input_method_ = NULL;
 }
 
 void KeyboardController::OnShowImeIfNeeded() {
-  if (IsKeyboardEnabled())
-    ShowKeyboardInternal();
+  // Calling |ShowKeyboardInternal| may move the keyboard to another display.
+  if (IsKeyboardEnabled() && !keyboard_locked())
+    ShowKeyboardInternal(display::kInvalidDisplayId);
 }
 
-void KeyboardController::ShowKeyboardInternal() {
+void KeyboardController::ShowKeyboardInternal(int64_t display_id) {
   if (!container_.get())
     return;
 
   if (container_->children().empty()) {
     keyboard::MarkKeyboardLoadStarted();
     aura::Window* keyboard = ui_->GetKeyboardWindow();
     keyboard->Show();
     container_->AddChild(keyboard);
     keyboard->set_owned_by_parent(false);
   }
 
   ui_->ReloadKeyboardIfNeeded();
 
+  if (layout_delegate_ != nullptr) {
+    if (display_id != display::kInvalidDisplayId)
+      layout_delegate_->MoveKeyboardToDisplay(display_id);
+    else
+      layout_delegate_->MoveKeyboardToTouchableDisplay();
+  }
+
   if (keyboard_visible_) {
     return;
   } else if (ui_->GetKeyboardWindow()->bounds().height() == 0) {
     show_on_resize_ = true;
     return;
   }
 
   keyboard_visible_ = true;
 
   // If the controller is in the process of hiding the keyboard, do not log
@@ skipping 62 matching lines @@
   ui_->EnsureCaretInWorkArea();
 }
 
 void KeyboardController::HideAnimationFinished() {
   ui_->HideKeyboardContainer(container_.get());
   for (KeyboardControllerObserver& observer : observer_list_)
     observer.OnKeyboardHidden();
 }
 
 }  // namespace keyboard