[VK] Use semantically-correct bounds when querying keyboard bounds.

There are several places where we query the keyboard bounds by
grabbing the keyboard container window and calling |bounds|. However,
it's unclear whether they mean the bounds relative to parent or bounds
relative to the screen, since both are currently the same for the
keyboard container.

This patch changes several callers to use |GetBoundsInScreen| since
they actually want the screen bounds. Note we don't change any behaviour
since currently keyboard container |bounds| == |GetBoundsInScreen|, but
this will change in future when we get rid of keyboard container.

Bug: 849980
Change-Id: I7211073a7697f168824c127319dfc40e6888195a
Reviewed-on: https://chromium-review.googlesource.com/1098417
Commit-Queue: James Cook <jamescook@chromium.org>
Reviewed-by: James Cook <jamescook@chromium.org>
Reviewed-by: Yuichiro Hanada <yhanada@chromium.org>
Cr-Commit-Position: refs/heads/master@{#567253}

ash/magnifier/magnification_controller.cc

@@ -927,8 +927,9 @@ void MagnificationController::MoveMagnifierWindowCenterPoint(
 
   // Reduce the viewport bounds if the keyboard is up.
   if (keyboard::KeyboardController::Get()->enabled()) {
-    gfx::Rect keyboard_rect =
-        keyboard::KeyboardController::Get()->GetContainerWindow()->bounds();
+    gfx::Rect keyboard_rect = keyboard::KeyboardController::Get()
+                                  ->GetContainerWindow()
+                                  ->GetBoundsInScreen();
     window_rect.set_height(window_rect.height() -
                            keyboard_rect.height() / scale_);
   }

chrome/browser/ui/ash/chrome_keyboard_ui.cc

@@ -294,8 +294,8 @@ void ChromeKeyboardUI::UpdateInsetsForWindow(aura::Window* window) {
     content::RenderWidgetHostView* view = widget->GetView();
     if (view && window->Contains(view->GetNativeView())) {
       gfx::Rect window_bounds = view->GetNativeView()->GetBoundsInScreen();
-      gfx::Rect intersect =
-          gfx::IntersectRects(window_bounds, keyboard_container->bounds());
+      gfx::Rect intersect = gfx::IntersectRects(
+          window_bounds, keyboard_container->GetBoundsInScreen());
       int overlap = ShouldEnableInsets(window) ? intersect.height() : 0;
       if (overlap > 0 && overlap < window_bounds.height())
         view->SetInsets(gfx::Insets(0, 0, overlap, 0));

ui/keyboard/container_behavior.h

@@ -61,7 +61,7 @@ class KEYBOARD_EXPORT ContainerBehavior {
   virtual bool IsDragHandle(const gfx::Vector2d& offset,
                             const gfx::Size& keyboard_size) const = 0;
 
-  virtual void SavePosition(const gfx::Rect& keyboard_bounds,
+  virtual void SavePosition(const gfx::Rect& keyboard_bounds_in_screen,
                             const gfx::Size& screen_size) = 0;
 
   virtual bool HandlePointerEvent(const ui::LocatedEvent& event,

ui/keyboard/container_floating_behavior.cc

@@ -67,70 +67,73 @@ void ContainerFloatingBehavior::InitializeShowAnimationStartingState(
 
 gfx::Rect ContainerFloatingBehavior::AdjustSetBoundsRequest(
     const gfx::Rect& display_bounds,
-    const gfx::Rect& requested_bounds) {
-  gfx::Rect keyboard_bounds = requested_bounds;
+    const gfx::Rect& requested_bounds_in_screen) {
+  gfx::Rect keyboard_bounds_in_screen = requested_bounds_in_screen;
 
-  if (!default_position_) {
+  if (!default_position_in_screen_) {
     // If the keyboard hasn't been shown yet, ignore the request and use
     // default.
-    gfx::Point default_location =
-        GetPositionForShowingKeyboard(keyboard_bounds.size(), display_bounds);
-    keyboard_bounds = gfx::Rect(default_location, keyboard_bounds.size());
+    gfx::Point default_location = GetPositionForShowingKeyboard(
+        keyboard_bounds_in_screen.size(), display_bounds);
+    keyboard_bounds_in_screen =
+        gfx::Rect(default_location, keyboard_bounds_in_screen.size());
   } else {
     // Otherwise, simply make sure that the new bounds are not off the edge of
     // the screen.
-    keyboard_bounds =
-        ContainKeyboardToScreenBounds(keyboard_bounds, display_bounds);
-    SavePosition(keyboard_bounds, display_bounds.size());
+    keyboard_bounds_in_screen = ContainKeyboardToScreenBounds(
+        keyboard_bounds_in_screen, display_bounds);
+    SavePosition(keyboard_bounds_in_screen, display_bounds.size());
   }
 
-  return keyboard_bounds;
+  return keyboard_bounds_in_screen;
 }
 
-void ContainerFloatingBehavior::SavePosition(const gfx::Rect& keyboard_bounds,
-                                             const gfx::Size& screen_size) {
-  int left_distance = keyboard_bounds.x();
-  int right_distance = screen_size.width() - (keyboard_bounds.right());
-  int top_distance = keyboard_bounds.y();
-  int bottom_distance = screen_size.height() - (keyboard_bounds.bottom());
+void ContainerFloatingBehavior::SavePosition(
+    const gfx::Rect& keyboard_bounds_in_screen,
+    const gfx::Size& screen_size) {
+  int left_distance = keyboard_bounds_in_screen.x();
+  int right_distance = screen_size.width() - keyboard_bounds_in_screen.right();
+  int top_distance = keyboard_bounds_in_screen.y();
+  int bottom_distance =
+      screen_size.height() - keyboard_bounds_in_screen.bottom();
 
   double available_width = left_distance + right_distance;
   double available_height = top_distance + bottom_distance;
 
-  if (!default_position_) {
-    default_position_ = std::make_unique<KeyboardPosition>();
+  if (!default_position_in_screen_) {
+    default_position_in_screen_ = std::make_unique<KeyboardPosition>();
   }
 
-  default_position_->left_padding_allotment_ratio =
+  default_position_in_screen_->left_padding_allotment_ratio =
       left_distance / available_width;
-  default_position_->top_padding_allotment_ratio =
+  default_position_in_screen_->top_padding_allotment_ratio =
       top_distance / available_height;
 }
 
 gfx::Rect ContainerFloatingBehavior::ContainKeyboardToScreenBounds(
-    const gfx::Rect& keyboard_bounds,
+    const gfx::Rect& keyboard_bounds_in_screen,
     const gfx::Rect& display_bounds) const {
-  int left = keyboard_bounds.x();
-  int top = keyboard_bounds.y();
-  int right = keyboard_bounds.right();
-  int bottom = keyboard_bounds.bottom();
+  int left = keyboard_bounds_in_screen.x();
+  int top = keyboard_bounds_in_screen.y();
+  int right = keyboard_bounds_in_screen.right();
+  int bottom = keyboard_bounds_in_screen.bottom();
 
   // Prevent keyboard from appearing off screen or overlapping with the edge.
   if (left < display_bounds.x()) {
     left = display_bounds.x();
-    right = left + keyboard_bounds.width();
+    right = left + keyboard_bounds_in_screen.width();
   }
   if (right >= display_bounds.right()) {
     right = display_bounds.right();
-    left = right - keyboard_bounds.width();
+    left = right - keyboard_bounds_in_screen.width();
   }
   if (top < display_bounds.y()) {
     top = display_bounds.y();
-    bottom = top + keyboard_bounds.height();
+    bottom = top + keyboard_bounds_in_screen.height();
   }
   if (bottom >= display_bounds.bottom()) {
     bottom = display_bounds.bottom();
-    top = bottom - keyboard_bounds.height();
+    top = bottom - keyboard_bounds_in_screen.height();
   }
 
   return gfx::Rect(left, top, right - left, bottom - top);
@@ -145,7 +148,7 @@ gfx::Point ContainerFloatingBehavior::GetPositionForShowingKeyboard(
     const gfx::Rect& display_bounds) const {
   // Start with the last saved position
   gfx::Point top_left_offset;
-  KeyboardPosition* position = default_position_.get();
+  KeyboardPosition* position = default_position_in_screen_.get();
   if (position == nullptr) {
     // If there is none, center the keyboard along the bottom of the screen.
     top_left_offset.set_x(display_bounds.width() - keyboard_size.width() -
@@ -189,10 +192,10 @@ bool ContainerFloatingBehavior::HandlePointerEvent(
 
   aura::Window* container = controller_->GetContainerWindow();
 
-  const gfx::Rect& keyboard_bounds = container->bounds();
+  const gfx::Rect& keyboard_bounds_in_screen = container->GetBoundsInScreen();
 
   // Don't handle events if this runs in a partially initialized state.
-  if (keyboard_bounds.height() <= 0)
+  if (keyboard_bounds_in_screen.height() <= 0)
     return false;
 
   ui::PointerId pointer_id = -1;
@@ -205,7 +208,7 @@ bool ContainerFloatingBehavior::HandlePointerEvent(
   switch (type) {
     case ui::ET_TOUCH_PRESSED:
     case ui::ET_MOUSE_PRESSED:
-      if (!IsDragHandle(kb_offset, keyboard_bounds.size())) {
+      if (!IsDragHandle(kb_offset, keyboard_bounds_in_screen.size())) {
         drag_descriptor_ = nullptr;
       } else if (type == ui::ET_MOUSE_PRESSED &&
                  !((const ui::MouseEvent*)&event)->IsOnlyLeftMouseButton()) {
@@ -215,7 +218,7 @@ bool ContainerFloatingBehavior::HandlePointerEvent(
         // If there is no active drag descriptor, start a new one.
         bool drag_started_by_touch = (type == ui::ET_TOUCH_PRESSED);
         drag_descriptor_.reset(
-            new DragDescriptor{keyboard_bounds.origin(), kb_offset,
+            new DragDescriptor{keyboard_bounds_in_screen.origin(), kb_offset,
                                drag_started_by_touch, pointer_id});
       }
       break;
@@ -239,14 +242,14 @@ bool ContainerFloatingBehavior::HandlePointerEvent(
             drag_descriptor_->original_keyboard_location +
             drag_descriptor_->original_click_offset;
         const gfx::Point current_drag_location =
-            keyboard_bounds.origin() + kb_offset;
+            keyboard_bounds_in_screen.origin() + kb_offset;
         const gfx::Vector2d cumulative_drag_offset =
             current_drag_location - original_click_location;
         const gfx::Point new_keyboard_location =
             drag_descriptor_->original_keyboard_location +
             cumulative_drag_offset;
         gfx::Rect new_bounds_in_local =
-            gfx::Rect(new_keyboard_location, keyboard_bounds.size());
+            gfx::Rect(new_keyboard_location, keyboard_bounds_in_screen.size());
 
         DisplayUtil display_util;
         const display::Display& new_display =
@@ -274,7 +277,7 @@ bool ContainerFloatingBehavior::HandlePointerEvent(
           controller_->MoveToDisplayWithTransition(new_display,
                                                    new_bounds_in_local);
         }
-        SavePosition(container->bounds(), new_display.size());
+        SavePosition(container->GetBoundsInScreen(), new_display.size());
         return true;
       }
       break;
@@ -291,10 +294,10 @@ void ContainerFloatingBehavior::SetCanonicalBounds(
     const gfx::Rect& display_bounds) {
   gfx::Point keyboard_location =
       GetPositionForShowingKeyboard(container->bounds().size(), display_bounds);
-  gfx::Rect keyboard_bounds =
+  gfx::Rect keyboard_bounds_in_screen =
       gfx::Rect(keyboard_location, container->bounds().size());
-  SavePosition(keyboard_bounds, display_bounds.size());
-  container->SetBounds(keyboard_bounds);
+  SavePosition(keyboard_bounds_in_screen, display_bounds.size());
+  container->SetBounds(keyboard_bounds_in_screen);
 }
 
 bool ContainerFloatingBehavior::TextBlurHidesKeyboard() const {

ui/keyboard/container_floating_behavior.h

@@ -47,7 +47,7 @@ class KEYBOARD_EXPORT ContainerFloatingBehavior : public ContainerBehavior {
   bool IsOverscrollAllowed() const override;
   bool IsDragHandle(const gfx::Vector2d& offset,
                     const gfx::Size& keyboard_size) const override;
-  void SavePosition(const gfx::Rect& keyboard_bounds,
+  void SavePosition(const gfx::Rect& keyboard_bounds_in_screen,
                     const gfx::Size& screen_size) override;
   bool HandlePointerEvent(const ui::LocatedEvent& event,
                           const display::Display& current_display) override;
@@ -69,7 +69,7 @@ class KEYBOARD_EXPORT ContainerFloatingBehavior : public ContainerBehavior {
   // Ensures that the keyboard is neither off the screen nor overlapping an
   // edge.
   gfx::Rect ContainKeyboardToScreenBounds(
-      const gfx::Rect& keyboard_bounds,
+      const gfx::Rect& keyboard_bounds_in_screen,
       const gfx::Rect& display_bounds) const;
 
   // Saves the current keyboard location for use the next time it is displayed.
@@ -78,8 +78,8 @@ class KEYBOARD_EXPORT ContainerFloatingBehavior : public ContainerBehavior {
   KeyboardController* controller_;
 
   // TODO(blakeo): cache the default_position_ on a per-display basis.
-  std::unique_ptr<struct keyboard::KeyboardPosition> default_position_ =
-      nullptr;
+  std::unique_ptr<struct keyboard::KeyboardPosition>
+      default_position_in_screen_ = nullptr;
 
   // Current state of a cursor drag to move the keyboard, if one exists.
   // Otherwise nullptr.