Replace scoped_ptr with std::unique_ptr in //ui

ui/aura/window_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/aura/window.h"
 
 #include <limits.h>
 
 #include <string>
 #include <utility>
@@ skipping 262 matching lines @@
 
 void OffsetBounds(Window* window, int horizontal, int vertical) {
   gfx::Rect bounds = window->bounds();
   bounds.Offset(horizontal, vertical);
   window->SetBounds(bounds);
 }
 
 }  // namespace
 
 TEST_F(WindowTest, GetChildById) {
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
-  scoped_ptr<Window> w11(CreateTestWindowWithId(11, w1.get()));
-  scoped_ptr<Window> w111(CreateTestWindowWithId(111, w11.get()));
-  scoped_ptr<Window> w12(CreateTestWindowWithId(12, w1.get()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> w11(CreateTestWindowWithId(11, w1.get()));
+  std::unique_ptr<Window> w111(CreateTestWindowWithId(111, w11.get()));
+  std::unique_ptr<Window> w12(CreateTestWindowWithId(12, w1.get()));
 
   EXPECT_EQ(NULL, w1->GetChildById(57));
   EXPECT_EQ(w12.get(), w1->GetChildById(12));
   EXPECT_EQ(w111.get(), w1->GetChildById(111));
 }
 
 // Make sure that Window::Contains correctly handles children, grandchildren,
 // and not containing NULL or parents.
 TEST_F(WindowTest, Contains) {
   Window parent(NULL);
   parent.Init(ui::LAYER_NOT_DRAWN);
   Window child1(NULL);
   child1.Init(ui::LAYER_NOT_DRAWN);
   Window child2(NULL);
   child2.Init(ui::LAYER_NOT_DRAWN);
 
   parent.AddChild(&child1);
   child1.AddChild(&child2);
 
   EXPECT_TRUE(parent.Contains(&parent));
   EXPECT_TRUE(parent.Contains(&child1));
   EXPECT_TRUE(parent.Contains(&child2));
 
   EXPECT_FALSE(parent.Contains(NULL));
   EXPECT_FALSE(child1.Contains(&parent));
   EXPECT_FALSE(child2.Contains(&child1));
 }
 
 TEST_F(WindowTest, ContainsPointInRoot) {
-  scoped_ptr<Window> w(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 5, 5),
-                       root_window()));
+  std::unique_ptr<Window> w(CreateTestWindow(
+      SK_ColorWHITE, 1, gfx::Rect(10, 10, 5, 5), root_window()));
   EXPECT_FALSE(w->ContainsPointInRoot(gfx::Point(9, 9)));
   EXPECT_TRUE(w->ContainsPointInRoot(gfx::Point(10, 10)));
   EXPECT_TRUE(w->ContainsPointInRoot(gfx::Point(14, 14)));
   EXPECT_FALSE(w->ContainsPointInRoot(gfx::Point(15, 15)));
   EXPECT_FALSE(w->ContainsPointInRoot(gfx::Point(20, 20)));
 }
 
 TEST_F(WindowTest, ContainsPoint) {
-  scoped_ptr<Window> w(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 5, 5),
-                       root_window()));
+  std::unique_ptr<Window> w(CreateTestWindow(
+      SK_ColorWHITE, 1, gfx::Rect(10, 10, 5, 5), root_window()));
   EXPECT_TRUE(w->ContainsPoint(gfx::Point(0, 0)));
   EXPECT_TRUE(w->ContainsPoint(gfx::Point(4, 4)));
   EXPECT_FALSE(w->ContainsPoint(gfx::Point(5, 5)));
   EXPECT_FALSE(w->ContainsPoint(gfx::Point(10, 10)));
 }
 
 TEST_F(WindowTest, ConvertPointToWindow) {
   // Window::ConvertPointToWindow is mostly identical to
   // Layer::ConvertPointToLayer, except NULL values for |source| are permitted,
   // in which case the function just returns.
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   gfx::Point reference_point(100, 100);
   gfx::Point test_point = reference_point;
   Window::ConvertPointToTarget(NULL, w1.get(), &test_point);
   EXPECT_EQ(reference_point, test_point);
 }
 
 TEST_F(WindowTest, MoveCursorTo) {
-  scoped_ptr<Window> w1(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500),
-                       root_window()));
-  scoped_ptr<Window> w11(
+  std::unique_ptr<Window> w1(CreateTestWindow(
+      SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), root_window()));
+  std::unique_ptr<Window> w11(
       CreateTestWindow(SK_ColorGREEN, 11, gfx::Rect(5, 5, 100, 100), w1.get()));
-  scoped_ptr<Window> w111(
+  std::unique_ptr<Window> w111(
       CreateTestWindow(SK_ColorCYAN, 111, gfx::Rect(5, 5, 75, 75), w11.get()));
-  scoped_ptr<Window> w1111(
+  std::unique_ptr<Window> w1111(
       CreateTestWindow(SK_ColorRED, 1111, gfx::Rect(5, 5, 50, 50), w111.get()));
 
   Window* root = root_window();
   root->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("10,10",
       gfx::Screen::GetScreen()->GetCursorScreenPoint().ToString());
   w1->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("20,20",
       gfx::Screen::GetScreen()->GetCursorScreenPoint().ToString());
   w11->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("25,25",
       gfx::Screen::GetScreen()->GetCursorScreenPoint().ToString());
   w111->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("30,30",
       gfx::Screen::GetScreen()->GetCursorScreenPoint().ToString());
   w1111->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("35,35",
       gfx::Screen::GetScreen()->GetCursorScreenPoint().ToString());
 }
 
 TEST_F(WindowTest, ContainsMouse) {
-  scoped_ptr<Window> w(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500),
-                       root_window()));
+  std::unique_ptr<Window> w(CreateTestWindow(
+      SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), root_window()));
   w->Show();
   WindowTestApi w_test_api(w.get());
   Window* root = root_window();
   root->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_TRUE(w_test_api.ContainsMouse());
   root->MoveCursorTo(gfx::Point(9, 10));
   EXPECT_FALSE(w_test_api.ContainsMouse());
 }
 
 // Test Window::ConvertPointToWindow() with transform to root_window.
 TEST_F(WindowTest, MoveCursorToWithTransformRootWindow) {
   gfx::Transform transform;
   transform.Translate(100.0, 100.0);
   transform.Rotate(90.0);
   transform.Scale(2.0, 5.0);
   host()->SetRootTransform(transform);
   host()->MoveCursorTo(gfx::Point(10, 10));
 #if !defined(OS_WIN)
   // TODO(yoshiki): fix this to build on Windows. See crbug.com/133413.OD
   EXPECT_EQ("50,120", QueryLatestMousePositionRequestInHost(host()).ToString());
 #endif
   EXPECT_EQ("10,10",
             gfx::Screen::GetScreen()->GetCursorScreenPoint().ToString());
 }
 
 // Tests Window::ConvertPointToWindow() with transform to non-root windows.
 TEST_F(WindowTest, MoveCursorToWithTransformWindow) {
-  scoped_ptr<Window> w1(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500),
-                       root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindow(
+      SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), root_window()));
 
   gfx::Transform transform1;
   transform1.Scale(2, 2);
   w1->SetTransform(transform1);
   w1->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("30,30",
       gfx::Screen::GetScreen()->GetCursorScreenPoint().ToString());
 
   gfx::Transform transform2;
   transform2.Translate(-10, 20);
@@ skipping 16 matching lines @@
   w1->SetTransform(transform4);
   w1->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("60,130",
       gfx::Screen::GetScreen()->GetCursorScreenPoint().ToString());
 }
 
 // Test Window::ConvertPointToWindow() with complex transforms to both root and
 // non-root windows.
 // Test Window::ConvertPointToWindow() with transform to root_window.
 TEST_F(WindowTest, MoveCursorToWithComplexTransform) {
-  scoped_ptr<Window> w1(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500),
-                       root_window()));
-  scoped_ptr<Window> w11(
+  std::unique_ptr<Window> w1(CreateTestWindow(
+      SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), root_window()));
+  std::unique_ptr<Window> w11(
       CreateTestWindow(SK_ColorGREEN, 11, gfx::Rect(5, 5, 100, 100), w1.get()));
-  scoped_ptr<Window> w111(
+  std::unique_ptr<Window> w111(
       CreateTestWindow(SK_ColorCYAN, 111, gfx::Rect(5, 5, 75, 75), w11.get()));
-  scoped_ptr<Window> w1111(
+  std::unique_ptr<Window> w1111(
       CreateTestWindow(SK_ColorRED, 1111, gfx::Rect(5, 5, 50, 50), w111.get()));
 
   // The root window expects transforms that produce integer rects.
   gfx::Transform root_transform;
   root_transform.Translate(60.0, 70.0);
   root_transform.Rotate(-90.0);
   root_transform.Translate(-50.0, -50.0);
   root_transform.Scale(2.0, 3.0);
 
   gfx::Transform transform;
@@ skipping 13 matching lines @@
   EXPECT_EQ("169,80", QueryLatestMousePositionRequestInHost(host()).ToString());
 #endif
   EXPECT_EQ("20,53",
       gfx::Screen::GetScreen()->GetCursorScreenPoint().ToString());
 }
 
 // Tests that we do not crash when a Window is destroyed by going out of
 // scope (as opposed to being explicitly deleted by its WindowDelegate).
 TEST_F(WindowTest, NoCrashOnWindowDelete) {
   CaptureWindowDelegateImpl delegate;
-  scoped_ptr<Window> window(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 20, 20), root_window()));
 }
 
 TEST_F(WindowTest, GetEventHandlerForPoint) {
-  scoped_ptr<Window> w1(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500),
-                       root_window()));
-  scoped_ptr<Window> w11(
+  std::unique_ptr<Window> w1(CreateTestWindow(
+      SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), root_window()));
+  std::unique_ptr<Window> w11(
       CreateTestWindow(SK_ColorGREEN, 11, gfx::Rect(5, 5, 100, 100), w1.get()));
