Implement overscroll support for the virtual keyboard.

ash/shelf/shelf_layout_manager.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 "ash/shelf/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 #include <string>
@@ skipping 28 matching lines @@
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/screen.h"
+#include "ui/keyboard/keyboard_util.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/public/activation_client.h"
 
 namespace ash {
 namespace {
 
 // Delay before showing the shelf. This is after the mouse stops moving.
 const int kAutoHideDelayMS = 200;
 
 // To avoid hiding the shelf when the mouse transitions from a message bubble
@@ skipping 709 matching lines @@
   bounds->Inset(SelectValueForShelfAlignment(
       gfx::Insets(0, 0, inset, 0),
       gfx::Insets(0, inset, 0, 0),
       gfx::Insets(0, 0, 0, inset),
       gfx::Insets(inset, 0, 0, 0)));
 }
 
 void ShelfLayoutManager::CalculateTargetBounds(
     const State& state,
     TargetBounds* target_bounds) {
-  const gfx::Rect available_bounds(GetAvailableBounds());
+  const gfx::Rect available_bounds(root_window_->bounds());
   gfx::Rect status_size(
       shelf_->status_area_widget()->GetWindowBoundsInScreen().size());
   int shelf_width = 0, shelf_height = 0;
   GetShelfSize(&shelf_width, &shelf_height);
   if (IsHorizontalAlignment())
     shelf_width = available_bounds.width();
   else
     shelf_height = available_bounds.height();
 
   if (state.visibility_state == SHELF_AUTO_HIDE &&
       state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN) {
     // Auto-hidden shelf always starts with the default size. If a gesture-drag
     // is in progress, then the call to UpdateTargetBoundsForGesture() below
     // takes care of setting the height properly.
     if (IsHorizontalAlignment())
       shelf_height = kAutoHideSize;
     else
       shelf_width = kAutoHideSize;
   } else if (state.visibility_state == SHELF_HIDDEN ||
-      !keyboard_bounds_.IsEmpty()) {
+      (!keyboard_bounds_.IsEmpty() && !keyboard::IsKeyboardOverscrollEnabled()))
+  {
     if (IsHorizontalAlignment())
       shelf_height = 0;
     else
       shelf_width = 0;
   }
 
+  int bottom_shelf_vertical_offset = available_bounds.bottom();
+  if (keyboard_bounds_.IsEmpty())
+    bottom_shelf_vertical_offset -= shelf_height;
+  else
+    bottom_shelf_vertical_offset -= keyboard_bounds_.height();
+
   target_bounds->shelf_bounds_in_root = SelectValueForShelfAlignment(
-      gfx::Rect(available_bounds.x(), available_bounds.bottom() - shelf_height,
+      gfx::Rect(available_bounds.x(), bottom_shelf_vertical_offset,
                     available_bounds.width(), shelf_height),
       gfx::Rect(available_bounds.x(), available_bounds.y(),
                     shelf_width, available_bounds.height()),
       gfx::Rect(available_bounds.right() - shelf_width, available_bounds.y(),
                     shelf_width, available_bounds.height()),
       gfx::Rect(available_bounds.x(), available_bounds.y(),
                     available_bounds.width(), shelf_height));
 
   if (IsHorizontalAlignment())
     status_size.set_height(kShelfSize);
@@ skipping 15 matching lines @@
   target_bounds->work_area_insets = SelectValueForShelfAlignment(
       gfx::Insets(0, 0, GetWorkAreaSize(state, shelf_height), 0),
       gfx::Insets(0, GetWorkAreaSize(state, shelf_width), 0, 0),
       gfx::Insets(0, 0, 0, GetWorkAreaSize(state, shelf_width)),
       gfx::Insets(GetWorkAreaSize(state, shelf_height), 0, 0, 0));
 
   // TODO(varkha): The functionality of managing insets for display areas
   // should probably be pushed to a separate component. This would simplify or
   // remove entirely the dependency on keyboard and dock.
 
-  // Also push in the work area inset for the keyboard if it is visible.
-  if (!keyboard_bounds_.IsEmpty()) {
+  if (!keyboard_bounds_.IsEmpty() && !keyboard::IsKeyboardOverscrollEnabled()) {
+    // Also push in the work area inset for the keyboard if it is visible.
     gfx::Insets keyboard_insets(0, 0, keyboard_bounds_.height(), 0);
     target_bounds->work_area_insets += keyboard_insets;
   }
 
   // Also push in the work area inset for the dock if it is visible.
   if (!dock_bounds_.IsEmpty()) {
     gfx::Insets dock_insets(
         0, (dock_bounds_.x() > 0 ? 0 : dock_bounds_.width()),
         0, (dock_bounds_.x() > 0 ? dock_bounds_.width() : 0));
     target_bounds->work_area_insets += dock_insets;
@@ skipping 273 matching lines @@
   // Bail out early when there is no |workspace_controller_|, which happens
   // during shutdown after PrepareForShutdown.
   if (!workspace_controller_)
     return force_shelf_always_visibile_;
 
   return force_shelf_always_visibile_ &&
       workspace_controller_->GetWindowState() !=
           WORKSPACE_WINDOW_STATE_FULL_SCREEN;
 }
 
-gfx::Rect ShelfLayoutManager::GetAvailableBounds() const {
-  gfx::Rect bounds(root_window_->bounds());
-  bounds.set_height(bounds.height() - keyboard_bounds_.height());
-  return bounds;
-}
-
 void ShelfLayoutManager::OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) {
   bool keyboard_is_about_to_hide = false;
   if (new_bounds.IsEmpty() && !keyboard_bounds_.IsEmpty())
     keyboard_is_about_to_hide = true;
 
   keyboard_bounds_ = new_bounds;
   OnWindowResized();
 
   SessionStateDelegate* session_state_delegate =
       Shell::GetInstance()->session_state_delegate();
@@ skipping 38 matching lines @@
 
 void ShelfLayoutManager::SessionStateChanged(
     SessionStateDelegate::SessionState state) {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(target_bounds, true, NULL);
   UpdateVisibilityState();
 }
 
 }  // namespace ash