Remove ScopedVector from content/browser/ [1].

content/browser/renderer_host/input/input_router_impl_unittest.cc

 // Copyright 2013 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 "content/browser/renderer_host/input/input_router_impl.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <tuple>
+#include <vector>
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/input/gesture_event_queue.h"
 #include "content/browser/renderer_host/input/input_router_client.h"
 #include "content/browser/renderer_host/input/mock_input_ack_handler.h"
 #include "content/browser/renderer_host/input/mock_input_router_client.h"
@@ skipping 96 matching lines @@
     return false;
   if (first.location() != second.location())
     return false;
   if (first.pointer_details().id != second.pointer_details().id)
     return false;
   if (second.time_stamp() != first.time_stamp())
     return false;
   return true;
 }
 
-bool EventListIsSubset(const ScopedVector<ui::TouchEvent>& subset,
-                       const ScopedVector<ui::TouchEvent>& set) {
+bool EventListIsSubset(
+    const std::vector<std::unique_ptr<ui::TouchEvent>>& subset,
+    const std::vector<std::unique_ptr<ui::TouchEvent>>& set) {
   if (subset.size() > set.size())
     return false;
   for (size_t i = 0; i < subset.size(); ++i) {
-    const ui::TouchEvent* first = subset[i];
-    const ui::TouchEvent* second = set[i];
-    bool equivalent = TouchEventsAreEquivalent(*first, *second);
+    bool equivalent = TouchEventsAreEquivalent(*(subset[i]), *(set[i]));
     if (!equivalent)
       return false;
   }
 
   return true;
 }
 #endif  // defined(USE_AURA)
 
 }  // namespace
 
@@ skipping 757 matching lines @@
 
 #if defined(USE_AURA)
 // Tests that the acked events have correct state. (ui::Events are used only on
 // windows and aura)
 TEST_F(InputRouterImplTest, AckedTouchEventState) {
   input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
   EXPECT_TRUE(TouchEventQueueEmpty());
 
   // Send a bunch of events, and make sure the ACKed events are correct.
-  ScopedVector<ui::TouchEvent> expected_events;
+  std::vector<std::unique_ptr<ui::TouchEvent>> expected_events;
 
   // Use a custom timestamp for all the events to test that the acked events
   // have the same timestamp;
   base::TimeTicks timestamp = base::TimeTicks::Now();
   timestamp -= base::TimeDelta::FromSeconds(600);
 
   // Press the first finger.
   PressTouchPoint(1, 1);
   SetTouchTimestamp(timestamp);
   uint32_t touch_press_event_id1 = SendTouchEvent();
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
-  expected_events.push_back(
-      new ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(1, 1), 0, timestamp));
+  expected_events.push_back(base::MakeUnique<ui::TouchEvent>(
+      ui::ET_TOUCH_PRESSED, gfx::Point(1, 1), 0, timestamp));
 
   // Move the finger.
   timestamp += base::TimeDelta::FromSeconds(10);
   MoveTouchPoint(0, 500, 500);
   SetTouchTimestamp(timestamp);
   uint32_t touch_move_event_id1 = SendTouchEvent();
   EXPECT_FALSE(TouchEventQueueEmpty());
-  expected_events.push_back(new ui::TouchEvent(
+  expected_events.push_back(base::MakeUnique<ui::TouchEvent>(
       ui::ET_TOUCH_MOVED, gfx::Point(500, 500), 0, timestamp));
 
   // Now press a second finger.
   timestamp += base::TimeDelta::FromSeconds(10);
   PressTouchPoint(2, 2);
   SetTouchTimestamp(timestamp);
   uint32_t touch_press_event_id2 = SendTouchEvent();
   EXPECT_FALSE(TouchEventQueueEmpty());
-  expected_events.push_back(
-      new ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(2, 2), 1, timestamp));
+  expected_events.push_back(base::MakeUnique<ui::TouchEvent>(
+      ui::ET_TOUCH_PRESSED, gfx::Point(2, 2), 1, timestamp));
 
   // Move both fingers.
   timestamp += base::TimeDelta::FromSeconds(10);
   MoveTouchPoint(0, 10, 10);
   MoveTouchPoint(1, 20, 20);
   SetTouchTimestamp(timestamp);
   uint32_t touch_move_event_id2 = SendTouchEvent();
   EXPECT_FALSE(TouchEventQueueEmpty());
-  expected_events.push_back(
-      new ui::TouchEvent(ui::ET_TOUCH_MOVED, gfx::Point(10, 10), 0, timestamp));
-  expected_events.push_back(
-      new ui::TouchEvent(ui::ET_TOUCH_MOVED, gfx::Point(20, 20), 1, timestamp));
+  expected_events.push_back(base::MakeUnique<ui::TouchEvent>(
+      ui::ET_TOUCH_MOVED, gfx::Point(10, 10), 0, timestamp));
+  expected_events.push_back(base::MakeUnique<ui::TouchEvent>(
+      ui::ET_TOUCH_MOVED, gfx::Point(20, 20), 1, timestamp));
 
   // Receive the ACKs and make sure the generated events from the acked events
   // are correct.
   WebInputEvent::Type acks[] = { WebInputEvent::TouchStart,
                                  WebInputEvent::TouchMove,
                                  WebInputEvent::TouchStart,
                                  WebInputEvent::TouchMove };
 
   uint32_t touch_event_ids[] = {touch_press_event_id1, touch_move_event_id1,
                                 touch_press_event_id2, touch_move_event_id2};
 
   TouchEventCoordinateSystem coordinate_system = LOCAL_COORDINATES;
 #if !defined(OS_WIN)
   coordinate_system = SCREEN_COORDINATES;
 #endif
   for (size_t i = 0; i < arraysize(acks); ++i) {
     SendTouchEventACK(acks[i], INPUT_EVENT_ACK_STATE_NOT_CONSUMED,
                       touch_event_ids[i]);
     EXPECT_EQ(acks[i], ack_handler_->acked_touch_event().event.type());
-    ScopedVector<ui::TouchEvent> acked;
+    std::vector<std::unique_ptr<ui::TouchEvent>> acked;
 
     MakeUITouchEventsFromWebTouchEvents(
         ack_handler_->acked_touch_event(), &acked, coordinate_system);
     bool success = EventListIsSubset(acked, expected_events);
     EXPECT_TRUE(success) << "Failed on step: " << i;
     if (!success)
       break;
     expected_events.erase(expected_events.begin(),
                           expected_events.begin() + acked.size());
   }
@@ skipping 1445 matching lines @@
   EXPECT_EQ(80, sent_event->data.flingStart.velocityY);
 
   const WebGestureEvent* filter_event =
       GetFilterWebInputEvent<WebGestureEvent>();
   TestLocationInFilterEvent(filter_event, orig);
   EXPECT_EQ(30, filter_event->data.flingStart.velocityX);
   EXPECT_EQ(40, filter_event->data.flingStart.velocityY);
 }
 
 }  // namespace content