Replace scoped_ptr with std::unique_ptr in //ui

ui/events/event_processor_unittest.cc

 // Copyright (c) 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 "ui/events/event.h"
-
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/events/event.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/events/event_targeter.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/test/events_test_utils.h"
 #include "ui/events/test/test_event_handler.h"
 #include "ui/events/test/test_event_processor.h"
 #include "ui/events/test/test_event_target.h"
 #include "ui/events/test/test_event_targeter.h"
 
 typedef std::vector<std::string> HandlerSequenceRecorder;
 
 namespace ui {
 namespace test {
 
 class EventProcessorTest : public testing::Test {
  public:
   EventProcessorTest() {}
   ~EventProcessorTest() override {}
 
  protected:
   // testing::Test:
   void SetUp() override {
-    processor_.SetRoot(make_scoped_ptr(new TestEventTarget()));
+    processor_.SetRoot(base::WrapUnique(new TestEventTarget()));
     processor_.Reset();
     root()->SetEventTargeter(
-        make_scoped_ptr(new TestEventTargeter(root(), false)));
+        base::WrapUnique(new TestEventTargeter(root(), false)));
   }
 
   TestEventTarget* root() {
     return static_cast<TestEventTarget*>(processor_.GetRootTarget());
   }
 
   TestEventProcessor* processor() {
     return &processor_;
   }
 
   void DispatchEvent(Event* event) {
     processor_.OnEventFromSource(event);
   }
 
   void SetTarget(TestEventTarget* target) {
     static_cast<TestEventTargeter*>(root()->GetEventTargeter())
         ->set_target(target);
   }
 
  private:
   TestEventProcessor processor_;
 
   DISALLOW_COPY_AND_ASSIGN(EventProcessorTest);
 };
 
 TEST_F(EventProcessorTest, Basic) {
-  scoped_ptr<TestEventTarget> child(new TestEventTarget());
+  std::unique_ptr<TestEventTarget> child(new TestEventTarget());
   child->SetEventTargeter(
-      make_scoped_ptr(new TestEventTargeter(child.get(), false)));
+      base::WrapUnique(new TestEventTargeter(child.get(), false)));
   SetTarget(child.get());
   root()->AddChild(std::move(child));
 
   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
                    EventTimeForNow(), EF_NONE, EF_NONE);
   DispatchEvent(&mouse);
   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 
   SetTarget(root());
@@ skipping 37 matching lines @@
   EventTarget* expected_target_;
 
   DISALLOW_COPY_AND_ASSIGN(ReDispatchEventHandler);
 };
 
 // Verifies that the phase and target information of an event is not mutated
 // as a result of sending the event to an event processor while it is still
 // being processed by another event processor.
 TEST_F(EventProcessorTest, NestedEventProcessing) {
   // Add one child to the default event processor used in this test suite.
-  scoped_ptr<TestEventTarget> child(new TestEventTarget());
+  std::unique_ptr<TestEventTarget> child(new TestEventTarget());
   SetTarget(child.get());
   root()->AddChild(std::move(child));
 
   // Define a second root target and child.
-  scoped_ptr<EventTarget> second_root_scoped(new TestEventTarget());
+  std::unique_ptr<EventTarget> second_root_scoped(new TestEventTarget());
   TestEventTarget* second_root =
       static_cast<TestEventTarget*>(second_root_scoped.get());
-  scoped_ptr<TestEventTarget> second_child(new TestEventTarget());
+  std::unique_ptr<TestEventTarget> second_child(new TestEventTarget());
   second_root->SetEventTargeter(
-      make_scoped_ptr(new TestEventTargeter(second_child.get(), false)));
+      base::WrapUnique(new TestEventTargeter(second_child.get(), false)));
   second_root->AddChild(std::move(second_child));
 
   // Define a second event processor which owns the second root.
-  scoped_ptr<TestEventProcessor> second_processor(new TestEventProcessor());
+  std::unique_ptr<TestEventProcessor> second_processor(
+      new TestEventProcessor());
   second_processor->SetRoot(std::move(second_root_scoped));
 
   // Indicate that an event which is dispatched to the child target owned by the
   // first event processor should be handled by |target_handler| instead.
-  scoped_ptr<TestEventHandler> target_handler(
+  std::unique_ptr<TestEventHandler> target_handler(
       new ReDispatchEventHandler(second_processor.get(), root()->child_at(0)));
   ignore_result(root()->child_at(0)->SetTargetHandler(target_handler.get()));
 
   // Dispatch a mouse event to the tree of event targets owned by the first
   // event processor, checking in ReDispatchEventHandler that the phase and
   // target information of the event is correct.
   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
                    EventTimeForNow(), EF_NONE, EF_NONE);
   DispatchEvent(&mouse);
 
