[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)
+      : 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;
-  }
+                               const gfx::Rect& new_bounds) OVERRIDE {}
   virtual gfx::NativeCursor GetCursor(const gfx::Point& point) OVERRIDE {
     return gfx::kNullCursor;
   }
   virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE {
     return HTNOWHERE;
   }
   virtual bool ShouldDescendIntoChildForEventHandling(
       aura::Window* child,
       const gfx::Point& location) OVERRIDE {
     return true;
   }
   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()
+        : gfx::Rect();
     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)
+      : 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());
+    // Records the keyboard new height. So that GetHitTestMask() can set the
+    // same keyboard bounds as the hit test mask.
+    SetChildBoundsDirect(keyboard_, keyboard_bounds);
+    controller_->NotifyKeyboardBoundsChanged(keyboard_bounds);

[kevers, 2013/12/03 02:53:07]

Is NotifyKeyboardBoundsChanged going to fire twice for the same resize event:
once in SetChildBounds and once here?  Possible that this notification and the
call to SetChildBoundsDirect should only be called if no resizing from contents.

[Shu Chen, 2013/12/03 04:12:25]

Done. I've removed this line and add comments.

   }
   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()) {
+      SetChildBoundsDirect(child, requested_bounds);
+      controller_->NotifyKeyboardBoundsChanged(requested_bounds);
+      controller_->proxy()->set_resizing_from_contents(false);
+    }
   }
 
  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::NotifyKeyboardBoundsChanged(
+    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()));
+  NotifyKeyboardBoundsChanged(gfx::Rect());

[kevers, 2013/12/03 02:53:07]

Will we now get extra notifications: here and when we pick up the size change?
There is also a verb tense change that is confusing.  We call notify changed,
but this dispatches to the observers that the size is changing. The
notifications here, were firing before that actual size change fires. We're also
calling the same notifications after the size change takes place. If we need
notifications after the change, we should be calling a separate method on the
observer.

[Shu Chen, 2013/12/03 04:12:25]

Done. I've renamed the method to NotifyKeyboardBoundsChanging.

Let's do a separated cl to address your comments about supporting both
BoundsChanging and BoundsChanged calls in KeyboardObserver.

 
   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()));
+      NotifyKeyboardBoundsChanged(container_->children()[0]->bounds());

[kevers, 2013/12/03 02:53:07]

See previous comment.

[Shu Chen, 2013/12/03 04:12:25]

Done.

+
       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