Focus following for the non-editable controls on web page in magnifier mode.

ash/magnifier/magnification_controller.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/magnifier/magnification_controller.h"
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accessibility_delegate.h"
 #include "ash/ash_switches.h"
 #include "ash/display/root_window_transformers.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/host/root_window_transformer.h"
 #include "ash/root_window_controller.h"
+#include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "base/command_line.h"
 #include "base/synchronization/waitable_event.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/input_method_observer.h"
@@ skipping 57 matching lines @@
   void SetEnabled(bool enabled) override;
   bool IsEnabled() const override;
   void SetScale(float scale, bool animate) override;
   float GetScale() const override { return scale_; }
   void MoveWindow(int x, int y, bool animate) override;
   void MoveWindow(const gfx::Point& point, bool animate) override;
   gfx::Point GetWindowPosition() const override {
     return gfx::ToFlooredPoint(origin_);
   }
   void SetScrollDirection(ScrollDirection direction) override;
+  gfx::Rect GetViewportRect() override;
+  void HandleFocusedNodeChanged(
+      bool is_editable_node,
+      const gfx::Rect& node_bounds_in_screen) override;
 
   // For test
   gfx::Point GetPointOfInterestForTesting() override {
     return point_of_interest_;
   }
 
  private:
   // ui::ImplicitAnimationObserver overrides:
   void OnImplicitAnimationsCompleted() override;
 
@@ skipping 37 matching lines @@
                               bool redraw_original_root_window);
 
   // Returns if the magnification scale is 1.0 or not (larger then 1.0).
   bool IsMagnified() const;
 
   // Returns the rect of the magnification window.
   gfx::RectF GetWindowRectDIP(float scale) const;
   // Returns the size of the root window.
   gfx::Size GetHostSizeDIP() const;
 
-  // Correct the givin scale value if nessesary.
+  // Correct the given scale value if necessary.
   void ValidateScale(float* scale);
 
   // ui::EventHandler overrides:
   void OnMouseEvent(ui::MouseEvent* event) override;
   void OnScrollEvent(ui::ScrollEvent* event) override;
   void OnTouchEvent(ui::TouchEvent* event) override;
 
   // Moves the view port when |point| is located within
   // |x_panning_margin| and |y_pannin_margin| to the edge of the visible
   // window region. The view port will be moved so that the |point| will be
   // moved to the point where it has |x_target_margin| and |y_target_margin|
   // to the edge of the visible region.
-  void MoveMagnifierWindow(const gfx::Point& point,
-                           int x_panning_margin,
-                           int y_panning_margin,
-                           int x_target_margin,
-                           int y_target_margin);
+  void MoveMagnifierWindowFollowPoint(const gfx::Point& point,
+                                      int x_panning_margin,
+                                      int y_panning_margin,
+                                      int x_target_margin,
+                                      int y_target_margin);
+
+  // Moves the view port to follow |rect|, if |rect| is partially or completely
+  // outside of the view port.
+  void MoveMaginifierWindowFollowRect(const gfx::Rect& rect);
 
   // ui::InputMethodObserver:
   void OnTextInputTypeChanged(const ui::TextInputClient* client) override {}
   void OnFocus() override {}
   void OnBlur() override {}
   void OnTextInputStateChanged(const ui::TextInputClient* client) override {}
   void OnInputMethodDestroyed(const ui::InputMethod* input_method) override {}
   void OnShowImeIfNeeded() override {}
   void OnCaretBoundsChanged(const ui::TextInputClient* client) override;
 
