Remove ScopedVector from ui/events/.

ui/events/gesture_detection/motion_event_buffer_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/gesture_detection/motion_event_buffer.h"
@@ skipping 28 matching lines @@
   }
 
 class MotionEventBufferTest : public testing::Test,
                               public MotionEventBufferClient {
  public:
   MotionEventBufferTest() : needs_flush_(false) {}
   ~MotionEventBufferTest() override {}
 
   // MotionEventBufferClient implementation.
   void ForwardMotionEvent(const MotionEvent& event) override {
-    forwarded_events_.push_back(event.Clone().release());
+    forwarded_events_.push_back(event.Clone());
   }
 
   void SetNeedsFlush() override { needs_flush_ = true; }
 
   bool GetAndResetNeedsFlush() {
     bool needs_flush = needs_flush_;
     needs_flush_ = false;
     return needs_flush;
   }
 
-  ScopedVector<MotionEvent> GetAndResetForwardedEvents() {
-    ScopedVector<MotionEvent> forwarded_events;
+  std::vector<std::unique_ptr<MotionEvent>> GetAndResetForwardedEvents() {
+    std::vector<std::unique_ptr<MotionEvent>> forwarded_events;
     forwarded_events.swap(forwarded_events_);
     return forwarded_events;
   }
 
   const MotionEvent* GetLastEvent() const {
-    return forwarded_events_.empty() ? NULL : forwarded_events_.back();
+    return forwarded_events_.empty() ? nullptr : forwarded_events_.back().get();
   }
 
   static base::TimeDelta LargeDelta() {
     return base::TimeDelta::FromMilliseconds(kLargeDeltaMs);
   }
 
   static base::TimeDelta SmallDelta() {
     return base::TimeDelta::FromMilliseconds(kSmallDeltaMs);
   }
 
@@ skipping 156 matching lines @@
           last_flushed_event = current_flushed_event->Clone();
           events += GetAndResetForwardedEvents().size();
         }
       }
     }
     events += GetAndResetForwardedEvents().size();
     EXPECT_GE(events, min_expected_events);
   }
 
  private:
-  ScopedVector<MotionEvent> forwarded_events_;
+  std::vector<std::unique_ptr<MotionEvent>> forwarded_events_;
   bool needs_flush_;
 };
 
 TEST_F(MotionEventBufferTest, BufferEmpty) {
   MotionEventBuffer buffer(this, true);
 
   buffer.Flush(base::TimeTicks::Now());
   EXPECT_FALSE(GetAndResetNeedsFlush());
   EXPECT_FALSE(GetLastEvent());
 }
@@ skipping 37 matching lines @@
   EXPECT_FALSE(GetAndResetNeedsFlush());
   EXPECT_FALSE(GetLastEvent());
 
   // The up should flush the buffer.
   MockMotionEvent up(MotionEvent::ACTION_UP, event_time, 4.f, 4.f);
   buffer.OnMotionEvent(up);
   EXPECT_FALSE(GetAndResetNeedsFlush());
 
   // The flushed events should include the up and the moves, with the latter
   // combined into a single event with history.
