New accessibility virtual keyboard behavior in non-sticky mode.

content/browser/renderer_host/render_widget_host_view_aura.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/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include <set>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 60 matching lines @@
 #include "ui/aura/client/window_parenting_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/mus/window_port_mus.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ime/input_method.h"
+#include "ui/base/ui_base_switches.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/compositor_vsync_manager.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/display/screen.h"
 #include "ui/events/blink/blink_event_util.h"
 #include "ui/events/blink/web_input_event.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/gesture_detection/gesture_configuration.h"
 #include "ui/events/gestures/gesture_recognizer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/touch_selection/touch_selection_controller.h"
+#include "ui/wm/core/coordinate_conversion.h"
+#include "ui/wm/core/ime_util.h"
 #include "ui/wm/public/activation_client.h"
 #include "ui/wm/public/scoped_tooltip_disabler.h"
 #include "ui/wm/public/tooltip_client.h"
 
 #if defined(OS_WIN)
 #include "base/time/time.h"
 #include "content/browser/accessibility/browser_accessibility_manager_win.h"
 #include "content/browser/accessibility/browser_accessibility_win.h"
 #include "content/browser/renderer_host/legacy_render_widget_host_win.h"
 #include "ui/base/win/hidden_window.h"
@@ skipping 460 matching lines @@
     }
 #endif
   }
 
 #if defined(OS_WIN)
   if (legacy_render_widget_host_HWND_)
     legacy_render_widget_host_HWND_->Hide();
 #endif
 }
 
+aura::Window* RenderWidgetHostViewAura::GetToplevelWindow() {
+  return window_->GetToplevelWindow();
+}
+
 void RenderWidgetHostViewAura::SetSize(const gfx::Size& size) {
   // For a SetSize operation, we don't care what coordinate system the origin
   // of the window is in, it's only important to make sure that the origin
   // remains constant after the operation.
   InternalSetBounds(gfx::Rect(window_->bounds().origin(), size));
 }
 
 void RenderWidgetHostViewAura::SetBounds(const gfx::Rect& rect) {
   gfx::Point relative_origin(rect.origin());
 
@@ skipping 680 matching lines @@
   if (!screen_position_client)
     return rect;
   screen_position_client->ConvertPointToScreen(window_, &origin);
   screen_position_client->ConvertPointToScreen(window_, &end);
   return gfx::Rect(origin.x(),
                    origin.y(),
                    end.x() - origin.x(),
                    end.y() - origin.y());
 }
 
-gfx::Rect RenderWidgetHostViewAura::ConvertRectFromScreen(
-    const gfx::Rect& rect) const {
-  gfx::Point origin = rect.origin();
-  gfx::Point end = gfx::Point(rect.right(), rect.bottom());
-
-  aura::Window* root_window = window_->GetRootWindow();
-  if (root_window) {
-    aura::client::ScreenPositionClient* screen_position_client =
-        aura::client::GetScreenPositionClient(root_window);
-    screen_position_client->ConvertPointFromScreen(window_, &origin);
-    screen_position_client->ConvertPointFromScreen(window_, &end);
-    return gfx::Rect(origin.x(),
-                     origin.y(),
-                     end.x() - origin.x(),
-                     end.y() - origin.y());
-  }
-
-  return rect;
-}
-
 gfx::Rect RenderWidgetHostViewAura::GetCaretBounds() const {
   if (!text_input_manager_ || !text_input_manager_->GetActiveWidget())
     return gfx::Rect();
 
   const TextInputManager::SelectionRegion* region =
       text_input_manager_->GetSelectionRegion();
   return ConvertRectToScreen(
       gfx::RectBetweenSelectionBounds(region->anchor, region->focus));
 }
 
@@ skipping 115 matching lines @@
   return true;
 }
 
 void RenderWidgetHostViewAura::ExtendSelectionAndDelete(
     size_t before, size_t after) {
   RenderFrameHostImpl* rfh = GetFocusedFrame();
   if (rfh)
     rfh->ExtendSelectionAndDelete(before, after);
 }
 
