Adjust virtual keyboard size base on input method candidates.

chrome/browser/ui/touch/frame/touch_browser_frame_view.cc

 // Copyright (c) 2011 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 "chrome/browser/ui/touch/frame/touch_browser_frame_view.h"
 
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/render_widget_host_view_views.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 10 matching lines @@
 #include "content/common/view_messages.h"
 #include "ui/base/animation/slide_animation.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 #include "views/controls/button/image_button.h"
 #include "views/controls/textfield/textfield.h"
 #include "views/focus/focus_manager.h"
 
 namespace {
 
-const int kKeyboardHeight = 360;
+const int kDefaultKeyboardHeight = 300;
 const int kKeyboardSlideDuration = 500;  // In milliseconds
 
 PropertyAccessor<bool>* GetFocusedStateAccessor() {
   static PropertyAccessor<bool> state;
   return &state;
 }
 
 bool TabContentsHasFocus(const TabContents* contents) {
   views::View* view = static_cast<TabContentsViewTouch*>(contents->view());
   return view->Contains(view->GetFocusManager()->GetFocusedView());
 }
 
 }  // namespace
 
 // static
 const char TouchBrowserFrameView::kViewClassName[] =
     "browser/ui/touch/frame/TouchBrowserFrameView";
 
 ///////////////////////////////////////////////////////////////////////////////
 // TouchBrowserFrameView, public:
 
 TouchBrowserFrameView::TouchBrowserFrameView(BrowserFrame* frame,
                                              BrowserView* browser_view)
     : OpaqueBrowserFrameView(frame, browser_view),
       keyboard_showing_(false),