-  scoped_ptr<Window> w111(
+  std::unique_ptr<Window> w111(
       CreateTestWindow(SK_ColorCYAN, 111, gfx::Rect(5, 5, 75, 75), w11.get()));
-  scoped_ptr<Window> w1111(
+  std::unique_ptr<Window> w1111(
       CreateTestWindow(SK_ColorRED, 1111, gfx::Rect(5, 5, 50, 50), w111.get()));
-  scoped_ptr<Window> w12(
-      CreateTestWindow(SK_ColorMAGENTA, 12, gfx::Rect(10, 420, 25, 25),
-                       w1.get()));
-  scoped_ptr<Window> w121(
+  std::unique_ptr<Window> w12(CreateTestWindow(
+      SK_ColorMAGENTA, 12, gfx::Rect(10, 420, 25, 25), w1.get()));
+  std::unique_ptr<Window> w121(
       CreateTestWindow(SK_ColorYELLOW, 121, gfx::Rect(5, 5, 5, 5), w12.get()));
-  scoped_ptr<Window> w13(
+  std::unique_ptr<Window> w13(
       CreateTestWindow(SK_ColorGRAY, 13, gfx::Rect(5, 470, 50, 50), w1.get()));
 
   Window* root = root_window();
   w1->parent()->SetBounds(gfx::Rect(500, 500));
   EXPECT_EQ(NULL, root->GetEventHandlerForPoint(gfx::Point(5, 5)));
   EXPECT_EQ(w1.get(), root->GetEventHandlerForPoint(gfx::Point(11, 11)));
   EXPECT_EQ(w11.get(), root->GetEventHandlerForPoint(gfx::Point(16, 16)));
   EXPECT_EQ(w111.get(), root->GetEventHandlerForPoint(gfx::Point(21, 21)));
   EXPECT_EQ(w1111.get(), root->GetEventHandlerForPoint(gfx::Point(26, 26)));
   EXPECT_EQ(w12.get(), root->GetEventHandlerForPoint(gfx::Point(21, 431)));
   EXPECT_EQ(w121.get(), root->GetEventHandlerForPoint(gfx::Point(26, 436)));
   EXPECT_EQ(w13.get(), root->GetEventHandlerForPoint(gfx::Point(26, 481)));
 }
 
 TEST_F(WindowTest, GetEventHandlerForPointWithOverride) {
   // If our child is flush to our top-left corner he gets events just inside the
   // window edges.
-  scoped_ptr<Window> parent(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 20, 400, 500),
-                       root_window()));
-  scoped_ptr<Window> child(
+  std::unique_ptr<Window> parent(CreateTestWindow(
+      SK_ColorWHITE, 1, gfx::Rect(10, 20, 400, 500), root_window()));
+  std::unique_ptr<Window> child(
       CreateTestWindow(SK_ColorRED, 2, gfx::Rect(0, 0, 60, 70), parent.get()));
   EXPECT_EQ(child.get(), parent->GetEventHandlerForPoint(gfx::Point(0, 0)));
   EXPECT_EQ(child.get(), parent->GetEventHandlerForPoint(gfx::Point(1, 1)));
 
   // We can override the hit test bounds of the parent to make the parent grab
   // events along that edge.
   parent->set_hit_test_bounds_override_inner(gfx::Insets(1, 1, 1, 1));
   EXPECT_EQ(parent.get(), parent->GetEventHandlerForPoint(gfx::Point(0, 0)));
   EXPECT_EQ(child.get(),  parent->GetEventHandlerForPoint(gfx::Point(1, 1)));
 }
 
 TEST_F(WindowTest, GetEventHandlerForPointWithOverrideDescendingOrder) {
-  scoped_ptr<SelfEventHandlingWindowDelegate> parent_delegate(
+  std::unique_ptr<SelfEventHandlingWindowDelegate> parent_delegate(
       new SelfEventHandlingWindowDelegate);
-  scoped_ptr<Window> parent(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> parent(CreateTestWindowWithDelegate(
       parent_delegate.get(), 1, gfx::Rect(10, 20, 400, 500), root_window()));
-  scoped_ptr<Window> child(
-      CreateTestWindow(SK_ColorRED, 2, gfx::Rect(0, 0, 390, 480),
-                       parent.get()));
+  std::unique_ptr<Window> child(CreateTestWindow(
+      SK_ColorRED, 2, gfx::Rect(0, 0, 390, 480), parent.get()));
 
   // We can override ShouldDescendIntoChildForEventHandling to make the parent
   // grab all events.
   EXPECT_EQ(parent.get(), parent->GetEventHandlerForPoint(gfx::Point(0, 0)));
   EXPECT_EQ(parent.get(), parent->GetEventHandlerForPoint(gfx::Point(50, 50)));
 }
 
 TEST_F(WindowTest, GetTopWindowContainingPoint) {
   Window* root = root_window();
   root->SetBounds(gfx::Rect(0, 0, 300, 300));
 
-  scoped_ptr<Window> w1(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(10, 10, 100, 100),
-                       root_window()));
-  scoped_ptr<Window> w11(
+  std::unique_ptr<Window> w1(CreateTestWindow(
+      SK_ColorWHITE, 1, gfx::Rect(10, 10, 100, 100), root_window()));
+  std::unique_ptr<Window> w11(
       CreateTestWindow(SK_ColorGREEN, 11, gfx::Rect(0, 0, 120, 120), w1.get()));
 
-  scoped_ptr<Window> w2(
-      CreateTestWindow(SK_ColorRED, 2, gfx::Rect(5, 5, 55, 55),
-                       root_window()));
+  std::unique_ptr<Window> w2(
+      CreateTestWindow(SK_ColorRED, 2, gfx::Rect(5, 5, 55, 55), root_window()));
 
-  scoped_ptr<Window> w3(
-      CreateTestWindowWithDelegate(
-          NULL, 3, gfx::Rect(200, 200, 100, 100), root_window()));
-  scoped_ptr<Window> w31(
+  std::unique_ptr<Window> w3(CreateTestWindowWithDelegate(
+      NULL, 3, gfx::Rect(200, 200, 100, 100), root_window()));
+  std::unique_ptr<Window> w31(
       CreateTestWindow(SK_ColorCYAN, 31, gfx::Rect(0, 0, 50, 50), w3.get()));
-  scoped_ptr<Window> w311(
+  std::unique_ptr<Window> w311(
       CreateTestWindow(SK_ColorBLUE, 311, gfx::Rect(0, 0, 10, 10), w31.get()));
 
   EXPECT_EQ(NULL, root->GetTopWindowContainingPoint(gfx::Point(0, 0)));
   EXPECT_EQ(w2.get(), root->GetTopWindowContainingPoint(gfx::Point(5, 5)));
   EXPECT_EQ(w2.get(), root->GetTopWindowContainingPoint(gfx::Point(10, 10)));
   EXPECT_EQ(w2.get(), root->GetTopWindowContainingPoint(gfx::Point(59, 59)));
   EXPECT_EQ(w1.get(), root->GetTopWindowContainingPoint(gfx::Point(60, 60)));
   EXPECT_EQ(w1.get(), root->GetTopWindowContainingPoint(gfx::Point(109, 109)));
   EXPECT_EQ(NULL, root->GetTopWindowContainingPoint(gfx::Point(110, 110)));
   EXPECT_EQ(w31.get(), root->GetTopWindowContainingPoint(gfx::Point(200, 200)));
   EXPECT_EQ(w31.get(), root->GetTopWindowContainingPoint(gfx::Point(220, 220)));
   EXPECT_EQ(NULL, root->GetTopWindowContainingPoint(gfx::Point(260, 260)));
 }
 
 TEST_F(WindowTest, GetToplevelWindow) {
   const gfx::Rect kBounds(0, 0, 10, 10);
   TestWindowDelegate delegate;
 
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
-  scoped_ptr<Window> w11(
+  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> w11(
       CreateTestWindowWithDelegate(&delegate, 11, kBounds, w1.get()));
-  scoped_ptr<Window> w111(CreateTestWindowWithId(111, w11.get()));
-  scoped_ptr<Window> w1111(
+  std::unique_ptr<Window> w111(CreateTestWindowWithId(111, w11.get()));
+  std::unique_ptr<Window> w1111(
       CreateTestWindowWithDelegate(&delegate, 1111, kBounds, w111.get()));
 
   EXPECT_TRUE(root_window()->GetToplevelWindow() == NULL);
   EXPECT_TRUE(w1->GetToplevelWindow() == NULL);
   EXPECT_EQ(w11.get(), w11->GetToplevelWindow());
   EXPECT_EQ(w11.get(), w111->GetToplevelWindow());
   EXPECT_EQ(w11.get(), w1111->GetToplevelWindow());
 }
 
 class AddedToRootWindowObserver : public WindowObserver {
  public:
   AddedToRootWindowObserver() : called_(false) {}
 
   void OnWindowAddedToRootWindow(Window* window) override { called_ = true; }
 
   bool called() const { return called_; }
 
  private:
   bool called_;
 
   DISALLOW_COPY_AND_ASSIGN(AddedToRootWindowObserver);
 };
 
 TEST_F(WindowTest, WindowAddedToRootWindowShouldNotifyChildAndNotParent) {
   AddedToRootWindowObserver parent_observer;
   AddedToRootWindowObserver child_observer;
-  scoped_ptr<Window> parent_window(CreateTestWindowWithId(1, root_window()));
-  scoped_ptr<Window> child_window(new Window(NULL));
+  std::unique_ptr<Window> parent_window(
+      CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> child_window(new Window(NULL));
   child_window->Init(ui::LAYER_TEXTURED);
   child_window->Show();
 
   parent_window->AddObserver(&parent_observer);
   child_window->AddObserver(&child_observer);
 
   parent_window->AddChild(child_window.get());
 
   EXPECT_FALSE(parent_observer.called());
   EXPECT_TRUE(child_observer.called());
 
   parent_window->RemoveObserver(&parent_observer);
   child_window->RemoveObserver(&child_observer);
 }
 
 // Various destruction assertions.
 TEST_F(WindowTest, DestroyTest) {
   DestroyTrackingDelegateImpl parent_delegate;
   ChildWindowDelegateImpl child_delegate(&parent_delegate);
   {
-    scoped_ptr<Window> parent(
-        CreateTestWindowWithDelegate(&parent_delegate, 0, gfx::Rect(),
-                                     root_window()));
+    std::unique_ptr<Window> parent(CreateTestWindowWithDelegate(
+        &parent_delegate, 0, gfx::Rect(), root_window()));
     CreateTestWindowWithDelegate(&child_delegate, 0, gfx::Rect(), parent.get());
   }
   // Both the parent and child should have been destroyed.
   EXPECT_EQ(1, parent_delegate.destroying_count());
   EXPECT_EQ(1, parent_delegate.destroyed_count());
   EXPECT_EQ(1, child_delegate.destroying_count());
   EXPECT_EQ(1, child_delegate.destroyed_count());
 }
 
 // Tests that a window is orphaned before OnWindowDestroyed is called.
 TEST_F(WindowTest, OrphanedBeforeOnDestroyed) {
   TestWindowDelegate parent_delegate;
   DestroyOrphanDelegate child_delegate;
   {
-    scoped_ptr<Window> parent(
-        CreateTestWindowWithDelegate(&parent_delegate, 0, gfx::Rect(),
-                                     root_window()));
-    scoped_ptr<Window> child(CreateTestWindowWithDelegate(&child_delegate, 0,
-          gfx::Rect(), parent.get()));
+    std::unique_ptr<Window> parent(CreateTestWindowWithDelegate(
+        &parent_delegate, 0, gfx::Rect(), root_window()));
+    std::unique_ptr<Window> child(CreateTestWindowWithDelegate(
+        &child_delegate, 0, gfx::Rect(), parent.get()));
     child_delegate.set_window(child.get());
   }
 }
 
 // Make sure StackChildAtTop moves both the window and layer to the front.
 TEST_F(WindowTest, StackChildAtTop) {
   Window parent(NULL);
   parent.Init(ui::LAYER_NOT_DRAWN);
   Window child1(NULL);
   child1.Init(ui::LAYER_NOT_DRAWN);
@@ skipping 105 matching lines @@
   EXPECT_EQ(&child3, parent.children()[2]);
   ASSERT_EQ(3u, parent.layer()->children().size());
   EXPECT_EQ(child2.layer(), parent.layer()->children()[0]);
   EXPECT_EQ(child1.layer(), parent.layer()->children()[1]);
   EXPECT_EQ(child3.layer(), parent.layer()->children()[2]);
 }
 
 // Various capture assertions.
 TEST_F(WindowTest, CaptureTests) {
   CaptureWindowDelegateImpl delegate;
-  scoped_ptr<Window> window(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 20, 20), root_window()));
   EXPECT_FALSE(window->HasCapture());
 
   delegate.ResetCounts();
 
   // Do a capture.
   window->SetCapture();
   EXPECT_TRUE(window->HasCapture());
   EXPECT_EQ(0, delegate.capture_lost_count());
   EXPECT_EQ(0, delegate.capture_changed_event_count());
@@ skipping 30 matching lines @@
   // in the root window.
   window->SetCapture();
   EXPECT_EQ(window.get(), aura::client::GetCaptureWindow(root_window()));
   window->parent()->RemoveChild(window.get());
   EXPECT_FALSE(window->HasCapture());
   EXPECT_EQ(NULL, aura::client::GetCaptureWindow(root_window()));
 }
 
 TEST_F(WindowTest, TouchCaptureCancelsOtherTouches) {
   CaptureWindowDelegateImpl delegate1;
-  scoped_ptr<Window> w1(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       &delegate1, 0, gfx::Rect(0, 0, 50, 50), root_window()));
   CaptureWindowDelegateImpl delegate2;
-  scoped_ptr<Window> w2(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> w2(CreateTestWindowWithDelegate(
       &delegate2, 0, gfx::Rect(50, 50, 50, 50), root_window()));
 
   // Press on w1.
   ui::TouchEvent press1(
       ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
   DispatchEventUsingWindowDispatcher(&press1);
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(2, delegate1.gesture_event_count());
   delegate1.ResetCounts();
 
@@ skipping 31 matching lines @@
   // And releasing capture changes nothing.
   w2->ReleaseCapture();
   EXPECT_EQ(0, delegate1.gesture_event_count());
   EXPECT_EQ(0, delegate1.touch_event_count());
   EXPECT_EQ(0, delegate2.gesture_event_count());
   EXPECT_EQ(0, delegate2.touch_event_count());
 }
 
 TEST_F(WindowTest, TouchCaptureDoesntCancelCapturedTouches) {
   CaptureWindowDelegateImpl delegate;
-  scoped_ptr<Window> window(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 50, 50), root_window()));
   base::TimeDelta time = getTime();
   const int kTimeDelta = 100;
 
   ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, time);
   DispatchEventUsingWindowDispatcher(&press);
 
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(2, delegate.gesture_event_count());
@@ skipping 35 matching lines @@
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_EQ(1, delegate.touch_event_count());
   EXPECT_EQ(2, delegate.gesture_event_count());
 }
 
 
 // Assertions around SetCapture() and touch/gestures.
 TEST_F(WindowTest, TransferCaptureTouchEvents) {
   // Touch on |w1|.
   CaptureWindowDelegateImpl d1;
-  scoped_ptr<Window> w1(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       &d1, 0, gfx::Rect(0, 0, 20, 20), root_window()));
   ui::TouchEvent p1(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
   DispatchEventUsingWindowDispatcher(&p1);
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(1, d1.touch_event_count());
   EXPECT_EQ(2, d1.gesture_event_count());
   d1.ResetCounts();
 
   // Touch on |w2| with a different id.
   CaptureWindowDelegateImpl d2;
-  scoped_ptr<Window> w2(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> w2(CreateTestWindowWithDelegate(
       &d2, 0, gfx::Rect(40, 0, 40, 20), root_window()));
   ui::TouchEvent p2(ui::ET_TOUCH_PRESSED, gfx::Point(41, 10), 1, getTime());
   DispatchEventUsingWindowDispatcher(&p2);
   EXPECT_EQ(0, d1.touch_event_count());
   EXPECT_EQ(0, d1.gesture_event_count());
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN for new target window.
   EXPECT_EQ(1, d2.touch_event_count());
   EXPECT_EQ(2, d2.gesture_event_count());
   d1.ResetCounts();
   d2.ResetCounts();
 
   // Set capture on |w2|, this should send a cancel (TAP_CANCEL, END) to |w1|
   // but not |w2|.
   w2->SetCapture();
   EXPECT_EQ(1, d1.touch_event_count());
   EXPECT_EQ(2, d1.gesture_event_count());
   EXPECT_EQ(0, d2.touch_event_count());
   EXPECT_EQ(0, d2.gesture_event_count());
   d1.ResetCounts();
   d2.ResetCounts();
 
   CaptureWindowDelegateImpl d3;
-  scoped_ptr<Window> w3(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> w3(CreateTestWindowWithDelegate(
       &d3, 0, gfx::Rect(0, 0, 100, 101), root_window()));
   // Set capture on |w3|. All touches have already been cancelled.
   w3->SetCapture();
   EXPECT_EQ(0, d1.touch_event_count());
   EXPECT_EQ(0, d1.gesture_event_count());
   EXPECT_EQ(1, d2.touch_event_count());
   EXPECT_EQ(2, d2.gesture_event_count());
   EXPECT_EQ(0, d3.touch_event_count());
   EXPECT_EQ(0, d3.gesture_event_count());
   d2.ResetCounts();
@@ skipping 25 matching lines @@
   EXPECT_EQ(0, d1.gesture_event_count());
   EXPECT_EQ(0, d2.touch_event_count());
   EXPECT_EQ(0, d2.gesture_event_count());
   EXPECT_EQ(0, d3.touch_event_count());
   EXPECT_EQ(0, d3.gesture_event_count());
 }
 
 // Changes capture while capture is already ongoing.
 TEST_F(WindowTest, ChangeCaptureWhileMouseDown) {
   CaptureWindowDelegateImpl delegate;
-  scoped_ptr<Window> window(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 20, 20), root_window()));
   CaptureWindowDelegateImpl delegate2;
-  scoped_ptr<Window> w2(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> w2(CreateTestWindowWithDelegate(
       &delegate2, 0, gfx::Rect(20, 20, 20, 20), root_window()));
 
   // Execute the scheduled draws so that mouse events are not
   // aggregated.
   RunAllPendingInMessageLoop();
 
   EXPECT_FALSE(window->HasCapture());
 
   // Do a capture.
   delegate.ResetCounts();
@@ skipping 15 matching lines @@
   generator.MoveMouseTo(gfx::Point(40, 40), 2);
   EXPECT_EQ(1, delegate.capture_lost_count());
   EXPECT_EQ(1, delegate.capture_changed_event_count());
   EXPECT_EQ(1, delegate.mouse_event_count());
   EXPECT_EQ(2, delegate2.mouse_event_count());
 }
 
 // Verifies capture is reset when a window is destroyed.
 TEST_F(WindowTest, ReleaseCaptureOnDestroy) {
   CaptureWindowDelegateImpl delegate;
-  scoped_ptr<Window> window(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 20, 20), root_window()));
   EXPECT_FALSE(window->HasCapture());
 
   // Do a capture.
   window->SetCapture();
   EXPECT_TRUE(window->HasCapture());
 
   // Destroy the window.
   window.reset();
 
   // Make sure the root window doesn't reference the window anymore.
   EXPECT_EQ(NULL, host()->dispatcher()->mouse_pressed_handler());
   EXPECT_EQ(NULL, aura::client::GetCaptureWindow(root_window()));
 }
 
 TEST_F(WindowTest, GetBoundsInRootWindow) {
-  scoped_ptr<Window> viewport(CreateTestWindowWithBounds(
-      gfx::Rect(0, 0, 300, 300), root_window()));
-  scoped_ptr<Window> child(CreateTestWindowWithBounds(
-      gfx::Rect(0, 0, 100, 100), viewport.get()));
+  std::unique_ptr<Window> viewport(
+      CreateTestWindowWithBounds(gfx::Rect(0, 0, 300, 300), root_window()));
+  std::unique_ptr<Window> child(
+      CreateTestWindowWithBounds(gfx::Rect(0, 0, 100, 100), viewport.get()));
   // Sanity check.
   EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString());
 
   // The |child| window's screen bounds should move along with the |viewport|.
   viewport->SetBounds(gfx::Rect(-100, -100, 300, 300));
   EXPECT_EQ("-100,-100 100x100", child->GetBoundsInRootWindow().ToString());
 
   // The |child| window is moved to the 0,0 in screen coordinates.
   // |GetBoundsInRootWindow()| should return 0,0.
   child->SetBounds(gfx::Rect(100, 100, 100, 100));
   EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString());
 }
 
 TEST_F(WindowTest, GetBoundsInRootWindowWithLayers) {
-  scoped_ptr<Window> viewport(
+  std::unique_ptr<Window> viewport(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 300, 300), root_window()));
 
-  scoped_ptr<Window> widget(
+  std::unique_ptr<Window> widget(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 200, 200), viewport.get()));
 
-  scoped_ptr<Window> child(
+  std::unique_ptr<Window> child(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 100, 100), widget.get()));
 
   // Sanity check.
   EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString());
 
   // The |child| window's screen bounds should move along with the |viewport|.
   OffsetBounds(viewport.get(), -100, -100);
   EXPECT_EQ("-100,-100 100x100", child->GetBoundsInRootWindow().ToString());
 
   OffsetBounds(widget.get(), 50, 50);
   EXPECT_EQ("-50,-50 100x100", child->GetBoundsInRootWindow().ToString());
 
   // The |child| window is moved to the 0,0 in screen coordinates.
   // |GetBoundsInRootWindow()| should return 0,0.
   OffsetBounds(child.get(), 50, 50);
   EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString());
 }
 
 TEST_F(WindowTest, GetBoundsInRootWindowWithLayersAndTranslations) {
-  scoped_ptr<Window> viewport(
+  std::unique_ptr<Window> viewport(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 300, 300), root_window()));
 
