Convert //components/mus from scoped_ptr to std::unique_ptr

components/mus/ws/event_dispatcher_unittest.cc

 // Copyright 2015 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 "components/mus/ws/event_dispatcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 15 matching lines @@
 namespace test {
 namespace {
 
 // Identifies a generated event.
 struct DispatchedEventDetails {
   DispatchedEventDetails()
       : window(nullptr), in_nonclient_area(false), accelerator(nullptr) {}
 
   ServerWindow* window;
   bool in_nonclient_area;
-  scoped_ptr<ui::Event> event;
+  std::unique_ptr<ui::Event> event;
   Accelerator* accelerator;
 };
 
 class TestEventDispatcherDelegate : public EventDispatcherDelegate {
  public:
   explicit TestEventDispatcherDelegate(ServerWindow* root)
       : root_(root),
         focused_window_(nullptr),
         lost_capture_window_(nullptr),
         last_accelerator_(0) {}
   ~TestEventDispatcherDelegate() override {}
 
   uint32_t GetAndClearLastAccelerator() {
     uint32_t return_value = last_accelerator_;
     last_accelerator_ = 0;
     return return_value;
   }
 
   // Returns the last dispatched event, or null if there are no more.
-  scoped_ptr<DispatchedEventDetails> GetAndAdvanceDispatchedEventDetails() {
+  std::unique_ptr<DispatchedEventDetails>
+  GetAndAdvanceDispatchedEventDetails() {
     if (dispatched_event_queue_.empty())
       return nullptr;
 
-    scoped_ptr<DispatchedEventDetails> details =
+    std::unique_ptr<DispatchedEventDetails> details =
         std::move(dispatched_event_queue_.front());
     dispatched_event_queue_.pop();
     return details;
   }
 
   ServerWindow* GetAndClearLastFocusedWindow() {
     ServerWindow* result = focused_window_;
     focused_window_ = nullptr;
     return result;
   }
@@ skipping 17 matching lines @@
   }
   void SetNativeCapture() override {}
   void ReleaseNativeCapture() override {}
   void OnServerWindowCaptureLost(ServerWindow* window) override {
     lost_capture_window_ = window;
   }
   void DispatchInputEventToWindow(ServerWindow* target,
                                   bool in_nonclient_area,
                                   const ui::Event& event,
                                   Accelerator* accelerator) override {
-    scoped_ptr<DispatchedEventDetails> details(new DispatchedEventDetails);
+    std::unique_ptr<DispatchedEventDetails> details(new DispatchedEventDetails);
     details->window = target;
     details->in_nonclient_area = in_nonclient_area;
     details->event = ui::Event::Clone(event);
     details->accelerator = accelerator;
     dispatched_event_queue_.push(std::move(details));
   }
 
   ServerWindow* root_;
   ServerWindow* focused_window_;
   ServerWindow* lost_capture_window_;
   uint32_t last_accelerator_;
-  std::queue<scoped_ptr<DispatchedEventDetails>> dispatched_event_queue_;
+  std::queue<std::unique_ptr<DispatchedEventDetails>> dispatched_event_queue_;
 
   DISALLOW_COPY_AND_ASSIGN(TestEventDispatcherDelegate);
 };
 
 // Used by RunMouseEventTests(). Can identify up to two generated events. The
 // first ServerWindow and two points identify the first event, the second
 // ServerWindow and points identify the second event. If only one event is
 // generated set the second window to null.
 struct MouseEventTest {
   ui::MouseEvent input_event;
@@ skipping 29 matching lines @@
                         size_t test_count) {
   for (size_t i = 0; i < test_count; ++i) {
     const MouseEventTest& test = tests[i];
     ASSERT_FALSE(dispatcher_delegate->has_queued_events())
         << " unexpected queued events before running " << i;
     if (test.input_event.IsMouseWheelEvent())
       dispatcher->ProcessEvent(test.input_event);
     else
       dispatcher->ProcessEvent(ui::PointerEvent(test.input_event));
 
-    scoped_ptr<DispatchedEventDetails> details =
+    std::unique_ptr<DispatchedEventDetails> details =
         dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
     ASSERT_NO_FATAL_FAILURE(ExpectDispatchedEventDetailsMatches(
         details.get(), test.expected_target_window1,
         test.expected_root_location1, test.expected_location1))
         << " details don't match " << i;
     details = dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
     ASSERT_NO_FATAL_FAILURE(ExpectDispatchedEventDetailsMatches(
         details.get(), test.expected_target_window2,
         test.expected_root_location2, test.expected_location2))
         << " details2 don't match " << i;
@@ skipping 14 matching lines @@
 
   ServerWindow* root_window() { return root_window_.get(); }
   TestEventDispatcherDelegate* test_event_dispatcher_delegate() {
     return test_event_dispatcher_delegate_.get();
   }
   EventDispatcher* event_dispatcher() { return event_dispatcher_.get(); }
 
   bool AreAnyPointersDown() const;
   // Deletes everything created during SetUp()
   void ClearSetup();
-  scoped_ptr<ServerWindow> CreateChildWindowWithParent(const WindowId& id,
-                                                       ServerWindow* parent);
+  std::unique_ptr<ServerWindow> CreateChildWindowWithParent(
+      const WindowId& id,
+      ServerWindow* parent);
   // Creates a window which is a child of |root_window_|.
-  scoped_ptr<ServerWindow> CreateChildWindow(const WindowId& id);
+  std::unique_ptr<ServerWindow> CreateChildWindow(const WindowId& id);
   bool IsMouseButtonDown() const;
   bool IsWindowPointerTarget(ServerWindow* window) const;
   int NumberPointerTargetsForWindow(ServerWindow* window) const;
 
  protected:
   // testing::Test:
   void SetUp() override;
 
  private:
-  scoped_ptr<TestServerWindowDelegate> window_delegate_;
-  scoped_ptr<ServerWindow> root_window_;
-  scoped_ptr<TestEventDispatcherDelegate> test_event_dispatcher_delegate_;
-  scoped_ptr<EventDispatcher> event_dispatcher_;
+  std::unique_ptr<TestServerWindowDelegate> window_delegate_;
+  std::unique_ptr<ServerWindow> root_window_;
+  std::unique_ptr<TestEventDispatcherDelegate> test_event_dispatcher_delegate_;
+  std::unique_ptr<EventDispatcher> event_dispatcher_;
 
   DISALLOW_COPY_AND_ASSIGN(EventDispatcherTest);
 };
 
 bool EventDispatcherTest::AreAnyPointersDown() const {
   return EventDispatcherTestApi(event_dispatcher_.get()).AreAnyPointersDown();
 }
 
 void EventDispatcherTest::ClearSetup() {
   window_delegate_.reset();
   root_window_.reset();
   test_event_dispatcher_delegate_.reset();
   event_dispatcher_.reset();
 }
 
-scoped_ptr<ServerWindow> EventDispatcherTest::CreateChildWindowWithParent(
+std::unique_ptr<ServerWindow> EventDispatcherTest::CreateChildWindowWithParent(
     const WindowId& id,
     ServerWindow* parent) {
-  scoped_ptr<ServerWindow> child(new ServerWindow(window_delegate_.get(), id));
+  std::unique_ptr<ServerWindow> child(
+      new ServerWindow(window_delegate_.get(), id));
   parent->Add(child.get());
   child->SetVisible(true);
   EnableHitTest(child.get());
   return child;
 }
 
-scoped_ptr<ServerWindow> EventDispatcherTest::CreateChildWindow(
+std::unique_ptr<ServerWindow> EventDispatcherTest::CreateChildWindow(
     const WindowId& id) {
   return CreateChildWindowWithParent(id, root_window_.get());
 }
 
 bool EventDispatcherTest::IsMouseButtonDown() const {
   return EventDispatcherTestApi(event_dispatcher_.get()).is_mouse_button_down();
 }
 
 bool EventDispatcherTest::IsWindowPointerTarget(ServerWindow* window) const {
   return EventDispatcherTestApi(event_dispatcher_.get())
@@ skipping 15 matching lines @@
   root_window_->SetVisible(true);
 
   test_event_dispatcher_delegate_.reset(
       new TestEventDispatcherDelegate(root_window_.get()));
   event_dispatcher_.reset(
       new EventDispatcher(test_event_dispatcher_delegate_.get()));
   event_dispatcher_->set_root(root_window_.get());
 }
 
 TEST_F(EventDispatcherTest, ProcessEvent) {
-  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   // Send event that is over child.
   const ui::PointerEvent ui_event(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(20, 25), gfx::Point(20, 25),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(ui_event);
 
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
   ASSERT_TRUE(details);
   ASSERT_EQ(child.get(), details->window);
 
   ASSERT_TRUE(details->event);
   ASSERT_TRUE(details->event->IsPointerEvent());
 
   ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
   EXPECT_EQ(gfx::Point(20, 25), dispatched_event->root_location());
   EXPECT_EQ(gfx::Point(10, 15), dispatched_event->location());
@@ skipping 87 matching lines @@
       mus::mojom::KeyboardCode::W, mus::mojom::kEventFlagControlDown);
   matcher->accelerator_phase = mojom::AcceleratorPhase::POST_TARGET;
   uint32_t accelerator_1 = 1;
   dispatcher->AddAccelerator(accelerator_1, std::move(matcher));
 
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
   // The post-target accelerator should be fired if there is no focused window.
   dispatcher->ProcessEvent(key);
   EXPECT_EQ(accelerator_1,
             event_dispatcher_delegate->GetAndClearLastAccelerator());
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(details);
 
   // Set focused window for EventDispatcher dispatches key events.
-  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
   event_dispatcher_delegate->SetFocusedWindowFromEventDispatcher(child.get());
 
   // With a focused window the event should be dispatched.
   dispatcher->ProcessEvent(key);
   EXPECT_EQ(0u, event_dispatcher_delegate->GetAndClearLastAccelerator());
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_TRUE(details);
   EXPECT_TRUE(details->accelerator);
 
   base::WeakPtr<Accelerator> accelerator_weak_ptr =
       details->accelerator->GetWeakPtr();
   dispatcher->RemoveAccelerator(accelerator_1);
   EXPECT_FALSE(accelerator_weak_ptr);
 
   // Post deletion there should be no accelerator
   dispatcher->ProcessEvent(key);
   EXPECT_EQ(0u, event_dispatcher_delegate->GetAndClearLastAccelerator());
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_TRUE(details);
   EXPECT_FALSE(details->accelerator);
 }
 
 TEST_F(EventDispatcherTest, Capture) {
   ServerWindow* root = root_window();
-  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   MouseEventTest tests[] = {
       // Send a mouse down event over child.
       {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(20, 25),
                       gfx::Point(20, 25), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        child.get(), gfx::Point(20, 25), gfx::Point(10, 15), nullptr,
@@ skipping 21 matching lines @@
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        child.get(), gfx::Point(50, 50), gfx::Point(40, 40), root,
        gfx::Point(50, 50), gfx::Point(50, 50)},
 
   };
   RunMouseEventTests(event_dispatcher(), test_event_dispatcher_delegate(),
                      tests, arraysize(tests));
 }
 
 TEST_F(EventDispatcherTest, CaptureMultipleMouseButtons) {
-  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   MouseEventTest tests[] = {
       // Send a mouse down event over child with a left mouse button
       {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(20, 25),
                       gfx::Point(20, 25), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        child.get(), gfx::Point(20, 25), gfx::Point(10, 15), nullptr,
@@ skipping 22 matching lines @@
                       ui::EF_LEFT_MOUSE_BUTTON, 0),
        child.get(), gfx::Point(50, 50), gfx::Point(40, 40), nullptr,
        gfx::Point(), gfx::Point()},
 
   };
   RunMouseEventTests(event_dispatcher(), test_event_dispatcher_delegate(),
                      tests, arraysize(tests));
 }
 
 TEST_F(EventDispatcherTest, ClientAreaGoesToOwner) {
-  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   child->SetClientArea(gfx::Insets(5, 5, 5, 5), std::vector<gfx::Rect>());
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Start move loop by sending mouse event over non-client area.
   const ui::PointerEvent press_event(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(12, 12), gfx::Point(12, 12),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   dispatcher->ProcessEvent(press_event);
 
   // Events should target child and be in the non-client area.
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   ASSERT_TRUE(details);
   ASSERT_EQ(child.get(), details->window);
   EXPECT_TRUE(details->in_nonclient_area);
 
   // Move the mouse 5,6 pixels and target is the same.
   const ui::PointerEvent move_event(
       ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(17, 18), gfx::Point(17, 18),
                      base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, 0));
@@ skipping 30 matching lines @@
   EXPECT_EQ(ui::ET_POINTER_EXITED, details->event->type());
 
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   ASSERT_EQ(child.get(), details->window);
   EXPECT_FALSE(details->in_nonclient_area);
   EXPECT_EQ(ui::ET_POINTER_DOWN, details->event->type());
 }
 
 TEST_F(EventDispatcherTest, AdditionalClientArea) {
-  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   std::vector<gfx::Rect> additional_client_areas;
   additional_client_areas.push_back(gfx::Rect(18, 0, 2, 2));
   child->SetClientArea(gfx::Insets(5, 5, 5, 5), additional_client_areas);
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   // Press in the additional client area, it should go to the child.
   const ui::PointerEvent press_event(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(28, 11), gfx::Point(28, 11),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(press_event);
 
   // Events should target child and be in the client area.
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   ASSERT_EQ(child.get(), details->window);
   EXPECT_FALSE(details->in_nonclient_area);
 }
 
 TEST_F(EventDispatcherTest, DontFocusOnSecondDown) {
-  scoped_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
-  scoped_ptr<ServerWindow> child2 = CreateChildWindow(WindowId(1, 4));
+  std::unique_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child2 = CreateChildWindow(WindowId(1, 4));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child1->SetBounds(gfx::Rect(10, 10, 20, 20));
   child2->SetBounds(gfx::Rect(50, 51, 11, 12));
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Press on child1. First press event should change focus.
   const ui::PointerEvent press_event(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(12, 12), gfx::Point(12, 12),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   dispatcher->ProcessEvent(press_event);
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   EXPECT_EQ(child1.get(), details->window);
   EXPECT_EQ(child1.get(),
             event_dispatcher_delegate->GetAndClearLastFocusedWindow());
 
   // Press (with a different pointer id) on child2. Event should go to child2,
   // but focus should not change.
   const ui::PointerEvent touch_event(ui::TouchEvent(
       ui::ET_TOUCH_PRESSED, gfx::Point(53, 54), 2, base::TimeDelta()));
   dispatcher->ProcessEvent(touch_event);
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   EXPECT_EQ(child2.get(), details->window);
   EXPECT_EQ(nullptr, event_dispatcher_delegate->GetAndClearLastFocusedWindow());
 }
 
 TEST_F(EventDispatcherTest, TwoPointersActive) {
-  scoped_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
-  scoped_ptr<ServerWindow> child2 = CreateChildWindow(WindowId(1, 4));
+  std::unique_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child2 = CreateChildWindow(WindowId(1, 4));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child1->SetBounds(gfx::Rect(10, 10, 20, 20));
   child2->SetBounds(gfx::Rect(50, 51, 11, 12));
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Press on child1.
   const ui::PointerEvent touch_event1(ui::TouchEvent(
       ui::ET_TOUCH_PRESSED, gfx::Point(12, 13), 1, base::TimeDelta()));
   dispatcher->ProcessEvent(touch_event1);
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_EQ(child1.get(), details->window);
 
   // Drag over child2, child1 should get the drag.
   const ui::PointerEvent drag_event1(ui::TouchEvent(
       ui::ET_TOUCH_MOVED, gfx::Point(53, 54), 1, base::TimeDelta()));
   dispatcher->ProcessEvent(drag_event1);
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_EQ(child1.get(), details->window);
 
@@ skipping 23 matching lines @@
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_EQ(child1.get(), details->window);
   const ui::PointerEvent touch_event3(ui::TouchEvent(
       ui::ET_TOUCH_PRESSED, gfx::Point(54, 55), 2, base::TimeDelta()));
   dispatcher->ProcessEvent(touch_event3);
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_EQ(child2.get(), details->window);
 }
 
 TEST_F(EventDispatcherTest, DestroyWindowWhileGettingEvents) {
-  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Press on child.
   const ui::PointerEvent touch_event1(ui::TouchEvent(
       ui::ET_TOUCH_PRESSED, gfx::Point(12, 13), 1, base::TimeDelta()));
   dispatcher->ProcessEvent(touch_event1);
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   EXPECT_EQ(child.get(), details->window);
 
   // Delete child, and continue the drag. Event should not be dispatched.
   child.reset();
 
   const ui::PointerEvent drag_event1(ui::TouchEvent(
       ui::ET_TOUCH_MOVED, gfx::Point(53, 54), 1, base::TimeDelta()));
   dispatcher->ProcessEvent(drag_event1);
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_EQ(nullptr, details.get());
 }
 
 TEST_F(EventDispatcherTest, MouseInExtendedHitTestRegion) {
   ServerWindow* root = root_window();
-  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Send event that is not over child.
   const ui::PointerEvent ui_event(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(8, 9), gfx::Point(8, 9),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   dispatcher->ProcessEvent(ui_event);
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   ASSERT_EQ(root, details->window);
 
   // Release the mouse.
   const ui::PointerEvent release_event(ui::MouseEvent(
       ui::ET_MOUSE_RELEASED, gfx::Point(8, 9), gfx::Point(8, 9),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   dispatcher->ProcessEvent(release_event);
   details = event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
@@ skipping 13 matching lines @@
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   EXPECT_TRUE(details->in_nonclient_area);
   ASSERT_EQ(child.get(), details->window);
   EXPECT_EQ(ui::ET_POINTER_DOWN, details->event->type());
   ASSERT_TRUE(details->event.get());
   ASSERT_TRUE(details->event->IsPointerEvent());
   EXPECT_EQ(gfx::Point(-2, -1), details->event->AsPointerEvent()->location());
 }
 
 TEST_F(EventDispatcherTest, WheelWhileDown) {
-  scoped_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
-  scoped_ptr<ServerWindow> child2 = CreateChildWindow(WindowId(1, 4));
+  std::unique_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child2 = CreateChildWindow(WindowId(1, 4));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child1->SetBounds(gfx::Rect(10, 10, 20, 20));
   child2->SetBounds(gfx::Rect(50, 51, 11, 12));
 
   MouseEventTest tests[] = {
       // Send a mouse down event over child1.
       {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(15, 15),
                       gfx::Point(15, 15), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        child1.get(), gfx::Point(15, 15), gfx::Point(5, 5), nullptr,
        gfx::Point(), gfx::Point()},
       // Send mouse wheel over child2, should go to child1 as it has capture.
       {ui::MouseWheelEvent(gfx::Vector2d(1, 0), gfx::Point(53, 54),
                            gfx::Point(53, 54), base::TimeDelta(), ui::EF_NONE,
                            ui::EF_NONE),
        child1.get(), gfx::Point(53, 54), gfx::Point(43, 44), nullptr,
        gfx::Point(), gfx::Point()},
   };
   RunMouseEventTests(event_dispatcher(), test_event_dispatcher_delegate(),
                      tests, arraysize(tests));
 }
 
 // Tests that when explicit capture has been set that all events go to the
 // designated window, and that when capture is cleared, events find the
 // appropriate target window.
 TEST_F(EventDispatcherTest, SetExplicitCapture) {
   ServerWindow* root = root_window();
-  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   {
     // Send all pointer events to the child.
     dispatcher->SetCaptureWindow(child.get(), false);
 
     // The mouse press should go to the child even though its outside its
     // bounds.
     const ui::PointerEvent left_press_event(ui::MouseEvent(
         ui::ET_MOUSE_PRESSED, gfx::Point(5, 5), gfx::Point(5, 5),
         base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
     dispatcher->ProcessEvent(left_press_event);
 
     // Events should target child.
-    scoped_ptr<DispatchedEventDetails> details =
+    std::unique_ptr<DispatchedEventDetails> details =
         event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
 
     ASSERT_TRUE(details);
     ASSERT_EQ(child.get(), details->window);
     EXPECT_FALSE(details->in_nonclient_area);
     EXPECT_TRUE(IsMouseButtonDown());
 
     // The mouse down state should update while capture is set.
     const ui::PointerEvent right_press_event(ui::MouseEvent(
         ui::ET_MOUSE_PRESSED, gfx::Point(5, 5), gfx::Point(5, 5),
@@ skipping 40 matching lines @@
 
   {
     // Releasing capture and sending the same event will go to the root.
     dispatcher->SetCaptureWindow(nullptr, false);
     const ui::PointerEvent press_event(ui::MouseEvent(
         ui::ET_MOUSE_PRESSED, gfx::Point(5, 5), gfx::Point(5, 5),
         base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
     dispatcher->ProcessEvent(press_event);
 
     // Events should target the root.
-    scoped_ptr<DispatchedEventDetails> details =
+    std::unique_ptr<DispatchedEventDetails> details =
         event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
 
     ASSERT_TRUE(details);
     ASSERT_EQ(root, details->window);
   }
 }
 
 // This test verifies that explicit capture overrides and resets implicit
 // capture.
 TEST_F(EventDispatcherTest, ExplicitCaptureOverridesImplicitCapture) {
   ServerWindow* root = root_window();
-  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   EventDispatcher* dispatcher = event_dispatcher();
 
   // Run some implicit capture tests.
   MouseEventTest tests[] = {
@@ skipping 25 matching lines @@
   RunMouseEventTests(dispatcher, event_dispatcher_delegate, tests,
                      arraysize(tests));
 
   // Add a second pointer target to the child.
   {
     const ui::PointerEvent touch_event(ui::TouchEvent(
         ui::ET_TOUCH_PRESSED, gfx::Point(12, 13), 1, base::TimeDelta()));
     dispatcher->ProcessEvent(touch_event);
   }
 
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   EXPECT_EQ(child.get(), details->window);
 
   // Verify that no window has explicit capture and hence we did indeed do
   // implicit capture.
   ASSERT_EQ(nullptr, dispatcher->capture_window());
 
   // Give the root window explicit capture and verify input events over the
   // child go to the root instead.
@@ skipping 30 matching lines @@
   ServerWindow* root = root_window();
   root->SetBounds(gfx::Rect(0, 0, 100, 100));
 
   EventDispatcher* dispatcher = event_dispatcher();
   {
     const ui::PointerEvent press_event(ui::MouseEvent(
         ui::ET_MOUSE_PRESSED, gfx::Point(5, 5), gfx::Point(5, 5),
         base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
     dispatcher->ProcessEvent(press_event);
 
-    scoped_ptr<DispatchedEventDetails> details =
+    std::unique_ptr<DispatchedEventDetails> details =
         test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
     ASSERT_TRUE(details);
     ASSERT_EQ(root, details->window);
   }
   {
     const ui::PointerEvent touch_event(ui::TouchEvent(
         ui::ET_TOUCH_PRESSED, gfx::Point(12, 13), 1, base::TimeDelta()));
     dispatcher->ProcessEvent(touch_event);
   }
 
   ASSERT_TRUE(AreAnyPointersDown());
   ASSERT_TRUE(IsWindowPointerTarget(root));
   EXPECT_EQ(2, NumberPointerTargetsForWindow(root));
 
   // Setting the capture should clear the implicit pointers for the specified
   // window.
   dispatcher->SetCaptureWindow(root, true);
   EXPECT_FALSE(AreAnyPointersDown());
   EXPECT_FALSE(IsWindowPointerTarget(root));
 }
 
 // Tests that when explicit capture is changed, that the previous window with
 // capture is no longer being observed.
 TEST_F(EventDispatcherTest, UpdatingCaptureStopsObservingPreviousCapture) {
-  scoped_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
-  scoped_ptr<ServerWindow> child2 = CreateChildWindow(WindowId(1, 4));
+  std::unique_ptr<ServerWindow> child1 = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child2 = CreateChildWindow(WindowId(1, 4));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child1->SetBounds(gfx::Rect(10, 10, 20, 20));
   child2->SetBounds(gfx::Rect(50, 51, 11, 12));
 
   EventDispatcher* dispatcher = event_dispatcher();
   ASSERT_FALSE(AreAnyPointersDown());
   ASSERT_FALSE(IsWindowPointerTarget(child1.get()));
   ASSERT_FALSE(IsWindowPointerTarget(child2.get()));
   dispatcher->SetCaptureWindow(child1.get(), false);
   dispatcher->SetCaptureWindow(child2.get(), false);
   EXPECT_EQ(child1.get(),
             test_event_dispatcher_delegate()->lost_capture_window());
 
   // If observing does not stop during the capture update this crashes.
   child1->AddObserver(dispatcher);
 }
 
 // Tests that destroying a window with explicit capture clears the capture
 // state.
 TEST_F(EventDispatcherTest, DestroyingCaptureWindowRemovesExplicitCapture) {
-  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   EventDispatcher* dispatcher = event_dispatcher();
   dispatcher->SetCaptureWindow(child.get(), false);
   EXPECT_EQ(child.get(), dispatcher->capture_window());
 
   ServerWindow* lost_capture_window = child.get();
   child.reset();
   EXPECT_EQ(nullptr, dispatcher->capture_window());
   EXPECT_EQ(lost_capture_window,
@@ skipping 13 matching lines @@
 
   TestEventDispatcherDelegate* event_dispatcher_delegate =
       test_event_dispatcher_delegate();
   // Press in the client area, it should be marked as non client.
   const ui::PointerEvent press_event(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(6, 6), gfx::Point(6, 6),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(press_event);
 
   // Events should target child and be in the client area.
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       event_dispatcher_delegate->GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate->has_queued_events());
   ASSERT_EQ(root, details->window);
   EXPECT_TRUE(details->in_nonclient_area);
 }
 
 TEST_F(EventDispatcherTest, ProcessPointerEvents) {
-  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   {
     const ui::PointerEvent pointer_event(ui::MouseEvent(
         ui::ET_MOUSE_PRESSED, gfx::Point(20, 25), gfx::Point(20, 25),
         base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
     event_dispatcher()->ProcessEvent(pointer_event);
 
-    scoped_ptr<DispatchedEventDetails> details =
+    std::unique_ptr<DispatchedEventDetails> details =
         test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
     ASSERT_TRUE(details);
     ASSERT_EQ(child.get(), details->window);
 
     ASSERT_TRUE(details->event);
     ASSERT_TRUE(details->event->IsPointerEvent());
 
     ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
     EXPECT_EQ(gfx::Point(20, 25), dispatched_event->root_location());
     EXPECT_EQ(gfx::Point(10, 15), dispatched_event->location());
   }
 
   {
     const int touch_id = 3;
     const ui::PointerEvent pointer_event(
         ui::TouchEvent(ui::ET_TOUCH_RELEASED, gfx::Point(25, 20), touch_id,
                        base::TimeDelta()));
     event_dispatcher()->ProcessEvent(pointer_event);
 
-    scoped_ptr<DispatchedEventDetails> details =
+    std::unique_ptr<DispatchedEventDetails> details =
         test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
     ASSERT_TRUE(details);
     ASSERT_EQ(child.get(), details->window);
 
     ASSERT_TRUE(details->event);
     ASSERT_TRUE(details->event->IsPointerEvent());
 
     ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
     EXPECT_EQ(gfx::Point(25, 20), dispatched_event->root_location());
     EXPECT_EQ(gfx::Point(15, 10), dispatched_event->location());
     EXPECT_EQ(touch_id, dispatched_event->pointer_id());
   }
 }
 
 TEST_F(EventDispatcherTest, ResetClearsPointerDown) {
-  scoped_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   // Send event that is over child.
   const ui::PointerEvent ui_event(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(20, 25), gfx::Point(20, 25),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(ui_event);
 
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
   ASSERT_TRUE(details);
   ASSERT_EQ(child.get(), details->window);
 
   EXPECT_TRUE(AreAnyPointersDown());
 
   event_dispatcher()->Reset();
   EXPECT_FALSE(test_event_dispatcher_delegate()->has_queued_events());
   EXPECT_FALSE(AreAnyPointersDown());
 }
 
 TEST_F(EventDispatcherTest, ResetClearsCapture) {
   ServerWindow* root = root_window();
   root->SetBounds(gfx::Rect(0, 0, 100, 100));
 
   root->SetClientArea(gfx::Insets(5, 5, 5, 5), std::vector<gfx::Rect>());
   EventDispatcher* dispatcher = event_dispatcher();
   dispatcher->SetCaptureWindow(root, true);
 
   event_dispatcher()->Reset();
   EXPECT_FALSE(test_event_dispatcher_delegate()->has_queued_events());
   EXPECT_EQ(nullptr, event_dispatcher()->capture_window());
 }
 
 // Tests that events on a modal parent target the modal child.
 TEST_F(EventDispatcherTest, ModalWindowEventOnModalParent) {
-  scoped_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
-  scoped_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
+  std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   w1->SetBounds(gfx::Rect(10, 10, 30, 30));
   w2->SetBounds(gfx::Rect(50, 10, 10, 10));
 
   w1->AddTransientWindow(w2.get());
   w2->SetModal();
 
   // Send event that is over |w1|.
   const ui::PointerEvent mouse_pressed(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(15, 15), gfx::Point(15, 15),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(mouse_pressed);
 
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
   ASSERT_TRUE(details);
   EXPECT_EQ(w2.get(), details->window);
   EXPECT_TRUE(details->in_nonclient_area);
 
   ASSERT_TRUE(details->event);
   ASSERT_TRUE(details->event->IsPointerEvent());
 
   ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
   EXPECT_EQ(gfx::Point(15, 15), dispatched_event->root_location());
   EXPECT_EQ(gfx::Point(-35, 5), dispatched_event->location());
 }
 
 // Tests that events on a modal child target the modal child itself.
 TEST_F(EventDispatcherTest, ModalWindowEventOnModalChild) {
-  scoped_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
-  scoped_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
+  std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   w1->SetBounds(gfx::Rect(10, 10, 30, 30));
   w2->SetBounds(gfx::Rect(50, 10, 10, 10));
 
   w1->AddTransientWindow(w2.get());
   w2->SetModal();
 
   // Send event that is over |w2|.
   const ui::PointerEvent mouse_pressed(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(55, 15), gfx::Point(55, 15),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(mouse_pressed);
 
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
   ASSERT_TRUE(details);
   EXPECT_EQ(w2.get(), details->window);
   EXPECT_FALSE(details->in_nonclient_area);
 
   ASSERT_TRUE(details->event);
   ASSERT_TRUE(details->event->IsPointerEvent());
 
   ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
   EXPECT_EQ(gfx::Point(55, 15), dispatched_event->root_location());
   EXPECT_EQ(gfx::Point(5, 5), dispatched_event->location());
 }
 
 // Tests that events on an unrelated window are not affected by the modal
 // window.
 TEST_F(EventDispatcherTest, ModalWindowEventOnUnrelatedWindow) {
-  scoped_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
-  scoped_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
-  scoped_ptr<ServerWindow> w3 = CreateChildWindow(WindowId(1, 6));
+  std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
+  std::unique_ptr<ServerWindow> w3 = CreateChildWindow(WindowId(1, 6));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   w1->SetBounds(gfx::Rect(10, 10, 30, 30));
   w2->SetBounds(gfx::Rect(50, 10, 10, 10));
   w3->SetBounds(gfx::Rect(70, 10, 10, 10));
 
   w1->AddTransientWindow(w2.get());
   w2->SetModal();
 
   // Send event that is over |w3|.
   const ui::PointerEvent mouse_pressed(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(75, 15), gfx::Point(75, 15),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(mouse_pressed);
 
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
   ASSERT_TRUE(details);
   EXPECT_EQ(w3.get(), details->window);
   EXPECT_FALSE(details->in_nonclient_area);
 
   ASSERT_TRUE(details->event);
   ASSERT_TRUE(details->event->IsPointerEvent());
 
   ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
   EXPECT_EQ(gfx::Point(75, 15), dispatched_event->root_location());
   EXPECT_EQ(gfx::Point(5, 5), dispatched_event->location());
 }
 
 // Tests that events events on a descendant of a modal parent target the modal
 // child.
 TEST_F(EventDispatcherTest, ModalWindowEventOnDescendantOfModalParent) {
-  scoped_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
-  scoped_ptr<ServerWindow> w11 =
+  std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> w11 =
       CreateChildWindowWithParent(WindowId(1, 4), w1.get());
-  scoped_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
+  std::unique_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   w1->SetBounds(gfx::Rect(10, 10, 30, 30));
   w11->SetBounds(gfx::Rect(10, 10, 10, 10));
   w2->SetBounds(gfx::Rect(50, 10, 10, 10));
 
   w1->AddTransientWindow(w2.get());
   w2->SetModal();
 
   // Send event that is over |w11|.
   const ui::PointerEvent mouse_pressed(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(25, 25), gfx::Point(25, 25),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   event_dispatcher()->ProcessEvent(mouse_pressed);
 
-  scoped_ptr<DispatchedEventDetails> details =
+  std::unique_ptr<DispatchedEventDetails> details =
       test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
   ASSERT_TRUE(details);
   EXPECT_EQ(w2.get(), details->window);
   EXPECT_TRUE(details->in_nonclient_area);
 
   ASSERT_TRUE(details->event);
   ASSERT_TRUE(details->event->IsPointerEvent());
 
   ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
   EXPECT_EQ(gfx::Point(25, 25), dispatched_event->root_location());
   EXPECT_EQ(gfx::Point(-25, 15), dispatched_event->location());
 }
 
 
 // Tests that setting capture to a descendant of a modal parent fails.
 TEST_F(EventDispatcherTest, ModalWindowSetCaptureDescendantOfModalParent) {
-  scoped_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
-  scoped_ptr<ServerWindow> w11 =
+  std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> w11 =
       CreateChildWindowWithParent(WindowId(1, 4), w1.get());
-  scoped_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
+  std::unique_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   w1->SetBounds(gfx::Rect(10, 10, 30, 30));
   w11->SetBounds(gfx::Rect(10, 10, 10, 10));
   w2->SetBounds(gfx::Rect(50, 10, 10, 10));
 
   w1->AddTransientWindow(w2.get());
   w2->SetModal();
 
   EXPECT_FALSE(event_dispatcher()->SetCaptureWindow(w11.get(), false));
   EXPECT_EQ(nullptr, event_dispatcher()->capture_window());
 }
 
 // Tests that setting capture to a window unrelated to a modal parent works.
 TEST_F(EventDispatcherTest, ModalWindowSetCaptureUnrelatedWindow) {
-  scoped_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
-  scoped_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
-  scoped_ptr<ServerWindow> w3 = CreateChildWindow(WindowId(1, 6));
+  std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
+  std::unique_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
+  std::unique_ptr<ServerWindow> w3 = CreateChildWindow(WindowId(1, 6));
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   w1->SetBounds(gfx::Rect(10, 10, 30, 30));
   w2->SetBounds(gfx::Rect(50, 10, 10, 10));
   w3->SetBounds(gfx::Rect(70, 10, 10, 10));
 
   w1->AddTransientWindow(w2.get());
   w2->SetModal();
 
   EXPECT_TRUE(event_dispatcher()->SetCaptureWindow(w3.get(), false));
   EXPECT_EQ(w3.get(), event_dispatcher()->capture_window());
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace mus