[Input View] Makes the input view window support window.resizeTo() and w3c visibility API its web c…

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 "base/bind.h"
 #include "base/command_line.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
@@ skipping 24 matching lines @@
       window_bounds.width(),
       window_bounds.height() * kKeyboardHeightRatio);
 }
 
 // The KeyboardWindowDelegate makes sure the keyboard-window does not get focus.
 // This is necessary to make sure that the synthetic key-events reach the target
 // window.
 // The delegate deletes itself when the window is destroyed.
 class KeyboardWindowDelegate : public aura::WindowDelegate {
  public:
-  KeyboardWindowDelegate() {}
+  explicit KeyboardWindowDelegate(keyboard::KeyboardControllerProxy* proxy)
+      : proxy_(proxy) {}
   virtual ~KeyboardWindowDelegate() {}
 
  private:
   // Overridden from aura::WindowDelegate:
   virtual gfx::Size GetMinimumSize() const OVERRIDE { return gfx::Size(); }
   virtual gfx::Size GetMaximumSize() const OVERRIDE { return gfx::Size(); }
   virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
                                const gfx::Rect& new_bounds) OVERRIDE {
     bounds_ = new_bounds;
   }
@@ skipping 10 matching lines @@
   }
   virtual bool CanFocus() OVERRIDE { return false; }
   virtual void OnCaptureLost() OVERRIDE {}
   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {}
   virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {}
   virtual void OnWindowDestroying() OVERRIDE {}
   virtual void OnWindowDestroyed() OVERRIDE { delete this; }
   virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE {}
   virtual bool HasHitTestMask() const OVERRIDE { return true; }
   virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE {
-    gfx::Rect keyboard_bounds = KeyboardBoundsFromWindowBounds(bounds_);
+    gfx::Rect keyboard_bounds = proxy_ ? proxy_->GetKeyboardWindow()->bounds()
+        : KeyboardBoundsFromWindowBounds(bounds_);
     mask->addRect(RectToSkRect(keyboard_bounds));
   }
   virtual void DidRecreateLayer(ui::Layer* old_layer,
                                 ui::Layer* new_layer) OVERRIDE {}
 
   gfx::Rect bounds_;
