Home | History | Annotate | Download | only in gesture_detection 
      1 // Copyright 2014 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 "base/basictypes.h"
      6 #include "base/logging.h"
      7 #include "base/time/time.h"
      8 #include "testing/gtest/include/gtest/gtest.h"
      9 #include "ui/events/gesture_detection/motion_event_buffer.h"
     10 #include "ui/events/test/mock_motion_event.h"
     11 
     12 using base::TimeDelta;
     13 using base::TimeTicks;
     14 using ui::test::MockMotionEvent;
     15 
     16 namespace ui {
     17 
     18 const int kSmallDeltaMs = 1;
     19 const int kLargeDeltaMs = 50;
     20 const int kResampleDeltaMs = 5;
     21 const float kVelocityEpsilon = 0.01f;
     22 const float kDeltaEpsilon = 0.1f;
     23 
     24 #define EXPECT_EVENT_EQ(A, B)         \
     25   {                                   \
     26     SCOPED_TRACE(testing::Message()); \
     27     ExpectEquals((A), (B));           \
     28   }
     29 #define EXPECT_EVENT_IGNORING_HISTORY_EQ(A, B) \
     30   {                                            \
     31     SCOPED_TRACE(testing::Message());          \
     32     ExpectEqualsIgnoringHistory((A), (B));     \
     33   }
     34 #define EXPECT_EVENT_HISTORY_EQ(A, I, B)     \
     35   {                                          \
     36     SCOPED_TRACE(testing::Message());        \
     37     ExpectEqualsHistoryIndex((A), (I), (B)); \
     38   }
     39 
     40 class MotionEventBufferTest : public testing::Test,
     41                               public MotionEventBufferClient {
     42  public:
     43   MotionEventBufferTest() : needs_flush_(false) {}
     44   virtual ~MotionEventBufferTest() {}
     45 
     46   // MotionEventBufferClient implementation.
     47   virtual void ForwardMotionEvent(const MotionEvent& event) OVERRIDE {
     48     forwarded_events_.push_back(event.Clone().release());
     49   }
     50 
     51   virtual void SetNeedsFlush() OVERRIDE { needs_flush_ = true; }
     52 
     53   bool GetAndResetNeedsFlush() {
     54     bool needs_flush = needs_flush_;
     55     needs_flush_ = false;
     56     return needs_flush;
     57   }
     58 
     59   ScopedVector<MotionEvent> GetAndResetForwardedEvents() {
     60     ScopedVector<MotionEvent> forwarded_events;
     61     forwarded_events.swap(forwarded_events_);
     62     return forwarded_events.Pass();
     63   }
     64 
     65   const MotionEvent* GetLastEvent() const {
     66     return forwarded_events_.empty() ? NULL : forwarded_events_.back();
     67   }
     68 
     69   static base::TimeDelta LargeDelta() {
     70     return base::TimeDelta::FromMilliseconds(kLargeDeltaMs);
     71   }
     72 
     73   static base::TimeDelta SmallDelta() {
     74     return base::TimeDelta::FromMilliseconds(kSmallDeltaMs);
     75   }
     76 
     77   static base::TimeDelta ResampleDelta() {
     78     return base::TimeDelta::FromMilliseconds(kResampleDeltaMs);
     79   }
     80 
     81   static void ExpectEqualsImpl(const MotionEvent& a,
     82                                const MotionEvent& b,
     83                                bool ignore_history) {
     84     EXPECT_EQ(a.GetId(), b.GetId());
     85     EXPECT_EQ(a.GetAction(), b.GetAction());
     86     EXPECT_EQ(a.GetActionIndex(), b.GetActionIndex());
     87     EXPECT_EQ(a.GetButtonState(), b.GetButtonState());
     88     EXPECT_EQ(a.GetEventTime(), b.GetEventTime());
     89 
     90     ASSERT_EQ(a.GetPointerCount(), b.GetPointerCount());
     91     for (size_t i = 0; i < a.GetPointerCount(); ++i) {
     92       int bi = b.FindPointerIndexOfId(a.GetPointerId(i));
     93       ASSERT_NE(bi, -1);
     94       EXPECT_EQ(a.GetX(i), b.GetX(bi));
     95       EXPECT_EQ(a.GetY(i), b.GetY(bi));
     96       EXPECT_EQ(a.GetRawX(i), b.GetRawX(bi));
     97       EXPECT_EQ(a.GetRawY(i), b.GetRawY(bi));
     98       EXPECT_EQ(a.GetTouchMajor(i), b.GetTouchMajor(bi));
     99       EXPECT_EQ(a.GetTouchMinor(i), b.GetTouchMinor(bi));
    100       EXPECT_EQ(a.GetOrientation(i), b.GetOrientation(bi));
    101       EXPECT_EQ(a.GetPressure(i), b.GetPressure(bi));
    102       EXPECT_EQ(a.GetToolType(i), b.GetToolType(bi));
    103     }
    104 
    105     if (ignore_history)
    106       return;
    107 
    108     ASSERT_EQ(a.GetHistorySize(), b.GetHistorySize());
    109     for (size_t h = 0; h < a.GetHistorySize(); ++h)
    110       ExpectEqualsHistoryIndex(a, h, b);
    111   }
    112 
    113   // Verify that all public data of |a|, excluding history, equals that of |b|.
    114   static void ExpectEqualsIgnoringHistory(const MotionEvent& a,
    115                                           const MotionEvent& b) {
    116     const bool ignore_history = true;
    117     ExpectEqualsImpl(a, b, ignore_history);
    118   }
    119 
    120   // Verify that all public data of |a| equals that of |b|.
    121   static void ExpectEquals(const MotionEvent& a, const MotionEvent& b) {
    122     const bool ignore_history = false;
    123     ExpectEqualsImpl(a, b, ignore_history);
    124   }
    125 
    126   // Verify that the historical data of |a| given by |historical_index|
    127   // corresponds to the *raw* data of |b|.
    128   static void ExpectEqualsHistoryIndex(const MotionEvent& a,
    129                                        size_t history_index,
    130                                        const MotionEvent& b) {
    131     ASSERT_LT(history_index, a.GetHistorySize());
    132     EXPECT_EQ(a.GetPointerCount(), b.GetPointerCount());
    133     EXPECT_TRUE(a.GetHistoricalEventTime(history_index) == b.GetEventTime());
    134 
    135     for (size_t i = 0; i < a.GetPointerCount(); ++i) {
    136       int bi = b.FindPointerIndexOfId(a.GetPointerId(i));
    137       ASSERT_NE(bi, -1);
    138       EXPECT_EQ(a.GetHistoricalX(i, history_index), b.GetX(bi));
    139       EXPECT_EQ(a.GetHistoricalY(i, history_index), b.GetY(bi));
    140       EXPECT_EQ(a.GetHistoricalTouchMajor(i, history_index),
    141                 b.GetTouchMajor(bi));
    142     }
    143   }
    144 
    145  protected:
    146   void RunResample(base::TimeDelta flush_time_delta,
    147                    base::TimeDelta event_time_delta) {
    148     for (base::TimeDelta offset; offset < event_time_delta;
    149          offset += event_time_delta / 3) {
    150       SCOPED_TRACE(testing::Message()
    151                    << "Resample(offset="
    152                    << static_cast<int>(offset.InMilliseconds()) << "ms)");
    153       RunResample(flush_time_delta, event_time_delta, offset);
    154     }
    155   }
    156 
    157   // Given an event and flush sampling frequency, inject a stream of events,
    158   // flushing at appropriate points in the stream. Verify that the continuous
    159   // velocity sampled by the *input* stream matches the discrete velocity
    160   // as computed from the resampled *output* stream.
    161   void RunResample(base::TimeDelta flush_time_delta,
    162                    base::TimeDelta event_time_delta,
    163                    base::TimeDelta event_time_offset) {
    164     base::TimeTicks event_time = base::TimeTicks::Now();
    165     base::TimeTicks flush_time =
    166         event_time + flush_time_delta - event_time_offset;
    167     base::TimeTicks max_event_time =
    168         event_time + base::TimeDelta::FromSecondsD(0.5f);
    169     const size_t min_expected_events =
    170         static_cast<size_t>((max_event_time - flush_time) /
    171                             std::max(event_time_delta, flush_time_delta));
    172 
    173     MotionEventBuffer buffer(this, true);
    174 
    175     gfx::Vector2dF velocity(33.f, -11.f);
    176     gfx::PointF position(17.f, 42.f);
    177     scoped_ptr<MotionEvent> last_flushed_event;
    178     size_t events = 0;
    179     float last_dx = 0, last_dy = 0;
    180     base::TimeDelta last_dt;
    181     while (event_time < max_event_time) {
    182       position += gfx::ScaleVector2d(velocity, event_time_delta.InSecondsF());
    183       MockMotionEvent move(
    184           MotionEvent::ACTION_MOVE, event_time, position.x(), position.y());
    185       buffer.OnMotionEvent(move);
    186       event_time += event_time_delta;
    187 
    188       while (flush_time < event_time) {
    189         buffer.Flush(flush_time);
    190         flush_time += flush_time_delta;
    191         const MotionEvent* current_flushed_event = GetLastEvent();
    192         if (current_flushed_event) {
    193           if (!last_flushed_event) {
    194             last_flushed_event = current_flushed_event->Clone();
    195             continue;
    196           }
    197 
    198           base::TimeDelta dt = current_flushed_event->GetEventTime() -
    199                                last_flushed_event->GetEventTime();
    200           EXPECT_GE(dt.ToInternalValue(), 0);
    201           // A time delta of 0 is possible if the flush rate is greater than the
    202           // event rate, in which case we can simply skip forward.
    203           if (dt == base::TimeDelta())
    204             continue;
    205 
    206           const float dx =
    207               current_flushed_event->GetX() - last_flushed_event->GetX();
    208           const float dy =
    209               current_flushed_event->GetY() - last_flushed_event->GetY();
    210           const float dt_s = (current_flushed_event->GetEventTime() -
    211                               last_flushed_event->GetEventTime()).InSecondsF();
    212 
    213           // The discrete velocity should mirror the constant velocity.
    214           EXPECT_NEAR(velocity.x(), dx / dt_s, kVelocityEpsilon);
    215           EXPECT_NEAR(velocity.y(), dy / dt_s, kVelocityEpsilon);
    216 
    217           // The impulse delta for each frame should remain constant.
    218           if (last_dy)
    219             EXPECT_NEAR(dx, last_dx, kDeltaEpsilon);
    220           if (last_dy)
    221             EXPECT_NEAR(dy, last_dy, kDeltaEpsilon);
    222 
    223           // The timestamp delta should remain constant.
    224           if (last_dt != base::TimeDelta())
    225             EXPECT_TRUE((dt - last_dt).InMillisecondsF() < kDeltaEpsilon);
    226 
    227           last_dx = dx;
    228           last_dy = dy;
    229           last_dt = dt;
    230           last_flushed_event = current_flushed_event->Clone();
    231           events += GetAndResetForwardedEvents().size();
    232         }
    233       }
    234     }
    235     events += GetAndResetForwardedEvents().size();
    236     EXPECT_GE(events, min_expected_events);
    237   }
    238 
    239  private:
    240   ScopedVector<MotionEvent> forwarded_events_;
    241   bool needs_flush_;
    242 };
    243 
    244 TEST_F(MotionEventBufferTest, BufferEmpty) {
    245   MotionEventBuffer buffer(this, true);
    246 
    247   buffer.Flush(base::TimeTicks::Now());
    248   EXPECT_FALSE(GetAndResetNeedsFlush());
    249   EXPECT_FALSE(GetLastEvent());
    250 }
    251 
    252 TEST_F(MotionEventBufferTest, BufferWithOneMoveNotResampled) {
    253   base::TimeTicks event_time = base::TimeTicks::Now();
    254   MotionEventBuffer buffer(this, true);
    255 
    256   MockMotionEvent move(MotionEvent::ACTION_MOVE, event_time, 4.f, 4.f);
    257   buffer.OnMotionEvent(move);
    258   EXPECT_TRUE(GetAndResetNeedsFlush());
    259   EXPECT_FALSE(GetLastEvent());
    260 
    261   buffer.Flush(event_time + ResampleDelta());
    262   EXPECT_FALSE(GetAndResetNeedsFlush());
    263   ASSERT_TRUE(GetLastEvent());
    264   EXPECT_EVENT_EQ(move, *GetLastEvent());
    265   EXPECT_EQ(1U, GetAndResetForwardedEvents().size());
    266 }
    267 
    268 TEST_F(MotionEventBufferTest, BufferFlushedOnNonActionMove) {
    269   base::TimeTicks event_time = base::TimeTicks::Now();
    270   MotionEventBuffer buffer(this, true);
    271 
    272   MockMotionEvent move0(MotionEvent::ACTION_MOVE, event_time, 1.f, 1.f);
    273   buffer.OnMotionEvent(move0);
    274   EXPECT_TRUE(GetAndResetNeedsFlush());
    275   EXPECT_FALSE(GetLastEvent());
    276 
    277   event_time += base::TimeDelta::FromMilliseconds(5);
    278 
    279   // The second move should remain buffered.
    280   MockMotionEvent move1(MotionEvent::ACTION_MOVE, event_time, 2.f, 2.f);
    281   buffer.OnMotionEvent(move1);
    282   EXPECT_FALSE(GetAndResetNeedsFlush());
    283   EXPECT_FALSE(GetLastEvent());
    284 
    285   // The third move should remain buffered.
    286   MockMotionEvent move2(MotionEvent::ACTION_MOVE, event_time, 3.f, 3.f);
    287   buffer.OnMotionEvent(move2);
    288   EXPECT_FALSE(GetAndResetNeedsFlush());
    289   EXPECT_FALSE(GetLastEvent());
    290 
    291   // The up should flush the buffer.
    292   MockMotionEvent up(MotionEvent::ACTION_UP, event_time, 4.f, 4.f);
    293   buffer.OnMotionEvent(up);
    294   EXPECT_FALSE(GetAndResetNeedsFlush());
    295 
    296   // The flushed events should include the up and the moves, with the latter
    297   // combined into a single event with history.
    298   ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
    299   ASSERT_EQ(2U, events.size());
    300   EXPECT_EVENT_EQ(up, *events.back());
    301   EXPECT_EQ(2U, events.front()->GetHistorySize());
    302   EXPECT_EVENT_IGNORING_HISTORY_EQ(*events.front(), move2);
    303   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
    304   EXPECT_EVENT_HISTORY_EQ(*events.front(), 1, move1);
    305 }
    306 
    307 TEST_F(MotionEventBufferTest, BufferFlushedOnIncompatibleActionMove) {
    308   base::TimeTicks event_time = base::TimeTicks::Now();
    309   MotionEventBuffer buffer(this, true);
    310 
    311   MockMotionEvent move0(MotionEvent::ACTION_MOVE, event_time, 1.f, 1.f);
    312   buffer.OnMotionEvent(move0);
    313   EXPECT_TRUE(GetAndResetNeedsFlush());
    314   EXPECT_FALSE(GetLastEvent());
    315 
    316   event_time += base::TimeDelta::FromMilliseconds(5);
    317 
    318   // The second move has a different pointer count, flushing the first.
    319   MockMotionEvent move1(
    320       MotionEvent::ACTION_MOVE, event_time, 2.f, 2.f, 3.f, 3.f);
    321   buffer.OnMotionEvent(move1);
    322   EXPECT_FALSE(GetAndResetNeedsFlush());
    323   ASSERT_TRUE(GetLastEvent());
    324   EXPECT_EVENT_EQ(move0, *GetLastEvent());
    325 
    326   event_time += base::TimeDelta::FromMilliseconds(5);
    327 
    328   // The third move has differing tool types, flushing the second.
    329   MockMotionEvent move2(move1);
    330   move2.SetToolType(0, MotionEvent::TOOL_TYPE_STYLUS);
    331   buffer.OnMotionEvent(move2);
    332   EXPECT_FALSE(GetAndResetNeedsFlush());
    333   EXPECT_EVENT_EQ(move1, *GetLastEvent());
    334 
    335   event_time += base::TimeDelta::FromMilliseconds(5);
    336 
    337   // The flushed event should only include the latest move event.
    338   buffer.Flush(event_time);
    339   ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
    340   ASSERT_EQ(3U, events.size());
    341   EXPECT_EVENT_EQ(move2, *events.back());
    342   EXPECT_FALSE(GetAndResetNeedsFlush());
    343 
    344   event_time += base::TimeDelta::FromMilliseconds(5);
    345 
    346   // Events with different pointer ids should not combine.
    347   PointerProperties pointer0(5.f, 5.f);
    348   pointer0.id = 1;
    349   PointerProperties pointer1(10.f, 10.f);
    350   pointer1.id = 2;
    351   MotionEventGeneric move3(MotionEvent::ACTION_MOVE, event_time, pointer0);
    352   move3.PushPointer(pointer1);
    353   buffer.OnMotionEvent(move3);
    354   ASSERT_FALSE(GetLastEvent());
    355   EXPECT_TRUE(GetAndResetNeedsFlush());
    356 
    357   MotionEventGeneric move4(MotionEvent::ACTION_MOVE, event_time, pointer0);
    358   pointer1.id = 7;
    359   move4.PushPointer(pointer1);
    360   buffer.OnMotionEvent(move2);
    361   EXPECT_FALSE(GetAndResetNeedsFlush());
    362   ASSERT_TRUE(GetLastEvent());
    363   EXPECT_EVENT_EQ(move3, *GetLastEvent());
    364 }
    365 
    366 TEST_F(MotionEventBufferTest, OnlyActionMoveBuffered) {
    367   base::TimeTicks event_time = base::TimeTicks::Now();
    368   MotionEventBuffer buffer(this, true);
    369 
    370   MockMotionEvent down(MotionEvent::ACTION_DOWN, event_time, 1.f, 1.f);
    371   buffer.OnMotionEvent(down);
    372   EXPECT_FALSE(GetAndResetNeedsFlush());
    373   ASSERT_TRUE(GetLastEvent());
    374   EXPECT_EVENT_EQ(down, *GetLastEvent());
    375 
    376   GetAndResetForwardedEvents();
    377 
    378   MockMotionEvent up(MotionEvent::ACTION_UP, event_time, 2.f, 2.f);
    379   buffer.OnMotionEvent(up);
    380   EXPECT_FALSE(GetAndResetNeedsFlush());
    381   ASSERT_TRUE(GetLastEvent());
    382   EXPECT_EVENT_EQ(up, *GetLastEvent());
    383 
    384   GetAndResetForwardedEvents();
    385 
    386   MockMotionEvent cancel(MotionEvent::ACTION_CANCEL, event_time, 3.f, 3.f);
    387   buffer.OnMotionEvent(cancel);
    388   EXPECT_FALSE(GetAndResetNeedsFlush());
    389   ASSERT_TRUE(GetLastEvent());
    390   EXPECT_EVENT_EQ(cancel, *GetLastEvent());
    391 
    392   GetAndResetForwardedEvents();
    393 
    394   MockMotionEvent move(MotionEvent::ACTION_MOVE, event_time, 4.f, 4.f);
    395   buffer.OnMotionEvent(move);
    396   EXPECT_TRUE(GetAndResetNeedsFlush());
    397   EXPECT_FALSE(GetLastEvent());
    398 
    399   base::TimeTicks flush_time = move.GetEventTime() + ResampleDelta();
    400   buffer.Flush(flush_time);
    401   EXPECT_FALSE(GetAndResetNeedsFlush());
    402   ASSERT_TRUE(GetLastEvent());
    403   EXPECT_EVENT_EQ(move, *GetLastEvent());
    404 }
    405 
    406 TEST_F(MotionEventBufferTest, OutOfOrderPointersBuffered) {
    407   base::TimeTicks event_time = base::TimeTicks::Now();
    408   MotionEventBuffer buffer(this, true);
    409 
    410   PointerProperties p0(1.f, 2.f);
    411   p0.id = 1;
    412   PointerProperties p1(2.f, 1.f);
    413   p1.id = 2;
    414 
    415   MotionEventGeneric move0(MotionEvent::ACTION_MOVE, event_time, p0);
    416   move0.PushPointer(p1);
    417   buffer.OnMotionEvent(move0);
    418   EXPECT_TRUE(GetAndResetNeedsFlush());
    419   ASSERT_FALSE(GetLastEvent());
    420 
    421   event_time += base::TimeDelta::FromMilliseconds(5);
    422 
    423   // The second move should remain buffered even if the logical pointers are
    424   // in a different order.
    425   MotionEventGeneric move1(MotionEvent::ACTION_MOVE, event_time, p1);
    426   move1.PushPointer(p0);
    427   buffer.OnMotionEvent(move1);
    428   EXPECT_FALSE(GetAndResetNeedsFlush());
    429   ASSERT_FALSE(GetLastEvent());
    430 
    431   // As the two events are logically the same but for ordering and time, the
    432   // synthesized event should yield a logically identical event.
    433   base::TimeTicks flush_time = move1.GetEventTime() + ResampleDelta();
    434   buffer.Flush(flush_time);
    435   EXPECT_FALSE(GetAndResetNeedsFlush());
    436   ASSERT_TRUE(GetLastEvent());
    437   ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
    438   ASSERT_EQ(1U, events.size());
    439   EXPECT_EVENT_IGNORING_HISTORY_EQ(move1, *events.front());
    440   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
    441 }
    442 
    443 TEST_F(MotionEventBufferTest, FlushedEventsNeverLaterThanFlushTime) {
    444   base::TimeTicks event_time = base::TimeTicks::Now();
    445   MotionEventBuffer buffer(this, true);
    446 
    447   MockMotionEvent move0(MotionEvent::ACTION_MOVE, event_time, 1.f, 1.f);
    448   buffer.OnMotionEvent(move0);
    449   ASSERT_FALSE(GetLastEvent());
    450   EXPECT_TRUE(GetAndResetNeedsFlush());
    451 
    452   // The second move should remain buffered.
    453   event_time += LargeDelta();
    454   MockMotionEvent move1(MotionEvent::ACTION_MOVE, event_time, 2.f, 2.f);
    455   buffer.OnMotionEvent(move1);
    456   ASSERT_FALSE(GetLastEvent());
    457   EXPECT_FALSE(GetAndResetNeedsFlush());
    458 
    459   // A flush occurring too early should not forward any events.
    460   base::TimeTicks flush_time = move0.GetEventTime() - ResampleDelta();
    461   buffer.Flush(flush_time);
    462   ASSERT_FALSE(GetLastEvent());
    463   EXPECT_TRUE(GetAndResetNeedsFlush());
    464 
    465   // With resampling enabled, a flush occurring before the resample
    466   // offset should not forward any events.
    467   flush_time = move0.GetEventTime();
    468   buffer.Flush(flush_time);
    469   ASSERT_FALSE(GetLastEvent());
    470   EXPECT_TRUE(GetAndResetNeedsFlush());
    471 
    472   // Only the first event should get flushed, as the flush timestamp precedes
    473   // the second's timestamp by a sufficient amount (preventing interpolation).
    474   flush_time = move0.GetEventTime() + ResampleDelta();
    475   buffer.Flush(flush_time);
    476 
    477   // There should only be one flushed event.
    478   EXPECT_TRUE(GetAndResetNeedsFlush());
    479   ASSERT_TRUE(GetLastEvent());
    480   EXPECT_TRUE(GetLastEvent()->GetEventTime() <= flush_time);
    481   GetAndResetForwardedEvents();
    482 
    483   // Flushing again with a similar timestamp should have no effect other than
    484   // triggering another flush request.
    485   flush_time += base::TimeDelta::FromMilliseconds(1);
    486   buffer.Flush(flush_time);
    487   EXPECT_FALSE(GetLastEvent());
    488   EXPECT_TRUE(GetAndResetNeedsFlush());
    489 
    490   // Flushing after the second move's time should trigger forwarding.
    491   flush_time = move1.GetEventTime() + ResampleDelta();
    492   buffer.Flush(flush_time);
    493   ASSERT_TRUE(GetLastEvent());
    494   EXPECT_EVENT_EQ(move1, *GetLastEvent());
    495   EXPECT_FALSE(GetAndResetNeedsFlush());
    496 }
    497 
    498 TEST_F(MotionEventBufferTest, NoResamplingWhenDisabled) {
    499   base::TimeTicks event_time = base::TimeTicks::Now();
    500   const bool resampling_enabled = false;
    501   MotionEventBuffer buffer(this, resampling_enabled);
    502 
    503   // Queue two events.
    504   MockMotionEvent move0(MotionEvent::ACTION_MOVE, event_time, 5.f, 10.f);
    505   buffer.OnMotionEvent(move0);
    506   ASSERT_FALSE(GetLastEvent());
    507   EXPECT_TRUE(GetAndResetNeedsFlush());
    508 
    509   event_time += base::TimeDelta::FromMilliseconds(5);
    510   MockMotionEvent move1(MotionEvent::ACTION_MOVE, event_time, 15.f, 30.f);
    511   buffer.OnMotionEvent(move1);
    512   ASSERT_FALSE(GetLastEvent());
    513   EXPECT_FALSE(GetAndResetNeedsFlush());
    514 
    515   // Flush at a time between the first and second events.
    516   base::TimeTicks interpolated_time =
    517       move0.GetEventTime() + (move1.GetEventTime() - move0.GetEventTime()) / 2;
    518   base::TimeTicks flush_time = interpolated_time;
    519   buffer.Flush(flush_time);
    520   ASSERT_TRUE(GetLastEvent());
    521   EXPECT_TRUE(GetAndResetNeedsFlush());
    522 
    523   // There should only be one flushed event, with the second remaining buffered
    524   // and no resampling having occurred.
    525   ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
    526   ASSERT_EQ(1U, events.size());
    527   EXPECT_EVENT_EQ(move0, *events.front());
    528 
    529   // The second move should be flushed without resampling.
    530   flush_time = move1.GetEventTime();
    531   buffer.Flush(flush_time);
    532   ASSERT_TRUE(GetLastEvent());
    533   EXPECT_EVENT_EQ(move1, *GetLastEvent());
    534   GetAndResetForwardedEvents();
    535 
    536   // Now queue two more events.
    537   move0 = MockMotionEvent(MotionEvent::ACTION_MOVE, event_time, 5.f, 10.f);
    538   buffer.OnMotionEvent(move0);
    539   ASSERT_FALSE(GetLastEvent());
    540   EXPECT_TRUE(GetAndResetNeedsFlush());
    541 
    542   // The second move should remain buffered.
    543   event_time += base::TimeDelta::FromMilliseconds(5);
    544   move1 = MockMotionEvent(MotionEvent::ACTION_MOVE, event_time, 10.f, 20.f);
    545   buffer.OnMotionEvent(move1);
    546   ASSERT_FALSE(GetLastEvent());
    547   EXPECT_FALSE(GetAndResetNeedsFlush());
    548 
    549   // Sample at a time beyond the first and second events.
    550   flush_time =
    551       move1.GetEventTime() + (move1.GetEventTime() - move0.GetEventTime());
    552   buffer.Flush(flush_time);
    553   ASSERT_TRUE(GetLastEvent());
    554   EXPECT_FALSE(GetAndResetNeedsFlush());
    555 
    556   // There should only be one flushed event, with the first event in the history
    557   // and the second event as the actual event data (no resampling).
    558   events = GetAndResetForwardedEvents();
    559   ASSERT_EQ(1U, events.size());
    560   EXPECT_EQ(1U, events.front()->GetHistorySize());
    561   EXPECT_EVENT_IGNORING_HISTORY_EQ(*events.front(), move1);
    562   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
    563 }
    564 
    565 TEST_F(MotionEventBufferTest, NoResamplingWithOutOfOrderActionMove) {
    566   base::TimeTicks event_time = base::TimeTicks::Now();
    567   MotionEventBuffer buffer(this, true);
    568 
    569   MockMotionEvent move0(MotionEvent::ACTION_MOVE, event_time, 5.f, 10.f);
    570   buffer.OnMotionEvent(move0);
    571   ASSERT_FALSE(GetLastEvent());
    572   EXPECT_TRUE(GetAndResetNeedsFlush());
    573 
    574   // The second move should remain buffered.
    575   event_time += base::TimeDelta::FromMilliseconds(10);
    576   MockMotionEvent move1(MotionEvent::ACTION_MOVE, event_time, 10.f, 20.f);
    577   buffer.OnMotionEvent(move1);
    578   ASSERT_FALSE(GetLastEvent());
    579   EXPECT_FALSE(GetAndResetNeedsFlush());
    580 
    581   // Sample at a time beyond the first and second events.
    582   base::TimeTicks extrapolated_time =
    583       move1.GetEventTime() + (move1.GetEventTime() - move0.GetEventTime());
    584   base::TimeTicks flush_time = extrapolated_time + ResampleDelta();
    585   buffer.Flush(flush_time);
    586   ASSERT_TRUE(GetLastEvent());
    587   EXPECT_FALSE(GetAndResetNeedsFlush());
    588 
    589   // There should only be one flushed event, with the event extrapolated from
    590   // the two events.
    591   base::TimeTicks expected_time =
    592       move1.GetEventTime() + (move1.GetEventTime() - move0.GetEventTime()) / 2;
    593   ScopedVector<MotionEvent> events0 = GetAndResetForwardedEvents();
    594   ASSERT_EQ(1U, events0.size());
    595   EXPECT_EQ(2U, events0.front()->GetHistorySize());
    596   EXPECT_EQ(expected_time, events0.front()->GetEventTime());
    597   EXPECT_FALSE(GetAndResetNeedsFlush());
    598 
    599   // Try enqueuing an event *after* the second event but *before* the
    600   // extrapolated event. It should be dropped.
    601   event_time = move1.GetEventTime() + base::TimeDelta::FromMilliseconds(1);
    602   MockMotionEvent move2(MotionEvent::ACTION_MOVE, event_time, 15.f, 25.f);
    603   buffer.OnMotionEvent(move1);
    604   ASSERT_FALSE(GetLastEvent());
    605   EXPECT_FALSE(GetAndResetNeedsFlush());
    606 
    607   // Finally queue an event *after* the extrapolated event.
    608   event_time = expected_time + base::TimeDelta::FromMilliseconds(1);
    609   MockMotionEvent move3(MotionEvent::ACTION_MOVE, event_time, 15.f, 25.f);
    610   buffer.OnMotionEvent(move3);
    611   ASSERT_FALSE(GetLastEvent());
    612   EXPECT_TRUE(GetAndResetNeedsFlush());
    613 
    614   // The flushed event should simply be the latest event.
    615   flush_time = event_time + ResampleDelta();
    616   buffer.Flush(flush_time);
    617   ASSERT_TRUE(GetLastEvent());
    618   ScopedVector<MotionEvent> events1 = GetAndResetForwardedEvents();
    619   ASSERT_EQ(1U, events1.size());
    620   EXPECT_EVENT_EQ(move3, *events1.front());
    621   EXPECT_FALSE(GetAndResetNeedsFlush());
    622 }
    623 
    624 TEST_F(MotionEventBufferTest, NoResamplingWithSmallTimeDeltaBetweenMoves) {
    625   base::TimeTicks event_time = base::TimeTicks::Now();
    626   MotionEventBuffer buffer(this, true);
    627 
    628   // The first move should be buffered.
    629   MockMotionEvent move0(MotionEvent::ACTION_MOVE, event_time, 1.f, 1.f);
    630   buffer.OnMotionEvent(move0);
    631   ASSERT_FALSE(GetLastEvent());
    632   EXPECT_TRUE(GetAndResetNeedsFlush());
    633 
    634   // The second move should remain buffered.
    635   event_time += SmallDelta();
    636   MockMotionEvent move1(MotionEvent::ACTION_MOVE, event_time, 2.f, 2.f);
    637   buffer.OnMotionEvent(move1);
    638   ASSERT_FALSE(GetLastEvent());
    639   EXPECT_FALSE(GetAndResetNeedsFlush());
    640 
    641   base::TimeTicks flush_time = event_time + ResampleDelta();
    642   buffer.Flush(flush_time);
    643   EXPECT_FALSE(GetAndResetNeedsFlush());
    644 
    645   // There should only be one flushed event, and no resampling should have
    646   // occured between the first and the second as they were temporally too close.
    647   ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
    648   ASSERT_EQ(1U, events.size());
    649   EXPECT_EQ(1U, events.front()->GetHistorySize());
    650   EXPECT_EVENT_IGNORING_HISTORY_EQ(*events.front(), move1);
    651   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
    652 }
    653 
    654 TEST_F(MotionEventBufferTest, NoResamplingWithMismatchBetweenMoves) {
    655   base::TimeTicks event_time = base::TimeTicks::Now();
    656   MotionEventBuffer buffer(this, true);
    657 
    658   // The first move should be buffered.
    659   MockMotionEvent move0(MotionEvent::ACTION_MOVE, event_time, 1.f, 1.f);
    660   buffer.OnMotionEvent(move0);
    661   ASSERT_FALSE(GetLastEvent());
    662   EXPECT_TRUE(GetAndResetNeedsFlush());
    663 
    664   // The second move should remain buffered.
    665   event_time += SmallDelta();
    666   MockMotionEvent move1(MotionEvent::ACTION_MOVE, event_time, 2.f, 2.f);
    667   buffer.OnMotionEvent(move1);
    668   ASSERT_FALSE(GetLastEvent());
    669   EXPECT_FALSE(GetAndResetNeedsFlush());
    670 
    671   base::TimeTicks flush_time = event_time + ResampleDelta();
    672   buffer.Flush(flush_time);
    673   EXPECT_FALSE(GetAndResetNeedsFlush());
    674 
    675   // There should only be one flushed event, and no resampling should have
    676   // occured between the first and the second as they were temporally too close.
    677   ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
    678   ASSERT_EQ(1U, events.size());
    679   EXPECT_EQ(1U, events.front()->GetHistorySize());
    680   EXPECT_EVENT_IGNORING_HISTORY_EQ(*events.front(), move1);
    681   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
    682 }
    683 
    684 TEST_F(MotionEventBufferTest, Interpolation) {
    685   base::TimeTicks event_time = base::TimeTicks::Now();
    686   MotionEventBuffer buffer(this, true);
    687 
    688   MockMotionEvent move0(MotionEvent::ACTION_MOVE, event_time, 5.f, 10.f);
    689   buffer.OnMotionEvent(move0);
    690   ASSERT_FALSE(GetLastEvent());
    691   EXPECT_TRUE(GetAndResetNeedsFlush());
    692 
    693   // The second move should remain buffered.
    694   event_time += base::TimeDelta::FromMilliseconds(5);
    695   MockMotionEvent move1(MotionEvent::ACTION_MOVE, event_time, 15.f, 30.f);
    696   buffer.OnMotionEvent(move1);
    697   ASSERT_FALSE(GetLastEvent());
    698   EXPECT_FALSE(GetAndResetNeedsFlush());
    699 
    700   // Sample at a time between the first and second events.
    701   base::TimeTicks interpolated_time =
    702       move0.GetEventTime() + (move1.GetEventTime() - move0.GetEventTime()) / 3;
    703   base::TimeTicks flush_time = interpolated_time + ResampleDelta();
    704   buffer.Flush(flush_time);
    705   ASSERT_TRUE(GetLastEvent());
    706   EXPECT_TRUE(GetAndResetNeedsFlush());
    707 
    708   // There should only be one flushed event, with the event interpolated between
    709   // the two events. The second event should remain buffered.
    710   float alpha = (interpolated_time - move0.GetEventTime()).InMillisecondsF() /
    711                 (move1.GetEventTime() - move0.GetEventTime()).InMillisecondsF();
    712   MockMotionEvent interpolated_event(
    713       MotionEvent::ACTION_MOVE,
    714       interpolated_time,
    715       move0.GetX(0) + (move1.GetX(0) - move0.GetX(0)) * alpha,
    716       move0.GetY(0) + (move1.GetY(0) - move0.GetY(0)) * alpha);
    717   ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
    718   ASSERT_EQ(1U, events.size());
    719   EXPECT_EQ(1U, events.front()->GetHistorySize());
    720   EXPECT_EVENT_IGNORING_HISTORY_EQ(*events.front(), interpolated_event);
    721   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
    722 
    723   // The second move should be flushed without resampling.
    724   flush_time = move1.GetEventTime() + ResampleDelta();
    725   buffer.Flush(flush_time);
    726   ASSERT_TRUE(GetLastEvent());
    727   EXPECT_EVENT_EQ(move1, *GetLastEvent());
    728 }
    729 
    730 TEST_F(MotionEventBufferTest, Extrapolation) {
    731   base::TimeTicks event_time = base::TimeTicks::Now();
    732   MotionEventBuffer buffer(this, true);
    733 
    734   MockMotionEvent move0(MotionEvent::ACTION_MOVE, event_time, 5.f, 10.f);
    735   buffer.OnMotionEvent(move0);
    736   ASSERT_FALSE(GetLastEvent());
    737   EXPECT_TRUE(GetAndResetNeedsFlush());
    738 
    739   // The second move should remain buffered.
    740   event_time += base::TimeDelta::FromMilliseconds(5);
    741   MockMotionEvent move1(MotionEvent::ACTION_MOVE, event_time, 10.f, 20.f);
    742   buffer.OnMotionEvent(move1);
    743   ASSERT_FALSE(GetLastEvent());
    744   EXPECT_FALSE(GetAndResetNeedsFlush());
    745 
    746   // Sample at a time beyond the first and second events.
    747   base::TimeTicks extrapolated_time =
    748       move1.GetEventTime() + (move1.GetEventTime() - move0.GetEventTime());
    749   base::TimeTicks flush_time = extrapolated_time + ResampleDelta();
    750   buffer.Flush(flush_time);
    751   ASSERT_TRUE(GetLastEvent());
    752   EXPECT_FALSE(GetAndResetNeedsFlush());
    753 
    754   // There should only be one flushed event, with the event extrapolated from
    755   // the two events. The first and second events should be in the history.
    756   // Note that the maximum extrapolation is limited by *half* of the time delta
    757   // between the two events, hence we divide the relative delta by 2 in
    758   // determining the extrapolated event.
    759   base::TimeTicks expected_time =
    760       move1.GetEventTime() + (move1.GetEventTime() - move0.GetEventTime()) / 2;
    761   float expected_alpha =
    762       (expected_time - move0.GetEventTime()).InMillisecondsF() /
    763       (move1.GetEventTime() - move0.GetEventTime()).InMillisecondsF();
    764   MockMotionEvent extrapolated_event(
    765       MotionEvent::ACTION_MOVE,
    766       expected_time,
    767       move0.GetX(0) + (move1.GetX(0) - move0.GetX(0)) * expected_alpha,
    768       move0.GetY(0) + (move1.GetY(0) - move0.GetY(0)) * expected_alpha);
    769   ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
    770   ASSERT_EQ(1U, events.size());
    771   EXPECT_EQ(2U, events.front()->GetHistorySize());
    772   EXPECT_EVENT_IGNORING_HISTORY_EQ(*events.front(), extrapolated_event);
    773   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
    774   EXPECT_EVENT_HISTORY_EQ(*events.front(), 1, move1);
    775 }
    776 
    777 TEST_F(MotionEventBufferTest, ExtrapolationHorizonLimited) {
    778   base::TimeTicks event_time = base::TimeTicks::Now();
    779   MotionEventBuffer buffer(this, true);
    780 
    781   MockMotionEvent move0(MotionEvent::ACTION_MOVE, event_time, 5.f, 10.f);
    782   buffer.OnMotionEvent(move0);
    783   ASSERT_FALSE(GetLastEvent());
    784   EXPECT_TRUE(GetAndResetNeedsFlush());
    785 
    786   // The second move should remain buffered.
    787   event_time += base::TimeDelta::FromMilliseconds(24);
    788   MockMotionEvent move1(MotionEvent::ACTION_MOVE, event_time, 10.f, 20.f);
    789   buffer.OnMotionEvent(move1);
    790   ASSERT_FALSE(GetLastEvent());
    791   EXPECT_FALSE(GetAndResetNeedsFlush());
    792 
    793   // Sample at a time beyond the first and second events.
    794   base::TimeTicks extrapolated_time =
    795       event_time + base::TimeDelta::FromMilliseconds(24);
    796   base::TimeTicks flush_time = extrapolated_time + ResampleDelta();
    797   buffer.Flush(flush_time);
    798   ASSERT_TRUE(GetLastEvent());
    799   EXPECT_FALSE(GetAndResetNeedsFlush());
    800 
    801   // There should only be one flushed event, with the event extrapolated from
    802   // the two events. The first and second events should be in the history.
    803   // Note that the maximum extrapolation is limited by 8 ms.
    804   base::TimeTicks expected_time =
    805       move1.GetEventTime() + base::TimeDelta::FromMilliseconds(8);
    806   float expected_alpha =
    807       (expected_time - move0.GetEventTime()).InMillisecondsF() /
    808       (move1.GetEventTime() - move0.GetEventTime()).InMillisecondsF();
    809   MockMotionEvent extrapolated_event(
    810       MotionEvent::ACTION_MOVE,
    811       expected_time,
    812       move0.GetX(0) + (move1.GetX(0) - move0.GetX(0)) * expected_alpha,
    813       move0.GetY(0) + (move1.GetY(0) - move0.GetY(0)) * expected_alpha);
    814   ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
    815   ASSERT_EQ(1U, events.size());
    816   EXPECT_EQ(2U, events.front()->GetHistorySize());
    817   EXPECT_EVENT_IGNORING_HISTORY_EQ(*events.front(), extrapolated_event);
    818   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
    819   EXPECT_EVENT_HISTORY_EQ(*events.front(), 1, move1);
    820 }
    821 
    822 TEST_F(MotionEventBufferTest, ResamplingWithReorderedPointers) {
    823 
    824 }
    825 
    826 TEST_F(MotionEventBufferTest, Resampling30to60) {
    827   base::TimeDelta flush_time_delta =
    828       base::TimeDelta::FromMillisecondsD(1000. / 60.);
    829   base::TimeDelta event_time_delta =
    830       base::TimeDelta::FromMillisecondsD(1000. / 30.);
    831 
    832   RunResample(flush_time_delta, event_time_delta);
    833 }
    834 
    835 TEST_F(MotionEventBufferTest, Resampling60to60) {
    836   base::TimeDelta flush_time_delta =
    837       base::TimeDelta::FromMillisecondsD(1000. / 60.);
    838   base::TimeDelta event_time_delta =
    839       base::TimeDelta::FromMillisecondsD(1000. / 60.);
    840 
    841   RunResample(flush_time_delta, event_time_delta);
    842 }
    843 
    844 TEST_F(MotionEventBufferTest, Resampling100to60) {
    845   base::TimeDelta flush_time_delta =
    846       base::TimeDelta::FromMillisecondsD(1000. / 60.);
    847   base::TimeDelta event_time_delta =
    848       base::TimeDelta::FromMillisecondsD(1000. / 100.);
    849 
    850   RunResample(flush_time_delta, event_time_delta);
    851 }
    852 
    853 TEST_F(MotionEventBufferTest, Resampling120to60) {
    854   base::TimeDelta flush_time_delta =
    855       base::TimeDelta::FromMillisecondsD(1000. / 60.);
    856   base::TimeDelta event_time_delta =
    857       base::TimeDelta::FromMillisecondsD(1000. / 120.);
    858 
    859   RunResample(flush_time_delta, event_time_delta);
    860 }
    861 
    862 TEST_F(MotionEventBufferTest, Resampling150to60) {
    863   base::TimeDelta flush_time_delta =
    864       base::TimeDelta::FromMillisecondsD(1000. / 60.);
    865   base::TimeDelta event_time_delta =
    866       base::TimeDelta::FromMillisecondsD(1000. / 150.);
    867 
    868   RunResample(flush_time_delta, event_time_delta);
    869 }
    870 
    871 }  // namespace ui
    872