-  scoped_ptr<Window> widget(
+  std::unique_ptr<Window> widget(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 200, 200), viewport.get()));
 
-  scoped_ptr<Window> child(
+  std::unique_ptr<Window> child(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 100, 100), widget.get()));
 
   // Sanity check.
   EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString());
 
   // The |child| window's screen bounds should move along with the |viewport|.
   viewport->SetBounds(gfx::Rect(-100, -100, 300, 300));
   EXPECT_EQ("-100,-100 100x100", child->GetBoundsInRootWindow().ToString());
 
   widget->SetBounds(gfx::Rect(50, 50, 200, 200));
@@ skipping 55 matching lines @@
   bool entered_;
   bool exited_;
 
   DISALLOW_COPY_AND_ASSIGN(MouseEnterExitWindowDelegate);
 };
 
 // Verifies that the WindowDelegate receives MouseExit and MouseEnter events for
 // mouse transitions from window to window.
 TEST_F(WindowTest, MouseEnterExit) {
   MouseEnterExitWindowDelegate d1;
-  scoped_ptr<Window> w1(
-      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50),
-                                   root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
+      &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
   MouseEnterExitWindowDelegate d2;
-  scoped_ptr<Window> w2(
-      CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(70, 70, 50, 50),
-                                   root_window()));
+  std::unique_ptr<Window> w2(CreateTestWindowWithDelegate(
+      &d2, 2, gfx::Rect(70, 70, 50, 50), root_window()));
 
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
   EXPECT_FALSE(d2.entered());
   EXPECT_FALSE(d2.exited());
 
   generator.MoveMouseToCenterOf(w2.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_TRUE(d1.exited());
   EXPECT_TRUE(d2.entered());
   EXPECT_FALSE(d2.exited());
 }
 
 // Verifies that the WindowDelegate receives MouseExit from ET_MOUSE_EXITED.
 TEST_F(WindowTest, WindowTreeHostExit) {
   MouseEnterExitWindowDelegate d1;
-  scoped_ptr<Window> w1(
-      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50),
-                                   root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
+      &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
 
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
   d1.ResetExpectations();
 
   ui::MouseEvent exit_event(ui::ET_MOUSE_EXITED, gfx::Point(), gfx::Point(),
                             ui::EventTimeForNow(), 0, 0);
   DispatchEventUsingWindowDispatcher(&exit_event);
   EXPECT_FALSE(d1.entered());
   EXPECT_TRUE(d1.exited());
 }
 
 // Verifies that the WindowDelegate receives MouseExit and MouseEnter events for
 // mouse transitions from window to window, even if the entered window sets
 // and releases capture.
 TEST_F(WindowTest, MouseEnterExitWithClick) {
   MouseEnterExitWindowDelegate d1;
-  scoped_ptr<Window> w1(
-      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50),
-                                   root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
+      &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
   MouseEnterExitWindowDelegate d2;
-  scoped_ptr<Window> w2(
-      CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(70, 70, 50, 50),
-                                   root_window()));
+  std::unique_ptr<Window> w2(CreateTestWindowWithDelegate(
+      &d2, 2, gfx::Rect(70, 70, 50, 50), root_window()));
 
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
   EXPECT_FALSE(d2.entered());
   EXPECT_FALSE(d2.exited());
 
   // Emmulate what Views does on a click by grabbing and releasing capture.
   generator.PressLeftButton();
   w1->SetCapture();
   w1->ReleaseCapture();
   generator.ReleaseLeftButton();
 
   generator.MoveMouseToCenterOf(w2.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_TRUE(d1.exited());
   EXPECT_TRUE(d2.entered());
   EXPECT_FALSE(d2.exited());
 }
 
 TEST_F(WindowTest, MouseEnterExitWhenDeleteWithCapture) {
   MouseEnterExitWindowDelegate delegate;
-  scoped_ptr<Window> window(
-      CreateTestWindowWithDelegate(&delegate, 1, gfx::Rect(10, 10, 50, 50),
-                                   root_window()));
+  std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
+      &delegate, 1, gfx::Rect(10, 10, 50, 50), root_window()));
 
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(window.get());
   EXPECT_TRUE(delegate.entered());
   EXPECT_FALSE(delegate.exited());
 
   // Emmulate what Views does on a click by grabbing and releasing capture.
   generator.PressLeftButton();
   window->SetCapture();
 
   delegate.ResetExpectations();
   generator.MoveMouseTo(0, 0);
   EXPECT_FALSE(delegate.entered());
   EXPECT_FALSE(delegate.exited());
 
   delegate.ResetExpectations();
   window.reset();
   EXPECT_FALSE(delegate.entered());
   EXPECT_FALSE(delegate.exited());
 }
 
 // Verifies that the correct enter / exits are sent if windows appear and are
 // deleted under the current mouse position.
 TEST_F(WindowTest, MouseEnterExitWithWindowAppearAndDelete) {
   MouseEnterExitWindowDelegate d1;
-  scoped_ptr<Window> w1(
-      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50),
-                                   root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
+      &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
 
   // The cursor is moved into the bounds of |w1|. We expect the delegate
   // of |w1| to see an ET_MOUSE_ENTERED event.
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
   d1.ResetExpectations();
 
   MouseEnterExitWindowDelegate d2;
   {
-    scoped_ptr<Window> w2(
-        CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(10, 10, 50, 50),
-                                     root_window()));
+    std::unique_ptr<Window> w2(CreateTestWindowWithDelegate(
+        &d2, 2, gfx::Rect(10, 10, 50, 50), root_window()));
     // Enters / exits can be sent asynchronously.
     RunAllPendingInMessageLoop();
 
     // |w2| appears over top of |w1|. We expect the delegate of |w1| to see
     // an ET_MOUSE_EXITED and the delegate of |w2| to see an ET_MOUSE_ENTERED.
     EXPECT_FALSE(d1.entered());
     EXPECT_TRUE(d1.exited());
     EXPECT_TRUE(d2.entered());
     EXPECT_FALSE(d2.exited());
     d1.ResetExpectations();
     d2.ResetExpectations();
   }
 
   // Enters / exits can be sent asynchronously.
   RunAllPendingInMessageLoop();
 
   // |w2| has been destroyed, so its delegate should see no further events.
   // The delegate of |w1| should see an ET_MOUSE_ENTERED event.
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
   EXPECT_FALSE(d2.entered());
   EXPECT_FALSE(d2.exited());
 }
 
 // Verifies that enter / exits are sent if windows appear and are hidden
 // under the current mouse position..
 TEST_F(WindowTest, MouseEnterExitWithHide) {
   MouseEnterExitWindowDelegate d1;
-  scoped_ptr<Window> w1(
-      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50),
-                                   root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
+      &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
 
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
 
   MouseEnterExitWindowDelegate d2;
-  scoped_ptr<Window> w2(
-      CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(10, 10, 50, 50),
-                                   root_window()));
+  std::unique_ptr<Window> w2(CreateTestWindowWithDelegate(
+      &d2, 2, gfx::Rect(10, 10, 50, 50), root_window()));
   // Enters / exits can be send asynchronously.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(d1.entered());
   EXPECT_TRUE(d1.exited());
   EXPECT_TRUE(d2.entered());
   EXPECT_FALSE(d2.exited());
 
   d1.ResetExpectations();
   w2->Hide();
   // Enters / exits can be send asynchronously.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(d2.exited());
   EXPECT_TRUE(d1.entered());
 }
 
 TEST_F(WindowTest, MouseEnterExitWithParentHide) {
   MouseEnterExitWindowDelegate d1;
-  scoped_ptr<Window> w1(
-      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50),
-                                   root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
+      &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
   MouseEnterExitWindowDelegate d2;
   Window* w2 = CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(10, 10, 50, 50),
                                             w1.get());
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w2);
   // Enters / exits can be send asynchronously.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(d2.entered());
   EXPECT_FALSE(d2.exited());
 
   d2.ResetExpectations();
   w1->Hide();
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(d2.entered());
   EXPECT_TRUE(d2.exited());
 
   w1.reset();
 }
 
 TEST_F(WindowTest, MouseEnterExitWithParentDelete) {
   MouseEnterExitWindowDelegate d1;
-  scoped_ptr<Window> w1(
-      CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50),
-                                   root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
+      &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
   MouseEnterExitWindowDelegate d2;
   Window* w2 = CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(10, 10, 50, 50),
                                             w1.get());
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w2);
 
   // Enters / exits can be send asynchronously.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(d2.entered());
   EXPECT_FALSE(d2.exited());