+  keyboard::KeyboardControllerProxy* proxy_;
+
   DISALLOW_COPY_AND_ASSIGN(KeyboardWindowDelegate);
 };
 
 }  // namespace
 
 namespace keyboard {
 
 // LayoutManager for the virtual keyboard container.  Manages a single window
 // (the virtual keyboard) and keeps it positioned at the bottom of the
 // owner window.

[bshe, 2013/12/10 21:18:08]

It starts to make sense that we move the KeyboardLayoutManager into a new file
like ui/keyboard/keyboard_layout_manager.*
I will do it once your patch lands.

[Shu Chen, 2013/12/11 00:48:32]

Thank you!

 class KeyboardLayoutManager : public aura::LayoutManager {
  public:
-  KeyboardLayoutManager(aura::Window* container)
-      : container_(container), keyboard_(NULL) {
-    CHECK(container_);
+  explicit KeyboardLayoutManager(KeyboardController* controller)
+      : controller_(controller) {
   }
 
   // Overridden from aura::LayoutManager
-  virtual void OnWindowResized() OVERRIDE {
-    if (!keyboard_)
-      return;
-    SetChildBoundsDirect(keyboard_,
-                         KeyboardBoundsFromWindowBounds(container_->bounds()));
-  }
+  virtual void OnWindowResized() OVERRIDE {}

[sadrul, 2013/12/06 12:30:02]

Did you verify that the keyboard-window gets resized correctly when the
container is resized with this change? What triggers that resize?

[sadrul, 2013/12/09 22:47:01]

You can test this trivially in a test by changing the bounds of the container,
and verifying that the bounds of the keyboard-window also changes when the
container-bounds is changed.

[bshe, 2013/12/10 21:18:08]

Looks like the keyboard-window size is now set by SetChildBounds below when the
bounds of the container changed.

The reason SetChildBounds is called is because of the code in
root_window_layout_manager here:
https://code.google.com/p/chromium/codesearch/#chromium/src/ash/wm/root_windo...

When the screen size changed, root_window_layout_manager try to SetBounds of top
level containers and second level containers. For virtual keyboard, the second
level container is the keyboard window. And it then triggers SetChildBounds
being called in this layout manager. I am not sure if we should SetBounds of
virtual keyboard window from root_window_layout_manager after screen resized
though.


On 2013/12/09 22:47:01, sadrul wrote:

[sadrul, 2013/12/10 21:21:19]

We shouldn't depend on outside code (ash) to maintain the internal state
(keyboard-window height ratio), when it's trivial to maintain the internal state
from here.

[Shu Chen, 2013/12/11 00:48:32]

Test added.

[Shu Chen, 2013/12/11 00:48:32]

I've modified the code to let OnWindowResized handle the resizing from container
(when the flag is not set). Thanks

   virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {
-    DCHECK(!keyboard_);
-    keyboard_ = child;

[sadrul, 2013/12/06 12:30:02]

Why did you remove this code?

[Shu Chen, 2013/12/11 00:48:32]

Done.

+    ResizeKeyboardToDefault(child);
   }
   virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {}
   virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {}
   virtual void OnChildWindowVisibilityChanged(aura::Window* child,
                                               bool visible) OVERRIDE {}
   virtual void SetChildBounds(aura::Window* child,
                               const gfx::Rect& requested_bounds) OVERRIDE {
-    // Drop these: the size should only be set in OnWindowResized.
+    // 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 keyboard is
+    // resizing from which.
+    if (controller_->proxy()->resizing_from_contents()) {
+      controller_->NotifyKeyboardBoundsChanging(requested_bounds);
+      SetChildBoundsDirect(child, requested_bounds);
+    } else {
+      ResizeKeyboardToDefault(child);
+    }
   }
 
  private:
-  aura::Window* container_;
-  aura::Window* keyboard_;
+  void ResizeKeyboardToDefault(aura::Window* child) {
+    gfx::Rect keyboard_bounds = KeyboardBoundsFromWindowBounds(
+        controller_->GetContainerWindow()->bounds());
+    SetChildBoundsDirect(child, keyboard_bounds);
+  }
+
+  KeyboardController* controller_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardLayoutManager);
 };
 
 KeyboardController::KeyboardController(KeyboardControllerProxy* proxy)
     : proxy_(proxy),
       input_method_(NULL),
       keyboard_visible_(false),
       weak_factory_(this) {
   CHECK(proxy);
   input_method_ = proxy_->GetInputMethod();
   input_method_->AddObserver(this);
 }
 
 KeyboardController::~KeyboardController() {
-  if (container_.get())
+  if (container_.get()) {
     container_->RemoveObserver(this);
+    // Remove the keyboard window from the children because the keyboard window
+    // is owned by proxy and it should be destroyed by proxy.
+    if (container_->Contains(proxy_->GetKeyboardWindow())) {
+      container_->RemoveChild(proxy_->GetKeyboardWindow());
+    }
+  }
   if (input_method_)
     input_method_->RemoveObserver(this);
 }
 
 aura::Window* KeyboardController::GetContainerWindow() {
   if (!container_.get()) {
-    container_.reset(new aura::Window(new KeyboardWindowDelegate()));
+    container_.reset(new aura::Window(
+        new KeyboardWindowDelegate(proxy_.get())));
     container_->SetName("KeyboardContainer");
     container_->set_owned_by_parent(false);
     container_->Init(ui::LAYER_NOT_DRAWN);
     container_->AddObserver(this);
-    container_->SetLayoutManager(new KeyboardLayoutManager(container_.get()));
+    container_->SetLayoutManager(new KeyboardLayoutManager(this));
   }
   return container_.get();
 }
 
+void KeyboardController::NotifyKeyboardBoundsChanging(
+    const gfx::Rect& new_bounds) {
+  if (proxy_ && proxy_->GetKeyboardWindow()->IsVisible()) {

[sadrul, 2013/12/06 12:30:02]

DCHECK(proxy_)

[Shu Chen, 2013/12/11 00:48:32]

Done.

+    FOR_EACH_OBSERVER(KeyboardControllerObserver,
+                      observer_list_,
+                      OnKeyboardBoundsChanging(new_bounds));
+  }
+}
+
 void KeyboardController::HideKeyboard(HideReason reason) {
   keyboard_visible_ = false;
 
   keyboard::LogKeyboardControlEvent(
       reason == HIDE_REASON_AUTOMATIC ?
           keyboard::KEYBOARD_CONTROL_HIDE_AUTO :
           keyboard::KEYBOARD_CONTROL_HIDE_USER);
 
-  FOR_EACH_OBSERVER(KeyboardControllerObserver,
-                    observer_list_,
-                    OnKeyboardBoundsChanging(gfx::Rect()));
+  NotifyKeyboardBoundsChanging(gfx::Rect());
 
   proxy_->HideKeyboardContainer(container_.get());
 }
 
 void KeyboardController::AddObserver(KeyboardControllerObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void KeyboardController::RemoveObserver(KeyboardControllerObserver* observer) {
   observer_list_.RemoveObserver(observer);
@@ skipping 20 matching lines @@
       client ? client->GetTextInputType() : ui::TEXT_INPUT_TYPE_NONE;
   if (type == ui::TEXT_INPUT_TYPE_NONE &&
       !IsKeyboardUsabilityExperimentEnabled()) {
     should_show = false;
   } else {
     if (container_->children().empty()) {
       keyboard::MarkKeyboardLoadStarted();
       aura::Window* keyboard = proxy_->GetKeyboardWindow();
       keyboard->Show();
       container_->AddChild(keyboard);
-      container_->layout_manager()->OnWindowResized();
     }
     if (type != ui::TEXT_INPUT_TYPE_NONE)
       proxy_->SetUpdateInputType(type);
     container_->parent()->StackChildAtTop(container_.get());
     should_show = true;
   }
 
   if (was_showing != should_show) {
     if (should_show) {
       keyboard_visible_ = true;
 
       // If the controller is in the process of hiding the keyboard, do not log
       // the stat here since the keyboard will not actually be shown.
       if (!WillHideKeyboard())
         keyboard::LogKeyboardControlEvent(keyboard::KEYBOARD_CONTROL_SHOW);
 
       weak_factory_.InvalidateWeakPtrs();
       if (container_->IsVisible())
         return;
 
-      FOR_EACH_OBSERVER(
-          KeyboardControllerObserver,
-          observer_list_,
-          OnKeyboardBoundsChanging(container_->children()[0]->bounds()));
+      NotifyKeyboardBoundsChanging(container_->children()[0]->bounds());
+
       proxy_->ShowKeyboardContainer(container_.get());
     } else {
       // Set the visibility state here so that any queries for visibility
       // before the timer fires returns the correct future value.
       keyboard_visible_ = false;
       base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&KeyboardController::HideKeyboard,
                      weak_factory_.GetWeakPtr(), HIDE_REASON_AUTOMATIC),
           base::TimeDelta::FromMilliseconds(kHideKeyboardDelayMs));
     }
   }
   // TODO(bryeung): whenever the TextInputClient changes we need to notify the
   // keyboard (with the TextInputType) so that it can reset it's state (e.g.
   // abandon compositions in progress)
 }
 
 void KeyboardController::OnInputMethodDestroyed(
     const ui::InputMethod* input_method) {
   DCHECK_EQ(input_method_, input_method);
   input_method_ = NULL;
 }
 
 bool KeyboardController::WillHideKeyboard() const {
   return weak_factory_.HasWeakPtrs();
 }
 
 }  // namespace keyboard