+      keyboard_height_(kDefaultKeyboardHeight),
       focus_listener_added_(false),
       keyboard_(NULL) {
   registrar_.Add(this,
                  NotificationType::NAV_ENTRY_COMMITTED,
                  NotificationService::AllSources());
   registrar_.Add(this,
                  NotificationType::FOCUS_CHANGED_IN_PAGE,
                  NotificationService::AllSources());
   registrar_.Add(this,
                  NotificationType::TAB_CONTENTS_DESTROYED,
                  NotificationService::AllSources());
   registrar_.Add(this,
                  NotificationType::HIDE_KEYBOARD_INVOKED,
                  NotificationService::AllSources());
+  registrar_.Add(this,
+                 NotificationType::SET_KEYBOARD_HEIGHT_INVOKED,
+                 NotificationService::AllSources());
 
   browser_view->browser()->tabstrip_model()->AddObserver(this);
 
   animation_.reset(new ui::SlideAnimation(this));
   animation_->SetTweenType(ui::Tween::LINEAR);
   animation_->SetSlideDuration(kKeyboardSlideDuration);
 }
 
 TouchBrowserFrameView::~TouchBrowserFrameView() {
   browser_view()->browser()->tabstrip_model()->RemoveObserver(this);
 }
 
 std::string TouchBrowserFrameView::GetClassName() const {
   return kViewClassName;
 }
 
 void TouchBrowserFrameView::Layout() {
   OpaqueBrowserFrameView::Layout();
 
   if (!keyboard_)
     return;
 
   keyboard_->SetVisible(keyboard_showing_ || animation_->is_animating());
   gfx::Rect bounds = GetBoundsForReservedArea();
   if (animation_->is_animating() && !keyboard_showing_) {
     // The keyboard is in the process of hiding. So pretend it still has the
     // same bounds as when the keyboard is visible. But
     // |GetBoundsForReservedArea| should not take this into account so that the
     // render view gets the entire area to relayout itself.
-    bounds.set_y(bounds.y() - kKeyboardHeight);
-    bounds.set_height(kKeyboardHeight);
+    bounds.set_y(bounds.y() - keyboard_height_);
+    bounds.set_height(keyboard_height_);
   }
   keyboard_->SetBoundsRect(bounds);
 }
 
 void TouchBrowserFrameView::FocusWillChange(views::View* focused_before,
                                             views::View* focused_now) {
   VirtualKeyboardType before = DecideKeyboardStateForView(focused_before);
   VirtualKeyboardType now = DecideKeyboardStateForView(focused_now);
   if (before != now) {
     // TODO(varunjain): support other types of keyboard.
     UpdateKeyboardAndLayout(now == GENERIC);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TouchBrowserFrameView, protected:
 int TouchBrowserFrameView::GetReservedHeight() const {
-  return keyboard_showing_ ? kKeyboardHeight : 0;
+  return keyboard_showing_ ? keyboard_height_ : 0;
 }
 
 void TouchBrowserFrameView::ViewHierarchyChanged(bool is_add,
                                                  View* parent,
                                                  View* child) {
   OpaqueBrowserFrameView::ViewHierarchyChanged(is_add, parent, child);
   if (!GetFocusManager())
     return;
 
   if (is_add && !focus_listener_added_) {
@@ skipping 37 matching lines @@
     animation_->Show();
 
     // We don't re-layout the client view until the animation ends (see
     // AnimationEnded below) because we want the client view to occupy the
     // entire height during the animation.
     Layout();
   } else {
     animation_->Hide();
 
     browser_view()->set_clip_y(ui::Tween::ValueBetween(
-          animation_->GetCurrentValue(), 0, kKeyboardHeight));
+          animation_->GetCurrentValue(), 0, keyboard_height_));
     parent()->Layout();
   }
 }
 
 TouchBrowserFrameView::VirtualKeyboardType
     TouchBrowserFrameView::DecideKeyboardStateForView(views::View* view) {
   if (!view)
     return NONE;
 
   std::string cname = view->GetClassName();
@@ skipping 91 matching lines @@
   } else if (type == NotificationType::PREF_CHANGED) {
     OpaqueBrowserFrameView::Observe(type, source, details);
   } else if (type == NotificationType::HIDE_KEYBOARD_INVOKED) {
     TabContents* tab_contents =
         browser_view()->browser()->GetSelectedTabContents();
     if (tab_contents) {
       GetFocusedStateAccessor()->SetProperty(tab_contents->property_bag(),
                                              false);
     }
     UpdateKeyboardAndLayout(false);
+  } else if (type == NotificationType::SET_KEYBOARD_HEIGHT_INVOKED) {
+    int height = *reinterpret_cast<int*>(details.map_key());
+    if (height != keyboard_height_) {
+      DCHECK_GE(height, 0) << "Height of the keyboar is less than 0.";
+      DCHECK_LE(height, View::height()) << "Height of the keyboard is great "
+        "than the height of frame view.";
+      keyboard_height_ = height;

[bryeung, 2011/06/07 22:45:03]

Please do not set the height or call Layout if the height is invalid.

I would suggest putting an if statement immediately after getting the height to
check if it is valid (instead of the DCHECKs).  If it is invalid, you could log
an error.

[Peng, 2011/06/08 14:59:57]

I added code in extension_input_api.cc to check the height to make sure it is
not less than 0.

For height > View::height(), I think we could keep using current code. In
future, we will refactory the CL to allow 
extension_input_api.cc access virtual keyboard directly. So we could check it
and return an error to javascript.

I added some TODO in code for them.

Done

+      parent()->Layout();
+    }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ui::AnimationDelegate implementation
 void TouchBrowserFrameView::AnimationProgressed(const ui::Animation* anim) {
   ui::Transform transform;
   transform.SetTranslateY(
-      ui::Tween::ValueBetween(anim->GetCurrentValue(), kKeyboardHeight, 0));
+      ui::Tween::ValueBetween(anim->GetCurrentValue(), keyboard_height_, 0));
   keyboard_->SetTransform(transform);
   browser_view()->set_clip_y(
-      ui::Tween::ValueBetween(anim->GetCurrentValue(), 0, kKeyboardHeight));
+      ui::Tween::ValueBetween(anim->GetCurrentValue(), 0, keyboard_height_));
   SchedulePaint();
 }
 
 void TouchBrowserFrameView::AnimationEnded(const ui::Animation* animation) {
   browser_view()->set_clip_y(0);
   if (keyboard_showing_) {
     // Because the NonClientFrameView is a sibling of the ClientView, we rely on
     // the parent to resize the ClientView instead of resizing it directly.
     parent()->Layout();
 
     // The keyboard that pops up may end up hiding the text entry. So make sure
     // the renderer scrolls when necessary to keep the textfield visible.
     RenderViewHost* host =
         browser_view()->browser()->GetSelectedTabContents()->render_view_host();
     host->Send(new ViewMsg_ScrollFocusedEditableNodeIntoView(
         host->routing_id()));
   }
   SchedulePaint();
 }