-void RenderWidgetHostViewAura::EnsureCaretNotInRect(const gfx::Rect& rect) {
-  gfx::Rect rect_in_local_space = ConvertRectFromScreen(rect);
-  gfx::Rect hiding_area_in_this_window =
-      gfx::IntersectRects(rect_in_local_space, window_->bounds());
+void RenderWidgetHostViewAura::EnsureCaretNotInRect(
+    const gfx::Rect& rect_in_screen) {
+  aura::Window* top_level_window = GetToplevelWindow();
+  gfx::Rect original_window_bounds = top_level_window->GetBoundsInScreen();
+  if (top_level_window->GetProperty(wm::kVirtualKeyboardRestoreBoundsKey)) {
+    original_window_bounds =
+        *top_level_window->GetProperty(wm::kVirtualKeyboardRestoreBoundsKey);
+  }
 
-  if (hiding_area_in_this_window.IsEmpty())
+  gfx::Rect hidden_window_bounds_in_screen =
+      gfx::IntersectRects(rect_in_screen, original_window_bounds);
+  if (hidden_window_bounds_in_screen.IsEmpty()) {
+    // The window isn't covered by the keyboard, restore the window position if
+    // necessary.
+    wm::RestoreWindowBoundsOnClientFocusLost(top_level_window);
     return;
+  }
 
-  host_->ScrollFocusedEditableNodeIntoRect(
-      gfx::SubtractRects(window_->bounds(), hiding_area_in_this_window));
+#if defined(OS_CHROMEOS)
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          ::switches::kUseNewVirtualKeyboardBehavior)) {
+    if (wm::MoveWindowToEnsureCaretNotInRect(top_level_window,
+                                             rect_in_screen)) {
+      // Recalculate hidden_window_bounds_in_screen after moving up the window.
+      original_window_bounds = top_level_window->GetBoundsInScreen();
+      hidden_window_bounds_in_screen =
+          gfx::IntersectRects(rect_in_screen, original_window_bounds);
+    } else {
+      // No need to move the window or need to restore the window position.
+      wm::RestoreWindowBoundsOnClientFocusLost(top_level_window);
+      return;
+    }
+  }
+#endif  // defined(OS_CHROMEOS)
+
+  // Perform overscroll if the caret is still hidden by the keyboard.
+  gfx::Rect visible_area_in_local_space = gfx::SubtractRects(
+      window_->GetBoundsInScreen(), hidden_window_bounds_in_screen);
+  wm::ConvertRectFromScreen(window_, &visible_area_in_local_space);
+  host_->ScrollFocusedEditableNodeIntoRect(visible_area_in_local_space);
 }
 
 bool RenderWidgetHostViewAura::IsTextEditCommandEnabled(
     ui::TextEditCommand command) const {
   return false;
 }
 
 void RenderWidgetHostViewAura::SetTextEditCommandForNextKeyEvent(
     ui::TextEditCommand command) {}
 
@@ skipping 758 matching lines @@
 #if defined(OS_WIN)
   // Update the legacy window's parent temporarily to the hidden window. It
   // will eventually get reparented to the right root.
   if (legacy_render_widget_host_HWND_)
     legacy_render_widget_host_HWND_->UpdateParent(ui::GetHiddenWindow());
 #endif
 }
 
 void RenderWidgetHostViewAura::DetachFromInputMethod() {
   ui::InputMethod* input_method = GetInputMethod();
-  if (input_method)
+  if (input_method) {
     input_method->DetachTextInputClient(this);
+    wm::RestoreWindowBoundsOnClientFocusLost(GetToplevelWindow());
+  }
 }
 
 void RenderWidgetHostViewAura::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& event,
     bool* update_event) {
   RenderWidgetHostImpl* target_host = host_;
 
   // If there are multiple widgets on the page (such as when there are
   // out-of-process iframes), pick the one that should process this event.
   if (host_->delegate())
@@ skipping 137 matching lines @@
 }
 
 void RenderWidgetHostViewAura::UpdateNeedsBeginFramesInternal() {
   if (!delegated_frame_host_)
     return;
   delegated_frame_host_->SetNeedsBeginFrames(needs_begin_frames_ ||
                                              needs_flush_input_);
 }
 
 }  // namespace content