@@ skipping 170 matching lines @@
       break;
   }
   RedrawDIP(new_origin, scale_, true);
 }
 
 void MagnificationControllerImpl::OnMouseMove(const gfx::Point& location) {
   DCHECK(root_window_);
 
   gfx::Point mouse(location);
   int margin = kPanningMergin / scale_;  // No need to consider DPI.
-  MoveMagnifierWindow(mouse, margin, margin, margin, margin);
+  MoveMagnifierWindowFollowPoint(mouse, margin, margin, margin, margin);
+}
+
+gfx::Rect MagnificationControllerImpl::GetViewportRect() {
+  return gfx::ToEnclosingRect(GetWindowRectDIP(scale_));
+}
+
+void MagnificationControllerImpl::HandleFocusedNodeChanged(
+    bool is_editable_node,
+    const gfx::Rect& node_bounds_in_screen) {
+  // The editable node is handled by OnCaretBoundsChanged.
+  if (is_editable_node)
+    return;
+
+  gfx::Rect node_bounds_in_root =
+      ScreenUtil::ConvertRectFromScreen(root_window_, node_bounds_in_screen);
+  if (GetViewportRect().Contains(node_bounds_in_root))
+    return;
+
+  MoveMaginifierWindowFollowRect(node_bounds_in_root);
 }
 
 void MagnificationControllerImpl::AfterAnimationMoveCursorTo(
     const gfx::Point& location) {
   DCHECK(root_window_);
 
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window_);
   if (cursor_client) {
     // When cursor is invisible, do not move or show the cursor after the
@@ skipping 223 matching lines @@
 void MagnificationControllerImpl::OnTouchEvent(ui::TouchEvent* event) {
   aura::Window* target = static_cast<aura::Window*>(event->target());
   aura::Window* current_root = target->GetRootWindow();
   if (current_root == root_window_) {
     gfx::Rect root_bounds = current_root->bounds();
     if (root_bounds.Contains(event->root_location()))
       point_of_interest_ = event->root_location();
   }
 }
 
-void MagnificationControllerImpl::MoveMagnifierWindow(const gfx::Point& point,
-                                                      int x_panning_margin,
-                                                      int y_panning_margin,
-                                                      int x_target_margin,
-                                                      int y_target_margin) {
+void MagnificationControllerImpl::MoveMagnifierWindowFollowPoint(
+    const gfx::Point& point,
+    int x_panning_margin,
+    int y_panning_margin,
+    int x_target_margin,
+    int y_target_margin) {
   DCHECK(root_window_);
-  int x = origin_.x();
-  int y = origin_.y();
   bool start_zoom = false;
 
-  const gfx::Rect window_rect = gfx::ToEnclosingRect(GetWindowRectDIP(scale_));
+  const gfx::Rect window_rect = GetViewportRect();
   const int left = window_rect.x();
   const int right = window_rect.right();
 
   int x_diff = 0;
   if (point.x() < left + x_panning_margin) {
     // Panning left.
     x_diff = point.x() - (left + x_target_margin);
     start_zoom = true;
   } else if (right - x_panning_margin < point.x()) {
     // Panning right.
     x_diff = point.x() - (right - x_target_margin);
     start_zoom = true;
   }
-  x = left + x_diff;
+  int x = left + x_diff;
 
   const int top = window_rect.y();
   const int bottom = window_rect.bottom();
 
   int y_diff = 0;
   if (point.y() < top + y_panning_margin) {
     // Panning up.
     y_diff = point.y() - (top + y_target_margin);
     start_zoom = true;
   } else if (bottom - y_panning_margin < point.y()) {
     // Panning down.
     y_diff = point.y() - (bottom - y_target_margin);
     start_zoom = true;
   }
-  y = top + y_diff;
+  int y = top + y_diff;
   if (start_zoom && !is_on_animation_) {
     // No animation on panning.
     bool animate = false;
     bool ret = RedrawDIP(gfx::Point(x, y), scale_, animate);
 
     if (ret) {
       // If the magnified region is moved, hides the mouse cursor and moves it.
       if (x_diff != 0 || y_diff != 0)
         MoveCursorTo(root_window_->GetHost(), point);
     }
   }
 }
 
+void MagnificationControllerImpl::MoveMaginifierWindowFollowRect(
+    const gfx::Rect& rect) {
+  DCHECK(root_window_);
+  bool start_zoom = false;
+
+  const gfx::Rect window_rect = GetViewportRect();
+  const int left = window_rect.x();
+  const int right = window_rect.right();
+  const gfx::Point rect_center = rect.CenterPoint();
+  const gfx::Point window_center = window_rect.CenterPoint();
+
+  int x_diff = 0;
+  if (rect.x() < left || right < rect.right()) {
+    // Panning horizontally.
+    x_diff = rect_center.x() - window_center.x();
+    start_zoom = true;
+  }
+  int x = left + x_diff;
+
+  const int top = window_rect.y();
+  const int bottom = window_rect.bottom();
+
+  int y_diff = 0;
+  if (rect.y() < top || bottom < rect.bottom()) {
+    // Panning vertically.
+    y_diff = rect_center.y() - window_center.y();
+    start_zoom = true;
+  }
+  int y = top + y_diff;
+
+  if (start_zoom && !is_on_animation_) {
+    RedrawDIP(gfx::Point(x, y), scale_, false);  // No animation on panning.
+  }
+}
+
 void MagnificationControllerImpl::OnCaretBoundsChanged(
     const ui::TextInputClient* client) {
   // caret bounds in screen coordinates.
   const gfx::Rect caret_bounds = client->GetCaretBounds();
   // Note: OnCaretBoundsChanged could be fired OnTextInputTypeChanged during
   // which the caret position is not set a meaning position, and we do not
   // need to adjust the view port position based on the bogus caret position.
   // This is only a transition period, the caret position will be fixed upon
   // focusing right after.
   if (caret_bounds.width() == 0 && caret_bounds.height() == 0)
     return;
 
   gfx::Point caret_origin = caret_bounds.origin();
   // caret_origin in |root_window_| coordinates.
   wm::ConvertPointFromScreen(root_window_, &caret_origin);
 
   // Visible window_rect in |root_window_| coordinates.
-  const gfx::Rect visible_window_rect =
-      gfx::ToEnclosingRect(GetWindowRectDIP(scale_));
+  const gfx::Rect visible_window_rect = GetViewportRect();
 
   const int panning_margin = kCaretPanningMargin / scale_;
-  MoveMagnifierWindow(caret_origin,
-                      panning_margin,
-                      panning_margin,
-                      visible_window_rect.width() / 2,
-                      visible_window_rect.height() / 2);
+  MoveMagnifierWindowFollowPoint(caret_origin, panning_margin, panning_margin,
+                                 visible_window_rect.width() / 2,
+                                 visible_window_rect.height() / 2);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationController:
 
 // static
 MagnificationController* MagnificationController::CreateInstance() {
   return new MagnificationControllerImpl();
 }
 
 }  // namespace ash