ui/events/gestures/gesture_sequence.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/events/gestures/gesture_sequence.h"
   6
   7 #include <stdlib.h>
   8 #include <cmath>
   9 #include <limits>
  10
  11 #include "base/command_line.h"
  12 #include "base/logging.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/time/time.h"
  16 #include "ui/events/event.h"
  17 #include "ui/events/event_constants.h"
  18 #include "ui/events/event_switches.h"
  19 #include "ui/events/gestures/gesture_configuration.h"
  20 #include "ui/gfx/rect.h"
  21
  22 namespace ui {
  23
  24 namespace {
  25
  26 // ui::EventType is mapped to TouchState so it can fit into 3 bits of
  27 // Signature.
  28 enum TouchState {
  29   TS_RELEASED,
  30   TS_PRESSED,
  31   TS_MOVED,
  32   TS_CANCELLED,
  33   TS_UNKNOWN,
  34 };
  35
  36 // ui::EventResult is mapped to TouchStatusInternal to simply indicate whether a
  37 // processed touch-event should affect gesture-recognition or not.
  38 enum TouchStatusInternal {
  39   TSI_NOT_PROCESSED,  // The touch-event should take-part into
  40                       // gesture-recognition only if the touch-event has not
  41                       // been processed.
  42
  43   TSI_PROCESSED,      // The touch-event should affect gesture-recognition only
  44                       // if the touch-event has been processed. For example,,
  45                       // this means that a JavaScript touch handler called
  46                       // |preventDefault| on the associated touch event
  47                       // or was processed by an aura-window or views-view.
  48
  49   TSI_ALWAYS          // The touch-event should always affect gesture
  50                       // recognition.
  51 };
  52
  53 // Get equivalent TouchState from EventType |type|.
  54 TouchState TouchEventTypeToTouchState(ui::EventType type) {
  55   switch (type) {
  56     case ui::ET_TOUCH_RELEASED:
  57       return TS_RELEASED;
  58     case ui::ET_TOUCH_PRESSED:
  59       return TS_PRESSED;
  60     case ui::ET_TOUCH_MOVED:
  61       return TS_MOVED;
  62     case ui::ET_TOUCH_CANCELLED:
  63       return TS_CANCELLED;
  64     default:
  65       DVLOG(1) << "Unknown Touch Event type";
  66   }
  67   return TS_UNKNOWN;
  68 }
  69
  70 // Gesture signature types for different values of combination (GestureState,
  71 // touch_id, ui::EventType, touch_handled), see Signature for more info.
  72 //
  73 // Note: New addition of types should be placed as per their Signature value.
  74 #define G(gesture_state, id, touch_state, handled) 1 + ( \
  75   (((touch_state) & 0x7) << 1) |                         \
  76   ((handled & 0x3) << 4) |                               \
  77   (((id) & 0xfff) << 6) |                                \
  78   ((gesture_state) << 18))
  79
  80 enum EdgeStateSignatureType {
  81   GST_INVALID = -1,
  82
  83   GST_NO_GESTURE_FIRST_PRESSED =
  84       G(GS_NO_GESTURE, 0, TS_PRESSED, TSI_NOT_PROCESSED),
  85
  86   GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED =
  87       G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_RELEASED, TSI_NOT_PROCESSED),
  88
  89   GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED_HANDLED =
  90       G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_RELEASED, TSI_PROCESSED),
  91
  92   // Ignore processed touch-move events until gesture-scroll starts.
  93   GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED =
  94       G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_MOVED, TSI_NOT_PROCESSED),
  95
  96   GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED_PROCESSED =
  97       G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_MOVED, TSI_PROCESSED),
  98
  99   GST_PENDING_SYNTHETIC_CLICK_FIRST_CANCELLED =
 100       G(GS_PENDING_SYNTHETIC_CLICK, 0, TS_CANCELLED, TSI_ALWAYS),
 101
 102   GST_PENDING_SYNTHETIC_CLICK_SECOND_PRESSED =
 103       G(GS_PENDING_SYNTHETIC_CLICK, 1, TS_PRESSED, TSI_NOT_PROCESSED),
 104
 105   GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_RELEASED =
 106       G(GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL,
 107         0,
 108         TS_RELEASED,
 109         TSI_NOT_PROCESSED),
 110
 111   GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_RELEASED_HANDLED =
 112       G(GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL, 0, TS_RELEASED, TSI_PROCESSED),
 113
 114   GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_MOVED =
 115       G(GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL, 0, TS_MOVED, TSI_ALWAYS),
 116
 117   GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_CANCELLED =
 118       G(GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL, 0, TS_CANCELLED, TSI_ALWAYS),
 119
 120   GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_SECOND_PRESSED =
 121       G(GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL, 1, TS_PRESSED, TSI_NOT_PROCESSED),
 122
 123   GST_SYNTHETIC_CLICK_ABORTED_FIRST_RELEASED =
 124       G(GS_SYNTHETIC_CLICK_ABORTED, 0, TS_RELEASED, TSI_ALWAYS),
 125
 126   GST_SYNTHETIC_CLICK_ABORTED_SECOND_PRESSED =
 127       G(GS_SYNTHETIC_CLICK_ABORTED, 1, TS_PRESSED, TSI_NOT_PROCESSED),
 128
 129   GST_SCROLL_FIRST_RELEASED =
 130       G(GS_SCROLL, 0, TS_RELEASED, TSI_ALWAYS),
 131
 132   GST_SCROLL_FIRST_MOVED =
 133       G(GS_SCROLL, 0, TS_MOVED, TSI_NOT_PROCESSED),
 134
 135   GST_SCROLL_FIRST_MOVED_HANDLED =
 136       G(GS_SCROLL, 0, TS_MOVED, TSI_PROCESSED),
 137
 138   GST_SCROLL_FIRST_CANCELLED =
 139       G(GS_SCROLL, 0, TS_CANCELLED, TSI_ALWAYS),
 140
 141   GST_SCROLL_SECOND_PRESSED =
 142       G(GS_SCROLL, 1, TS_PRESSED, TSI_NOT_PROCESSED),
 143
 144   GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED =
 145       G(GS_PENDING_TWO_FINGER_TAP, 0, TS_RELEASED, TSI_NOT_PROCESSED),
 146
 147   GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED_HANDLED =
 148       G(GS_PENDING_TWO_FINGER_TAP, 0, TS_RELEASED, TSI_PROCESSED),
 149
 150   GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED =
 151       G(GS_PENDING_TWO_FINGER_TAP, 1, TS_RELEASED, TSI_NOT_PROCESSED),
 152
 153   GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED_HANDLED =
 154       G(GS_PENDING_TWO_FINGER_TAP, 1, TS_RELEASED, TSI_PROCESSED),
 155
 156   GST_PENDING_TWO_FINGER_TAP_FIRST_MOVED =
 157       G(GS_PENDING_TWO_FINGER_TAP, 0, TS_MOVED, TSI_NOT_PROCESSED),
 158
 159   GST_PENDING_TWO_FINGER_TAP_SECOND_MOVED =
 160       G(GS_PENDING_TWO_FINGER_TAP, 1, TS_MOVED, TSI_NOT_PROCESSED),
 161
 162   GST_PENDING_TWO_FINGER_TAP_FIRST_MOVED_HANDLED =
 163       G(GS_PENDING_TWO_FINGER_TAP, 0, TS_MOVED, TSI_PROCESSED),
 164
 165   GST_PENDING_TWO_FINGER_TAP_SECOND_MOVED_HANDLED =
 166       G(GS_PENDING_TWO_FINGER_TAP, 1, TS_MOVED, TSI_PROCESSED),
 167
 168   GST_PENDING_TWO_FINGER_TAP_FIRST_CANCELLED =
 169       G(GS_PENDING_TWO_FINGER_TAP, 0, TS_CANCELLED, TSI_ALWAYS),
 170
 171   GST_PENDING_TWO_FINGER_TAP_SECOND_CANCELLED =
 172       G(GS_PENDING_TWO_FINGER_TAP, 1, TS_CANCELLED, TSI_ALWAYS),
 173
 174   GST_PENDING_TWO_FINGER_TAP_NO_PINCH_FIRST_RELEASED =
 175       G(GS_PENDING_TWO_FINGER_TAP_NO_PINCH, 0, TS_RELEASED, TSI_NOT_PROCESSED),
 176
 177   GST_PENDING_TWO_FINGER_TAP_NO_PINCH_FIRST_RELEASED_HANDLED =
 178       G(GS_PENDING_TWO_FINGER_TAP_NO_PINCH, 0, TS_RELEASED, TSI_PROCESSED),
 179
 180   GST_PENDING_TWO_FINGER_TAP_NO_PINCH_SECOND_RELEASED =
 181       G(GS_PENDING_TWO_FINGER_TAP_NO_PINCH, 1, TS_RELEASED, TSI_NOT_PROCESSED),
 182
 183   GST_PENDING_TWO_FINGER_TAP_NO_PINCH_SECOND_RELEASED_HANDLED =
 184       G(GS_PENDING_TWO_FINGER_TAP_NO_PINCH, 1, TS_RELEASED, TSI_PROCESSED),
 185
 186   GST_PENDING_TWO_FINGER_TAP_NO_PINCH_FIRST_MOVED =
 187       G(GS_PENDING_TWO_FINGER_TAP_NO_PINCH, 0, TS_MOVED, TSI_ALWAYS),
 188
 189   GST_PENDING_TWO_FINGER_TAP_NO_PINCH_SECOND_MOVED =
 190       G(GS_PENDING_TWO_FINGER_TAP_NO_PINCH, 1, TS_MOVED, TSI_ALWAYS),
 191
 192   GST_PENDING_TWO_FINGER_TAP_NO_PINCH_FIRST_CANCELLED =
 193       G(GS_PENDING_TWO_FINGER_TAP_NO_PINCH, 0, TS_CANCELLED, TSI_ALWAYS),
 194
 195   GST_PENDING_TWO_FINGER_TAP_NO_PINCH_SECOND_CANCELLED =
 196       G(GS_PENDING_TWO_FINGER_TAP_NO_PINCH, 1, TS_CANCELLED, TSI_ALWAYS),
 197
 198   GST_PENDING_TWO_FINGER_TAP_THIRD_PRESSED =
 199       G(GS_PENDING_TWO_FINGER_TAP, 2, TS_PRESSED, TSI_NOT_PROCESSED),
 200
 201   GST_PENDING_PINCH_FIRST_MOVED =
 202       G(GS_PENDING_PINCH, 0, TS_MOVED, TSI_NOT_PROCESSED),
 203
 204   GST_PENDING_PINCH_SECOND_MOVED =
 205       G(GS_PENDING_PINCH, 1, TS_MOVED, TSI_NOT_PROCESSED),
 206
 207   GST_PENDING_PINCH_FIRST_MOVED_HANDLED =
 208       G(GS_PENDING_PINCH, 0, TS_MOVED, TSI_PROCESSED),
 209
 210   GST_PENDING_PINCH_SECOND_MOVED_HANDLED =
 211       G(GS_PENDING_PINCH, 1, TS_MOVED, TSI_PROCESSED),
 212
 213   GST_PENDING_PINCH_FIRST_CANCELLED =
 214       G(GS_PENDING_PINCH, 0, TS_CANCELLED, TSI_ALWAYS),
 215
 216   GST_PENDING_PINCH_SECOND_CANCELLED =
 217       G(GS_PENDING_PINCH, 1, TS_CANCELLED, TSI_ALWAYS),
 218
 219   GST_PENDING_PINCH_FIRST_RELEASED =
 220       G(GS_PENDING_PINCH, 0, TS_RELEASED, TSI_ALWAYS),
 221
 222   GST_PENDING_PINCH_SECOND_RELEASED =
 223       G(GS_PENDING_PINCH, 1, TS_RELEASED, TSI_ALWAYS),
 224
 225   GST_PENDING_PINCH_NO_PINCH_FIRST_MOVED =
 226       G(GS_PENDING_PINCH_NO_PINCH, 0, TS_MOVED, TSI_ALWAYS),
 227
 228   GST_PENDING_PINCH_NO_PINCH_SECOND_MOVED =
 229       G(GS_PENDING_PINCH_NO_PINCH, 1, TS_MOVED, TSI_ALWAYS),
 230
 231   GST_PENDING_PINCH_NO_PINCH_FIRST_CANCELLED =
 232       G(GS_PENDING_PINCH_NO_PINCH, 0, TS_CANCELLED, TSI_ALWAYS),
 233
 234   GST_PENDING_PINCH_NO_PINCH_SECOND_CANCELLED =
 235       G(GS_PENDING_PINCH_NO_PINCH, 1, TS_CANCELLED, TSI_ALWAYS),
 236
 237   GST_PENDING_PINCH_NO_PINCH_FIRST_RELEASED =
 238       G(GS_PENDING_PINCH_NO_PINCH, 0, TS_RELEASED, TSI_ALWAYS),
 239
 240   GST_PENDING_PINCH_NO_PINCH_SECOND_RELEASED =
 241       G(GS_PENDING_PINCH_NO_PINCH, 1, TS_RELEASED, TSI_ALWAYS),
 242
 243   GST_PINCH_FIRST_MOVED =
 244       G(GS_PINCH, 0, TS_MOVED, TSI_NOT_PROCESSED),
 245
 246   GST_PINCH_FIRST_MOVED_HANDLED =
 247       G(GS_PINCH, 0, TS_MOVED, TSI_PROCESSED),
 248
 249   GST_PINCH_SECOND_MOVED =
 250       G(GS_PINCH, 1, TS_MOVED, TSI_NOT_PROCESSED),
 251
 252   GST_PINCH_SECOND_MOVED_HANDLED =
 253       G(GS_PINCH, 1, TS_MOVED, TSI_PROCESSED),
 254
 255   GST_PINCH_FIRST_RELEASED =
 256       G(GS_PINCH, 0, TS_RELEASED, TSI_ALWAYS),
 257
 258   GST_PINCH_SECOND_RELEASED =
 259       G(GS_PINCH, 1, TS_RELEASED, TSI_ALWAYS),
 260
 261   GST_PINCH_FIRST_CANCELLED =
 262       G(GS_PINCH, 0, TS_CANCELLED, TSI_ALWAYS),
 263
 264   GST_PINCH_SECOND_CANCELLED =
 265       G(GS_PINCH, 1, TS_CANCELLED, TSI_ALWAYS),
 266
 267   GST_PINCH_THIRD_PRESSED =
 268       G(GS_PINCH, 2, TS_PRESSED, TSI_NOT_PROCESSED),
 269
 270   GST_PINCH_THIRD_MOVED =
 271       G(GS_PINCH, 2, TS_MOVED, TSI_NOT_PROCESSED),
 272
 273   GST_PINCH_THIRD_MOVED_HANDLED =
 274       G(GS_PINCH, 2, TS_MOVED, TSI_PROCESSED),
 275
 276   GST_PINCH_THIRD_RELEASED =
 277       G(GS_PINCH, 2, TS_RELEASED, TSI_ALWAYS),
 278
 279   GST_PINCH_THIRD_CANCELLED =
 280       G(GS_PINCH, 2, TS_CANCELLED, TSI_ALWAYS),
 281
 282   GST_PINCH_FOURTH_PRESSED =
 283       G(GS_PINCH, 3, TS_PRESSED, TSI_NOT_PROCESSED),
 284
 285   GST_PINCH_FOURTH_MOVED =
 286       G(GS_PINCH, 3, TS_MOVED, TSI_NOT_PROCESSED),
 287
 288   GST_PINCH_FOURTH_MOVED_HANDLED =
 289       G(GS_PINCH, 3, TS_MOVED, TSI_PROCESSED),
 290
 291   GST_PINCH_FOURTH_RELEASED =
 292       G(GS_PINCH, 3, TS_RELEASED, TSI_ALWAYS),
 293
 294   GST_PINCH_FOURTH_CANCELLED =
 295       G(GS_PINCH, 3, TS_CANCELLED, TSI_ALWAYS),
 296
 297   GST_PINCH_FIFTH_PRESSED =
 298       G(GS_PINCH, 4, TS_PRESSED, TSI_NOT_PROCESSED),
 299
 300   GST_PINCH_FIFTH_MOVED =
 301       G(GS_PINCH, 4, TS_MOVED, TSI_NOT_PROCESSED),
 302
 303   GST_PINCH_FIFTH_MOVED_HANDLED =
 304       G(GS_PINCH, 4, TS_MOVED, TSI_PROCESSED),
 305
 306   GST_PINCH_FIFTH_RELEASED =
 307       G(GS_PINCH, 4, TS_RELEASED, TSI_ALWAYS),
 308
 309   GST_PINCH_FIFTH_CANCELLED =
 310       G(GS_PINCH, 4, TS_CANCELLED, TSI_ALWAYS),
 311 };
 312
 313 // Builds a signature. Signatures are assembled by joining together
 314 // multiple bits.
 315 // 1 LSB bit so that the computed signature is always greater than 0
 316 // 3 bits for the |type|.
 317 // 2 bit for |touch_status|
 318 // 12 bits for |touch_id|
 319 // 14 bits for the |gesture_state|.
 320 EdgeStateSignatureType Signature(GestureState gesture_state,
 321                                  unsigned int touch_id,
 322                                  ui::EventType type,
 323                                  TouchStatusInternal touch_status) {
 324   CHECK((touch_id & 0xfff) == touch_id);
 325   TouchState touch_state = TouchEventTypeToTouchState(type);
 326   EdgeStateSignatureType signature = static_cast<EdgeStateSignatureType>
 327       (G(gesture_state, touch_id, touch_state, touch_status));
 328
 329   switch (signature) {
 330     case GST_NO_GESTURE_FIRST_PRESSED:
 331     case GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED:
 332     case GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED_HANDLED:
 333     case GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED:
 334     case GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED_PROCESSED:
 335     case GST_PENDING_SYNTHETIC_CLICK_FIRST_CANCELLED:
 336     case GST_PENDING_SYNTHETIC_CLICK_SECOND_PRESSED:
 337     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_RELEASED:
 338     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_RELEASED_HANDLED:
 339     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_MOVED:
 340     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_CANCELLED:
 341     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_SECOND_PRESSED:
 342     case GST_SYNTHETIC_CLICK_ABORTED_FIRST_RELEASED:
 343     case GST_SYNTHETIC_CLICK_ABORTED_SECOND_PRESSED:
 344     case GST_SCROLL_FIRST_RELEASED:
 345     case GST_SCROLL_FIRST_MOVED:
 346     case GST_SCROLL_FIRST_MOVED_HANDLED:
 347     case GST_SCROLL_FIRST_CANCELLED:
 348     case GST_SCROLL_SECOND_PRESSED:
 349     case GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED:
 350     case GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED_HANDLED:
 351     case GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED:
 352     case GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED_HANDLED:
 353     case GST_PENDING_TWO_FINGER_TAP_FIRST_MOVED:
 354     case GST_PENDING_TWO_FINGER_TAP_SECOND_MOVED:
 355     case GST_PENDING_TWO_FINGER_TAP_FIRST_MOVED_HANDLED:
 356     case GST_PENDING_TWO_FINGER_TAP_SECOND_MOVED_HANDLED:
 357     case GST_PENDING_TWO_FINGER_TAP_FIRST_CANCELLED:
 358     case GST_PENDING_TWO_FINGER_TAP_SECOND_CANCELLED:
 359     case GST_PENDING_TWO_FINGER_TAP_THIRD_PRESSED:
 360     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_FIRST_MOVED:
 361     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_SECOND_MOVED:
 362     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_FIRST_RELEASED:
 363     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_SECOND_RELEASED:
 364     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_FIRST_RELEASED_HANDLED:
 365     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_SECOND_RELEASED_HANDLED:
 366     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_FIRST_CANCELLED:
 367     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_SECOND_CANCELLED:
 368     case GST_PENDING_PINCH_FIRST_MOVED:
 369     case GST_PENDING_PINCH_SECOND_MOVED:
 370     case GST_PENDING_PINCH_FIRST_MOVED_HANDLED:
 371     case GST_PENDING_PINCH_SECOND_MOVED_HANDLED:
 372     case GST_PENDING_PINCH_FIRST_RELEASED:
 373     case GST_PENDING_PINCH_SECOND_RELEASED:
 374     case GST_PENDING_PINCH_FIRST_CANCELLED:
 375     case GST_PENDING_PINCH_SECOND_CANCELLED:
 376     case GST_PENDING_PINCH_NO_PINCH_FIRST_MOVED:
 377     case GST_PENDING_PINCH_NO_PINCH_SECOND_MOVED:
 378     case GST_PENDING_PINCH_NO_PINCH_FIRST_RELEASED:
 379     case GST_PENDING_PINCH_NO_PINCH_SECOND_RELEASED:
 380     case GST_PENDING_PINCH_NO_PINCH_FIRST_CANCELLED:
 381     case GST_PENDING_PINCH_NO_PINCH_SECOND_CANCELLED:
 382     case GST_PINCH_FIRST_MOVED:
 383     case GST_PINCH_FIRST_MOVED_HANDLED:
 384     case GST_PINCH_SECOND_MOVED:
 385     case GST_PINCH_SECOND_MOVED_HANDLED:
 386     case GST_PINCH_FIRST_RELEASED:
 387     case GST_PINCH_SECOND_RELEASED:
 388     case GST_PINCH_FIRST_CANCELLED:
 389     case GST_PINCH_SECOND_CANCELLED:
 390     case GST_PINCH_THIRD_PRESSED:
 391     case GST_PINCH_THIRD_MOVED:
 392     case GST_PINCH_THIRD_MOVED_HANDLED:
 393     case GST_PINCH_THIRD_RELEASED:
 394     case GST_PINCH_THIRD_CANCELLED:
 395     case GST_PINCH_FOURTH_PRESSED:
 396     case GST_PINCH_FOURTH_MOVED:
 397     case GST_PINCH_FOURTH_MOVED_HANDLED:
 398     case GST_PINCH_FOURTH_RELEASED:
 399     case GST_PINCH_FOURTH_CANCELLED:
 400     case GST_PINCH_FIFTH_PRESSED:
 401     case GST_PINCH_FIFTH_MOVED:
 402     case GST_PINCH_FIFTH_MOVED_HANDLED:
 403     case GST_PINCH_FIFTH_RELEASED:
 404     case GST_PINCH_FIFTH_CANCELLED:
 405       break;
 406     default:
 407       signature = GST_INVALID;
 408       break;
 409   }
 410
 411   return signature;
 412 }
 413 #undef G
 414
 415 float BoundingBoxDiagonal(const gfx::RectF& rect) {
 416   float width = rect.width() * rect.width();
 417   float height = rect.height() * rect.height();
 418   return sqrt(width + height);
 419 }
 420
 421 unsigned int ComputeTouchBitmask(const GesturePoint* points) {
 422   unsigned int touch_bitmask = 0;
 423   for (int i = 0; i < GestureSequence::kMaxGesturePoints; ++i) {
 424     if (points[i].in_use())
 425       touch_bitmask |= 1 << points[i].touch_id();
 426   }
 427   return touch_bitmask;
 428 }
 429
 430 const float kFlingCurveNormalization = 1.0f / 1875.f;
 431
 432 float CalibrateFlingVelocity(float velocity) {
 433   const unsigned last_coefficient =
 434       GestureConfiguration::NumAccelParams - 1;
 435   float normalized_velocity = fabs(velocity * kFlingCurveNormalization);
 436   float nu = 0.0f, x = 1.f;
 437
 438   for (int i = last_coefficient ; i >= 0; i--) {
 439     float a = GestureConfiguration::fling_acceleration_curve_coefficients(i);
 440     nu += x * a;
 441     x *= normalized_velocity;
 442   }
 443   if (velocity < 0.f)
 444     return std::max(nu * velocity, -GestureConfiguration::fling_velocity_cap());
 445   else
 446     return std::min(nu * velocity, GestureConfiguration::fling_velocity_cap());
 447 }
 448
 449
 450 void UpdateGestureEventLatencyInfo(const TouchEvent& event,
 451                                    GestureSequence::Gestures* gestures) {
 452   // Copy some of the touch event's LatencyInfo into the generated gesture's
 453   // LatencyInfo so we can compute touch to scroll latency from gesture
 454   // event's LatencyInfo.
 455   GestureSequence::Gestures::iterator it = gestures->begin();
 456   for (; it != gestures->end(); it++) {
 457     ui::LatencyInfo* gesture_latency = (*it)->latency();
 458     gesture_latency->CopyLatencyFrom(
 459         *event.latency(), ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT);
 460     gesture_latency->CopyLatencyFrom(
 461         *event.latency(), ui::INPUT_EVENT_LATENCY_UI_COMPONENT);
 462     gesture_latency->CopyLatencyFrom(
 463         *event.latency(), ui::INPUT_EVENT_LATENCY_ACKED_TOUCH_COMPONENT);
 464   }
 465 }
 466
 467 bool GestureStateSupportsActiveTimer(GestureState state) {
 468   switch(state) {
 469     case GS_PENDING_SYNTHETIC_CLICK:
 470     case GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL:
 471       return true;
 472     default:
 473       return false;
 474   }
 475 }
 476
 477 }  // namespace
 478
 479 ////////////////////////////////////////////////////////////////////////////////
 480 // GestureSequence Public:
 481
 482 GestureSequence::GestureSequence(GestureSequenceDelegate* delegate)
 483     : state_(GS_NO_GESTURE),
 484       flags_(0),
 485       pinch_distance_start_(0.f),
 486       pinch_distance_current_(0.f),
 487       scroll_type_(ST_FREE),
 488       point_count_(0),
 489       delegate_(delegate) {
 490   CHECK(delegate_);
 491 }
 492
 493 GestureSequence::~GestureSequence() {
 494 }
 495
 496 GestureSequence::Gestures* GestureSequence::ProcessTouchEventForGesture(
 497     const TouchEvent& event,
 498     EventResult result) {
 499   StopTimersIfRequired(event);
 500   last_touch_location_ = event.location();
 501   if (result & ER_CONSUMED)
 502     return NULL;
 503
 504   // Set a limit on the number of simultaneous touches in a gesture.
 505   if (event.touch_id() >= kMaxGesturePoints)
 506     return NULL;
 507
 508   if (event.type() == ui::ET_TOUCH_PRESSED) {
 509     if (point_count_ == kMaxGesturePoints)
 510       return NULL;
 511     GesturePoint* new_point = &points_[event.touch_id()];
 512     // We shouldn't be able to get two PRESSED events from the same
 513     // finger without either a RELEASE or CANCEL in between. But let's not crash
 514     // in a release build.
 515     if (new_point->in_use()) {
 516       LOG(ERROR) << "Received a second press for a point: " << event.touch_id();
 517       new_point->ResetVelocity();
 518       new_point->UpdateValues(event);
 519       return NULL;
 520     }
 521     new_point->set_point_id(point_count_++);
 522     new_point->set_touch_id(event.touch_id());
 523     new_point->set_source_device_id(event.source_device_id());
 524   }
 525
 526   GestureState last_state = state_;
 527
 528   // NOTE: when modifying these state transitions, also update gestures.dot
 529   scoped_ptr<Gestures> gestures(new Gestures());
 530   GesturePoint& point = GesturePointForEvent(event);
 531   point.UpdateValues(event);
 532   RecreateBoundingBox();
 533   flags_ = event.flags();
 534   const int point_id = point.point_id();
 535   if (point_id < 0)
 536     return NULL;
 537
 538   // Send GESTURE_BEGIN for any touch pressed.
 539   if (event.type() == ui::ET_TOUCH_PRESSED)
 540     AppendBeginGestureEvent(point, gestures.get());
 541
 542   TouchStatusInternal status_internal = (result == ER_UNHANDLED) ?
 543       TSI_NOT_PROCESSED : TSI_PROCESSED;
 544
 545   EdgeStateSignatureType signature = Signature(state_, point_id,
 546       event.type(), status_internal);
 547
 548   if (signature == GST_INVALID)
 549     signature = Signature(state_, point_id, event.type(), TSI_ALWAYS);
 550
 551   switch (signature) {
 552     case GST_INVALID:
 553       break;
 554
 555     case GST_NO_GESTURE_FIRST_PRESSED:
 556       TouchDown(event, point, gestures.get());
 557       set_state(GS_PENDING_SYNTHETIC_CLICK);
 558       break;
 559     case GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED:
 560     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_RELEASED:
 561       if (Click(event, point, gestures.get()))
 562         point.UpdateForTap();
 563       else
 564         PrependTapCancelGestureEvent(point, gestures.get());
 565       set_state(GS_NO_GESTURE);
 566       break;
 567     case GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED:
 568       if (ScrollStart(event, point, gestures.get())) {
 569         PrependTapCancelGestureEvent(point, gestures.get());
 570         set_state(GS_SCROLL);
 571         if (ScrollUpdate(event, point, gestures.get(), FS_FIRST_SCROLL))
 572           point.UpdateForScroll();
 573       }
 574       break;
 575     case GST_PENDING_SYNTHETIC_CLICK_FIRST_MOVED_PROCESSED:
 576     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_MOVED:
 577       if (point.IsInScrollWindow(event)) {
 578         PrependTapCancelGestureEvent(point, gestures.get());
 579         set_state(GS_SYNTHETIC_CLICK_ABORTED);
 580       } else {
 581         set_state(GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL);
 582       }
 583       break;
 584     case GST_PENDING_SYNTHETIC_CLICK_FIRST_RELEASED_HANDLED:
 585     case GST_PENDING_SYNTHETIC_CLICK_FIRST_CANCELLED:
 586     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_RELEASED_HANDLED:
 587     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_FIRST_CANCELLED:
 588       PrependTapCancelGestureEvent(point, gestures.get());
 589       set_state(GS_NO_GESTURE);
 590       break;
 591     case GST_SYNTHETIC_CLICK_ABORTED_FIRST_RELEASED:
 592       set_state(GS_NO_GESTURE);
 593       break;
 594     case GST_SCROLL_FIRST_MOVED:
 595       if (scroll_type_ == ST_VERTICAL ||
 596           scroll_type_ == ST_HORIZONTAL)
 597         BreakRailScroll(event, point, gestures.get());
 598       if (ScrollUpdate(event, point, gestures.get(), FS_NOT_FIRST_SCROLL))
 599         point.UpdateForScroll();
 600       break;
 601     case GST_SCROLL_FIRST_MOVED_HANDLED:
 602       if (point.DidScroll(event, 0))
 603         point.UpdateForScroll();
 604       break;
 605     case GST_SCROLL_FIRST_RELEASED:
 606     case GST_SCROLL_FIRST_CANCELLED:
 607       ScrollEnd(event, point, gestures.get());
 608       set_state(GS_NO_GESTURE);
 609       break;
 610     case GST_PENDING_SYNTHETIC_CLICK_SECOND_PRESSED:
 611     case GST_PENDING_SYNTHETIC_CLICK_NO_SCROLL_SECOND_PRESSED:
 612       PrependTapCancelGestureEvent(point, gestures.get());
 613       TwoFingerTapOrPinch(event, point, gestures.get());
 614       break;
 615     case GST_SYNTHETIC_CLICK_ABORTED_SECOND_PRESSED:
 616       TwoFingerTapOrPinch(event, point, gestures.get());
 617       break;
 618     case GST_SCROLL_SECOND_PRESSED:
 619       PinchStart(event, point, gestures.get());
 620       set_state(GS_PINCH);
 621       break;
 622     case GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED:
 623     case GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED:
 624       TwoFingerTouchReleased(event, point, gestures.get());
 625       StartRailFreeScroll(point, gestures.get());
 626       break;
 627     case GST_PENDING_TWO_FINGER_TAP_FIRST_MOVED:
 628     case GST_PENDING_TWO_FINGER_TAP_SECOND_MOVED:
 629       if (TwoFingerTouchMove(event, point, gestures.get()))
 630         set_state(GS_PINCH);
 631       break;
 632     case GST_PENDING_TWO_FINGER_TAP_FIRST_MOVED_HANDLED:
 633     case GST_PENDING_TWO_FINGER_TAP_SECOND_MOVED_HANDLED:
 634       set_state(GS_PENDING_TWO_FINGER_TAP_NO_PINCH);
 635       break;
 636     case GST_PENDING_TWO_FINGER_TAP_FIRST_RELEASED_HANDLED:
 637     case GST_PENDING_TWO_FINGER_TAP_SECOND_RELEASED_HANDLED:
 638     case GST_PENDING_TWO_FINGER_TAP_FIRST_CANCELLED:
 639     case GST_PENDING_TWO_FINGER_TAP_SECOND_CANCELLED:
 640       StartRailFreeScroll(point, gestures.get());
 641       break;
 642     case GST_PENDING_TWO_FINGER_TAP_THIRD_PRESSED:
 643       set_state(GS_PENDING_PINCH);
 644       break;
 645     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_FIRST_MOVED:
 646     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_SECOND_MOVED:
 647       // No pinch allowed, so nothing happens.
 648       break;
 649     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_FIRST_RELEASED:
 650     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_SECOND_RELEASED:
 651       TwoFingerTouchReleased(event, point, gestures.get());
 652       // We transition into GS_SCROLL even though the touch move can be consumed
 653       // and no scroll should happen. crbug.com/240399.
 654       StartRailFreeScroll(point, gestures.get());
 655       break;
 656     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_FIRST_RELEASED_HANDLED:
 657     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_SECOND_RELEASED_HANDLED:
 658     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_FIRST_CANCELLED:
 659     case GST_PENDING_TWO_FINGER_TAP_NO_PINCH_SECOND_CANCELLED:
 660       // We transition into GS_SCROLL even though the touch move can be consumed
 661       // and no scroll should happen. crbug.com/240399.
 662       StartRailFreeScroll(point, gestures.get());
 663       break;
 664     case GST_PENDING_PINCH_FIRST_MOVED:
 665     case GST_PENDING_PINCH_SECOND_MOVED:
 666       if (TwoFingerTouchMove(event, point, gestures.get()))
 667         set_state(GS_PINCH);
 668       break;
 669     case GST_PENDING_PINCH_FIRST_MOVED_HANDLED:
 670     case GST_PENDING_PINCH_SECOND_MOVED_HANDLED:
 671       set_state(GS_PENDING_PINCH_NO_PINCH);
 672       break;
 673     case GST_PENDING_PINCH_FIRST_RELEASED:
 674     case GST_PENDING_PINCH_SECOND_RELEASED:
 675     case GST_PENDING_PINCH_FIRST_CANCELLED:
 676     case GST_PENDING_PINCH_SECOND_CANCELLED:
 677       // We transition into GS_SCROLL even though the touch move can be consumed
 678       // and no scroll should happen. crbug.com/240399.
 679       StartRailFreeScroll(point, gestures.get());
 680       break;
 681     case GST_PENDING_PINCH_NO_PINCH_FIRST_MOVED:
 682     case GST_PENDING_PINCH_NO_PINCH_SECOND_MOVED:
 683       // No pinch allowed, so nothing happens.
 684       break;
 685     case GST_PENDING_PINCH_NO_PINCH_FIRST_RELEASED:
 686     case GST_PENDING_PINCH_NO_PINCH_SECOND_RELEASED:
 687     case GST_PENDING_PINCH_NO_PINCH_FIRST_CANCELLED:
 688     case GST_PENDING_PINCH_NO_PINCH_SECOND_CANCELLED:
 689       // We transition into GS_SCROLL even though the touch move can be consumed
 690       // and no scroll should happen. crbug.com/240399.
 691       StartRailFreeScroll(point, gestures.get());
 692       break;
 693     case GST_PINCH_FIRST_MOVED_HANDLED:
 694     case GST_PINCH_SECOND_MOVED_HANDLED:
 695     case GST_PINCH_THIRD_MOVED_HANDLED:
 696     case GST_PINCH_FOURTH_MOVED_HANDLED:
 697     case GST_PINCH_FIFTH_MOVED_HANDLED:
 698       // If touches are consumed for a while, and then left unconsumed, we don't
 699       // want a PinchUpdate or ScrollUpdate with a massive delta.
 700       latest_multi_scroll_update_location_ = bounding_box_.CenterPoint();
 701       pinch_distance_current_ = BoundingBoxDiagonal(bounding_box_);
 702       break;
 703     case GST_PINCH_FIRST_MOVED:
 704     case GST_PINCH_SECOND_MOVED:
 705     case GST_PINCH_THIRD_MOVED:
 706     case GST_PINCH_FOURTH_MOVED:
 707     case GST_PINCH_FIFTH_MOVED:
 708       if (PinchUpdate(event, point, gestures.get())) {
 709         for (int i = 0; i < point_count_; ++i)
 710           GetPointByPointId(i)->UpdateForScroll();
 711       }
 712       break;
 713     case GST_PINCH_FIRST_RELEASED:
 714     case GST_PINCH_SECOND_RELEASED:
 715     case GST_PINCH_THIRD_RELEASED:
 716     case GST_PINCH_FOURTH_RELEASED:
 717     case GST_PINCH_FIFTH_RELEASED:
 718     case GST_PINCH_FIRST_CANCELLED:
 719     case GST_PINCH_SECOND_CANCELLED:
 720     case GST_PINCH_THIRD_CANCELLED:
 721     case GST_PINCH_FOURTH_CANCELLED:
 722     case GST_PINCH_FIFTH_CANCELLED:
 723       // Was it a swipe? i.e. were all the fingers moving in the same
 724       // direction?
 725       MaybeSwipe(event, point, gestures.get());
 726
 727       if (point_count_ == 2) {
 728         PinchEnd(event, point, gestures.get());
 729
 730         // Once pinch ends, it should still be possible to scroll with the
 731         // remaining finger on the screen.
 732         set_state(GS_SCROLL);
 733       } else {
 734         // Nothing else to do if we have more than 2 fingers active, since after
 735         // the release/cancel, there are still enough fingers to do pinch.
 736         // pinch_distance_current_ and pinch_distance_start_ will be updated
 737         // when the bounding-box is updated.
 738       }
 739       ResetVelocities();
 740       break;
 741     case GST_PINCH_THIRD_PRESSED:
 742     case GST_PINCH_FOURTH_PRESSED:
 743     case GST_PINCH_FIFTH_PRESSED:
 744       pinch_distance_current_ = BoundingBoxDiagonal(bounding_box_);
 745       pinch_distance_start_ = pinch_distance_current_;
 746       break;
 747   }
 748
 749   if (event.type() == ui::ET_TOUCH_RELEASED ||
 750       event.type() == ui::ET_TOUCH_CANCELLED)
 751     AppendEndGestureEvent(point, gestures.get());
 752
 753   if (state_ != last_state)
 754     DVLOG(4) << "Gesture Sequence"
 755              << " State: " << state_
 756              << " touch id: " << event.touch_id();
 757
 758   // If the state has changed from one in which a long/show press is possible to
 759   // one in which they are not possible, cancel the timers.
 760   if (GestureStateSupportsActiveTimer(last_state) &&
 761       !GestureStateSupportsActiveTimer(state_)) {
 762     GetLongPressTimer()->Stop();
 763     GetShowPressTimer()->Stop();
 764   }
 765
 766   // The set of point_ids must be contiguous and include 0.
 767   // When a touch point is released, all points with ids greater than the
 768   // released point must have their ids decremented, or the set of point_ids
 769   // could end up with gaps.
 770   if (event.type() == ui::ET_TOUCH_RELEASED ||
 771       event.type() == ui::ET_TOUCH_CANCELLED) {
 772     for (int i = 0; i < kMaxGesturePoints; ++i) {
 773       GesturePoint& iter_point = points_[i];
 774       if (iter_point.point_id() > point.point_id())
 775         iter_point.set_point_id(iter_point.point_id() - 1);
 776     }
 777
 778     point.Reset();
 779     --point_count_;
 780     CHECK_GE(point_count_, 0);
 781     RecreateBoundingBox();
 782     if (state_ == GS_PINCH) {
 783       pinch_distance_current_ = BoundingBoxDiagonal(bounding_box_);
 784       pinch_distance_start_ = pinch_distance_current_;
 785     }
 786   }
 787
 788   UpdateGestureEventLatencyInfo(event, gestures.get());
 789   return gestures.release();
 790 }
 791
 792 void GestureSequence::RecreateBoundingBox() {
 793   // TODO(sad): Recreating the bounding box at every touch-event is not very
 794   // efficient. This should be made better.
 795   if (point_count_ == 0) {
 796     bounding_box_.SetRect(0, 0, 0, 0);
 797   } else if (point_count_ == 1) {
 798     bounding_box_ = GetPointByPointId(0)->enclosing_rectangle();
 799   } else {
 800     float left = std::numeric_limits<float>::max();
 801     float top = std::numeric_limits<float>::max();
 802     float right = -std::numeric_limits<float>::max();
 803     float bottom = -std::numeric_limits<float>::max();
 804     for (int i = 0; i < kMaxGesturePoints; ++i) {
 805       if (!points_[i].in_use())
 806         continue;
 807       // Using the |enclosing_rectangle()| for the touch-points would be ideal.
 808       // However, this becomes brittle especially when a finger is in motion
 809       // because the change in radius can overshadow the actual change in
 810       // position. So the actual position of the point is used instead.
 811       const gfx::PointF& point = points_[i].last_touch_position();
 812       left = std::min(left, point.x());
 813       right = std::max(right, point.x());
 814       top = std::min(top, point.y());
 815       bottom = std::max(bottom, point.y());
 816     }
 817     bounding_box_.SetRect(left, top, right - left, bottom - top);
 818   }
 819 }
 820
 821 void GestureSequence::ResetVelocities() {
 822   for (int i = 0; i < kMaxGesturePoints; ++i) {
 823     if (points_[i].in_use())
 824       points_[i].ResetVelocity();
 825   }
 826 }
 827
 828 ////////////////////////////////////////////////////////////////////////////////
 829 // GestureSequence Protected:
 830
 831 base::OneShotTimer<GestureSequence>* GestureSequence::CreateTimer() {
 832   return new base::OneShotTimer<GestureSequence>();
 833 }
 834
 835 base::OneShotTimer<GestureSequence>* GestureSequence::GetLongPressTimer() {
 836   if (!long_press_timer_.get())
 837     long_press_timer_.reset(CreateTimer());
 838   return long_press_timer_.get();
 839 }
 840
 841 base::OneShotTimer<GestureSequence>* GestureSequence::GetShowPressTimer() {
 842   if (!show_press_timer_.get())
 843     show_press_timer_.reset(CreateTimer());
 844   return show_press_timer_.get();
 845 }
 846
 847 ////////////////////////////////////////////////////////////////////////////////
 848 // GestureSequence Private:
 849
 850 GesturePoint& GestureSequence::GesturePointForEvent(
 851     const TouchEvent& event) {
 852   return points_[event.touch_id()];
 853 }
 854
 855 GesturePoint* GestureSequence::GetPointByPointId(int point_id) {
 856   DCHECK(0 <= point_id && point_id < kMaxGesturePoints);
 857   for (int i = 0; i < kMaxGesturePoints; ++i) {
 858     GesturePoint& point = points_[i];
 859     if (point.in_use() && point.point_id() == point_id)
 860       return &point;
 861   }
 862   NOTREACHED();
 863   return NULL;
 864 }
 865
 866 bool GestureSequence::IsSecondTouchDownCloseEnoughForTwoFingerTap() {
 867   gfx::PointF p1 = GetPointByPointId(0)->last_touch_position();
 868   gfx::PointF p2 = GetPointByPointId(1)->last_touch_position();
 869   double max_distance =
 870       GestureConfiguration::max_distance_for_two_finger_tap_in_pixels();
 871   double distance = (p1.x() - p2.x()) * (p1.x() - p2.x()) +
 872       (p1.y() - p2.y()) * (p1.y() - p2.y());
 873   if (distance < max_distance * max_distance)
 874     return true;
 875   return false;
 876 }
 877
 878 GestureEvent* GestureSequence::CreateGestureEvent(
 879     const GestureEventDetails& details,
 880     const gfx::PointF& location,
 881     int flags,
 882     base::Time timestamp,
 883     unsigned int touch_id_bitmask) {
 884   GestureEventDetails gesture_details(details);
 885   gesture_details.set_touch_points(point_count_);
 886   gesture_details.set_bounding_box(bounding_box_);
 887   base::TimeDelta time_stamp =
 888       base::TimeDelta::FromMicroseconds(timestamp.ToDoubleT() * 1000000);
 889   return new GestureEvent(gesture_details.type(), location.x(), location.y(),
 890                           flags, time_stamp, gesture_details,
 891                           touch_id_bitmask);
 892 }
 893
 894 void GestureSequence::AppendTapDownGestureEvent(const GesturePoint& point,
 895                                                 Gestures* gestures) {
 896   gestures->push_back(CreateGestureEvent(
 897       GestureEventDetails(ui::ET_GESTURE_TAP_DOWN, 0, 0),
 898       point.first_touch_position(),
 899       flags_,
 900       base::Time::FromDoubleT(point.last_touch_time()),
 901       1 << point.touch_id()));
 902 }
 903
 904 void GestureSequence::PrependTapCancelGestureEvent(const GesturePoint& point,
 905                                             Gestures* gestures) {
 906   gestures->insert(gestures->begin(), CreateGestureEvent(
 907     GestureEventDetails(ui::ET_GESTURE_TAP_CANCEL, 0, 0),
 908     point.first_touch_position(),
 909     flags_,
 910     base::Time::FromDoubleT(point.last_touch_time()),
 911     1 << point.touch_id()));
 912 }
 913
 914 void GestureSequence::AppendBeginGestureEvent(const GesturePoint& point,
 915                                               Gestures* gestures) {
 916   gestures->push_back(CreateGestureEvent(
 917       GestureEventDetails(ui::ET_GESTURE_BEGIN, 0, 0),
 918       point.first_touch_position(),
 919       flags_,
 920       base::Time::FromDoubleT(point.last_touch_time()),
 921       1 << point.touch_id()));
 922 }
 923
 924 void GestureSequence::AppendEndGestureEvent(const GesturePoint& point,
 925                                               Gestures* gestures) {
 926   gestures->push_back(CreateGestureEvent(
 927       GestureEventDetails(ui::ET_GESTURE_END, 0, 0),
 928       point.last_touch_position(),
 929       flags_,
 930       base::Time::FromDoubleT(point.last_touch_time()),
 931       1 << point.touch_id()));
 932 }
 933
 934 void GestureSequence::AppendClickGestureEvent(const GesturePoint& point,
 935                                               int tap_count,
 936                                               Gestures* gestures) {
 937   gfx::RectF er = point.enclosing_rectangle();
 938   gfx::PointF center = er.CenterPoint();
 939   gestures->push_back(CreateGestureEvent(
 940       GestureEventDetails(ui::ET_GESTURE_TAP, tap_count, 0),
 941       center,
 942       flags_,
 943       base::Time::FromDoubleT(point.last_touch_time()),
 944       1 << point.touch_id()));
 945 }
 946
 947 void GestureSequence::AppendScrollGestureBegin(const GesturePoint& point,
 948                                                const gfx::PointF& location,
 949                                                Gestures* gestures) {
 950   gfx::Vector2dF d = point.ScrollDelta();
 951   gestures->push_back(CreateGestureEvent(
 952       GestureEventDetails(ui::ET_GESTURE_SCROLL_BEGIN, d.x(), d.y()),
 953       location,
 954       flags_,
 955       base::Time::FromDoubleT(point.last_touch_time()),
 956       1 << point.touch_id()));
 957 }
 958
 959 void GestureSequence::AppendScrollGestureEnd(const GesturePoint& point,
 960                                              const gfx::PointF& location,
 961                                              Gestures* gestures,
 962                                              float x_velocity,
 963                                              float y_velocity) {
 964   float railed_x_velocity = x_velocity;
 965   float railed_y_velocity = y_velocity;
 966   last_scroll_prediction_offset_.set_x(0);
 967   last_scroll_prediction_offset_.set_y(0);
 968
 969   if (scroll_type_ == ST_HORIZONTAL)
 970     railed_y_velocity = 0;
 971   else if (scroll_type_ == ST_VERTICAL)
 972     railed_x_velocity = 0;
 973
 974   if (railed_x_velocity != 0 || railed_y_velocity != 0) {
 975
 976     gestures->push_back(CreateGestureEvent(
 977         GestureEventDetails(ui::ET_SCROLL_FLING_START,
 978             CalibrateFlingVelocity(railed_x_velocity),
 979             CalibrateFlingVelocity(railed_y_velocity)),
 980         location,
 981         flags_,
 982         base::Time::FromDoubleT(point.last_touch_time()),
 983         1 << point.touch_id()));
 984   } else {
 985     gestures->push_back(CreateGestureEvent(
 986         GestureEventDetails(ui::ET_GESTURE_SCROLL_END, 0, 0),
 987         location,
 988         flags_,
 989         base::Time::FromDoubleT(point.last_touch_time()),
 990         1 << point.touch_id()));
 991   }
 992 }
 993
 994 void GestureSequence::AppendScrollGestureUpdate(GesturePoint& point,
 995                                                 Gestures* gestures,
 996                                                 IsFirstScroll is_first_scroll) {
 997   static bool use_scroll_prediction = CommandLine::ForCurrentProcess()->
 998       HasSwitch(switches::kEnableScrollPrediction);
 999   gfx::Vector2dF d;
1000   gfx::PointF location;
1001   if (point_count_ == 1) {
1002     d = point.ScrollDelta();
1003     location = point.last_touch_position();
1004   } else {
1005     location = bounding_box_.CenterPoint();
1006     d = location - latest_multi_scroll_update_location_;
1007     latest_multi_scroll_update_location_ = location;
1008   }
1009
1010   if (use_scroll_prediction) {
1011     // Remove the extra distance added by the last scroll prediction and add
1012     // the new prediction offset.
1013     d -= last_scroll_prediction_offset_;
1014     last_scroll_prediction_offset_.set_x(
1015         GestureConfiguration::scroll_prediction_seconds() * point.XVelocity());
1016     last_scroll_prediction_offset_.set_y(
1017         GestureConfiguration::scroll_prediction_seconds() * point.YVelocity());
1018     d += last_scroll_prediction_offset_;
1019     location += gfx::Vector2dF(last_scroll_prediction_offset_.x(),
1020                                last_scroll_prediction_offset_.y());
1021   }
1022
1023   if (is_first_scroll == FS_FIRST_SCROLL) {
1024     float slop = GestureConfiguration::max_touch_move_in_pixels_for_click();
1025     float length = d.Length();
1026     float ratio = std::max((length - slop) / length, 0.0f);
1027
1028     d.set_x(d.x() * ratio);
1029     d.set_y(d.y() * ratio);
1030   }
1031
1032   if (scroll_type_ == ST_HORIZONTAL)
1033     d.set_y(0);
1034   else if (scroll_type_ == ST_VERTICAL)
1035     d.set_x(0);
1036   if (d.IsZero())
1037     return;
1038
1039   GestureEventDetails details(ui::ET_GESTURE_SCROLL_UPDATE, d.x(), d.y());
1040   gestures->push_back(CreateGestureEvent(
1041       details,
1042       location,
1043       flags_,
1044       base::Time::FromDoubleT(point.last_touch_time()),
1045       ComputeTouchBitmask(points_)));
1046 }
1047
1048 void GestureSequence::AppendPinchGestureBegin(const GesturePoint& p1,
1049                                               const GesturePoint& p2,
1050                                               Gestures* gestures) {
1051   gfx::PointF center = bounding_box_.CenterPoint();
1052   gestures->push_back(CreateGestureEvent(
1053       GestureEventDetails(ui::ET_GESTURE_PINCH_BEGIN, 0, 0),
1054       center,
1055       flags_,
1056       base::Time::FromDoubleT(p1.last_touch_time()),
1057       1 << p1.touch_id() | 1 << p2.touch_id()));
1058 }
1059
1060 void GestureSequence::AppendPinchGestureEnd(const GesturePoint& p1,
1061                                             const GesturePoint& p2,
1062                                             float scale,
1063                                             Gestures* gestures) {
1064   gfx::PointF center = bounding_box_.CenterPoint();
1065   gestures->push_back(CreateGestureEvent(
1066       GestureEventDetails(ui::ET_GESTURE_PINCH_END, 0, 0),
1067       center,
1068       flags_,
1069       base::Time::FromDoubleT(p1.last_touch_time()),
1070       1 << p1.touch_id() | 1 << p2.touch_id()));
1071 }
1072
1073 void GestureSequence::AppendPinchGestureUpdate(const GesturePoint& point,
1074                                                float scale,
1075                                                Gestures* gestures) {
1076   // TODO(sad): Compute rotation and include it in delta_y.
1077   // http://crbug.com/113145
1078   gestures->push_back(CreateGestureEvent(
1079       GestureEventDetails(ui::ET_GESTURE_PINCH_UPDATE, scale, 0),
1080       bounding_box_.CenterPoint(),
1081       flags_,
1082       base::Time::FromDoubleT(point.last_touch_time()),
1083       ComputeTouchBitmask(points_)));
1084 }
1085
1086 void GestureSequence::AppendSwipeGesture(const GesturePoint& point,
1087                                          int swipe_x,
1088                                          int swipe_y,
1089                                          Gestures* gestures) {
1090   gestures->push_back(CreateGestureEvent(
1091       GestureEventDetails(ui::ET_GESTURE_SWIPE, swipe_x, swipe_y),
1092       bounding_box_.CenterPoint(),
1093       flags_,
1094       base::Time::FromDoubleT(point.last_touch_time()),
1095       ComputeTouchBitmask(points_)));
1096 }
1097
1098 void GestureSequence::AppendTwoFingerTapGestureEvent(Gestures* gestures) {
1099   const GesturePoint* point = GetPointByPointId(0);
1100   const gfx::RectF& rect = point->enclosing_rectangle();
1101   gestures->push_back(CreateGestureEvent(
1102       GestureEventDetails(ui::ET_GESTURE_TWO_FINGER_TAP,
1103                           rect.width(),
1104                           rect.height()),
1105       point->enclosing_rectangle().CenterPoint(),
1106       flags_,
1107       base::Time::FromDoubleT(point->last_touch_time()),
1108       1 << point->touch_id()));
1109 }
1110
1111 bool GestureSequence::Click(const TouchEvent& event,
1112                             const GesturePoint& point,
1113                             Gestures* gestures) {
1114   DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK ||
1115          state_ == GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL);
1116   if (point.IsInClickWindow(event)) {
1117     int tap_count = 1;
1118     if (point.IsInTripleClickWindow(event))
1119       tap_count = 3;
1120     else if (point.IsInDoubleClickWindow(event))
1121       tap_count = 2;
1122     if (tap_count == 1 && GetShowPressTimer()->IsRunning()) {
1123       GetShowPressTimer()->Stop();
1124       AppendShowPressGestureEvent();
1125     }
1126     AppendClickGestureEvent(point, tap_count, gestures);
1127     return true;
1128   } else if (point.IsInsideTouchSlopRegion(event) &&
1129       !GetLongPressTimer()->IsRunning()) {
1130     AppendLongTapGestureEvent(point, gestures);
1131   }
1132   return false;
1133 }
1134
1135 bool GestureSequence::ScrollStart(const TouchEvent& event,
1136                                   GesturePoint& point,
1137                                   Gestures* gestures) {
1138   DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK);
1139   if (!point.IsInScrollWindow(event))
1140     return false;
1141   AppendScrollGestureBegin(point, point.first_touch_position(), gestures);
1142   if (point.IsInHorizontalRailWindow())
1143     scroll_type_ = ST_HORIZONTAL;
1144   else if (point.IsInVerticalRailWindow())
1145     scroll_type_ = ST_VERTICAL;
1146   else
1147     scroll_type_ = ST_FREE;
1148   return true;
1149 }
1150
1151 void GestureSequence::BreakRailScroll(const TouchEvent& event,
1152                                       GesturePoint& point,
1153                                       Gestures* gestures) {
1154   DCHECK(state_ == GS_SCROLL);
1155   if (scroll_type_ == ST_HORIZONTAL &&
1156       point.BreaksHorizontalRail())
1157     scroll_type_ = ST_FREE;
1158   else if (scroll_type_ == ST_VERTICAL &&
1159            point.BreaksVerticalRail())
1160     scroll_type_ = ST_FREE;
1161 }
1162
1163 bool GestureSequence::ScrollUpdate(const TouchEvent& event,
1164                                    GesturePoint& point,
1165                                    Gestures* gestures,
1166                                    IsFirstScroll is_first_scroll) {
1167   DCHECK(state_ == GS_SCROLL);
1168   if (!point.DidScroll(event, 0))
1169     return false;
1170   AppendScrollGestureUpdate(point, gestures, is_first_scroll);
1171   return true;
1172 }
1173
1174 bool GestureSequence::TouchDown(const TouchEvent& event,
1175                                 const GesturePoint& point,
1176                                 Gestures* gestures) {
1177   DCHECK(state_ == GS_NO_GESTURE);
1178   AppendTapDownGestureEvent(point, gestures);
1179   GetLongPressTimer()->Start(
1180       FROM_HERE,
1181       base::TimeDelta::FromMilliseconds(
1182           GestureConfiguration::long_press_time_in_seconds() * 1000),
1183       this,
1184       &GestureSequence::AppendLongPressGestureEvent);
1185
1186   GetShowPressTimer()->Start(
1187       FROM_HERE,
1188       base::TimeDelta::FromMilliseconds(
1189           GestureConfiguration::show_press_delay_in_ms()),
1190       this,
1191       &GestureSequence::AppendShowPressGestureEvent);
1192
1193   return true;
1194 }
1195
1196 bool GestureSequence::TwoFingerTouchDown(const TouchEvent& event,
1197                                          const GesturePoint& point,
1198                                          Gestures* gestures) {
1199   DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK ||
1200          state_ == GS_PENDING_SYNTHETIC_CLICK_NO_SCROLL ||
1201          state_ == GS_SYNTHETIC_CLICK_ABORTED ||
1202          state_ == GS_SCROLL);
1203
1204   if (state_ == GS_SCROLL) {
1205     AppendScrollGestureEnd(point,
1206                            point.last_touch_position(),
1207                            gestures, 0.f, 0.f);
1208   }
1209   second_touch_time_ = event.time_stamp();
1210   return true;
1211 }
1212
1213 bool GestureSequence::TwoFingerTouchMove(const TouchEvent& event,
1214                                          const GesturePoint& point,
1215                                          Gestures* gestures) {
1216   DCHECK(state_ == GS_PENDING_TWO_FINGER_TAP ||
1217          state_ == GS_PENDING_PINCH);
1218
1219   base::TimeDelta time_delta = event.time_stamp() - second_touch_time_;
1220   base::TimeDelta max_delta = base::TimeDelta::FromMilliseconds(1000 *
1221       ui::GestureConfiguration::max_touch_down_duration_in_seconds_for_click());
1222   if (time_delta > max_delta || !point.IsInsideTouchSlopRegion(event)) {
1223     PinchStart(event, point, gestures);
1224     return true;
1225   }
1226   return false;
1227 }
1228
1229 bool GestureSequence::TwoFingerTouchReleased(const TouchEvent& event,
1230                                              const GesturePoint& point,
1231                                              Gestures* gestures) {
1232   DCHECK(state_ == GS_PENDING_TWO_FINGER_TAP ||
1233          state_ == GS_PENDING_TWO_FINGER_TAP_NO_PINCH);
1234   base::TimeDelta time_delta = event.time_stamp() - second_touch_time_;
1235   base::TimeDelta max_delta = base::TimeDelta::FromMilliseconds(1000 *
1236       ui::GestureConfiguration::max_touch_down_duration_in_seconds_for_click());
1237   if (time_delta < max_delta && point.IsInsideTouchSlopRegion(event))
1238     AppendTwoFingerTapGestureEvent(gestures);
1239   return true;
1240 }
1241
1242 void GestureSequence::AppendLongPressGestureEvent() {
1243   const GesturePoint* point = GetPointByPointId(0);
1244   scoped_ptr<GestureEvent> gesture(CreateGestureEvent(
1245       GestureEventDetails(ui::ET_GESTURE_LONG_PRESS, 0, 0),
1246       point->first_touch_position(),
1247       flags_,
1248       base::Time::FromDoubleT(point->last_touch_time()),
1249       1 << point->touch_id()));
1250   delegate_->DispatchPostponedGestureEvent(gesture.get());
1251 }
1252
1253 void GestureSequence::AppendShowPressGestureEvent() {
1254   const GesturePoint* point = GetPointByPointId(0);
1255   scoped_ptr<GestureEvent> gesture(CreateGestureEvent(
1256       GestureEventDetails(ui::ET_GESTURE_SHOW_PRESS, 0, 0),
1257       point->first_touch_position(),
1258       flags_,
1259       base::Time::FromDoubleT(point->last_touch_time()),
1260       1 << point->touch_id()));
1261   delegate_->DispatchPostponedGestureEvent(gesture.get());
1262 }
1263
1264 void GestureSequence::AppendLongTapGestureEvent(const GesturePoint& point,
1265                                                 Gestures* gestures) {
1266   gestures->push_back(CreateGestureEvent(
1267       GestureEventDetails(ui::ET_GESTURE_LONG_TAP, 0, 0),
1268       point.enclosing_rectangle().CenterPoint(),
1269       flags_,
1270       base::Time::FromDoubleT(point.last_touch_time()),
1271       1 << point.touch_id()));
1272 }
1273
1274 bool GestureSequence::ScrollEnd(const TouchEvent& event,
1275                                 GesturePoint& point,
1276                                 Gestures* gestures) {
1277   DCHECK(state_ == GS_SCROLL);
1278   if (point.IsInFlickWindow(event)) {
1279     AppendScrollGestureEnd(point,
1280                            point.last_touch_position(),
1281                            gestures,
1282                            point.XVelocity(), point.YVelocity());
1283   } else {
1284     AppendScrollGestureEnd(point,
1285                            point.last_touch_position(),
1286                            gestures, 0.f, 0.f);
1287   }
1288   return true;
1289 }
1290
1291 bool GestureSequence::PinchStart(const TouchEvent& event,
1292                                  const GesturePoint& point,
1293                                  Gestures* gestures) {
1294   DCHECK(state_ == GS_SCROLL ||
1295          state_ == GS_PENDING_TWO_FINGER_TAP ||
1296          state_ == GS_PENDING_PINCH);
1297
1298   // Once pinch starts, we immediately break rail scroll.
1299   scroll_type_ = ST_FREE;
1300
1301   const GesturePoint* point1 = GetPointByPointId(0);
1302   const GesturePoint* point2 = GetPointByPointId(1);
1303
1304   if (state_ == GS_PENDING_TWO_FINGER_TAP ||
1305       state_ == GS_PENDING_PINCH) {
1306     AppendScrollGestureBegin(point, bounding_box_.CenterPoint(), gestures);
1307   }
1308
1309   pinch_distance_current_ = BoundingBoxDiagonal(bounding_box_);
1310   pinch_distance_start_ = pinch_distance_current_;
1311   latest_multi_scroll_update_location_ = bounding_box_.CenterPoint();
1312   AppendPinchGestureBegin(*point1, *point2, gestures);
1313
1314   return true;
1315 }
1316
1317 bool GestureSequence::PinchUpdate(const TouchEvent& event,
1318                                   GesturePoint& point,
1319                                   Gestures* gestures) {
1320   DCHECK(state_ == GS_PINCH);
1321
1322   // It is possible that the none of the touch-points changed their position,
1323   // but their radii changed, and that caused the bounding box to also change.
1324   // But in such cases, we do not want to either pinch or scroll.
1325   // To avoid small jiggles, it is also necessary to make sure that at least one
1326   // of the fingers moved enough before a pinch or scroll update is created.
1327   bool did_scroll = false;
1328   for (int i = 0; i < kMaxGesturePoints; ++i) {
1329     if (!points_[i].in_use() || !points_[i].DidScroll(event, 0))
1330       continue;
1331     did_scroll = true;
1332     break;
1333   }
1334
1335   if (!did_scroll)
1336     return false;
1337
1338   float distance = BoundingBoxDiagonal(bounding_box_);
1339
1340   if (std::abs(distance - pinch_distance_current_) >=
1341       GestureConfiguration::min_pinch_update_distance_in_pixels()) {
1342     AppendPinchGestureUpdate(point,
1343         distance / pinch_distance_current_, gestures);
1344     pinch_distance_current_ = distance;
1345   }
1346   AppendScrollGestureUpdate(point, gestures, FS_NOT_FIRST_SCROLL);
1347
1348   return true;
1349 }
1350
1351 bool GestureSequence::PinchEnd(const TouchEvent& event,
1352                                const GesturePoint& point,
1353                                Gestures* gestures) {
1354   DCHECK(state_ == GS_PINCH);
1355
1356   GesturePoint* point1 = GetPointByPointId(0);
1357   GesturePoint* point2 = GetPointByPointId(1);
1358
1359   float distance = BoundingBoxDiagonal(bounding_box_);
1360   AppendPinchGestureEnd(*point1, *point2,
1361       distance / pinch_distance_start_, gestures);
1362
1363   pinch_distance_start_ = 0;
1364   pinch_distance_current_ = 0;
1365   return true;
1366 }
1367
1368 bool GestureSequence::MaybeSwipe(const TouchEvent& event,
1369                                  const GesturePoint& point,
1370                                  Gestures* gestures) {
1371   DCHECK(state_ == GS_PINCH);
1372   float velocity_x = 0.f, velocity_y = 0.f;
1373   bool swipe_x = true, swipe_y = true;
1374   int sign_x = 0, sign_y = 0;
1375   int i = 0;
1376
1377   for (i = 0; i < kMaxGesturePoints; ++i) {
1378     if (points_[i].in_use())
1379       break;
1380   }
1381   DCHECK(i < kMaxGesturePoints);
1382
1383   velocity_x = points_[i].XVelocity();
1384   velocity_y = points_[i].YVelocity();
1385   sign_x = velocity_x < 0.f ? -1 : 1;
1386   sign_y = velocity_y < 0.f ? -1 : 1;
1387
1388   for (++i; i < kMaxGesturePoints; ++i) {
1389     if (!points_[i].in_use())
1390       continue;
1391
1392     if (sign_x * points_[i].XVelocity() < 0)
1393       swipe_x = false;
1394
1395     if (sign_y * points_[i].YVelocity() < 0)
1396       swipe_y = false;
1397
1398     velocity_x += points_[i].XVelocity();
1399     velocity_y += points_[i].YVelocity();
1400   }
1401
1402   float min_velocity = GestureConfiguration::min_swipe_speed();
1403
1404   velocity_x = fabs(velocity_x / point_count_);
1405   velocity_y = fabs(velocity_y / point_count_);
1406   if (velocity_x < min_velocity)
1407     swipe_x = false;
1408   if (velocity_y < min_velocity)
1409     swipe_y = false;
1410
1411   if (!swipe_x && !swipe_y)
1412     return false;
1413
1414   if (!swipe_x)
1415     velocity_x = 0.001f;
1416   if (!swipe_y)
1417     velocity_y = 0.001f;
1418
1419   float ratio = velocity_x > velocity_y ? velocity_x / velocity_y :
1420                                           velocity_y / velocity_x;
1421   if (ratio < GestureConfiguration::max_swipe_deviation_ratio())
1422     return false;
1423
1424   if (velocity_x > velocity_y)
1425     sign_y = 0;
1426   else
1427     sign_x = 0;
1428
1429   AppendSwipeGesture(point, sign_x, sign_y, gestures);
1430
1431   return true;
1432 }
1433
1434 void GestureSequence::TwoFingerTapOrPinch(const TouchEvent& event,
1435                                           const GesturePoint& point,
1436                                           Gestures* gestures) {
1437   if (IsSecondTouchDownCloseEnoughForTwoFingerTap()) {
1438     TwoFingerTouchDown(event, point, gestures);
1439     set_state(GS_PENDING_TWO_FINGER_TAP);
1440   } else {
1441     set_state(GS_PENDING_PINCH);
1442   }
1443 }
1444
1445
1446 void GestureSequence::StopTimersIfRequired(const TouchEvent& event) {
1447   if ((!GetLongPressTimer()->IsRunning() &&
1448        !GetShowPressTimer()->IsRunning()) ||
1449       event.type() != ui::ET_TOUCH_MOVED)
1450     return;
1451
1452   // Since a timer is running, there should be a non-NULL point.
1453   const GesturePoint* point = GetPointByPointId(0);
1454   if (!point->IsInsideTouchSlopRegion(event)) {
1455     GetLongPressTimer()->Stop();
1456     GetShowPressTimer()->Stop();
1457   }
1458 }
1459
1460 void GestureSequence::StartRailFreeScroll(const GesturePoint& point,
1461                                           Gestures* gestures) {
1462   AppendScrollGestureBegin(point, point.first_touch_position(), gestures);
1463   scroll_type_ = ST_FREE;
1464   set_state(GS_SCROLL);
1465 }
1466
1467 }  // namespace ui