@@ skipping 11 matching lines @@
 }
 
 // Creates a window with a delegate (w111) that can handle events at a lower
 // z-index than a window without a delegate (w12). w12 is sized to fill the
 // entire bounds of the container. This test verifies that
 // GetEventHandlerForPoint() skips w12 even though its bounds contain the event,
 // because it has no children that can handle the event and it has no delegate
 // allowing it to handle the event itself.
 TEST_F(WindowTest, GetEventHandlerForPoint_NoDelegate) {
   TestWindowDelegate d111;
-  scoped_ptr<Window> w1(CreateTestWindowWithDelegate(NULL, 1,
-      gfx::Rect(0, 0, 500, 500), root_window()));
-  scoped_ptr<Window> w11(CreateTestWindowWithDelegate(NULL, 11,
-      gfx::Rect(0, 0, 500, 500), w1.get()));
-  scoped_ptr<Window> w111(CreateTestWindowWithDelegate(&d111, 111,
-      gfx::Rect(50, 50, 450, 450), w11.get()));
-  scoped_ptr<Window> w12(CreateTestWindowWithDelegate(NULL, 12,
-      gfx::Rect(0, 0, 500, 500), w1.get()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
+      NULL, 1, gfx::Rect(0, 0, 500, 500), root_window()));
+  std::unique_ptr<Window> w11(CreateTestWindowWithDelegate(
+      NULL, 11, gfx::Rect(0, 0, 500, 500), w1.get()));
+  std::unique_ptr<Window> w111(CreateTestWindowWithDelegate(
+      &d111, 111, gfx::Rect(50, 50, 450, 450), w11.get()));
+  std::unique_ptr<Window> w12(CreateTestWindowWithDelegate(
+      NULL, 12, gfx::Rect(0, 0, 500, 500), w1.get()));
 
   gfx::Point target_point = w111->bounds().CenterPoint();
   EXPECT_EQ(w111.get(), w1->GetEventHandlerForPoint(target_point));
 }
 
 class VisibilityWindowDelegate : public TestWindowDelegate {
  public:
   VisibilityWindowDelegate()
       : shown_(0),
         hidden_(0) {
@@ skipping 17 matching lines @@
   int shown_;
   int hidden_;
 
   DISALLOW_COPY_AND_ASSIGN(VisibilityWindowDelegate);
 };
 
 // Verifies show/hide propagate correctly to children and the layer.
 TEST_F(WindowTest, Visibility) {
   VisibilityWindowDelegate d;
   VisibilityWindowDelegate d2;
-  scoped_ptr<Window> w1(CreateTestWindowWithDelegate(&d, 1, gfx::Rect(),
-                                                     root_window()));
-  scoped_ptr<Window> w2(
-      CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(),  w1.get()));
-  scoped_ptr<Window> w3(CreateTestWindowWithId(3, w2.get()));
+  std::unique_ptr<Window> w1(
+      CreateTestWindowWithDelegate(&d, 1, gfx::Rect(), root_window()));
+  std::unique_ptr<Window> w2(
+      CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(), w1.get()));
+  std::unique_ptr<Window> w3(CreateTestWindowWithId(3, w2.get()));
 
   // Create shows all the windows.
   EXPECT_TRUE(w1->IsVisible());
   EXPECT_TRUE(w2->IsVisible());
   EXPECT_TRUE(w3->IsVisible());
   EXPECT_EQ(1, d.shown());
 
   d.Clear();
   w1->Hide();
   EXPECT_FALSE(w1->IsVisible());
