[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() {}
+  KeyboardWindowDelegate(keyboard::KeyboardControllerProxy* proxy)

[sadrul, 2013/12/04 17:35:20]

explicit

[Shu Chen, 2013/12/05 05:01:39]

Done.

+      : 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.
 class KeyboardLayoutManager : public aura::LayoutManager {
  public:
-  KeyboardLayoutManager(aura::Window* container)
-      : container_(container), keyboard_(NULL) {
-    CHECK(container_);
+  KeyboardLayoutManager(KeyboardController* controller)

[sadrul, 2013/12/04 17:35:20]

explicit here too

[Shu Chen, 2013/12/05 05:01:39]

Done.

+      : controller_(controller), keyboard_(NULL) {
   }
 
   // Overridden from aura::LayoutManager
   virtual void OnWindowResized() OVERRIDE {
     if (!keyboard_)
       return;
-    SetChildBoundsDirect(keyboard_,
-                         KeyboardBoundsFromWindowBounds(container_->bounds()));
+    gfx::Rect keyboard_bounds = KeyboardBoundsFromWindowBounds(
+        controller_->GetContainerWindow()->bounds());
+    // Don't notify keyboard bounds changing, because the bounds has been
+    // changed here.

[kevers, 2013/12/04 15:18:28]

Nit: Find this comment more confusing than helpful.  Consider removing.

[sadrul, 2013/12/04 17:35:20]

+1

[Shu Chen, 2013/12/05 05:01:39]

Done.

[Shu Chen, 2013/12/05 05:01:39]

Done.

+    SetChildBoundsDirect(keyboard_, keyboard_bounds);

[sadrul, 2013/12/04 17:35:20]

We should not be doing this when proxy::resizing_from_contents() is set, right?

[Shu Chen, 2013/12/05 05:01:39]

I think it won't happen because the flag resizing_from_contents() is supposed to
be auto-reset from MoveContents() to SetChildBounds(). OnWindowResized()
shouldn't be called in the middle.

Anyway, I've removed the implementation of OnWindowResized() per your comments
in SetChildBounds().

   }
   virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {
     DCHECK(!keyboard_);
     keyboard_ = 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).
+    // OnWindowResized() can take care of resizing from the container.
+    // While here should only take care of resizing from the contents.
+    if (controller_->proxy()->resizing_from_contents()) {
+      controller_->NotifyKeyboardBoundsChanging(requested_bounds);
+      SetChildBoundsDirect(child, requested_bounds);
+      controller_->proxy()->set_resizing_from_contents(false);

[sadrul, 2013/12/04 17:35:20]

Why reset here?

[Shu Chen, 2013/12/05 05:01:39]

After finishing resizing the web content window, we should reset the flag.

+    }

[sadrul, 2013/12/04 17:35:20]

I think you should just do keyboard_->SetBounds() in OnWindowResized(), and call
SetChildBoundsDirect() in here, with |requested_bounds| if
resizing_from_contents(), and with KeyboardBoundsFromWindowBounds() otherwise.

[Shu Chen, 2013/12/05 05:01:39]

When resizing from contents, the code flow is
WebContentsDelegate::MoveContents() -> aura::LayoutManager::SetChildBounds(),
which is nothing to do with OnWindowResized() here.

OnWindowResized() is called when the keyboard container window is resized (e.g.
screen rotate, etc.).
I found that when OnWindowResized() happens, SetChildBounds() also happens.

Therefore, OnWindowResized() is useless, we only need to implement
SetChildBounds().

   }
 
  private:
-  aura::Window* container_;
+  KeyboardController* controller_;
   aura::Window* keyboard_;
 
   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())
     container_->RemoveObserver(this);
   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()) {
+    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 41 matching lines @@
 
       // 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