Restore window size after accessbility keyboard hides.

ash/wm/workspace/workspace_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/wm/workspace/workspace_layout_manager.h"
 
 #include <algorithm>
 
 #include "ash/display/display_controller.h"
 #include "ash/root_window_controller.h"
@@ skipping 125 matching lines @@
     const gfx::Rect& new_bounds) {
   aura::Window* root_window = window_->GetRootWindow();
   ui::InputMethod* input_method =
       root_window->GetProperty(aura::client::kRootWindowInputMethodKey);
   ui::TextInputClient* text_input_client = input_method->GetTextInputClient();
   if (!text_input_client)
     return;
   aura::Window *window = text_input_client->GetAttachedWindow();
   if (!window || !window_->Contains(window))
     return;
-  gfx::Rect window_bounds = ScreenUtil::ConvertRectToScreen(
-      window_,
-      window->GetTargetBounds());
-  gfx::Rect intersect = gfx::IntersectRects(window_bounds, new_bounds);
-  int shift = std::min(intersect.height(),
-                       window->bounds().y() - work_area_in_parent_.y());
-  if (shift > 0) {
-    gfx::Point origin(window->bounds().x(), window->bounds().y() - shift);
-    SetChildBounds(window, gfx::Rect(origin, window->bounds().size()));
+  aura::Window *toplevel_window = window->GetToplevelWindow();
+  wm::WindowState* toplevel_window_state = wm::GetWindowState(toplevel_window);
+  if (!new_bounds.IsEmpty()) {
+    // Store existing bounds to be restored before resizing for keyboard if it
+    // is not already stored.
+    if (!toplevel_window_state->HasRestoreBounds()) {

[flackr, 2014/08/14 19:17:58]

nit: no curlies { } for single line statement.

Note: I think it's probably okay to clobber the restore bounds if the keyboard
was previously not shown, just not to clobber if the keyboard changes size. The
window may have restore bounds if side snapped for example.

[Peter Wen, 2014/08/15 13:44:48]

Done.

It seems that workspace_layout_manager's onKeyboardBoundsChanging is only used
when the window is non-maximized, so it has no restore bounds. This check should
always pass the first time VK is shown (in non-maximized mode) and once the VK
is hidden the previous restore bounds are used and discarded in preparation for
next time VK is shown.

If the window is at any time snapped to the side or maximized, before or during
this process, then the maximized case takes over and this code is no longer
relevant.

The only unexpected case I found is if a window is maximized, then the
accessibility keyboard is used, the window resizes and resets correctly back to
maximized, but afterwards the original unmaximized size is lost. That is not a
result of the code here but of the code for the maximized case clobbering the
restore bounds. I think that is unavoidable unless we store a stack of restore
bounds anyways.

+      toplevel_window_state->SaveCurrentBoundsForRestore();
+    }
+
+    gfx::Rect window_bounds = ScreenUtil::ConvertRectToScreen(
+        window_,
+        window->GetTargetBounds());
+    gfx::Rect intersect = gfx::IntersectRects(window_bounds, new_bounds);
+    int shift = std::min(intersect.height(),
+                         window->bounds().y() - work_area_in_parent_.y());
+    if (shift > 0) {

[flackr, 2014/08/14 19:17:58]

Should we even set restore bounds if there is no change?

[Peter Wen, 2014/08/15 13:44:48]

Yes, as that way even if the focused input area does not overlap with the
keyboard, we still restore to the correct one. "shift" is only positive if the
focused area overlaps with the VK's half of the screen.

[flackr, 2014/08/20 15:02:14]

Alright, sounds fine. It should be fine either way since it only tries to
restore if the window has restore bounds.

+      gfx::Point origin(window->bounds().x(), window->bounds().y() - shift);
+      SetChildBounds(window, gfx::Rect(origin, window->bounds().size()));
+    }
+  } else if (toplevel_window_state->HasRestoreBounds()) {
+    // Keyboard hidden, restore original bounds if they exist.
+    toplevel_window_state->SetAndClearRestoreBounds();
   }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, ash::ShellObserver implementation:
 
 void WorkspaceLayoutManager::OnDisplayWorkAreaInsetsChanged() {
   const gfx::Rect work_area(ScreenUtil::ConvertRectFromScreen(
       window_,
       Shell::GetScreen()->GetDisplayNearestWindow(window_).work_area()));
@@ skipping 142 matching lines @@
   bool is_fullscreen = GetRootWindowController(
       window_->GetRootWindow())->GetWindowForFullscreenMode() != NULL;
   if (is_fullscreen != is_fullscreen_) {
     ash::Shell::GetInstance()->NotifyFullscreenStateChange(
         is_fullscreen, window_->GetRootWindow());
     is_fullscreen_ = is_fullscreen;
   }
 }
 
 }  // namespace ash