Allow javascript change the virtual keyboard window size and position freely in FLOATING mode

ui/keyboard/keyboard_layout_manager.cc

 // Copyright 2014 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_layout_manager.h"
 
 #include "ui/compositor/layer_animator.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_controller_proxy.h"
 #include "ui/keyboard/keyboard_util.h"
 
 namespace keyboard {
 
 // Overridden from aura::LayoutManager
 void KeyboardLayoutManager::OnWindowResized() {
   if (keyboard_) {
-    gfx::Rect window_bounds = controller_->GetContainerWindow()->bounds();
-    // Keep the same height when window resize. It usually get called when
-    // screen rotate.
-    int height = keyboard_->bounds().height();
-    keyboard_->SetBounds(gfx::Rect(
-        window_bounds.x(),
-        window_bounds.bottom() - height,
-        window_bounds.width(),
-        height));
+    // Container window is the top level window of the virtual keyboard window.
+    // To support window.moveTo for the virtual keyboard window, as it actually
+    // moves the top level window, the container window should be set to the
+    // desired bounds before changing the bounds of the virtual keyboard window.
+    gfx::Rect container_bounds = controller_->GetContainerWindow()->bounds();
+    // Always align container window and keyboard window.
+    SetChildBoundsDirect(keyboard_, gfx::Rect(0, 0, container_bounds.width(),
+                                              container_bounds.height()));
   }
 }
 
 void KeyboardLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
   DCHECK(!keyboard_);
   keyboard_ = child;
-  keyboard_->SetBounds(DefaultKeyboardBoundsFromWindowBounds(
-      controller_->GetContainerWindow()->bounds()));
+  if (controller_->keyboard_mode() == FULL_WIDTH) {
+    controller_->GetContainerWindow()->SetBounds(
+        DefaultKeyboardBoundsFromWindowBounds(
+            controller_->GetContainerWindow()->GetRootWindow()->bounds()));
+  } else if (controller_->keyboard_mode() == FLOATING) {
+    controller_->GetContainerWindow()->SetBounds(child->bounds());

[sadrul, 2015/03/20 17:32:17]

Looks like you are setting container-bounds == keyboard-bounds. That wouldn't do
the right thing when keyboard-bounds origin is not at (0,0), right? For example,
if child-bounds == (0, 100, 500, 300), then setting the container's bounds to
(0, 100, 500, 300) would end up (assuming the container's parent is at (0,0))
moving the keyboard window at (0, 200) in the screen, and parts of the
keyboard-window will fall out of the container window.

[bshe, 2015/03/27 16:29:16]

Discussed offline. The child bounds is used by container window first. After we
positioned container window to where the child suppose to be positioned, we then
set child bounds to (0, 0, width, height) in container window (see line 23 in
this file).  So in the above example, the keyboard window is still at (0, 100,
500, 300). Add a SetChildDirect call to make code easier to read.

+  }
 }
 
 void KeyboardLayoutManager::SetChildBounds(aura::Window* child,
                                            const gfx::Rect& requested_bounds) {
-  // SetChildBounds can be invoked by resizing from the container or by
-  // resizing from the contents (through window.resizeTo call in JS).
-  // The flag resizing_from_contents() is used to determine the source of the
-  // resize.
   DCHECK(child == keyboard_);
 
+  // Request to change the bounds of child window (AKA the virtual keyboard
+  // window) should change the container window first. Then the child window is
+  // resized and covers the container window. Note the child's bound is only set
+  // in OnWindowResized.
+  gfx::Rect old_bounds = controller_->GetContainerWindow()->bounds();
+  gfx::Rect new_bounds = requested_bounds;
+  if (controller_->keyboard_mode() == FULL_WIDTH) {
+    gfx::Rect window_bounds =
+        controller_->GetContainerWindow()->GetRootWindow()->bounds();
+    new_bounds.set_y(window_bounds.height() - new_bounds.height());
+    new_bounds.set_width(window_bounds.width());
+  }
+  // Keyboard bounds should only be reset when it actually changes. Otherwise
+  // it interrupts the initial animation of showing the keyboard. Described in
+  // crbug.com/356753.
+  if (new_bounds == old_bounds) {
+    return;
+  }
+
   ui::LayerAnimator* animator =
       controller_->GetContainerWindow()->layer()->GetAnimator();
   // Stops previous animation if a window resize is requested during animation.
   if (animator->is_animating())
     animator->StopAnimating();
 
-  gfx::Rect old_bounds = child->bounds();
-  SetChildBoundsDirect(child, requested_bounds);
-  if (old_bounds.height() == 0 && child->bounds().height() != 0 &&
-      controller_->show_on_resize()) {
-    // The window height is set to 0 initially or before switch to an IME in a
-    // different extension. Virtual keyboard window may wait for this bounds
-    // change to correctly animate in.
-    controller_->ShowKeyboard(false);
-  } else {
-    // We need to send out this notification only if keyboard is visible since
-    // keyboard window is resized even if keyboard is hidden.
-    if (controller_->keyboard_visible())
-      controller_->NotifyKeyboardBoundsChanging(requested_bounds);
+  controller_->GetContainerWindow()->SetBounds(new_bounds);
+
+  if (controller_->keyboard_mode() == FULL_WIDTH) {
+    if (old_bounds.height() == 0 && child->bounds().height() != 0 &&
+        controller_->show_on_resize()) {
+      // The window height is set to 0 initially or before switch to an IME in a
+      // different extension. Virtual keyboard window may wait for this bounds
+      // change to correctly animate in.
+      controller_->ShowKeyboard(false);
+    } else {
+      // We need to send out this notification only if keyboard is visible since
+      // keyboard window is resized even if keyboard is hidden.
+      if (controller_->keyboard_visible())
+        controller_->NotifyKeyboardBoundsChanging(requested_bounds);
+    }
+  } else if (controller_->keyboard_mode() == FLOATING) {
+    controller_->NotifyKeyboardBoundsChanging(gfx::Rect());
   }
 }
 
 }  // namespace keyboard