Implement overscroll support for the virtual keyboard.

content/renderer/render_widget.cc

 // Copyright (c) 2012 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 "content/renderer/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_synthetic_delay.h"
@@ skipping 168 matching lines @@
 
   // The following methods alter handlers' behavior for messages related to
   // widget size and position.
   void OnResizeMessage(const ViewMsg_Resize_Params& params);
   void OnUpdateScreenRectsMessage(const gfx::Rect& view_screen_rect,
                                   const gfx::Rect& window_screen_rect);
   void OnShowContextMenu(ContextMenuParams* params);
 
  private:
   void Reapply();
-  void Apply(float overdraw_bottom_height,
+  void Apply(float overdraw_bottom_height, int visible_viewport_height,
       gfx::Rect resizer_rect, bool is_fullscreen);
 
   RenderWidget* widget_;
 
   // Parameters as passed by RenderWidget::EnableScreenMetricsEmulation.
   WebDeviceEmulationParams params_;
 
   // The computed scale and offset used to fit widget into browser window.
   float scale_;
   gfx::Point offset_;
@@ skipping 13 matching lines @@
     RenderWidget* widget,
     const WebDeviceEmulationParams& params)
     : widget_(widget),
       params_(params),
       scale_(1.f) {
   original_size_ = widget_->size_;
   original_physical_backing_size_ = widget_->physical_backing_size_;
   original_screen_info_ = widget_->screen_info_;
   original_view_screen_rect_ = widget_->view_screen_rect_;
   original_window_screen_rect_ = widget_->window_screen_rect_;
-  Apply(widget_->overdraw_bottom_height_,
+  Apply(widget_->overdraw_bottom_height_, widget_->visible_viewport_height_,
         widget_->resizer_rect_, widget_->is_fullscreen_);
 }
 
 RenderWidget::ScreenMetricsEmulator::~ScreenMetricsEmulator() {
   widget_->screen_info_ = original_screen_info_;
 
   widget_->SetDeviceScaleFactor(original_screen_info_.deviceScaleFactor);
   widget_->SetScreenMetricsEmulationParameters(0.f, gfx::Point(), 1.f);
   widget_->view_screen_rect_ = original_view_screen_rect_;
   widget_->window_screen_rect_ = original_window_screen_rect_;
   widget_->Resize(original_size_, original_physical_backing_size_,
-      widget_->overdraw_bottom_height_, widget_->resizer_rect_,
-      widget_->is_fullscreen_, NO_RESIZE_ACK);
+      widget_->overdraw_bottom_height_, widget_->visible_viewport_height_,
+      widget_->resizer_rect_, widget_->is_fullscreen_, NO_RESIZE_ACK);
 }
 
 void RenderWidget::ScreenMetricsEmulator::ChangeEmulationParams(
     const WebDeviceEmulationParams& params) {
   params_ = params;
   Reapply();
 }
 
 void RenderWidget::ScreenMetricsEmulator::Reapply() {
-  Apply(widget_->overdraw_bottom_height_,
+  Apply(widget_->overdraw_bottom_height_, widget_->visible_viewport_height_,
         widget_->resizer_rect_, widget_->is_fullscreen_);
 }
 
 void RenderWidget::ScreenMetricsEmulator::Apply(
-    float overdraw_bottom_height, gfx::Rect resizer_rect, bool is_fullscreen) {
+    float overdraw_bottom_height, int visible_viewport_height,
+    gfx::Rect resizer_rect, bool is_fullscreen) {
   applied_widget_rect_.set_size(params_.viewSize.isEmpty() ?
       original_size_ : gfx::Size(params_.viewSize));
 
   if (params_.fitToView) {
     DCHECK(!original_size_.IsEmpty());
 
     int width_with_gutter =
         std::max(original_size_.width() - 2 * params_.viewInsets.width, 1);
     int height_with_gutter =
         std::max(original_size_.height() - 2 * params_.viewInsets.height, 1);
@@ skipping 37 matching lines @@
   //   root layer.
   widget_->SetScreenMetricsEmulationParameters(
       original_screen_info_.deviceScaleFactor, offset_, scale_);
 
   widget_->SetDeviceScaleFactor(applied_device_scale_factor);
   widget_->view_screen_rect_ = applied_widget_rect_;
 
   gfx::Size physical_backing_size = gfx::ToCeiledSize(gfx::ScaleSize(
       original_size_, original_screen_info_.deviceScaleFactor));
   widget_->Resize(applied_widget_rect_.size(), physical_backing_size,
-      overdraw_bottom_height, resizer_rect, is_fullscreen, NO_RESIZE_ACK);
+      overdraw_bottom_height, visible_viewport_height, resizer_rect,
+      is_fullscreen, NO_RESIZE_ACK);
 }
 
 void RenderWidget::ScreenMetricsEmulator::OnResizeMessage(
     const ViewMsg_Resize_Params& params) {
   bool need_ack = params.new_size != original_size_ &&
       !params.new_size.IsEmpty() && !params.physical_backing_size.IsEmpty();
   original_size_ = params.new_size;
   original_physical_backing_size_ = params.physical_backing_size;
   original_screen_info_ = params.screen_info;
-  Apply(params.overdraw_bottom_height, params.resizer_rect,
-        params.is_fullscreen);
+  Apply(params.overdraw_bottom_height, params.visible_viewport_height,
+        params.resizer_rect, params.is_fullscreen);
 
   if (need_ack) {
     widget_->set_next_paint_is_resize_ack();
     if (widget_->compositor_)
       widget_->compositor_->SetNeedsRedrawRect(gfx::Rect(widget_->size_));
   }
 }
 
 void RenderWidget::ScreenMetricsEmulator::OnUpdateScreenRectsMessage(
     const gfx::Rect& view_screen_rect,
@@ skipping 307 matching lines @@
   // If given a messsage without a routing ID, then assign our routing ID.
   if (message->routing_id() == MSG_ROUTING_NONE)
     message->set_routing_id(routing_id_);
 
   return RenderThread::Get()->Send(message);
 }
 
 void RenderWidget::Resize(const gfx::Size& new_size,
                           const gfx::Size& physical_backing_size,
                           float overdraw_bottom_height,
+                          int visible_viewport_height,
                           const gfx::Rect& resizer_rect,
                           bool is_fullscreen,
                           ResizeAck resize_ack) {
   if (resizing_mode_selector_->NeverUsesSynchronousResize()) {
     // A resize ack shouldn't be requested if we have not ACK'd the previous
     // one.
     DCHECK(resize_ack != SEND_RESIZE_ACK || !next_paint_is_resize_ack());
     DCHECK(resize_ack == SEND_RESIZE_ACK || resize_ack == NO_RESIZE_ACK);
   }
 
   // Ignore this during shutdown.
   if (!webwidget_)
     return;
 
   if (compositor_) {
     compositor_->setViewportSize(new_size, physical_backing_size);
     compositor_->SetOverdrawBottomHeight(overdraw_bottom_height);
+    gfx::Size pinch_viewport_size(new_size.width(), visible_viewport_height);
+    webwidget()->resizePinchViewport(pinch_viewport_size);
   }
 
   physical_backing_size_ = physical_backing_size;
   overdraw_bottom_height_ = overdraw_bottom_height;
   resizer_rect_ = resizer_rect;
 
   // NOTE: We may have entered fullscreen mode without changing our size.
   bool fullscreen_change = is_fullscreen_ != is_fullscreen;
   if (fullscreen_change)
     WillToggleFullscreen();
@@ skipping 34 matching lines @@
   if (fullscreen_change)
     DidToggleFullscreen();
 
   // If a resize ack is requested and it isn't set-up, then no more resizes will
   // come in and in general things will go wrong.
   DCHECK(resize_ack != SEND_RESIZE_ACK || next_paint_is_resize_ack());
 }
 
 void RenderWidget::ResizeSynchronously(const gfx::Rect& new_position) {
   Resize(new_position.size(), new_position.size(), overdraw_bottom_height_,
-         gfx::Rect(), is_fullscreen_, NO_RESIZE_ACK);
+         visible_viewport_height_, gfx::Rect(), is_fullscreen_, NO_RESIZE_ACK);
   view_screen_rect_ = new_position;
   window_screen_rect_ = new_position;
   if (!did_show_)
     initial_pos_ = new_position;
 }
 
 void RenderWidget::OnClose() {
   if (closing_)
     return;
   closing_ = true;
@@ skipping 29 matching lines @@
     return;
 
   if (screen_metrics_emulator_) {
     screen_metrics_emulator_->OnResizeMessage(params);
     return;
   }
 
   screen_info_ = params.screen_info;
   SetDeviceScaleFactor(screen_info_.deviceScaleFactor);
   Resize(params.new_size, params.physical_backing_size,
-         params.overdraw_bottom_height, params.resizer_rect,
-         params.is_fullscreen, SEND_RESIZE_ACK);
+         params.overdraw_bottom_height, params.visible_viewport_height,
+         params.resizer_rect, params.is_fullscreen, SEND_RESIZE_ACK);
 }
 
 void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
   if (resizer_rect_ != resizer_rect) {
     gfx::Rect view_rect(size_);
 
     gfx::Rect old_damage_rect = gfx::IntersectRects(view_rect, resizer_rect_);
     if (!old_damage_rect.IsEmpty())
       has_frame_pending_ = true;
 
@@ skipping 1709 matching lines @@
 
 void RenderWidget::RegisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterSwappedOutChildFrame(RenderFrameImpl* frame) {
   swapped_out_frames_.RemoveObserver(frame);
 }
 
 }  // namespace content