BASELINE: Update Chromium to 60.0.3112.96

Change-Id: I8fa4120b6b8153b5be2520e57cf76c8d210bc2b5
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

5 files changed, 86 insertions, 136 deletions

diff --git a/chromium/third_party/gestures/gestures/include/finger_metrics.h b/chromium/third_party/gestures/gestures/include/finger_metrics.h
index aafddc91251..42ecb9e970f 100644
--- a/chromium/third_party/gestures/gestures/include/finger_metrics.h
+++ b/chromium/third_party/gestures/gestures/include/finger_metrics.h
@@ -5,8 +5,6 @@
 #ifndef GESTURES_FINGER_METRICS_H_
 #define GESTURES_FINGER_METRICS_H_
 
-#include <cmath>
-
 #include "gestures/include/gestures.h"
 #include "gestures/include/prop_registry.h"
 #include "gestures/include/vector.h"
diff --git a/chromium/third_party/gestures/gestures/include/immediate_interpreter.h b/chromium/third_party/gestures/gestures/include/immediate_interpreter.h
index 45737e4c4eb..908e2f40235 100644
--- a/chromium/third_party/gestures/gestures/include/immediate_interpreter.h
+++ b/chromium/third_party/gestures/gestures/include/immediate_interpreter.h
@@ -756,10 +756,6 @@ class ImmediateInterpreter : public Interpreter, public PropertyDelegate {
   // Distance [mm] a finger must move after fingers change to count as real
   // motion
   DoubleProperty change_move_distance_;
-  // Speed [mm/s] a finger must move to lock on to that finger
-  DoubleProperty move_lock_speed_;
-  // Distance [mm] a finger must move to report that movement
-  DoubleProperty move_report_distance_;
   // Time [s] to block movement after number or identify of fingers change
   DoubleProperty change_timeout_;
   // Time [s] to wait before locking on to a gesture
@@ -822,9 +818,6 @@ class ImmediateInterpreter : public Interpreter, public PropertyDelegate {
   DoubleProperty thumb_click_prevention_timeout_;
   // Consider scroll vs pointing if finger moves at least this distance [mm]
   DoubleProperty two_finger_scroll_distance_thresh_;
-  // Consider move if there is no scroll and one finger moves at least this
-  // distance [mm]
-  DoubleProperty two_finger_move_distance_thresh_;
   // Maximum distance [mm] between the outermost fingers while performing a
   // three-finger gesture.
   DoubleProperty three_finger_close_distance_thresh_;
@@ -837,14 +830,11 @@ class ImmediateInterpreter : public Interpreter, public PropertyDelegate {
   // Minimum distance [mm] one of the four fingers must move to perform a
   // four finger swipe gesture.
   DoubleProperty four_finger_swipe_distance_thresh_;
-  // Minimum ratio between least and most moving finger to perform a
-  // three finger swipe gesture.
-  DoubleProperty three_finger_swipe_distance_ratio_;
-  // Minimum ratio between least and most moving finger to perform a
-  // four finger swipe gesture.
-  DoubleProperty four_finger_swipe_distance_ratio_;
   // If three-finger swipe should be enabled
   BoolProperty three_finger_swipe_enable_;
+  // During a scroll one finger determines scroll speed and direction.
+  // Maximum distance [mm] the other finger can move in opposite direction
+  DoubleProperty scroll_stationary_finger_max_distance_;
   // Height [mm] of the bottom zone
   DoubleProperty bottom_zone_size_;
   // Time [s] to after button down to evaluate number of fingers for a click
diff --git a/chromium/third_party/gestures/gestures/include/metrics_filter_interpreter.h b/chromium/third_party/gestures/gestures/include/metrics_filter_interpreter.h
index cae1c065ccc..f0f24f54ba0 100644
--- a/chromium/third_party/gestures/gestures/include/metrics_filter_interpreter.h
+++ b/chromium/third_party/gestures/gestures/include/metrics_filter_interpreter.h
@@ -115,8 +115,8 @@ class MetricsFilterInterpreter : public FilterInterpreter {
 
   // Number of mouse movement sessions that we skip at startup. We do this
   // because it takes time for the user to "get used to" the mouse speed when
-  // they first start using the mouse. We only want to capture the user metrics
-  // after the user has been familiar with their mouse.
+  // he/she first starts using the mouse. We only want to capture the user
+  // metrics after the user have been familiar with his/her mouse.
   IntProperty mouse_control_warmup_sessions_;
 };
 
diff --git a/chromium/third_party/gestures/gestures/src/immediate_interpreter.cc b/chromium/third_party/gestures/gestures/src/immediate_interpreter.cc
index b3c2fae4b10..af953d236bc 100644
--- a/chromium/third_party/gestures/gestures/src/immediate_interpreter.cc
+++ b/chromium/third_party/gestures/gestures/src/immediate_interpreter.cc
@@ -1017,10 +1017,8 @@ ImmediateInterpreter::ImmediateInterpreter(PropRegistry* prop_reg,
                                       "T5R2 Three Finger Click Enable",
                                       0),
       change_move_distance_(prop_reg, "Change Min Move Distance", 3.0),
-      move_lock_speed_(prop_reg, "Move Lock Speed", 10.0),
-      move_report_distance_(prop_reg, "Move Report Distance", 0.35),
       change_timeout_(prop_reg, "Change Timeout", 0.04),
-      evaluation_timeout_(prop_reg, "Evaluation Timeout", 0.15),
+      evaluation_timeout_(prop_reg, "Evaluation Timeout", 0.2),
       pinch_evaluation_timeout_(prop_reg, "Pinch Evaluation Timeout", 0.3),
       thumb_pinch_evaluation_timeout_(prop_reg,
                                       "Thumb Pinch Evaluation Timeout", 0.5),
@@ -1057,32 +1055,25 @@ ImmediateInterpreter::ImmediateInterpreter(PropRegistry* prop_reg,
       thumb_pinch_threshold_ratio_(prop_reg,
                                    "Thumb Pinch Threshold Ratio", 0.25),
       thumb_click_prevention_timeout_(prop_reg,
-                                      "Thumb Click Prevention Timeout", 0.15),
+                                      "Thumb Click Prevention Timeout", 0.2),
       two_finger_scroll_distance_thresh_(prop_reg,
                                          "Two Finger Scroll Distance Thresh",
-                                         1.5),
-      two_finger_move_distance_thresh_(prop_reg,
-                                       "Two Finger Move Distance Thresh",
-                                       7.0),
+                                         2.0),
       three_finger_close_distance_thresh_(prop_reg,
                                           "Three Finger Close Distance Thresh",
-                                          55.0),
+                                          50.0),
       four_finger_close_distance_thresh_(prop_reg,
                                          "Four Finger Close Distance Thresh",
                                          60.0),
       three_finger_swipe_distance_thresh_(prop_reg,
                                           "Three Finger Swipe Distance Thresh",
-                                          1.5),
+                                          2.0),
       four_finger_swipe_distance_thresh_(prop_reg,
                                          "Four Finger Swipe Distance Thresh",
-                                         1.5),
-      three_finger_swipe_distance_ratio_(prop_reg,
-                                          "Three Finger Swipe Distance Ratio",
-                                          0.2),
-      four_finger_swipe_distance_ratio_(prop_reg,
-                                         "Four Finger Swipe Distance Ratio",
-                                         0.2),
+                                         2.0),
       three_finger_swipe_enable_(prop_reg, "Three Finger Swipe EnableX", 1),