-  ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
+  std::vector<std::unique_ptr<MotionEvent>> events =
+      GetAndResetForwardedEvents();
   ASSERT_EQ(2U, events.size());
   EXPECT_EVENT_EQ(up, *events.back());
   EXPECT_EQ(2U, events.front()->GetHistorySize());
   EXPECT_EVENT_IGNORING_HISTORY_EQ(*events.front(), move2);
   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
   EXPECT_EVENT_HISTORY_EQ(*events.front(), 1, move1);
 }
 
 TEST_F(MotionEventBufferTest, BufferFlushedOnIncompatibleActionMove) {
   base::TimeTicks event_time = base::TimeTicks::Now();
@@ skipping 20 matching lines @@
   MockMotionEvent move2(move1);
   move2.SetToolType(0, MotionEvent::TOOL_TYPE_STYLUS);
   buffer.OnMotionEvent(move2);
   EXPECT_FALSE(GetAndResetNeedsFlush());
   EXPECT_EVENT_EQ(move1, *GetLastEvent());
 
   event_time += base::TimeDelta::FromMilliseconds(5);
 
   // The flushed event should only include the latest move event.
   buffer.Flush(event_time);
-  ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
+  std::vector<std::unique_ptr<MotionEvent>> events =
+      GetAndResetForwardedEvents();
   ASSERT_EQ(3U, events.size());
   EXPECT_EVENT_EQ(move2, *events.back());
   EXPECT_FALSE(GetAndResetNeedsFlush());
 
   event_time += base::TimeDelta::FromMilliseconds(5);
 
   // Events with different pointer ids should not combine.
   PointerProperties pointer0(5.f, 5.f, 1.f);
   pointer0.id = 1;
   PointerProperties pointer1(10.f, 10.f, 2.f);
@@ skipping 77 matching lines @@
   buffer.OnMotionEvent(move1);
   EXPECT_FALSE(GetAndResetNeedsFlush());
   ASSERT_FALSE(GetLastEvent());
 
   // As the two events are logically the same but for ordering and time, the
   // synthesized event should yield a logically identical event.
   base::TimeTicks flush_time = move1.GetEventTime() + ResampleDelta();
   buffer.Flush(flush_time);
   EXPECT_FALSE(GetAndResetNeedsFlush());
   ASSERT_TRUE(GetLastEvent());
-  ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
+  std::vector<std::unique_ptr<MotionEvent>> events =
+      GetAndResetForwardedEvents();
   ASSERT_EQ(1U, events.size());
   EXPECT_EVENT_IGNORING_HISTORY_EQ(move1, *events.front());
   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
 }
 
 TEST_F(MotionEventBufferTest, FlushedEventsNeverLaterThanFlushTime) {
   base::TimeTicks event_time = base::TimeTicks::Now();
   MotionEventBuffer buffer(this, true);
 
   MockMotionEvent move0(MotionEvent::ACTION_MOVE, event_time, 1.f, 1.f);
@@ skipping 67 matching lines @@
   // Flush at a time between the first and second events.
   base::TimeTicks interpolated_time =
       move0.GetEventTime() + (move1.GetEventTime() - move0.GetEventTime()) / 2;
   base::TimeTicks flush_time = interpolated_time;
   buffer.Flush(flush_time);
   ASSERT_TRUE(GetLastEvent());
   EXPECT_TRUE(GetAndResetNeedsFlush());
 
   // There should only be one flushed event, with the second remaining buffered
   // and no resampling having occurred.
-  ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
+  std::vector<std::unique_ptr<MotionEvent>> events =
+      GetAndResetForwardedEvents();
   ASSERT_EQ(1U, events.size());
   EXPECT_EVENT_EQ(move0, *events.front());
 
   // The second move should be flushed without resampling.
   flush_time = move1.GetEventTime();
   buffer.Flush(flush_time);
   ASSERT_TRUE(GetLastEvent());
   EXPECT_EVENT_EQ(move1, *GetLastEvent());
   GetAndResetForwardedEvents();
 
@@ skipping 47 matching lines @@
       move1.GetEventTime() + (move1.GetEventTime() - move0.GetEventTime());
   base::TimeTicks flush_time = extrapolated_time + ResampleDelta();
   buffer.Flush(flush_time);
   ASSERT_TRUE(GetLastEvent());
   EXPECT_FALSE(GetAndResetNeedsFlush());
 
   // There should only be one flushed event, with the event extrapolated from
   // the two events.
   base::TimeTicks expected_time =
       move1.GetEventTime() + (move1.GetEventTime() - move0.GetEventTime()) / 2;
-  ScopedVector<MotionEvent> events0 = GetAndResetForwardedEvents();
+  std::vector<std::unique_ptr<MotionEvent>> events0 =
+      GetAndResetForwardedEvents();
   ASSERT_EQ(1U, events0.size());
   EXPECT_EQ(2U, events0.front()->GetHistorySize());
   EXPECT_EQ(expected_time, events0.front()->GetEventTime());
   EXPECT_FALSE(GetAndResetNeedsFlush());
 
   // Try enqueuing an event *after* the second event but *before* the
   // extrapolated event. It should be dropped.
   event_time = move1.GetEventTime() + base::TimeDelta::FromMilliseconds(1);
   MockMotionEvent move2(MotionEvent::ACTION_MOVE, event_time, 15.f, 25.f);
   buffer.OnMotionEvent(move1);
   ASSERT_FALSE(GetLastEvent());
   EXPECT_FALSE(GetAndResetNeedsFlush());
 
   // Finally queue an event *after* the extrapolated event.
   event_time = expected_time + base::TimeDelta::FromMilliseconds(1);
   MockMotionEvent move3(MotionEvent::ACTION_MOVE, event_time, 15.f, 25.f);
   buffer.OnMotionEvent(move3);
   ASSERT_FALSE(GetLastEvent());
   EXPECT_TRUE(GetAndResetNeedsFlush());
 
   // The flushed event should simply be the latest event.
   flush_time = event_time + ResampleDelta();
   buffer.Flush(flush_time);
   ASSERT_TRUE(GetLastEvent());
-  ScopedVector<MotionEvent> events1 = GetAndResetForwardedEvents();
+  std::vector<std::unique_ptr<MotionEvent>> events1 =
+      GetAndResetForwardedEvents();
   ASSERT_EQ(1U, events1.size());
   EXPECT_EVENT_EQ(move3, *events1.front());
   EXPECT_FALSE(GetAndResetNeedsFlush());
 }
 
 TEST_F(MotionEventBufferTest, NoResamplingWithSmallTimeDeltaBetweenMoves) {
   base::TimeTicks event_time = base::TimeTicks::Now();
   MotionEventBuffer buffer(this, true);
 
   // The first move should be buffered.
   MockMotionEvent move0(MotionEvent::ACTION_MOVE, event_time, 1.f, 1.f);
   buffer.OnMotionEvent(move0);
   ASSERT_FALSE(GetLastEvent());
   EXPECT_TRUE(GetAndResetNeedsFlush());
 
   // The second move should remain buffered.
   event_time += SmallDelta();
   MockMotionEvent move1(MotionEvent::ACTION_MOVE, event_time, 2.f, 2.f);
   buffer.OnMotionEvent(move1);
   ASSERT_FALSE(GetLastEvent());
   EXPECT_FALSE(GetAndResetNeedsFlush());
 
   base::TimeTicks flush_time = event_time + ResampleDelta();
   buffer.Flush(flush_time);
   EXPECT_FALSE(GetAndResetNeedsFlush());
 
   // There should only be one flushed event, and no resampling should have
   // occured between the first and the second as they were temporally too close.
-  ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
+  std::vector<std::unique_ptr<MotionEvent>> events =
+      GetAndResetForwardedEvents();
   ASSERT_EQ(1U, events.size());
   EXPECT_EQ(1U, events.front()->GetHistorySize());
   EXPECT_EVENT_IGNORING_HISTORY_EQ(*events.front(), move1);
   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
 }
 
 TEST_F(MotionEventBufferTest, NoResamplingWithMismatchBetweenMoves) {
   base::TimeTicks event_time = base::TimeTicks::Now();
   MotionEventBuffer buffer(this, true);
 
   // The first move should be buffered.
   MockMotionEvent move0(MotionEvent::ACTION_MOVE, event_time, 1.f, 1.f);
   buffer.OnMotionEvent(move0);
   ASSERT_FALSE(GetLastEvent());
   EXPECT_TRUE(GetAndResetNeedsFlush());
 
   // The second move should remain buffered.
   event_time += SmallDelta();
   MockMotionEvent move1(MotionEvent::ACTION_MOVE, event_time, 2.f, 2.f);
   buffer.OnMotionEvent(move1);
   ASSERT_FALSE(GetLastEvent());
   EXPECT_FALSE(GetAndResetNeedsFlush());
 
   base::TimeTicks flush_time = event_time + ResampleDelta();
   buffer.Flush(flush_time);
   EXPECT_FALSE(GetAndResetNeedsFlush());
 
   // There should only be one flushed event, and no resampling should have
   // occured between the first and the second as they were temporally too close.
-  ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
+  std::vector<std::unique_ptr<MotionEvent>> events =
+      GetAndResetForwardedEvents();
   ASSERT_EQ(1U, events.size());
   EXPECT_EQ(1U, events.front()->GetHistorySize());
   EXPECT_EVENT_IGNORING_HISTORY_EQ(*events.front(), move1);
   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
 }
 
 TEST_F(MotionEventBufferTest, Interpolation) {
   base::TimeTicks event_time = base::TimeTicks::Now();
   MotionEventBuffer buffer(this, true);
 
@@ skipping 19 matching lines @@
 
   // There should only be one flushed event, with the event interpolated between
   // the two events. The second event should remain buffered.
   float alpha = (interpolated_time - move0.GetEventTime()).InMillisecondsF() /
                 (move1.GetEventTime() - move0.GetEventTime()).InMillisecondsF();
   MockMotionEvent interpolated_event(
       MotionEvent::ACTION_MOVE,
       interpolated_time,
       move0.GetX(0) + (move1.GetX(0) - move0.GetX(0)) * alpha,
       move0.GetY(0) + (move1.GetY(0) - move0.GetY(0)) * alpha);
-  ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
+  std::vector<std::unique_ptr<MotionEvent>> events =
+      GetAndResetForwardedEvents();
   ASSERT_EQ(1U, events.size());
   EXPECT_EQ(1U, events.front()->GetHistorySize());
   EXPECT_EVENT_IGNORING_HISTORY_EQ(*events.front(), interpolated_event);
   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
 
   // The second move should be flushed without resampling.
   flush_time = move1.GetEventTime() + ResampleDelta();
   buffer.Flush(flush_time);
   ASSERT_TRUE(GetLastEvent());
   EXPECT_EVENT_EQ(move1, *GetLastEvent());
@@ skipping 31 matching lines @@
   base::TimeTicks expected_time =
       move1.GetEventTime() + (move1.GetEventTime() - move0.GetEventTime()) / 2;
   float expected_alpha =
       (expected_time - move0.GetEventTime()).InMillisecondsF() /
       (move1.GetEventTime() - move0.GetEventTime()).InMillisecondsF();
   MockMotionEvent extrapolated_event(
       MotionEvent::ACTION_MOVE,
       expected_time,
       move0.GetX(0) + (move1.GetX(0) - move0.GetX(0)) * expected_alpha,
       move0.GetY(0) + (move1.GetY(0) - move0.GetY(0)) * expected_alpha);
-  ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
+  std::vector<std::unique_ptr<MotionEvent>> events =
+      GetAndResetForwardedEvents();
   ASSERT_EQ(1U, events.size());
   EXPECT_EQ(2U, events.front()->GetHistorySize());
   EXPECT_EVENT_IGNORING_HISTORY_EQ(*events.front(), extrapolated_event);
   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
   EXPECT_EVENT_HISTORY_EQ(*events.front(), 1, move1);
 }
 
 TEST_F(MotionEventBufferTest, ExtrapolationHorizonLimited) {
   base::TimeTicks event_time = base::TimeTicks::Now();
   MotionEventBuffer buffer(this, true);
@@ skipping 24 matching lines @@
   base::TimeTicks expected_time =
       move1.GetEventTime() + base::TimeDelta::FromMilliseconds(8);
   float expected_alpha =
       (expected_time - move0.GetEventTime()).InMillisecondsF() /
       (move1.GetEventTime() - move0.GetEventTime()).InMillisecondsF();
   MockMotionEvent extrapolated_event(
       MotionEvent::ACTION_MOVE,
       expected_time,
       move0.GetX(0) + (move1.GetX(0) - move0.GetX(0)) * expected_alpha,
       move0.GetY(0) + (move1.GetY(0) - move0.GetY(0)) * expected_alpha);
-  ScopedVector<MotionEvent> events = GetAndResetForwardedEvents();
+  std::vector<std::unique_ptr<MotionEvent>> events =
+      GetAndResetForwardedEvents();
   ASSERT_EQ(1U, events.size());
   EXPECT_EQ(2U, events.front()->GetHistorySize());
   EXPECT_EVENT_IGNORING_HISTORY_EQ(*events.front(), extrapolated_event);
   EXPECT_EVENT_HISTORY_EQ(*events.front(), 0, move0);
   EXPECT_EVENT_HISTORY_EQ(*events.front(), 1, move1);
 }
 
 TEST_F(MotionEventBufferTest, Resampling30to60) {
   base::TimeDelta flush_time_delta =
       base::TimeDelta::FromMillisecondsD(1000. / 60.);
@@ skipping 33 matching lines @@
 TEST_F(MotionEventBufferTest, Resampling150to60) {
   base::TimeDelta flush_time_delta =
       base::TimeDelta::FromMillisecondsD(1000. / 60.);
   base::TimeDelta event_time_delta =
       base::TimeDelta::FromMillisecondsD(1000. / 150.);
 
   RunResample(flush_time_delta, event_time_delta);
 }
 
 }  // namespace ui