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 53 matching lines @@
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/env.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/display.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"
@@ skipping 1529 matching lines @@
 }
 
 void RenderWidgetHostViewAura::ExtendSelectionAndDelete(
     size_t before, size_t after) {
   RenderFrameHostImpl* rfh = GetFocusedFrame();
   if (rfh)
     rfh->ExtendSelectionAndDelete(before, after);
 }
 
 void RenderWidgetHostViewAura::EnsureCaretInRect(const gfx::Rect& rect) {
+  // Perform overscroll.
   gfx::Rect intersected_rect(
       gfx::IntersectRects(rect, window_->GetBoundsInScreen()));
+  if (!intersected_rect.IsEmpty())

[sky, 2016/08/19 20:21:39]

Generally we only drop {} if the body if the conditional and body are only a
single line. As the body isn't a single line use {}

+    host_->ScrollFocusedEditableNodeIntoRect(
+        ConvertRectFromScreen(intersected_rect));
 
-  if (intersected_rect.IsEmpty())
+#if defined(OS_CHROMEOS)
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          ::switches::kUseNewVKWindowBehavior))
     return;
 
-  host_->ScrollFocusedEditableNodeIntoRect(
-      ConvertRectFromScreen(intersected_rect));
+  // Only windows in primary display should be moved by virtual keyboard.
+  display::Screen* screen = display::Screen::GetScreen();
+  if (screen->GetPrimaryDisplay().id() !=
+      screen->GetDisplayNearestWindow(window_).id())
+    return;
+
+  // Get restore bounds of window.
+  aura::Window* top_level_window = window_->GetToplevelWindow();
+  gfx::Rect* vk_restore_bounds = top_level_window->GetProperty(
+      aura::client::kVirtualKeyboardRestoreBoundsKey);
+
+  if (vk_restore_bounds) {

[sky, 2016/08/19 20:21:39]

I don't understand the logic here. Why does an existing vk_restore_bounds mean
you set the bounds to it here? Can't EnsureCaretInRect be called multiple times?

[hariank, 2016/08/19 20:32:11]

EnsureCaretInRect is only called when the keyboard is opened or closed, or when
the focus changes to a different window. It is never called twice in succession
on the same window unless the keyboard was opened and then immediately closed,
in which case we would want to restore it. 

[sky, 2016/08/19 22:29:12]

Interesting. Having a method mean totally different things and depend upon call
ordering is super confusing. This is why I said you should add a separate
function OnClientFocusLost  and use it for the second case.

+    // Restore window.
+    top_level_window->SetBounds(*vk_restore_bounds);
+    top_level_window->ClearProperty(
+        aura::client::kVirtualKeyboardRestoreBoundsKey);
+  } else if (rect != screen->GetPrimaryDisplay().bounds()) {
+    // Calculate vertical window shift.
+    gfx::Rect window_bounds = top_level_window->GetBoundsInRootWindow();
+    int vertical_displacement =
+        std::max(0, window_bounds.bottom() - rect.bottom());
+    int shift = std::min(vertical_displacement, window_bounds.y());
+
+    // Set restore bounds and move window.
+    if (shift > 0) {
+      gfx::Point origin(window_bounds.x(), window_bounds.y() - shift);
+      top_level_window->SetProperty(
+          aura::client::kVirtualKeyboardRestoreBoundsKey,
+          new gfx::Rect(window_bounds));
+      top_level_window->SetBounds(gfx::Rect(origin, window_bounds.size()));
+    }
+  }
+#endif
 }
 
 bool RenderWidgetHostViewAura::IsTextEditCommandEnabled(
     ui::TextEditCommand command) const {
   return false;
 }
 
 void RenderWidgetHostViewAura::SetTextEditCommandForNextKeyEvent(
     ui::TextEditCommand command) {}
 
@@ skipping 1414 matching lines @@
           ->GetTextSelection(focused_view)
           ->GetSelectedText(&selected_text)) {
     // Set the CLIPBOARD_TYPE_SELECTION to the ui::Clipboard.
     ui::ScopedClipboardWriter clipboard_writer(ui::CLIPBOARD_TYPE_SELECTION);
     clipboard_writer.WriteText(selected_text);
   }
 #endif  // defined(USE_X11) && !defined(OS_CHROMEOS)
 }
 
 }  // namespace content