@@ skipping 14 matching lines @@
                     EventTimeForNow(), EF_NONE, EF_NONE);
   DispatchEvent(&mouse2);
   EXPECT_EQ(1, target_handler->num_mouse_events());
   EXPECT_TRUE(second_root->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(mouse2.handled());
 }
 
 // Verifies that OnEventProcessingFinished() is called when an event
 // has been handled.
 TEST_F(EventProcessorTest, OnEventProcessingFinished) {
-  scoped_ptr<TestEventTarget> child(new TestEventTarget());
+  std::unique_ptr<TestEventTarget> child(new TestEventTarget());
   child->set_mark_events_as_handled(true);
   SetTarget(child.get());
   root()->AddChild(std::move(child));
 
   // Dispatch a mouse event. We expect the event to be seen by the target,
   // handled, and we expect OnEventProcessingFinished() to be invoked once.
   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
                    EventTimeForNow(), EF_NONE, EF_NONE);
   DispatchEvent(&mouse);
   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(mouse.handled());
   EXPECT_EQ(1, processor()->num_times_processing_finished());
 }
 
 // Verifies that OnEventProcessingStarted() has been called when starting to
 // process an event, and that processing does not take place if
 // OnEventProcessingStarted() marks the event as handled. Also verifies that
 // OnEventProcessingFinished() is also called in either case.
 TEST_F(EventProcessorTest, OnEventProcessingStarted) {
-  scoped_ptr<TestEventTarget> child(new TestEventTarget());
+  std::unique_ptr<TestEventTarget> child(new TestEventTarget());
   SetTarget(child.get());
   root()->AddChild(std::move(child));
 
   // Dispatch a mouse event. We expect the event to be seen by the target,
   // OnEventProcessingStarted() should be called once, and
   // OnEventProcessingFinished() should be called once. The event should
   // remain unhandled.
   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
                    EventTimeForNow(), EF_NONE, EF_NONE);
   DispatchEvent(&mouse);
@@ skipping 17 matching lines @@
   EXPECT_FALSE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(mouse2.handled());
   EXPECT_EQ(1, processor()->num_times_processing_started());
   EXPECT_EQ(1, processor()->num_times_processing_finished());
 }
 
 // Tests that unhandled events are correctly dispatched to the next-best
 // target as decided by the TestEventTargeter.
 TEST_F(EventProcessorTest, DispatchToNextBestTarget) {
-  scoped_ptr<TestEventTarget> child(new TestEventTarget());
-  scoped_ptr<TestEventTarget> grandchild(new TestEventTarget());
+  std::unique_ptr<TestEventTarget> child(new TestEventTarget());
+  std::unique_ptr<TestEventTarget> grandchild(new TestEventTarget());
 
   // Install a TestEventTargeter which permits bubbling.
   root()->SetEventTargeter(
-      make_scoped_ptr(new TestEventTargeter(grandchild.get(), true)));
+      base::WrapUnique(new TestEventTargeter(grandchild.get(), true)));
   child->AddChild(std::move(grandchild));
   root()->AddChild(std::move(child));
 
   ASSERT_EQ(1u, root()->child_count());
   ASSERT_EQ(1u, root()->child_at(0)->child_count());
   ASSERT_EQ(0u, root()->child_at(0)->child_at(0)->child_count());
 
   TestEventTarget* child_r = root()->child_at(0);
   TestEventTarget* grandchild_r = child_r->child_at(0);
 
@@ skipping 48 matching lines @@
   root()->ResetReceivedEvents();
   child_r->ResetReceivedEvents();
   grandchild_r->ResetReceivedEvents();
   child_r->set_mark_events_as_handled(false);
 }
 
 // Tests that unhandled events are seen by the correct sequence of
 // targets, pre-target handlers, and post-target handlers when
 // a TestEventTargeter is installed on the root target which permits bubbling.
 TEST_F(EventProcessorTest, HandlerSequence) {
-  scoped_ptr<TestEventTarget> child(new TestEventTarget());
-  scoped_ptr<TestEventTarget> grandchild(new TestEventTarget());
+  std::unique_ptr<TestEventTarget> child(new TestEventTarget());
+  std::unique_ptr<TestEventTarget> grandchild(new TestEventTarget());
 
   // Install a TestEventTargeter which permits bubbling.
   root()->SetEventTargeter(
-      make_scoped_ptr(new TestEventTargeter(grandchild.get(), true)));
+      base::WrapUnique(new TestEventTargeter(grandchild.get(), true)));
   child->AddChild(std::move(grandchild));
   root()->AddChild(std::move(child));
 
   ASSERT_EQ(1u, root()->child_count());
   ASSERT_EQ(1u, root()->child_at(0)->child_count());
   ASSERT_EQ(0u, root()->child_at(0)->child_at(0)->child_count());
 
   TestEventTarget* child_r = root()->child_at(0);
   TestEventTarget* grandchild_r = child_r->child_at(0);
 
@@ skipping 40 matching lines @@
   DispatchEvent(&mouse);
 
   std::string expected[] = { "PreR", "PreC", "PreG", "G", "PostG", "PostC",
       "PostR", "PreR", "PreC", "C", "PostC", "PostR", "PreR", "R", "PostR" };
   EXPECT_EQ(std::vector<std::string>(
       expected, expected + arraysize(expected)), recorder);
 }
 
 }  // namespace test
 }  // namespace ui