@@ skipping 36 matching lines @@
   w2->Show();
   EXPECT_EQ(0, d2.hidden());
   EXPECT_EQ(1, d2.shown());
 }
 
 TEST_F(WindowTest, IgnoreEventsTest) {
   TestWindowDelegate d11;
   TestWindowDelegate d12;
   TestWindowDelegate d111;
   TestWindowDelegate d121;
-  scoped_ptr<Window> w1(CreateTestWindowWithDelegate(NULL, 1,
-      gfx::Rect(0, 0, 500, 500), root_window()));
-  scoped_ptr<Window> w11(CreateTestWindowWithDelegate(&d11, 11,
-      gfx::Rect(0, 0, 500, 500), w1.get()));
-  scoped_ptr<Window> w111(CreateTestWindowWithDelegate(&d111, 111,
-      gfx::Rect(50, 50, 450, 450), w11.get()));
-  scoped_ptr<Window> w12(CreateTestWindowWithDelegate(&d12, 12,
-      gfx::Rect(0, 0, 500, 500), w1.get()));
-  scoped_ptr<Window> w121(CreateTestWindowWithDelegate(&d121, 121,
-      gfx::Rect(150, 150, 50, 50), w12.get()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
+      NULL, 1, gfx::Rect(0, 0, 500, 500), root_window()));
+  std::unique_ptr<Window> w11(CreateTestWindowWithDelegate(
+      &d11, 11, gfx::Rect(0, 0, 500, 500), w1.get()));
+  std::unique_ptr<Window> w111(CreateTestWindowWithDelegate(
+      &d111, 111, gfx::Rect(50, 50, 450, 450), w11.get()));
+  std::unique_ptr<Window> w12(CreateTestWindowWithDelegate(
+      &d12, 12, gfx::Rect(0, 0, 500, 500), w1.get()));
+  std::unique_ptr<Window> w121(CreateTestWindowWithDelegate(
+      &d121, 121, gfx::Rect(150, 150, 50, 50), w12.get()));
 
   EXPECT_EQ(w12.get(), w1->GetEventHandlerForPoint(gfx::Point(10, 10)));
   w12->set_ignore_events(true);
   EXPECT_EQ(w11.get(), w1->GetEventHandlerForPoint(gfx::Point(10, 10)));
   w12->set_ignore_events(false);
 
   EXPECT_EQ(w121.get(), w1->GetEventHandlerForPoint(gfx::Point(160, 160)));
   w121->set_ignore_events(true);
   EXPECT_EQ(w12.get(), w1->GetEventHandlerForPoint(gfx::Point(160, 160)));
   w12->set_ignore_events(true);
@@ skipping 24 matching lines @@
       gfx::Screen::GetScreen()->GetDisplayNearestPoint(
           gfx::Point()).bounds().ToString());
 
   // Host size shouldn't change.
   EXPECT_EQ(size.ToString(), host()->GetBounds().size().ToString());
 }
 
 TEST_F(WindowTest, TransformGesture) {
   gfx::Size size = host()->GetBounds().size();
 
-  scoped_ptr<GestureTrackPositionDelegate> delegate(
+  std::unique_ptr<GestureTrackPositionDelegate> delegate(
       new GestureTrackPositionDelegate);
-  scoped_ptr<Window> window(CreateTestWindowWithDelegate(delegate.get(), -1234,
-      gfx::Rect(0, 0, 20, 20), root_window()));
+  std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, gfx::Rect(0, 0, 20, 20), root_window()));
 
   // Rotate the root-window clock-wise 90 degrees.
   gfx::Transform transform;
   transform.Translate(size.height(), 0.0);
   transform.Rotate(90.0);
   host()->SetRootTransform(transform);
 
   ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(size.height() - 10, 10), 0, getTime());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_EQ(gfx::Point(10, 10).ToString(), delegate->position().ToString());
 }
 
 namespace {
 DEFINE_WINDOW_PROPERTY_KEY(int, kIntKey, -2);
 DEFINE_WINDOW_PROPERTY_KEY(const char*, kStringKey, "squeamish");
 }
 
 TEST_F(WindowTest, Property) {
-  scoped_ptr<Window> w(CreateTestWindowWithId(0, root_window()));
+  std::unique_ptr<Window> w(CreateTestWindowWithId(0, root_window()));
 
   static const char native_prop_key[] = "fnord";
 
   // Non-existent properties should return the default values.
   EXPECT_EQ(-2, w->GetProperty(kIntKey));
   EXPECT_EQ(std::string("squeamish"), w->GetProperty(kStringKey));
   EXPECT_EQ(NULL, w->GetNativeWindowProperty(native_prop_key));
 
   // A set property value should be returned again (even if it's the default
   // value).
@@ skipping 17 matching lines @@
   EXPECT_EQ(NULL, w->GetNativeWindowProperty(native_prop_key));
 
   // ClearProperty should restore the default value.
   w->ClearProperty(kIntKey);
   EXPECT_EQ(-2, w->GetProperty(kIntKey));
   w->ClearProperty(kStringKey);
   EXPECT_EQ(std::string("squeamish"), w->GetProperty(kStringKey));
 }
 
 TEST_F(WindowTest, OwnedProperty) {
-  scoped_ptr<Window> w(CreateTestWindowWithId(0, root_window()));
+  std::unique_ptr<Window> w(CreateTestWindowWithId(0, root_window()));
   EXPECT_EQ(NULL, w->GetProperty(kOwnedKey));
   TestProperty* last_deleted = TestProperty::last_deleted();
   TestProperty* p1 = new TestProperty();
   w->SetProperty(kOwnedKey, p1);
   EXPECT_EQ(p1, w->GetProperty(kOwnedKey));
   EXPECT_EQ(last_deleted, TestProperty::last_deleted());
 
   TestProperty* p2 = new TestProperty();
   w->SetProperty(kOwnedKey, p2);
   EXPECT_EQ(p2, w->GetProperty(kOwnedKey));
   EXPECT_EQ(p1, TestProperty::last_deleted());
 
   w->ClearProperty(kOwnedKey);
   EXPECT_EQ(NULL, w->GetProperty(kOwnedKey));
   EXPECT_EQ(p2, TestProperty::last_deleted());
 
   TestProperty* p3 = new TestProperty();
   w->SetProperty(kOwnedKey, p3);
   EXPECT_EQ(p3, w->GetProperty(kOwnedKey));
   EXPECT_EQ(p2, TestProperty::last_deleted());
   w.reset();
   EXPECT_EQ(p3, TestProperty::last_deleted());
 }
 
 TEST_F(WindowTest, SetBoundsInternalShouldCheckTargetBounds) {
   // We cannot short-circuit animations in this test.
   ui::ScopedAnimationDurationScaleMode test_duration_mode(
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
 
-  scoped_ptr<Window> w1(
+  std::unique_ptr<Window> w1(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 100, 100), root_window()));
 
   EXPECT_TRUE(w1->layer());
   w1->layer()->GetAnimator()->set_disable_timer_for_test(true);
   ui::LayerAnimator* animator = w1->layer()->GetAnimator();
 
   EXPECT_EQ("0,0 100x100", w1->bounds().ToString());
   EXPECT_EQ("0,0 100x100", w1->layer()->GetTargetBounds().ToString());
 
   // Animate to a different position.
@@ skipping 118 matching lines @@
   }
 
   void OnAncestorWindowTransformed(Window* source, Window* window) override {
     transform_notifications_.push_back(
         std::make_pair(source->id(), window->id()));
   }
 
   int added_count_;
   int removed_count_;
   int destroyed_count_;