+      scroll_stationary_finger_max_distance_(
+          prop_reg, "Scroll Stationary Finger Max Distance", 1.0),
       bottom_zone_size_(prop_reg, "Bottom Zone Size", 10.0),
       button_evaluation_timeout_(prop_reg, "Button Evaluation Timeout", 0.05),
       button_finger_timeout_(prop_reg, "Button Finger Timeout", 0.03),
@@ -1567,12 +1558,6 @@ void ImmediateInterpreter::UpdateThumbState(const HardwareState& hwstate) {
         (fs.pressure > min_pressure + two_finger_pressure_diff_thresh_.val_ &&
          fs.pressure > min_pressure * two_finger_pressure_diff_factor_.val_ &&
          fs.position_y > min_fs->position_y);
-    bool non_gs = (hwstate.timestamp > changed_time_ &&
-                   (prev_active_gs_fingers_.find(fs.tracking_id) ==
-                    prev_active_gs_fingers_.end()) &&
-                   prev_result_.type != kGestureTypeNull);
-    non_gs |= moving_finger_id_ >= 0 && moving_finger_id_ != fs.tracking_id;
-    likely_thumb |= non_gs;
     // We sometimes can't decide the thumb state if some fingers are undergoing
     // warp moves as the decision could be off (DistanceTravelledSq may
     // under-estimate the real distance). The cases that we need to re-evaluate
@@ -1723,7 +1708,6 @@ void ImmediateInterpreter::UpdateCurrentGestureType(
       if (AnyGesturingFingerLeft(*state_buffer_.Get(0),
                                  prev_gs_fingers_)) {
         current_gesture_type_ = GetFingerLiftGesture(current_gesture_type_);
-        moving_.clear();
         return;
       }
       // fallthrough
@@ -1790,7 +1774,7 @@ void ImmediateInterpreter::UpdateCurrentGestureType(
                 // ambiguous. Only move if they've been down long enough.
                 if (new_gs_type == kGestureTypeMove &&
                     hwstate.timestamp -
-                        min(origin_timestamps_[fingers[0]->tracking_id],
+                        max(origin_timestamps_[fingers[0]->tracking_id],
                             origin_timestamps_[fingers[1]->tracking_id]) <
                     evaluation_timeout_.val_)
                   new_gs_type = kGestureTypeNull;
@@ -2224,17 +2208,12 @@ GestureType ImmediateInterpreter::GetTwoFingerGestureType(
   float large_dy = MaxMag(dy1, dy2);
   // These compares are okay if d{x,y}1 == d{x,y}2:
   short large_dx_id =
-      (large_dx == dx1) ? finger1.tracking_id : finger2.tracking_id;
+      large_dx == dx1 ? finger1.tracking_id : finger2.tracking_id;
   short large_dy_id =
-      (large_dy == dy1) ? finger1.tracking_id : finger2.tracking_id;
+      large_dy == dy1 ? finger1.tracking_id : finger2.tracking_id;
   float small_dx = MinMag(dx1, dx2);
   float small_dy = MinMag(dy1, dy2);
 
-  short small_dx_id =
-      (small_dx == dx1) ? finger1.tracking_id : finger2.tracking_id;
-  short small_dy_id =
-      (small_dy == dy1) ? finger1.tracking_id : finger2.tracking_id;
-
   bool dampened_zone_occupied = false;
   // movements of the finger in the dampened zone. If there are multiple
   // fingers in the dampened zone, dx is min(dx_1, dx_2), dy is min(dy_1, dy_2).
@@ -2242,6 +2221,8 @@ GestureType ImmediateInterpreter::GetTwoFingerGestureType(
   float damp_dy = INFINITY;
   float non_damp_dx = 0.0;
   float non_damp_dy = 0.0;
+  bool damp_instaneous_moving_x = false;
+  bool damp_instaneous_moving_y = false;
   if (FingerInDampenedZone(finger1) ||
       (finger1.flags & GESTURES_FINGER_POSSIBLE_PALM)) {
     dampened_zone_occupied = true;
@@ -2249,6 +2230,8 @@ GestureType ImmediateInterpreter::GetTwoFingerGestureType(
     damp_dy = dy1;
     non_damp_dx = dx2;
     non_damp_dy = dy2;
+    damp_instaneous_moving_x = damp_instaneous_moving_y =
+        finger1.flags & GESTURES_FINGER_INSTANTANEOUS_MOVING;
   }
   if (FingerInDampenedZone(finger2) ||
       (finger2.flags & GESTURES_FINGER_POSSIBLE_PALM)) {
@@ -2257,6 +2240,14 @@ GestureType ImmediateInterpreter::GetTwoFingerGestureType(
     damp_dy = MinMag(damp_dy, dy2);
     non_damp_dx = MaxMag(non_damp_dx, dx1);
     non_damp_dy = MaxMag(non_damp_dy, dy1);
+    damp_instaneous_moving_x =
+        damp_dx == dx1
+            ? !!(finger1.flags & GESTURES_FINGER_INSTANTANEOUS_MOVING)
+            : !!(finger2.flags & GESTURES_FINGER_INSTANTANEOUS_MOVING);
+    damp_instaneous_moving_y =
+        damp_dy == dy1
+            ? !!(finger1.flags & GESTURES_FINGER_INSTANTANEOUS_MOVING)
+            : !!(finger2.flags & GESTURES_FINGER_INSTANTANEOUS_MOVING);
   }
 
   // Trending in the same direction?
@@ -2273,16 +2264,21 @@ GestureType ImmediateInterpreter::GetTwoFingerGestureType(
   bool large_dy_moving =
       fabsf(large_dy) >= two_finger_scroll_distance_thresh_.val_ ||
       SetContainsValue(moving_, large_dy_id);
-  bool small_dx_moving =
-      fabsf(small_dx) >= two_finger_scroll_distance_thresh_.val_ ||
-      SetContainsValue(moving_, small_dx_id);
-  bool small_dy_moving =
-      fabsf(small_dy) >= two_finger_scroll_distance_thresh_.val_ ||
-      SetContainsValue(moving_, small_dy_id);
+  // We use a tighter moving criteria for damped finger here: it needs to be
+  // moving in the past a few frames rather than just being moving before.
+  bool small_dx_moving = fabsf(damp_dx) >=
+      damp_scroll_min_movement_factor_.val_ * fabsf(non_damp_dx) ||
+      damp_instaneous_moving_x;
+  bool small_dy_moving = fabsf(damp_dy) >=
+      damp_scroll_min_movement_factor_.val_ * fabsf(non_damp_dy) ||
+      damp_instaneous_moving_y;
+  // If not in damp zone, we allow one-finger scrolling
+  bool small_dx_scrolling = !dampened_zone_occupied || small_dx_moving;
+  bool small_dy_scrolling = !dampened_zone_occupied || small_dy_moving;
   bool trend_scrolling_x = (common_trend_flags & kTrendX) &&
-       large_dx_moving && small_dx_moving;
+       large_dx_moving && small_dx_scrolling;
   bool trend_scrolling_y = (common_trend_flags & kTrendY) &&
-       large_dy_moving && small_dy_moving;
+       large_dy_moving && small_dy_scrolling;
 
   if (trend_scrolling_x || trend_scrolling_y) {
     if (pinch_enable_.val_ && !ScrollAngle(finger1, finger2))
@@ -2292,22 +2288,17 @@ GestureType ImmediateInterpreter::GetTwoFingerGestureType(
 
   if (fabsf(large_dx) > fabsf(large_dy)) {
     // consider horizontal scroll
-    if (fabsf(small_dx) < two_finger_scroll_distance_thresh_.val_)
-      small_dx = 0.0;
-    if (large_dx * small_dx <= 0.0) {
-      // not same direction
-      if (fabsf(large_dx) < two_finger_move_distance_thresh_.val_)
-        return kGestureTypeNull;
-      else
-        return kGestureTypeMove;
-    }
     if (fabsf(large_dx) < two_finger_scroll_distance_thresh_.val_)
       return kGestureTypeNull;
+    if (fabsf(small_dx) < scroll_stationary_finger_max_distance_.val_)
+      small_dx = 0.0;
+    if (large_dx * small_dx < 0.0)
+      return kGestureTypeMove;  // not same direction
     if (dampened_zone_occupied) {
       // Require damp to move at least some amount with the other finger
       if (fabsf(damp_dx) <
           damp_scroll_min_movement_factor_.val_ * fabsf(non_damp_dx)) {
-        return kGestureTypeNull;
+        return kGestureTypeMove;
       }
     }
     if (pinch_enable_.val_ && !ScrollAngle(finger1, finger2))
@@ -2315,19 +2306,17 @@ GestureType ImmediateInterpreter::GetTwoFingerGestureType(
     return kGestureTypeScroll;
   } else {
     // consider vertical scroll
-    if (fabsf(small_dy) < two_finger_scroll_distance_thresh_.val_)
+    if (fabsf(large_dy) < two_finger_scroll_distance_thresh_.val_)
+      return kGestureTypeNull;
+    if (fabsf(small_dy) < scroll_stationary_finger_max_distance_.val_)
       small_dy = 0.0;
-    if (large_dy * small_dy <= 0.0) {
-      if (fabsf(large_dy) < two_finger_move_distance_thresh_.val_)
-        return kGestureTypeNull;
-      else
-        return kGestureTypeMove;
-    }
+    if (large_dy * small_dy < 0.0)
+      return kGestureTypeMove;
     if (dampened_zone_occupied) {
       // Require damp to move at least some amount with the other finger
       if (fabsf(damp_dy) <
           damp_scroll_min_movement_factor_.val_ * fabsf(non_damp_dy)) {
-        return kGestureTypeNull;
+        return kGestureTypeMove;
       }
     }
     if (pinch_enable_.val_ && !ScrollAngle(finger1, finger2))
@@ -2350,17 +2339,14 @@ GestureType ImmediateInterpreter::GetMultiFingerGestureType(
     const FingerState* const fingers[], const int num_fingers) {
   float close_distance_thresh;
   float swipe_distance_thresh;
-  float swipe_distance_ratio;
   GestureType gesture_type;
   if (num_fingers == 4) {
     close_distance_thresh = four_finger_close_distance_thresh_.val_;
     swipe_distance_thresh = four_finger_swipe_distance_thresh_.val_;
-    swipe_distance_ratio = four_finger_swipe_distance_ratio_.val_;
     gesture_type = kGestureTypeFourFingerSwipe;
   } else if (num_fingers == 3) {
     close_distance_thresh = three_finger_close_distance_thresh_.val_;
     swipe_distance_thresh = three_finger_swipe_distance_thresh_.val_;
-    swipe_distance_ratio = three_finger_swipe_distance_ratio_.val_;
     gesture_type = kGestureTypeSwipe;
   } else {
     return kGestureTypeNull;
@@ -2409,16 +2395,12 @@ GestureType ImmediateInterpreter::GetMultiFingerGestureType(
     }
   }
 
-  // All fingers must have traveled far enough.
-  float max_delta = fabsf(deltas[0]);
-  float min_delta = fabsf(deltas[0]);
-  for (int i = 1; i < num_fingers; i++) {
-    max_delta = max(max_delta, fabsf(deltas[i]));
-    min_delta = min(min_delta, fabsf(deltas[i]));
+  // One finger must have traveled far enough.
+  for (int i = 0; i < num_fingers; i++) {
+    if (fabsf(deltas[i]) >= swipe_distance_thresh) {
+      return gesture_type;
+    }
   }
-  if (max_delta >= swipe_distance_thresh &&
-      min_delta >= swipe_distance_ratio * max_delta)
-    return gesture_type;
   return kGestureTypeNull;
 }
 
@@ -3042,30 +3024,22 @@ void ImmediateInterpreter::FillResultGesture(
     case kGestureTypeMove: {
       if (fingers.empty())
         return;
-      // Use the finger which has moved the most to compute motion.
-      // First, need to find out which finger that is.
+      // Use highest finger (the one closes to the keyboard), excluding
+      // palms, to compute motion. First, need to find out which finger that is.
       const FingerState* current = NULL;
       if (moving_finger_id_ >= 0)
         current = hwstate.GetFingerState(moving_finger_id_);
 
-      const HardwareState* prev_hs = state_buffer_.Get(1);
-      if (prev_hs && !current) {
-        float curr_dist_sq = -1;
+      if (!current) {
         for (FingerMap::const_iterator it =
                  fingers.begin(), e = fingers.end(); it != e; ++it) {
           const FingerState* fs = hwstate.GetFingerState(*it);
-          const FingerState* prev_fs = prev_hs->GetFingerState(fs->tracking_id);
-          if (!prev_fs)
-            break;
-          float dist_sq = DistSq(*fs, *prev_fs);
-          if (dist_sq > curr_dist_sq) {
+          if (!current || fs->position_y < current->position_y ||
+              (current->flags & GESTURES_FINGER_POSSIBLE_PALM &&
+               !(fs->flags & GESTURES_FINGER_POSSIBLE_PALM)))
             current = fs;
-            curr_dist_sq = dist_sq;
-          }
         }
       }
-      if (!current)
-        return;
 
       // Find corresponding finger id in previous state
       const FingerState* prev =
@@ -3105,23 +3079,10 @@ void ImmediateInterpreter::FillResultGesture(
       float dy = current->position_y - prev->position_y;
       if (current->flags & GESTURES_FINGER_WARP_Y_MOVE)
         dy = 0.0;
-      float dsq = dx * dx + dy * dy;
-      float dx_total = current->position_x -
-                       start_positions_[current->tracking_id].x_;
-      float dy_total = current->position_y -
-                       start_positions_[current->tracking_id].y_;
-      float dsq_total = dx_total * dx_total + dy_total * dy_total;
-
-      float dsq_thresh = (move_lock_speed_.val_ * move_lock_speed_.val_) *
-                         (dt * dt);
-      if (dsq > dsq_thresh) {
+      if (dx != 0.0 || dy != 0.0) {
         // lock onto this finger
         moving_finger_id_ = current->tracking_id;
-      }
 
-      float dsq_total_thresh =
-          move_report_distance_.val_ * move_report_distance_.val_;
-      if (dsq_total >= dsq_total_thresh && dsq != 0.0) {
         result_ = Gesture(kGestureMove,
                           state_buffer_.Get(1)->timestamp,
                           hwstate.timestamp,
diff --git a/chromium/third_party/gestures/gestures/src/immediate_interpreter_unittest.cc b/chromium/third_party/gestures/gestures/src/immediate_interpreter_unittest.cc
index 7cd9fb8c03a..ffa11626fd9 100644
--- a/chromium/third_party/gestures/gestures/src/immediate_interpreter_unittest.cc
+++ b/chromium/third_party/gestures/gestures/src/immediate_interpreter_unittest.cc
@@ -619,7 +619,7 @@ TEST(ImmediateInterpreterTest, OneFingerThenTwoDelayedStartScrollTest) {
     {0, 0, 0, 0, 20, 0, 40, 85, 1, 0},
     {0, 0, 0, 0, 20, 0, 60, 83, 2, 0},
 
-    {0, 0, 0, 0, 20, 0, 40, 77, 1, 0},
+    {0, 0, 0, 0, 20, 0, 40, 85, 1, 0},
     {0, 0, 0, 0, 20, 0, 60, 75, 2, 0},
 
   };
@@ -1096,7 +1096,7 @@ TEST(ImmediateInterpreterTest, RestingFingerTest) {
   TestInterpreterWrapper wrapper(ii.get(), &hwprops);
 
   const float kX = 7;
-  float dx = 7;
+  float dx = 5;
   const float kRestY = hwprops.bottom - 7;
   const float kMoveY = kRestY - 10;
 
@@ -1769,13 +1769,13 @@ TEST(ImmediateInterpreterTest, TapToClickStateMachineTest) {
     {S,{0.00,0,1,1,&fs[0],0,0,0,0},-1,MkSet(91),0,0,kFTB,false},
     {C,{0.01,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,0,kTpC,true},
     {C,{0.02,0,1,1,&fs[4],0,0,0,0},-1,MkSet(95),0,0,kSTB,false},
-    {C,{0.08,0,1,1,&fs[5],0,0,0,0},-1,MkSet(95),kBL,0,kDrg,false},
-    {C,{0.09,0,1,1,&fs[6],0,0,0,0},-1,MkSet(95),0,0,kDrg,false},
-    {C,{0.10,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,0,kDRl,true},
-    {C,{0.11,0,1,1,&fs[7],0,0,0,0},-1,MkSet(96),0,0,kDRt,false},
-    {C,{0.12,0,1,1,&fs[8],0,0,0,0},-1,MkSet(96),0,0,kDrg,false},
-    {C,{0.13,0,1,1,&fs[9],0,0,0,0},-1,MkSet(96),0,0,kDrg,false},
-    {C,{0.14,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,0,kDRl,true},
+    {C,{0.13,0,1,1,&fs[5],0,0,0,0},-1,MkSet(95),kBL,0,kDrg,false},
+    {C,{0.14,0,1,1,&fs[6],0,0,0,0},-1,MkSet(95),0,0,kDrg,false},
+    {C,{0.15,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,0,kDRl,true},
+    {C,{0.16,0,1,1,&fs[7],0,0,0,0},-1,MkSet(96),0,0,kDRt,false},
+    {C,{0.17,0,1,1,&fs[8],0,0,0,0},-1,MkSet(96),0,0,kDrg,false},
+    {C,{0.18,0,1,1,&fs[9],0,0,0,0},-1,MkSet(96),0,0,kDrg,false},
+    {C,{0.19,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,0,kDRl,true},
     {C,{0.99,0,0,0,NULL,0,0,0,0},.99,MkSet(),0,kBL,kIdl,false},
     // 1-finger long press
     {S,{0.00,0,1,1,&fs[0],0,0,0,0},-1,MkSet(91),0,0,kFTB,false},
@@ -1883,11 +1883,11 @@ TEST(ImmediateInterpreterTest, TapToClickStateMachineTest) {
     {S,{0.00,0,1,1,&fs[0],0,0,0,0},-1,MkSet(91),0,0,kFTB,false},
     {C,{0.01,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,0,kTpC,true},
     {C,{0.02,0,1,1,&fs[4],0,0,0,0},-1,MkSet(95),0,0,kSTB,false},
-    {C,{0.10,0,1,1,&fs[5],0,0,0,0},-1,MkSet(95),kBL,0,kDrg,false},
-    {C,{0.11,0,1,1,&fs[6],0,0,0,0},-1,MkSet(95),0,0,kDrg,false},
-    {C,{0.12,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,0,kDRl,true},
-    {C,{0.13,0,2,2,&fs[10],0,0,0,0},-1,MkSet(97,98),0,0,kDRt,false},
-    {C,{0.14,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,kBL,kTpC,true},
+    {C,{0.13,0,1,1,&fs[5],0,0,0,0},-1,MkSet(95),kBL,0,kDrg,false},
+    {C,{0.14,0,1,1,&fs[6],0,0,0,0},-1,MkSet(95),0,0,kDrg,false},
+    {C,{0.15,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,0,kDRl,true},
+    {C,{0.16,0,2,2,&fs[10],0,0,0,0},-1,MkSet(97,98),0,0,kDRt,false},
+    {C,{0.17,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,kBL,kTpC,true},
     {C,{0.99,0,0,0,NULL,0,0,0,0},.99,MkSet(),kBR,kBR,kIdl,false},
     // slow double tap
     {D,{ 0.00, 0, 1, 1, &fs[0],0,0,0,0}, -1, MkSet(91),   0,   0, kFTB, false },
@@ -2300,13 +2300,13 @@ TEST(ImmediateInterpreterTest, TapToClickEnableTest) {
     {S,{0.00,0,1,1,&fs[0],0,0,0,0},-1,MkSet(91),0,0,kFTB,false},
     {C,{0.01,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,0,kTpC,true},
     {C,{0.02,0,1,1,&fs[1],0,0,0,0},-1,MkSet(92),0,0,kSTB,false},
-    {C,{0.08,0,1,1,&fs[2],0,0,0,0},-1,MkSet(92),kBL,0,kDrg,false},
-    {C,{0.09,0,1,1,&fs[3],0,0,0,0},-1,MkSet(92),0,0,kDrg,false},
-    {C,{0.10,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,0,kDRl,true},
-    {C,{0.11,0,1,1,&fs[4],0,0,0,0},-1,MkSet(93),0,0,kDRt,false},
-    {C,{0.12,0,1,1,&fs[5],0,0,0,0},-1,MkSet(93),0,0,kDrg,false},
-    {C,{0.13,0,1,1,&fs[6],0,0,0,0},-1,MkSet(93),0,0,kDrg,false},
-    {C,{0.14,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,0,kDRl,true},
+    {C,{0.13,0,1,1,&fs[2],0,0,0,0},-1,MkSet(92),kBL,0,kDrg,false},
+    {C,{0.14,0,1,1,&fs[3],0,0,0,0},-1,MkSet(92),0,0,kDrg,false},
+    {C,{0.15,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,0,kDRl,true},
+    {C,{0.16,0,1,1,&fs[4],0,0,0,0},-1,MkSet(93),0,0,kDRt,false},
+    {C,{0.17,0,1,1,&fs[5],0,0,0,0},-1,MkSet(93),0,0,kDrg,false},
+    {C,{0.18,0,1,1,&fs[6],0,0,0,0},-1,MkSet(93),0,0,kDrg,false},
+    {C,{0.19,0,0,0,NULL,0,0,0,0},-1,MkSet(),0,0,kDRl,true},
     {C,{0.99,0,0,0,NULL,0,0,0,0},.99,MkSet(),0,kBL,kIdl,false}
   };
 
@@ -3442,6 +3442,7 @@ TEST(ImmediateInterpreterTest, ScrollResetTapTest) {
 
   // SemiMt-specific properties
   ii.tapping_finger_min_separation_.val_ = 0.0;
+  ii.scroll_stationary_finger_max_distance_.val_ = 20.0;
 
   ii.tap_enable_.val_ = 1;
   TestInterpreterWrapper wrapper(&ii, &hwprops);