Corner Passthrough for Accessibility

ui/chromeos/touch_exploration_controller.cc

 // Copyright 2014 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 "ui/chromeos/touch_exploration_controller.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/events/event.h"
 #include "ui/events/event_processor.h"
 #include "ui/gfx/geometry/rect.h"
 
 #define VLOG_STATE() if (VLOG_IS_ON(0)) VlogState(__func__)
 #define VLOG_EVENT(event) if (VLOG_IS_ON(0)) VlogEvent(event, __func__)
 
 namespace ui {
 
 namespace {
 
 // Delay between adjustment sounds.
 const base::TimeDelta kSoundDelay = base::TimeDelta::FromMilliseconds(150);
 
+// Delay before corner passthrough activates.
+const base::TimeDelta kCornerPassthroughDelay =
+    base::TimeDelta::FromMilliseconds(500);
+
 // In ChromeOS, VKEY_LWIN is synonymous for the search key.
 const ui::KeyboardCode kChromeOSSearchKey = ui::VKEY_LWIN;
 }  // namespace
 
 TouchExplorationController::TouchExplorationController(
     aura::Window* root_window,
     TouchExplorationControllerDelegate* delegate)
     : root_window_(root_window),
       delegate_(delegate),
       state_(NO_FINGERS_DOWN),
       event_handler_for_testing_(NULL),
       gesture_provider_(this),
       prev_state_(NO_FINGERS_DOWN),
-      VLOG_on_(true) {
+      VLOG_on_(true),
+      waiting_for_corner_passthrough_(false) {
   CHECK(root_window);
   root_window->GetHost()->GetEventSource()->AddEventRewriter(this);
 }
 
 TouchExplorationController::~TouchExplorationController() {
   root_window_->GetHost()->GetEventSource()->RemoveEventRewriter(this);
 }
 
 ui::EventRewriteStatus TouchExplorationController::RewriteEvent(
     const ui::Event& event,
@@ skipping 16 matching lines @@
   // the timer.
   if (tap_timer_.IsRunning() &&
       touch_event.time_stamp() - initial_press_->time_stamp() >
           gesture_detector_config_.double_tap_timeout) {
     tap_timer_.Stop();
     OnTapTimerFired();
     // Note: this may change the state. We should now continue and process
     // this event under this new state.
   }
 
+  if (long_press_timer_.IsRunning() &&
+      event.time_stamp() - initial_press_->time_stamp() >
+          gesture_detector_config_.longpress_timeout) {
+    long_press_timer_.Stop();
+    OnLongPressTimerFired();
+  }
+
   const ui::EventType type = touch_event.type();
   const gfx::PointF& location = touch_event.location_f();
   const int touch_id = touch_event.touch_id();
 
   // Always update touch ids and touch locations, so we can use those
   // no matter what state we're in.
   if (type == ui::ET_TOUCH_PRESSED) {
     current_touch_ids_.push_back(touch_id);
     touch_locations_.insert(std::pair<int, gfx::PointF>(touch_id, location));
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
@@ skipping 39 matching lines @@
     case DOUBLE_TAP_PRESSED:
       return InDoubleTapPressed(touch_event, rewritten_event);
     case TOUCH_EXPLORATION:
       return InTouchExploration(touch_event, rewritten_event);
     case GESTURE_IN_PROGRESS:
       return InGestureInProgress(touch_event, rewritten_event);
     case TOUCH_EXPLORE_SECOND_PRESS:
       return InTouchExploreSecondPress(touch_event, rewritten_event);
     case TWO_TO_ONE_FINGER:
       return InTwoToOneFinger(touch_event, rewritten_event);
+    case CORNER_PASSTHROUGH:
+      return InCornerPassthrough(touch_event, rewritten_event);
     case PASSTHROUGH:
       return InPassthrough(touch_event, rewritten_event);
     case WAIT_FOR_RELEASE:
       return InWaitForRelease(touch_event, rewritten_event);
     case SLIDE_GESTURE:
       return InSlideGesture(touch_event, rewritten_event);
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::NextDispatchEvent(
     const ui::Event& last_event, scoped_ptr<ui::Event>* new_event) {
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InNoFingersDown(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
-  if (type == ui::ET_TOUCH_PRESSED) {
-    initial_press_.reset(new TouchEvent(event));
-    last_unused_finger_event_.reset(new TouchEvent(event));
-    tap_timer_.Start(FROM_HERE,
-                     gesture_detector_config_.double_tap_timeout,
-                     this,
-                     &TouchExplorationController::OnTapTimerFired);
-    gesture_provider_.OnTouchEvent(event);
-    gesture_provider_.OnTouchEventAck(false);
-    ProcessGestureEvents();
-    state_ = SINGLE_TAP_PRESSED;
-    VLOG_STATE();
-    return ui::EVENT_REWRITE_DISCARD;
+  if (type != ui::ET_TOUCH_PRESSED) {
+    NOTREACHED() << "Unexpected event type received: " << event.name();
+    return ui::EVENT_REWRITE_CONTINUE;
   }
-  NOTREACHED() << "Unexpected event type received: " << event.name();;
-  return ui::EVENT_REWRITE_CONTINUE;
+  int location = FindEdgesWithinBounds(event.location(), kSlopDistanceFromEdge);
+  base::TimeDelta timeout;
+
+  // If the press was at a corner, the user might go into corner passthrough
+  // instead.
+  bool in_a_bottom_corner =
+      (BOTTOM_LEFT_CORNER == location) || (BOTTOM_RIGHT_CORNER == location);
+  if (in_a_bottom_corner) {
+    VLOG(0) << "Location: " << location;
+    long_press_timer_.Start(FROM_HERE,
+                            gesture_detector_config_.longpress_timeout,
+                            this,
+                            &TouchExplorationController::OnLongPressTimerFired);
+    waiting_for_corner_passthrough_ = true;
+  } else {
+    waiting_for_corner_passthrough_ = false;
+  }
+  tap_timer_.Start(FROM_HERE,
+                   gesture_detector_config_.double_tap_timeout,
+                   this,
+                   &TouchExplorationController::OnTapTimerFired);
+  initial_press_.reset(new TouchEvent(event));
+  last_unused_finger_event_.reset(new TouchEvent(event));
+  gesture_provider_.OnTouchEvent(event);
+  gesture_provider_.OnTouchEventAck(false);
+  ProcessGestureEvents();
+  state_ = SINGLE_TAP_PRESSED;
+  VLOG_STATE();
+  return ui::EVENT_REWRITE_DISCARD;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSingleTapPressed(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
 
+  int location = FindEdgesWithinBounds(event.location(), kMaxDistanceFromEdge);
+  bool in_a_bottom_corner =
+      (location == BOTTOM_LEFT_CORNER) || (location == BOTTOM_RIGHT_CORNER);
+  // If the event is from the initial press and the location is no longer in the
+  // corner, then we are not waiting for a corner passthrough anymore.
+  if (event.touch_id() == initial_press_->touch_id() && !in_a_bottom_corner) {
+    waiting_for_corner_passthrough_ = false;
+    if (long_press_timer_.IsRunning()) {
+      long_press_timer_.Stop();
+      if (event.time_stamp() - initial_press_->time_stamp() >
+          gesture_detector_config_.double_tap_timeout) {
+        OnTapTimerFired();
+      }
+    }
+  }
+
   if (type == ui::ET_TOUCH_PRESSED) {
+    waiting_for_corner_passthrough_ = false;
     // Adding a second finger within the timeout period switches to
     // passing through every event from the second finger and none form the
     // first. The event from the first finger is still saved in initial_press_.
     state_ = TWO_TO_ONE_FINGER;
     last_two_to_one_.reset(new TouchEvent(event));
     rewritten_event->reset(new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
                                               event.location(),
                                               event.touch_id(),
                                               event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
     return EVENT_REWRITE_REWRITTEN;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
+    waiting_for_corner_passthrough_ = false;
     DCHECK_EQ(0U, current_touch_ids_.size());
     state_ = SINGLE_TAP_RELEASED;
     VLOG_STATE();
     return EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_MOVED) {
     float distance = (event.location() - initial_press_->location()).Length();
     // If the user does not move far enough from the original position, then the
     // resulting movement should not be considered to be a deliberate gesture or
     // touch exploration.
     if (distance <= gesture_detector_config_.touch_slop)
@@ skipping 195 matching lines @@
                                                 event.time_stamp()));
       (*rewritten_event)->set_flags(event.flags());
       state_ = WAIT_FOR_RELEASE;
       return ui::EVENT_REWRITE_REWRITTEN;
     }
   } else if (type == ui::ET_TOUCH_PRESSED) {
     DCHECK(current_touch_ids_.size() == 3);
     // If a third finger is pressed, we are now going into passthrough mode
     // and now need to dispatch the first finger into a press, as well as the
     // recent press.
-    if (current_touch_ids_.size() == 3){
+    if (current_touch_ids_.size() == 3) {
       state_ = PASSTHROUGH;
       scoped_ptr<ui::TouchEvent> first_finger_press;
       first_finger_press.reset(
           new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
                              last_unused_finger_event_->location(),
                              last_unused_finger_event_->touch_id(),
                              event.time_stamp()));
       DispatchEvent(first_finger_press.get());
       rewritten_event->reset(new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
                                                 event.location(),
@@ skipping 18 matching lines @@
                                                 event.touch_id(),
                                                 event.time_stamp()));
       (*rewritten_event)->set_flags(event.flags());
       return ui::EVENT_REWRITE_REWRITTEN;
     }
   }
   NOTREACHED() << "Unexpected event type received: " << event.name();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
+ui::EventRewriteStatus TouchExplorationController::InCornerPassthrough(
+    const ui::TouchEvent& event,
+    scoped_ptr<ui::Event>* rewritten_event) {
+  ui::EventType type = event.type();
+
+  // If the first finger has left the corner, then exit passthrough.
+  if (event.touch_id() == initial_press_->touch_id()) {
+    int edges = FindEdgesWithinBounds(event.location(), kSlopDistanceFromEdge);
+    bool in_a_bottom_corner = (edges == BOTTOM_LEFT_CORNER) ||
+                              (edges == BOTTOM_RIGHT_CORNER);
+    if (type == ui::ET_TOUCH_MOVED && in_a_bottom_corner)
+      return ui::EVENT_REWRITE_DISCARD;
+
+    if (current_touch_ids_.size() == 0) {
+      ResetToNoFingersDown();
+      return ui::EVENT_REWRITE_DISCARD;
+    }
+
+    waiting_for_corner_passthrough_ = false;
+    VLOG(0) << "Waiting for corner passthrough is false";
+    state_ = WAIT_FOR_RELEASE;
+    VLOG_STATE();
+    return ui::EVENT_REWRITE_DISCARD;
+  }
+
+  rewritten_event->reset(new ui::TouchEvent(
+      type, event.location(), event.touch_id(), event.time_stamp()));
+  (*rewritten_event)->set_flags(event.flags());
+
+  if (current_touch_ids_.size() == 0)
+    ResetToNoFingersDown();
+
+  return ui::EVENT_REWRITE_REWRITTEN;
+}
+
 ui::EventRewriteStatus TouchExplorationController::InPassthrough(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   ui::EventType type = event.type();
 
   if (!(type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED ||
         type == ui::ET_TOUCH_MOVED || type == ui::ET_TOUCH_PRESSED)) {
     NOTREACHED() << "Unexpected event type received: " << event.name();
     return ui::EVENT_REWRITE_CONTINUE;
   }
@@ skipping 47 matching lines @@
     VLOG_STATE();
     return ui::EVENT_REWRITE_REWRITTEN;
   }
   NOTREACHED() << "Unexpected event type received: " << event.name();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InWaitForRelease(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
+  waiting_for_corner_passthrough_ = false;
   ui::EventType type = event.type();
   if (!(type == ui::ET_TOUCH_PRESSED || type == ui::ET_TOUCH_MOVED ||
         type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED)) {
     NOTREACHED() << "Unexpected event type received: " << event.name();
     return ui::EVENT_REWRITE_CONTINUE;
   }
   if (current_touch_ids_.size() == 0) {
     state_ = NO_FINGERS_DOWN;
     VLOG_STATE();
     ResetToNoFingersDown();
@@ skipping 67 matching lines @@
 void TouchExplorationController::OnTapTimerFired() {
   switch (state_) {
     case SINGLE_TAP_RELEASED:
       ResetToNoFingersDown();
       break;
     case TOUCH_EXPLORE_RELEASED:
       ResetToNoFingersDown();
       last_touch_exploration_.reset(new TouchEvent(*initial_press_));
       return;
     case SINGLE_TAP_PRESSED:
+      if (waiting_for_corner_passthrough_)
+        return;
     case GESTURE_IN_PROGRESS:
+      waiting_for_corner_passthrough_ = false;
       // Discard any pending gestures.
       delete gesture_provider_.GetAndResetPendingGestures();
       EnterTouchToMouseMode();
       state_ = TOUCH_EXPLORATION;
       VLOG_STATE();
       break;
     default:
       return;
   }
   scoped_ptr<ui::Event> mouse_move =
       CreateMouseMoveEvent(initial_press_->location(), initial_press_->flags());
   DispatchEvent(mouse_move.get());
   last_touch_exploration_.reset(new TouchEvent(*initial_press_));
 }
 
+void TouchExplorationController::OnLongPressTimerFired() {
+  if (waiting_for_corner_passthrough_) {
+    delegate_->PlayCornerPassthroughEarcon();
+    delete gesture_provider_.GetAndResetPendingGestures();
+    state_ = CORNER_PASSTHROUGH;
+    VLOG_STATE();
+    return;
+  }
+}
+
 void TouchExplorationController::DispatchEvent(ui::Event* event) {
   if (event_handler_for_testing_) {
     event_handler_for_testing_->OnEvent(event);
     return;
   }
   ui::EventDispatchDetails result ALLOW_UNUSED =
       root_window_->GetHost()->dispatcher()->OnEventFromSource(event);
 }
 
 void TouchExplorationController::OnGestureEvent(
@@ skipping 174 matching lines @@
 void TouchExplorationController::EnterTouchToMouseMode() {
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window_);
   if (cursor_client && !cursor_client->IsMouseEventsEnabled())
     cursor_client->EnableMouseEvents();
   if (cursor_client && cursor_client->IsCursorVisible())
     cursor_client->HideCursor();
 }
 
 void TouchExplorationController::ResetToNoFingersDown() {
+  waiting_for_corner_passthrough_ = false;
   ProcessGestureEvents();
   if (sound_timer_.IsRunning())
     sound_timer_.Stop();
   state_ = NO_FINGERS_DOWN;
   VLOG_STATE();
   if (tap_timer_.IsRunning())
     tap_timer_.Stop();
 }
 
 void TouchExplorationController::VlogState(const char* function_name) {
@@ skipping 50 matching lines @@
     case DOUBLE_TAP_PRESSED:
       return "DOUBLE_TAP_PRESSED";
     case TOUCH_EXPLORATION:
       return "TOUCH_EXPLORATION";
     case GESTURE_IN_PROGRESS:
       return "GESTURE_IN_PROGRESS";
     case TOUCH_EXPLORE_SECOND_PRESS:
       return "TOUCH_EXPLORE_SECOND_PRESS";
     case TWO_TO_ONE_FINGER:
       return "TWO_TO_ONE_FINGER";
+    case CORNER_PASSTHROUGH:
+      return "CORNER_PASSTHROUGH";
     case PASSTHROUGH:
       return "PASSTHROUGH";
     case WAIT_FOR_RELEASE:
       return "WAIT_FOR_RELEASE";
     case SLIDE_GESTURE:
       return "SLIDE_GESTURE";
   }
   return "Not a state";
 }
 
 }  // namespace ui