-  scoped_ptr<VisibilityInfo> visibility_info_;
+  std::unique_ptr<VisibilityInfo> visibility_info_;
   const void* property_key_;
   intptr_t old_property_value_;
   std::vector<std::pair<int, int> > transform_notifications_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowObserverTest);
 };
 
 // Various assertions for WindowObserver.
 TEST_F(WindowObserverTest, WindowObserver) {
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   w1->AddObserver(this);
 
   // Create a new window as a child of w1, our observer should be notified.
-  scoped_ptr<Window> w2(CreateTestWindowWithId(2, w1.get()));
+  std::unique_ptr<Window> w2(CreateTestWindowWithId(2, w1.get()));
   EXPECT_EQ("added=1 removed=0", WindowObserverCountStateAndClear());
 
   // Delete w2, which should result in the remove notification.
   w2.reset();
   EXPECT_EQ("added=0 removed=1", WindowObserverCountStateAndClear());
 
   // Create a window that isn't parented to w1, we shouldn't get any
   // notification.
-  scoped_ptr<Window> w3(CreateTestWindowWithId(3, root_window()));
+  std::unique_ptr<Window> w3(CreateTestWindowWithId(3, root_window()));
   EXPECT_EQ("added=0 removed=0", WindowObserverCountStateAndClear());
 
   // Similarly destroying w3 shouldn't notify us either.
   w3.reset();
   EXPECT_EQ("added=0 removed=0", WindowObserverCountStateAndClear());
   w1->RemoveObserver(this);
 }
 
 // Test if OnWindowVisibilityChanged is invoked with expected
 // parameters.
 TEST_F(WindowObserverTest, WindowVisibility) {
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
-  scoped_ptr<Window> w2(CreateTestWindowWithId(1, w1.get()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> w2(CreateTestWindowWithId(1, w1.get()));
   w2->AddObserver(this);
 
   // Hide should make the window invisible and the passed visible
   // parameter is false.
   w2->Hide();
   EXPECT_TRUE(GetVisibilityInfo());
   EXPECT_TRUE(GetVisibilityInfo());
   if (!GetVisibilityInfo())
     return;
   EXPECT_FALSE(GetVisibilityInfo()->window_visible);
@@ skipping 31 matching lines @@
   w2->Hide();
   EXPECT_EQ(2, GetVisibilityInfo()->changed_count);
 
   w2->Hide();
   EXPECT_EQ(2, GetVisibilityInfo()->changed_count);
 }
 
 // Test if OnWindowDestroyed is invoked as expected.
 TEST_F(WindowObserverTest, WindowDestroyed) {
   // Delete a window should fire a destroyed notification.
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   w1->AddObserver(this);
   w1.reset();
   EXPECT_EQ(1, DestroyedCountAndClear());
 
   // Observe on child and delete parent window should fire a notification.
-  scoped_ptr<Window> parent(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> parent(CreateTestWindowWithId(1, root_window()));
   Window* child = CreateTestWindowWithId(1, parent.get());  // owned by parent
   child->AddObserver(this);
   parent.reset();
   EXPECT_EQ(1, DestroyedCountAndClear());
 }
 
 TEST_F(WindowObserverTest, PropertyChanged) {
   // Setting property should fire a property change notification.
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   w1->AddObserver(this);
 
   static const WindowProperty<int> prop = {-2};
   static const char native_prop_key[] = "fnord";
 
   w1->SetProperty(&prop, 1);
   EXPECT_EQ(PropertyChangeInfo(&prop, -2), PropertyChangeInfoAndClear());
   w1->SetProperty(&prop, -2);
   EXPECT_EQ(PropertyChangeInfo(&prop, 1), PropertyChangeInfoAndClear());
   w1->SetProperty(&prop, 3);
@@ skipping 16 matching lines @@
 
 TEST_F(WindowObserverTest, AncestorTransformed) {
   // Create following window hierarchy:
   //   root_window
   //   +-- w1
   //       +-- w2
   //       +-- w3
   //           +-- w4
   // Then, apply a transform to |w1| and ensure all its descendants are
   // notified.
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   w1->AddObserver(this);
-  scoped_ptr<Window> w2(CreateTestWindowWithId(2, w1.get()));
+  std::unique_ptr<Window> w2(CreateTestWindowWithId(2, w1.get()));
   w2->AddObserver(this);
-  scoped_ptr<Window> w3(CreateTestWindowWithId(3, w1.get()));
+  std::unique_ptr<Window> w3(CreateTestWindowWithId(3, w1.get()));
   w3->AddObserver(this);
-  scoped_ptr<Window> w4(CreateTestWindowWithId(4, w3.get()));
+  std::unique_ptr<Window> w4(CreateTestWindowWithId(4, w3.get()));
   w4->AddObserver(this);
 
   EXPECT_EQ(std::string(), TransformNotificationsAndClear());
 
   gfx::Transform transform;
   transform.Translate(10, 10);
   w1->SetTransform(transform);
 
   EXPECT_EQ("(1,1)(1,2)(1,3)(1,4)", TransformNotificationsAndClear());
 }
 
 TEST_F(WindowTest, AcquireLayer) {
-  scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
-  scoped_ptr<Window> window2(CreateTestWindowWithId(2, root_window()));
+  std::unique_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> window2(CreateTestWindowWithId(2, root_window()));
   ui::Layer* parent = window1->parent()->layer();
   EXPECT_EQ(2U, parent->children().size());
 
   WindowTestApi window1_test_api(window1.get());
   WindowTestApi window2_test_api(window2.get());
 
   EXPECT_TRUE(window1_test_api.OwnsLayer());
   EXPECT_TRUE(window2_test_api.OwnsLayer());
 
   // After acquisition, window1 should not own its layer, but it should still
   // be available to the window.
-  scoped_ptr<ui::Layer> window1_layer(window1->AcquireLayer());
+  std::unique_ptr<ui::Layer> window1_layer(window1->AcquireLayer());
   EXPECT_FALSE(window1_test_api.OwnsLayer());
   EXPECT_TRUE(window1_layer.get() == window1->layer());
 
   // The acquired layer's owner should be set NULL and re-acquring
   // should return NULL.
   EXPECT_FALSE(window1_layer->owner());
-  scoped_ptr<ui::Layer> window1_layer_reacquired(window1->AcquireLayer());
+  std::unique_ptr<ui::Layer> window1_layer_reacquired(window1->AcquireLayer());
   EXPECT_FALSE(window1_layer_reacquired.get());
 
   // Upon destruction, window1's layer should still be valid, and in the layer
   // hierarchy, but window2's should be gone, and no longer in the hierarchy.
   window1.reset();
   window2.reset();
 
   // This should be set by the window's destructor.
   EXPECT_TRUE(window1_layer->delegate() == NULL);
   EXPECT_EQ(1U, parent->children().size());
 }
 
 // Make sure that properties which should persist from the old layer to the new
 // layer actually do.
 TEST_F(WindowTest, RecreateLayer) {
   // Set properties to non default values.
   gfx::Rect window_bounds(100, 100);
   Window w(new ColorTestWindowDelegate(SK_ColorWHITE));
   w.set_id(1);
   w.Init(ui::LAYER_SOLID_COLOR);
   w.SetBounds(window_bounds);
 
   ui::Layer* layer = w.layer();
   layer->SetVisible(false);
   layer->SetMasksToBounds(true);
 
   ui::Layer child_layer;
   layer->Add(&child_layer);
 
-  scoped_ptr<ui::Layer> old_layer(w.RecreateLayer());
+  std::unique_ptr<ui::Layer> old_layer(w.RecreateLayer());
   layer = w.layer();
   EXPECT_EQ(ui::LAYER_SOLID_COLOR, layer->type());
   EXPECT_FALSE(layer->visible());
   EXPECT_EQ(1u, layer->children().size());
   EXPECT_TRUE(layer->GetMasksToBounds());
   EXPECT_EQ("0,0 100x100", w.bounds().ToString());
   EXPECT_EQ("0,0 100x100", layer->bounds().ToString());
 }
 
 // Verify that RecreateLayer() stacks the old layer above the newly creatd
 // layer.
 TEST_F(WindowTest, RecreateLayerZOrder) {
-  scoped_ptr<Window> w(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(0, 0, 100, 100),
-                       root_window()));
-  scoped_ptr<ui::Layer> old_layer(w->RecreateLayer());
+  std::unique_ptr<Window> w(CreateTestWindow(
+      SK_ColorWHITE, 1, gfx::Rect(0, 0, 100, 100), root_window()));
+  std::unique_ptr<ui::Layer> old_layer(w->RecreateLayer());
 
   const std::vector<ui::Layer*>& child_layers =
       root_window()->layer()->children();
   ASSERT_EQ(2u, child_layers.size());
   EXPECT_EQ(w->layer(), child_layers[0]);
   EXPECT_EQ(old_layer.get(), child_layers[1]);
 }
 
 // Ensure that acquiring a layer then recreating a layer does not crash
 // and that RecreateLayer returns null.
 TEST_F(WindowTest, AcquireThenRecreateLayer) {
-  scoped_ptr<Window> w(
-      CreateTestWindow(SK_ColorWHITE, 1, gfx::Rect(0, 0, 100, 100),
-                       root_window()));
-  scoped_ptr<ui::Layer> acquired_layer(w->AcquireLayer());
-  scoped_ptr<ui::Layer> doubly_acquired_layer(w->RecreateLayer());
+  std::unique_ptr<Window> w(CreateTestWindow(
+      SK_ColorWHITE, 1, gfx::Rect(0, 0, 100, 100), root_window()));
+  std::unique_ptr<ui::Layer> acquired_layer(w->AcquireLayer());
+  std::unique_ptr<ui::Layer> doubly_acquired_layer(w->RecreateLayer());
   EXPECT_EQ(NULL, doubly_acquired_layer.get());
 
   // Destroy window before layer gets destroyed.
   w.reset();
 }
 
 class TestVisibilityClient : public client::VisibilityClient {
  public:
   explicit TestVisibilityClient(Window* root_window)
       : ignore_visibility_changes_(false) {
@@ skipping 12 matching lines @@
   }
 
  private:
   bool ignore_visibility_changes_;
   DISALLOW_COPY_AND_ASSIGN(TestVisibilityClient);
 };
 
 TEST_F(WindowTest, VisibilityClientIsVisible) {
   TestVisibilityClient client(root_window());
 
-  scoped_ptr<Window> window(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> window(CreateTestWindowWithId(1, root_window()));
   EXPECT_TRUE(window->IsVisible());
   EXPECT_TRUE(window->layer()->visible());
 
   window->Hide();
   EXPECT_FALSE(window->IsVisible());
   EXPECT_FALSE(window->layer()->visible());
   window->Show();
 
   client.set_ignore_visibility_changes(true);
   window->Hide();
   EXPECT_FALSE(window->IsVisible());
   EXPECT_TRUE(window->layer()->visible());
 }
 
 // Tests the mouse events seen by WindowDelegates in a Window hierarchy when
 // changing the properties of a leaf Window.
 TEST_F(WindowTest, MouseEventsOnLeafWindowChange) {
   gfx::Size size = host()->GetBounds().size();
 
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseTo(50, 50);
 
   EventCountDelegate d1;
-  scoped_ptr<Window> w1(CreateTestWindowWithDelegate(&d1, 1,
-      gfx::Rect(0, 0, 100, 100), root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
+      &d1, 1, gfx::Rect(0, 0, 100, 100), root_window()));
   RunAllPendingInMessageLoop();
   // The format of result is "Enter/Move/Leave".
   EXPECT_EQ("1 1 0", d1.GetMouseMotionCountsAndReset());
 
   // Add new window |w11| on top of |w1| which contains the cursor.
   EventCountDelegate d11;
-  scoped_ptr<Window> w11(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> w11(CreateTestWindowWithDelegate(
       &d11, 1, gfx::Rect(0, 0, 100, 100), w1.get()));
   RunAllPendingInMessageLoop();
   EXPECT_EQ("0 0 1", d1.GetMouseMotionCountsAndReset());
   EXPECT_EQ("1 1 0", d11.GetMouseMotionCountsAndReset());
 
   // Resize |w11| so that it does not contain the cursor.
   w11->SetBounds(gfx::Rect(0, 0, 10, 10));
   RunAllPendingInMessageLoop();
   EXPECT_EQ("1 1 0", d1.GetMouseMotionCountsAndReset());
   EXPECT_EQ("0 0 1", d11.GetMouseMotionCountsAndReset());
@@ skipping 72 matching lines @@
 
 // Tests the mouse events seen by WindowDelegates in a Window hierarchy when
 // deleting a non-leaf Window.
 TEST_F(WindowTest, MouseEventsOnNonLeafWindowDelete) {
   gfx::Size size = host()->GetBounds().size();
 
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseTo(50, 50);
 
   EventCountDelegate d1;
-  scoped_ptr<Window> w1(CreateTestWindowWithDelegate(&d1, 1,
-      gfx::Rect(0, 0, 100, 100), root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
+      &d1, 1, gfx::Rect(0, 0, 100, 100), root_window()));
   RunAllPendingInMessageLoop();
   // The format of result is "Enter/Move/Leave".
   EXPECT_EQ("1 1 0", d1.GetMouseMotionCountsAndReset());
 
   // Add new window |w2| on top of |w1| which contains the cursor.
   EventCountDelegate d2;
-  scoped_ptr<Window> w2(CreateTestWindowWithDelegate(
+  std::unique_ptr<Window> w2(CreateTestWindowWithDelegate(
       &d2, 1, gfx::Rect(0, 0, 100, 100), w1.get()));
   RunAllPendingInMessageLoop();
   EXPECT_EQ("0 0 1", d1.GetMouseMotionCountsAndReset());
   EXPECT_EQ("1 1 0", d2.GetMouseMotionCountsAndReset());
 
   // Add new window on top of |w2| which contains the cursor.
   EventCountDelegate d3;
   CreateTestWindowWithDelegate(
       &d3, 1, gfx::Rect(0, 0, 100, 100), w2.get());
   RunAllPendingInMessageLoop();
@@ skipping 35 matching lines @@
   int added_count_;
   int removed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindowAttachmentObserver);
 };
 
 TEST_F(WindowTest, RootWindowAttachment) {
   RootWindowAttachmentObserver observer;
 
   // Test a direct add/remove from the RootWindow.
-  scoped_ptr<Window> w1(new Window(NULL));
+  std::unique_ptr<Window> w1(new Window(NULL));
   w1->Init(ui::LAYER_NOT_DRAWN);
   w1->AddObserver(&observer);
 
   ParentWindow(w1.get());
   EXPECT_EQ(1, observer.added_count());
   EXPECT_EQ(0, observer.removed_count());
 
   w1.reset();
   EXPECT_EQ(1, observer.added_count());
   EXPECT_EQ(1, observer.removed_count());
@@ skipping 100 matching lines @@
   // got reparented.
   EXPECT_EQ(new_bounds.ToString(), child.GetTargetBounds().ToString());
   EXPECT_EQ(new_bounds.ToString(), child.bounds().ToString());
   EXPECT_EQ("55,55 50x50", child.GetBoundsInRootWindow().ToString());
 }
 
 TEST_F(WindowTest, OwnedByParentFalse) {
   // By default, a window is owned by its parent. If this is set to false, the
   // window will not be destroyed when its parent is.
 
-  scoped_ptr<Window> w1(new Window(NULL));
+  std::unique_ptr<Window> w1(new Window(NULL));
   w1->Init(ui::LAYER_NOT_DRAWN);
-  scoped_ptr<Window> w2(new Window(NULL));
+  std::unique_ptr<Window> w2(new Window(NULL));
   w2->set_owned_by_parent(false);
   w2->Init(ui::LAYER_NOT_DRAWN);
   w1->AddChild(w2.get());
 
   w1.reset();
 
   // We should be able to deref w2 still, but its parent should now be NULL.
   EXPECT_EQ(NULL, w2->parent());
 }
 
 namespace {
 
 // Used By DeleteWindowFromOnWindowDestroyed. Destroys a Window from
 // OnWindowDestroyed().
 class OwningWindowDelegate : public TestWindowDelegate {
  public:
   OwningWindowDelegate() {}
 
   void SetOwnedWindow(Window* window) {
     owned_window_.reset(window);
   }
 
   void OnWindowDestroyed(Window* window) override { owned_window_.reset(NULL); }
 
  private:
-  scoped_ptr<Window> owned_window_;
+  std::unique_ptr<Window> owned_window_;
 
   DISALLOW_COPY_AND_ASSIGN(OwningWindowDelegate);
 };
 
 }  // namespace
 
 // Creates a window with two child windows. When the first child window is
 // destroyed (WindowDelegate::OnWindowDestroyed) it deletes the second child.
 // This synthesizes BrowserView and the status bubble. Both are children of the
 // same parent and destroying BrowserView triggers it destroying the status
 // bubble.
 TEST_F(WindowTest, DeleteWindowFromOnWindowDestroyed) {
-  scoped_ptr<Window> parent(new Window(NULL));
+  std::unique_ptr<Window> parent(new Window(NULL));
   parent->Init(ui::LAYER_NOT_DRAWN);
   OwningWindowDelegate delegate;
   Window* c1 = new Window(&delegate);
   c1->Init(ui::LAYER_NOT_DRAWN);
   parent->AddChild(c1);
   Window* c2 = new Window(NULL);
   c2->Init(ui::LAYER_NOT_DRAWN);
   parent->AddChild(c2);
   delegate.SetOwnedWindow(c2);
   parent.reset();
@@ skipping 29 matching lines @@
 
 // Verifies the delegate is notified when the actual bounds of the layer
 // change.
 TEST_F(WindowTest, DelegateNotifiedAsBoundsChange) {
   BoundsChangeDelegate delegate;
 
   // We cannot short-circuit animations in this test.
   ui::ScopedAnimationDurationScaleMode test_duration_mode(
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
 
-  scoped_ptr<Window> window(
-      CreateTestWindowWithDelegate(&delegate, 1,
-                                   gfx::Rect(0, 0, 100, 100), root_window()));
+  std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
+      &delegate, 1, gfx::Rect(0, 0, 100, 100), root_window()));
   window->layer()->GetAnimator()->set_disable_timer_for_test(true);
 
   delegate.clear_bounds_changed();
 
   // Animate to a different position.
   {
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
     window->SetBounds(gfx::Rect(100, 100, 100, 100));
   }
 
@@ skipping 12 matching lines @@
 
 // Verifies the delegate is notified when the actual bounds of the layer
 // change even when the window is not the layer's delegate
 TEST_F(WindowTest, DelegateNotifiedAsBoundsChangeInHiddenLayer) {
   BoundsChangeDelegate delegate;
 
   // We cannot short-circuit animations in this test.
   ui::ScopedAnimationDurationScaleMode test_duration_mode(
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
 
-  scoped_ptr<Window> window(
-      CreateTestWindowWithDelegate(&delegate, 1,
-                                   gfx::Rect(0, 0, 100, 100), root_window()));
+  std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
+      &delegate, 1, gfx::Rect(0, 0, 100, 100), root_window()));
   window->layer()->GetAnimator()->set_disable_timer_for_test(true);
 
   delegate.clear_bounds_changed();
 
   // Suppress paint on the window since it is hidden (should reset the layer's
   // delegate to NULL)
   window->SuppressPaint();
   EXPECT_EQ(NULL, window->layer()->delegate());
 
   // Animate to a different position.
@@ skipping 46 matching lines @@
   int removed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(AddChildNotificationsObserver);
 };
 
 }  // namespace
 
 // Assertions around when root window notifications are sent.
 TEST_F(WindowTest, AddChildNotifications) {
   AddChildNotificationsObserver observer;
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
-  scoped_ptr<Window> w2(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> w2(CreateTestWindowWithId(1, root_window()));
   w2->AddObserver(&observer);
   w2->Focus();
   EXPECT_TRUE(w2->HasFocus());
 
   // Move |w2| to be a child of |w1|.
   w1->AddChild(w2.get());
   // Sine we moved in the same root, observer shouldn't be notified.
   EXPECT_EQ("0 0", observer.CountStringAndReset());
   // |w2| should still have focus after moving.
   EXPECT_TRUE(w2->HasFocus());
 }
 
 // Tests that a delegate that destroys itself when the window is destroyed does
 // not break.
 TEST_F(WindowTest, DelegateDestroysSelfOnWindowDestroy) {
-  scoped_ptr<Window> w1(CreateTestWindowWithDelegate(
-      new DestroyWindowDelegate(),
-      0,
-      gfx::Rect(10, 20, 30, 40),
-      root_window()));
+  std::unique_ptr<Window> w1(
+      CreateTestWindowWithDelegate(new DestroyWindowDelegate(), 0,
+                                   gfx::Rect(10, 20, 30, 40), root_window()));
 }
 
 class HierarchyObserver : public WindowObserver {
  public:
   explicit HierarchyObserver(Window* target) : target_(target) {
     target_->AddObserver(this);
   }
   ~HierarchyObserver() override { target_->RemoveObserver(this); }
 
   void ValidateState(
@@ skipping 29 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(HierarchyObserver);
 };
 
 // Tests hierarchy change notifications.
 TEST_F(WindowTest, OnWindowHierarchyChange) {
   {
     // Simple add & remove.
     HierarchyObserver oroot(root_window());
 
-    scoped_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
+    std::unique_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
     HierarchyObserver o1(w1.get());
 
     // Add.
     root_window()->AddChild(w1.get());
 
     WindowObserver::HierarchyChangeParams params;
     params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING;
     params.target = w1.get();
     params.old_parent = NULL;
     params.new_parent = root_window();
@@ skipping 25 matching lines @@
 
     params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED;
     params.receiver = w1.get();
     o1.ValidateState(1, params);
   }
 
   {
     // Add & remove of hierarchy. Tests notification order per documentation in
     // WindowObserver.
     HierarchyObserver o(root_window());
-    scoped_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
+    std::unique_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
     Window* w11 = CreateTestWindowWithId(11, w1.get());
     w1->AddObserver(&o);
     w11->AddObserver(&o);
 
     // Add.
     root_window()->AddChild(w1.get());
 
     // Dispatched to target first.
     int index = 0;
     WindowObserver::HierarchyChangeParams params;
@@ skipping 33 matching lines @@
     params.receiver = w1.get();
     o.ValidateState(index++, params);
     params.receiver = w11;
     o.ValidateState(index++, params);
 
     w1.reset();
   }
 
   {
     // Reparent. Tests notification order per documentation in WindowObserver.
-    scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
+    std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
     Window* w11 = CreateTestWindowWithId(11, w1.get());
     Window* w111 = CreateTestWindowWithId(111, w11);
-    scoped_ptr<Window> w2(CreateTestWindowWithId(2, root_window()));
+    std::unique_ptr<Window> w2(CreateTestWindowWithId(2, root_window()));
 
     HierarchyObserver o(root_window());
     w1->AddObserver(&o);
     w11->AddObserver(&o);
     w111->AddObserver(&o);
     w2->AddObserver(&o);
 
     w2->AddChild(w11);
 
     // Dispatched to target first.
@@ skipping 72 matching lines @@
 
 TEST_F(WindowTest, WindowDestroyCompletesAnimations) {
   ui::ScopedAnimationDurationScaleMode test_duration_mode(
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
   scoped_refptr<ui::LayerAnimator> animator =
       ui::LayerAnimator::CreateImplicitAnimator();
   TestLayerAnimationObserver observer;
   animator->AddObserver(&observer);
   // Make sure destroying a Window completes the animation.
   {
-    scoped_ptr<Window> window(CreateTestWindowWithId(1, root_window()));
+    std::unique_ptr<Window> window(CreateTestWindowWithId(1, root_window()));
     window->layer()->SetAnimator(animator.get());
 
     gfx::Transform transform;
     transform.Scale(0.5f, 0.5f);
     window->SetTransform(transform);
 
     EXPECT_TRUE(animator->is_animating());
     EXPECT_FALSE(observer.animation_completed());
   }
   EXPECT_TRUE(animator.get());
   EXPECT_FALSE(animator->is_animating());
   EXPECT_TRUE(observer.animation_completed());
   EXPECT_FALSE(observer.animation_aborted());
   animator->RemoveObserver(&observer);
   observer.Reset();
 
   animator = ui::LayerAnimator::CreateImplicitAnimator();
   animator->AddObserver(&observer);
   ui::Layer layer;
   layer.SetAnimator(animator.get());
   {
-    scoped_ptr<Window> window(CreateTestWindowWithId(1, root_window()));
+    std::unique_ptr<Window> window(CreateTestWindowWithId(1, root_window()));
     window->layer()->Add(&layer);
 
     gfx::Transform transform;
     transform.Scale(0.5f, 0.5f);
     layer.SetTransform(transform);
 
     EXPECT_TRUE(animator->is_animating());
     EXPECT_FALSE(observer.animation_completed());
   }
 
   EXPECT_TRUE(animator.get());
   EXPECT_FALSE(animator->is_animating());
   EXPECT_TRUE(observer.animation_completed());
   EXPECT_FALSE(observer.animation_aborted());
   animator->RemoveObserver(&observer);
 }
 
 }  // namespace test
 }  // namespace aura