Replace scoped_ptr with std::unique_ptr in //ui

ui/events/event_unittest.cc

 // Copyright (c) 2012 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/event.h"
+
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/test/events_test_utils.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #include "ui/events/test/events_test_utils_x11.h"
 #include "ui/gfx/x/x11_types.h"  // nogncheck
 #endif
@@ skipping 99 matching lines @@
   EXPECT_FALSE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2));
 }
 
 // Tests that an event only increases the click count and gets marked as a
 // double click if a release event was seen for the previous click. This
 // prevents the same PRESSED event from being processed twice:
 // http://crbug.com/389162
 TEST(EventTest, DoubleClickRequiresRelease) {
   const gfx::Point origin1(0, 0);
   const gfx::Point origin2(100, 0);
-  scoped_ptr<MouseEvent> ev;
+  std::unique_ptr<MouseEvent> ev;
   base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
   base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1);
 
   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin1, origin1, EventTimeForNow(),
                           0, 0));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin1, origin1, EventTimeForNow(),
                           0, 0));
   ev->set_time_stamp(start);
@@ skipping 15 matching lines @@
                           EventTimeForNow(), 0, 0));
   ev->set_time_stamp(soon);
   EXPECT_EQ(2, MouseEvent::GetRepeatCount(*ev));
   MouseEvent::ResetLastClickForTest();
 }
 
 // Tests that clicking right and then left clicking does not generate a double
 // click.
 TEST(EventTest, SingleClickRightLeft) {
   const gfx::Point origin(0, 0);
-  scoped_ptr<MouseEvent> ev;
+  std::unique_ptr<MouseEvent> ev;
   base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
   base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1);
 
   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(),
                           ui::EF_RIGHT_MOUSE_BUTTON,
                           ui::EF_RIGHT_MOUSE_BUTTON));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(),
                           ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
@@ skipping 167 matching lines @@
   {
     KeyEvent keyev(ET_KEY_RELEASED, VKEY_MENU, EF_ALT_DOWN);
     EXPECT_EQ(EF_ALT_DOWN, keyev.flags());
     keyev.NormalizeFlags();
     EXPECT_EQ(EF_NONE, keyev.flags());
   }
 }
 
 TEST(EventTest, KeyEventCopy) {
   KeyEvent key(ET_KEY_PRESSED, VKEY_A, EF_NONE);
-  scoped_ptr<KeyEvent> copied_key(new KeyEvent(key));
+  std::unique_ptr<KeyEvent> copied_key(new KeyEvent(key));
   EXPECT_EQ(copied_key->type(), key.type());
   EXPECT_EQ(copied_key->key_code(), key.key_code());
 }
 
 TEST(EventTest, KeyEventCode) {
   const DomCode kDomCodeForSpace = DomCode::SPACE;
   const char kCodeForSpace[] = "Space";
   ASSERT_EQ(kDomCodeForSpace,
             ui::KeycodeConverter::CodeStringToDomCode(kCodeForSpace));
   const uint16_t kNativeCodeSpace =
@@ skipping 479 matching lines @@
   ui::PointerEvent pointer_event_from_mouse(mouse_event);
   EXPECT_EQ(mouse_event.pointer_details(),
             pointer_event_from_mouse.pointer_details());
 }
 
 TEST(EventTest, PointerEventClone) {
   {
     ui::PointerEvent ptr_event(
         ui::TouchEvent(ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0,
                        ui::EventTimeForNow(), 10.0f, 5.0f, 0.0f, 15.0f));
-    scoped_ptr<ui::Event> clone(ui::Event::Clone(ptr_event));
+    std::unique_ptr<ui::Event> clone(ui::Event::Clone(ptr_event));
     EXPECT_TRUE(clone->IsPointerEvent());
     ui::PointerEvent* clone_as_ptr = clone->AsPointerEvent();
 
     EXPECT_EQ(ptr_event.type(), clone_as_ptr->type());
     EXPECT_EQ(ptr_event.pointer_id(), clone_as_ptr->pointer_id());
     EXPECT_EQ(ptr_event.pointer_details(), clone_as_ptr->pointer_details());
     EXPECT_EQ(ptr_event.location(), clone_as_ptr->location());
     EXPECT_EQ(ptr_event.root_location(), clone_as_ptr->root_location());
   }
 
   {
     ui::PointerEvent ptr_event(
         ui::MouseEvent(ET_MOUSE_PRESSED, gfx::Point(0, 0), gfx::Point(0, 0),
                        ui::EventTimeForNow(), 0, 0));
-    scoped_ptr<ui::Event> clone(ui::Event::Clone(ptr_event));
+    std::unique_ptr<ui::Event> clone(ui::Event::Clone(ptr_event));
     EXPECT_TRUE(clone->IsPointerEvent());
     ui::PointerEvent* clone_as_ptr = clone->AsPointerEvent();
 
     EXPECT_EQ(ptr_event.type(), clone_as_ptr->type());
     EXPECT_EQ(ptr_event.pointer_id(), clone_as_ptr->pointer_id());
     EXPECT_EQ(ptr_event.pointer_details(), clone_as_ptr->pointer_details());
     EXPECT_EQ(ptr_event.location(), clone_as_ptr->location());
     EXPECT_EQ(ptr_event.root_location(), clone_as_ptr->root_location());
   }
 }
 
 }  // namespace ui