Only exclude workarea from touch-exploration with active shell-surface

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 <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 45 matching lines @@
 
 void TouchExplorationController::SetTouchAccessibilityAnchorPoint(
     const gfx::Point& anchor_point) {
   gfx::Point native_point = anchor_point;
   root_window_->GetHost()->ConvertPointToNativeScreen(&native_point);
 
   anchor_point_ = gfx::PointF(native_point.x(), native_point.y());
   anchor_point_state_ = ANCHOR_POINT_EXPLICITLY_SET;
 }
 
+void TouchExplorationController::SetExcludeBounds(const gfx::Rect& bounds) {
+  exclude_bounds_ = bounds;
+}
+
 ui::EventRewriteStatus TouchExplorationController::RewriteEvent(
     const ui::Event& event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   if (!event.IsTouchEvent()) {
     if (event.IsKeyEvent()) {
       const ui::KeyEvent& key_event = static_cast<const ui::KeyEvent&>(event);
       VLOG(0) << "\nKeyboard event: " << key_event.name()
               << "\n Key code: " << key_event.key_code()
               << ", Flags: " << key_event.flags()
               << ", Is char: " << key_event.is_char();
     }
     return ui::EVENT_REWRITE_CONTINUE;
   }
   const ui::TouchEvent& touch_event = static_cast<const ui::TouchEvent&>(event);
 
+  if (!exclude_bounds_.IsEmpty()) {
+    gfx::Point location = touch_event.location();
+    root_window_->GetHost()->ConvertPointFromNativeScreen(&location);
+    bool in_exclude_area = exclude_bounds_.Contains(location);
+    if (in_exclude_area) {
+      if (state_ == NO_FINGERS_DOWN)
+        return ui::EVENT_REWRITE_CONTINUE;
+      if (touch_event.type() == ui::ET_TOUCH_MOVED ||
+          touch_event.type() == ui::ET_TOUCH_PRESSED) {
+        return ui::EVENT_REWRITE_DISCARD;
+      }
+      // Otherwise, continue handling events. Basically, we want to let
+      // CANCELLED or RELEASE events through so this can get back to
+      // the NO_FINGERS_DOWN state.
+    }
+  }
+
   // If the tap timer should have fired by now but hasn't, run it now and
   // stop the timer. This is important so that behavior is consistent with
   // the timestamps of the events, and not dependent on the granularity of
   // 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
@@ skipping 13 matching lines @@
 
   // 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) {
     std::vector<int>::iterator it = std::find(
         current_touch_ids_.begin(), current_touch_ids_.end(), touch_id);
 
-    // Can happen if touch exploration is enabled while fingers were down.
+    // Can happen if touch exploration is enabled while fingers were down
+    // or if an additional press occurred within the exclusion bounds.
     if (it == current_touch_ids_.end())
       return ui::EVENT_REWRITE_CONTINUE;
 
     current_touch_ids_.erase(it);
     touch_locations_.erase(touch_id);
   } else if (type == ui::ET_TOUCH_MOVED) {
     std::vector<int>::iterator it = std::find(
         current_touch_ids_.begin(), current_touch_ids_.end(), touch_id);
 
     // Can happen if touch exploration is enabled while fingers were down.
@@ skipping 1035 matching lines @@
       return "TWO_FINGER_TAP";
   }
   return "Not a state";
 }
 
 float TouchExplorationController::GetSplitTapTouchSlop() {
   return gesture_detector_config_.touch_slop * 3;
 }
 
 }  // namespace ui