[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 72 matching lines @@
   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 {
+class KeyboardLayoutManager : public aura::LayoutManager,
+                              public KeyboardResizer {
  public:
   KeyboardLayoutManager(aura::Window* container)
-      : container_(container), keyboard_(NULL) {
+      : container_(container), keyboard_(NULL), resizing_(false) {
     CHECK(container_);
   }
 
+  // Overridden from KeyboardResizer
+  virtual void SetKeyboardHeight(int height) {
+    gfx::Rect rect = keyboard_->bounds();
+    int old_height = rect.height();
+    rect.set_height(height);
+    rect.set_y(rect.y() + old_height - height);
+    resizing_ = true;
+    keyboard_->SetBounds(rect);
+    resizing_ = false;
+  }
+
   // Overridden from aura::LayoutManager
   virtual void OnWindowResized() OVERRIDE {
     if (!keyboard_)
       return;
     SetChildBoundsDirect(keyboard_,
                          KeyboardBoundsFromWindowBounds(container_->bounds()));
   }
   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.
+    if (resizing_) {
+      SetChildBoundsDirect(child, requested_bounds);
+    }
   }
 
  private:
   aura::Window* container_;
   aura::Window* keyboard_;
+  bool resizing_;
 
   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_->SetName("KeyboardContainer");
     container_->set_owned_by_parent(false);
     container_->Init(ui::LAYER_NOT_DRAWN);
     container_->AddObserver(this);
-    container_->SetLayoutManager(new KeyboardLayoutManager(container_.get()));
+    KeyboardLayoutManager* layout_manager = new KeyboardLayoutManager(
+        container_.get());
+    proxy_->SetKeyboardResizer(layout_manager);
+    container_->SetLayoutManager(layout_manager);

[kevers, 2013/11/29 20:26:05]

It looks a bit odd passing a raw pointer to 2 separate objects.  Appears to be
safe in this case only because the container and proxy have the same lifetime. 
Perhaps a comment is warranted.

[Shu Chen, 2013/12/02 03:54:40]

Done. I've refactored the changes and removed the keyboard resizer.

   }
   return container_.get();
 }
 
 void KeyboardController::HideKeyboard(HideReason reason) {
   keyboard_visible_ = false;
 
   keyboard::LogKeyboardControlEvent(
       reason == HIDE_REASON_AUTOMATIC ?
           keyboard::KEYBOARD_CONTROL_HIDE_AUTO :
@@ skipping 88 matching lines @@
     const ui::InputMethod* input_method) {
   DCHECK_EQ(input_method_, input_method);
   input_method_ = NULL;
 }
 
 bool KeyboardController::WillHideKeyboard() const {
   return weak_factory_.HasWeakPtrs();
 }
 
 }  // namespace keyboard