[Switch Access] Add vertical range scan

Point scanning performs a vertical range scan before a vertical line
scan. The vetical line should scan within the range. Currently, the
point scan performs the following step:
	1. Horizontal Range Scan
	2. Horizontal Line Scan
	3. Vertical Range Scan
	4. Vertical Line Scan
Signed-off-by: Shannon Chen <shannc@chromium.org>
Bug: 1061537
Change-Id: If29f7bbf7f1e3c29c8872523bf48214dcc9f6bd4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2580139Reviewed-by: Dominic Mazzoni <dmazzoni@chromium.org>
Commit-Queue: Shannon Chen <shannc@google.com>
Cr-Commit-Position: refs/heads/master@{#835306}

ash/accessibility/point_scan_controller.cc

@@ -14,7 +14,9 @@ namespace {
 constexpr float kHorizontalScanTimeSecs = 20;
 constexpr float kVerticalScanTimeSecs = 20;
 constexpr float kHorizontalRangeScanTimeSecs = 30;
+constexpr float kVerticalRangeScanTimeSecs = 20;
 constexpr int kDefaultRangeWidthDips = 150;
+constexpr float kDefaultRangeHeightDips = 120;
 
 }  // namespace
 
@@ -24,6 +26,7 @@ PointScanController::PointScanController() {
   horizontal_line_layer_info_.animation_rate = kHorizontalScanTimeSecs;
   horizontal_range_layer_info_.animation_rate = kHorizontalRangeScanTimeSecs;
   vertical_line_layer_info_.animation_rate = kVerticalScanTimeSecs;
+  vertical_range_layer_info_.animation_rate = kVerticalRangeScanTimeSecs;
 }
 
 PointScanController::~PointScanController() = default;
@@ -48,12 +51,23 @@ void PointScanController::StartHorizontalLineScan() {
   horizontal_line_layer_->StartHorizontalScanning();
 }
 
-void PointScanController::Pause() {
-  state_ = PointScanState::kVerticalScanning;
+void PointScanController::StartVerticalRangeScan() {
+  state_ = PointScanState::kVerticalRangeScanning;
   horizontal_line_layer_->PauseHorizontalScanning();
+  vertical_range_layer_.reset(new PointScanLayer(this));
+  vertical_range_layer_info_.offset_bound =
+      vertical_range_layer_->GetBounds().height() - kDefaultRangeHeightDips;
+  vertical_range_layer_->StartVerticalRangeScanning();
+}
+
+void PointScanController::StartVerticalLineScan() {
+  state_ = PointScanState::kVerticalScanning;
+  vertical_range_layer_->PauseVerticalRangeScanning();
   vertical_line_layer_.reset(new PointScanLayer(this));
+  vertical_line_layer_info_.offset = vertical_range_layer_info_.offset;
+  vertical_line_layer_info_.offset_start = vertical_range_layer_info_.offset;
   vertical_line_layer_info_.offset_bound =
-      vertical_line_layer_->GetBounds().height();
+      vertical_range_layer_info_.offset + kDefaultRangeHeightDips;
   vertical_line_layer_->StartVerticalScanning();
 }
 
@@ -68,7 +82,10 @@ base::Optional<gfx::PointF> PointScanController::OnPointSelect() {
       StartHorizontalLineScan();
       return base::nullopt;
     case PointScanState::kHorizontalScanning:
-      Pause();
+      StartVerticalRangeScan();
+      return base::nullopt;
+    case PointScanState::kVerticalRangeScanning:
+      StartVerticalLineScan();
       return base::nullopt;
     case PointScanState::kVerticalScanning:
       Stop();
@@ -82,8 +99,9 @@ base::Optional<gfx::PointF> PointScanController::OnPointSelect() {
 bool PointScanController::IsPointScanEnabled() {
   switch (state_) {
     case PointScanState::kHorizontalRangeScanning:
-    case PointScanState::kVerticalScanning:
     case PointScanState::kHorizontalScanning:
+    case PointScanState::kVerticalRangeScanning:
+    case PointScanState::kVerticalScanning:
       return true;
     case PointScanState::kOff:
       return false;
@@ -114,6 +132,11 @@ void PointScanController::AnimateLine(base::TimeTicks timestamp) {
     horizontal_line_layer_->SetSubpixelPositionOffset(
         gfx::Vector2dF(horizontal_line_layer_info_.offset, 0.0));
     UpdateTimeInfo(&horizontal_line_layer_info_, timestamp);
+  } else if (vertical_range_layer_->IsMoving()) {
+    ComputeOffset(&vertical_range_layer_info_, timestamp);
+    vertical_range_layer_->SetSubpixelPositionOffset(
+        gfx::Vector2dF(0.0, vertical_range_layer_info_.offset));
+    UpdateTimeInfo(&vertical_range_layer_info_, timestamp);
   } else if (vertical_line_layer_->IsMoving()) {
     ComputeOffset(&vertical_line_layer_info_, timestamp);
     vertical_line_layer_->SetSubpixelPositionOffset(

ash/accessibility/point_scan_controller.h

@@ -30,6 +30,8 @@ class ASH_EXPORT PointScanController : public AccessibilityLayerDelegate {
     kHorizontalRangeScanning,
     // Point scanning is currently scanning horizontally.
     kHorizontalScanning,
+    // Point scanning is currently range scanning vertically.
+    kVerticalRangeScanning,
     // Point scanning is currently scanning vertically.
     kVerticalScanning,
     // Point scanning is not scanning.
@@ -40,7 +42,8 @@ class ASH_EXPORT PointScanController : public AccessibilityLayerDelegate {
   // user input.
   void StartHorizontalRangeScan();
   void StartHorizontalLineScan();
-  void Pause();
+  void StartVerticalRangeScan();
+  void StartVerticalLineScan();
   void Stop();
   base::Optional<gfx::PointF> OnPointSelect();
   bool IsPointScanEnabled();
@@ -58,6 +61,8 @@ class ASH_EXPORT PointScanController : public AccessibilityLayerDelegate {
   std::unique_ptr<PointScanLayer> horizontal_range_layer_;
   PointScanLayerAnimationInfo horizontal_line_layer_info_;
   std::unique_ptr<PointScanLayer> horizontal_line_layer_;
+  PointScanLayerAnimationInfo vertical_range_layer_info_;
+  std::unique_ptr<PointScanLayer> vertical_range_layer_;
   PointScanLayerAnimationInfo vertical_line_layer_info_;
   std::unique_ptr<PointScanLayer> vertical_line_layer_;
 

ash/accessibility/point_scan_layer.cc

@@ -21,6 +21,7 @@ namespace ash {
 namespace {
 const int kDefaultStrokeWidth = 6;
 constexpr int kDefaultRangeWidthDips = 150;
+constexpr int kDefaultRangeHeightDips = 120;
 
 display::Display GetPrimaryDisplay() {
   DCHECK(display::Screen::GetScreen());
@@ -44,6 +45,7 @@ void PointScanLayer::StartHorizontalRangeScanning() {
   bounds_.set_origin(line_.start);
   line_.end = end;
   is_moving_ = true;
+  is_horizontal_range_ = true;
 }
 
 void PointScanLayer::StartHorizontalScanning() {
@@ -52,6 +54,23 @@ void PointScanLayer::StartHorizontalScanning() {
   bounds_.set_origin(line_.start);
   line_.end = end;
   is_moving_ = true;
+  is_horizontal_range_ = false;
+}
+
+void PointScanLayer::StartVerticalRangeScanning() {
+  is_range_scan_ = true;
+  gfx::Point end = bounds_.top_right();
+  bounds_.set_origin(line_.start);
+  line_.end = end;
+  is_moving_ = true;
+}
+
+void PointScanLayer::StartVerticalScanning() {
+  is_range_scan_ = false;
+  gfx::Point end = bounds_.top_right();
+  bounds_.set_origin(line_.start);
+  line_.end = end;
+  is_moving_ = true;
 }
 
 void PointScanLayer::PauseHorizontalRangeScanning() {
@@ -62,11 +81,8 @@ void PointScanLayer::PauseHorizontalScanning() {
   is_moving_ = false;
 }
 
-void PointScanLayer::StartVerticalScanning() {
-  gfx::Point end = bounds_.top_right();
-  bounds_.set_origin(line_.start);
-  line_.end = end;
-  is_moving_ = true;
+void PointScanLayer::PauseVerticalRangeScanning() {
+  is_moving_ = false;
 }
 
 void PointScanLayer::PauseVerticalScanning() {
@@ -102,8 +118,13 @@ void PointScanLayer::OnPaintLayer(const ui::PaintContext& context) {
   SkPath path;
 
   if (is_range_scan_) {
-    path.moveTo(line_.start.x() + kDefaultRangeWidthDips, line_.start.y());
-    path.lineTo(line_.end.x() + kDefaultRangeWidthDips, line_.end.y());
+    if (is_horizontal_range_) {
+      path.moveTo(line_.start.x() + kDefaultRangeWidthDips, line_.start.y());
+      path.lineTo(line_.end.x() + kDefaultRangeWidthDips, line_.end.y());
+    } else {
+      path.moveTo(line_.start.x(), line_.start.y() + kDefaultRangeHeightDips);
+      path.lineTo(line_.end.x(), line_.end.y() + kDefaultRangeHeightDips);
+    }
   }
 
   path.moveTo(line_.start.x(), line_.start.y());

ash/accessibility/point_scan_layer.h

@@ -23,10 +23,13 @@ class PointScanLayer : public AccessibilityLayer {
   // an x-coordinate.
   void StartHorizontalRangeScanning();
   void StartHorizontalScanning();
-  void PauseHorizontalRangeScanning();
-  void PauseHorizontalScanning();
+  void StartVerticalRangeScanning();
   void StartVerticalScanning();
+  void PauseHorizontalScanning();
+  void PauseHorizontalRangeScanning();
   void PauseVerticalScanning();
+  void PauseVerticalRangeScanning();
+
   gfx::Rect GetBounds() const;
   bool IsMoving() const;
 
@@ -54,6 +57,8 @@ class PointScanLayer : public AccessibilityLayer {
   bool is_moving_ = false;
 
   bool is_range_scan_ = false;
+
+  bool is_horizontal_range_ = false;
 };
 
 }  // namespace ash