Replace scoped_ptr with std::unique_ptr in //ui

ui/events/ozone/evdev/touch_event_converter_evdev_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 "ui/events/ozone/evdev/touch_event_converter_evdev.h"
+
 #include <errno.h>
 #include <linux/input.h>
 #include <stddef.h>
 #include <unistd.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/events/event_switches.h"
 #include "ui/events/ozone/evdev/device_event_dispatcher_evdev.h"
 #include "ui/events/ozone/evdev/event_device_test_util.h"
 #include "ui/events/ozone/evdev/touch_evdev_types.h"
-#include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
 #include "ui/events/ozone/evdev/touch_noise/touch_noise_filter.h"
 #include "ui/events/ozone/evdev/touch_noise/touch_noise_finder.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_source.h"
 
 namespace ui {
 
 namespace {
 
 const char kTestDevicePath[] = "/dev/input/test-device";
@@ skipping 162 matching lines @@
     DCHECK_GT(dispatched_events_.size(), index);
     return dispatched_events_[index];
   }
 
   void ClearDispatchedEvents() { dispatched_events_.clear(); }
 
   void DestroyDevice() { device_.reset(); }
 
  private:
   base::MessageLoop* loop_;
-  scoped_ptr<ui::MockTouchEventConverterEvdev> device_;
-  scoped_ptr<ui::MockDeviceEventDispatcherEvdev> dispatcher_;
+  std::unique_ptr<ui::MockTouchEventConverterEvdev> device_;
+  std::unique_ptr<ui::MockDeviceEventDispatcherEvdev> dispatcher_;
 
   int events_out_;
   int events_in_;
 
   void DispatchCallback(const ui::TouchEventParams& params) {
     dispatched_events_.push_back(params);
   }
   std::vector<ui::TouchEventParams> dispatched_events_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchEventConverterEvdevTest);
@@ skipping 600 matching lines @@
 }  // namespace
 
 class TouchEventConverterEvdevTouchNoiseTest
     : public TouchEventConverterEvdevTest {
  public:
   TouchEventConverterEvdevTouchNoiseTest() {}
   ~TouchEventConverterEvdevTouchNoiseTest() override {}
 
   // Makes the TouchNoiseFinder use |filter| and only |filter| to filter out
   // touch noise.
-  void SetTouchNoiseFilter(scoped_ptr<TouchNoiseFilter> filter) {
+  void SetTouchNoiseFilter(std::unique_ptr<TouchNoiseFilter> filter) {
     TouchNoiseFinder* finder = device()->touch_noise_finder();
     finder->filters_.clear();
     finder->filters_.push_back(filter.release());
   }
 
   // Returns the first of TouchNoiseFinder's filters.
   ui::TouchNoiseFilter* first_filter() {
     TouchNoiseFinder* finder = device()->touch_noise_finder();
     return finder->filters_.empty() ? nullptr : *finder->filters_.begin();
   }
@@ skipping 21 matching lines @@
 
     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 42},
     {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 43},
     {{0, 0}, EV_SYN, SYN_REPORT, 0},
 
     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1},
     {{0, 0}, EV_SYN, SYN_REPORT, 0}
   };
 
   MockTouchEventConverterEvdev* dev = device();
-  SetTouchNoiseFilter(scoped_ptr<TouchNoiseFilter>(
+  SetTouchNoiseFilter(std::unique_ptr<TouchNoiseFilter>(
       new EventTypeTouchNoiseFilter(ET_TOUCH_PRESSED)));
   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
   dev->ReadNow();
   ASSERT_EQ(0u, size());
 
   ClearDispatchedEvents();
-  SetTouchNoiseFilter(scoped_ptr<TouchNoiseFilter>(
+  SetTouchNoiseFilter(std::unique_ptr<TouchNoiseFilter>(
       new EventTypeTouchNoiseFilter(ET_TOUCH_MOVED)));
   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
   dev->ReadNow();
   ASSERT_EQ(2u, size());
   TouchEventParams event0 = dispatched_event(0);
   EXPECT_EQ(ET_TOUCH_PRESSED, event0.type);
   EXPECT_EQ(40, event0.location.x());
   EXPECT_EQ(41, event0.location.y());
   EXPECT_EQ(ET_TOUCH_CANCELLED, dispatched_event(1).type);
 
   ClearDispatchedEvents();
-  SetTouchNoiseFilter(scoped_ptr<TouchNoiseFilter>(
+  SetTouchNoiseFilter(std::unique_ptr<TouchNoiseFilter>(
       new EventTypeTouchNoiseFilter(ET_TOUCH_RELEASED)));
   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
   dev->ReadNow();
   ASSERT_EQ(3u, size());
   event0 = dispatched_event(0);
   EXPECT_EQ(ET_TOUCH_PRESSED, event0.type);
   EXPECT_EQ(40, event0.location.x());
   EXPECT_EQ(41, event0.location.y());
   TouchEventParams event1 = dispatched_event(1);
   EXPECT_EQ(ET_TOUCH_MOVED, event1.type);
@@ skipping 18 matching lines @@
 
     {{0, 0}, EV_ABS, ABS_MT_POSITION_X, 43},
     {{0, 0}, EV_ABS, ABS_MT_POSITION_Y, 44},
     {{0, 0}, EV_SYN, SYN_REPORT, 0},
 
     {{0, 0}, EV_ABS, ABS_MT_TRACKING_ID, -1},
     {{0, 0}, EV_SYN, SYN_REPORT, 0}
   };
 
   MockTouchEventConverterEvdev* dev = device();
-  SetTouchNoiseFilter(scoped_ptr<TouchNoiseFilter>(
+  SetTouchNoiseFilter(std::unique_ptr<TouchNoiseFilter>(
       new EventTypeTouchNoiseFilter(ET_TOUCH_PRESSED)));
   dev->ConfigureReadMock(mock_kernel_queue, arraysize(mock_kernel_queue), 0);
   dev->ReadNow();
   ASSERT_EQ(0u, size());
 
   EventTypeTouchNoiseFilter* filter =
       static_cast<EventTypeTouchNoiseFilter*>(first_filter());
   EXPECT_EQ(1u, filter->num_events(ET_TOUCH_PRESSED));
   EXPECT_EQ(2u, filter->num_events(ET_TOUCH_MOVED));
   EXPECT_EQ(1u, filter->num_events(ET_TOUCH_RELEASED));
@@ skipping 99 matching lines @@
   event = dispatched_event(3);
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, event.type);
   EXPECT_EQ(8930, event.location.x());
   EXPECT_EQ(980, event.location.y());
   EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
             event.pointer_details.pointer_type);
   EXPECT_EQ(0.f / 1024, event.pointer_details.force);
 }
 
 }  // namespace ui