Replace scoped_ptr with std::unique_ptr in //ui

ui/wm/core/transient_window_manager_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/wm/core/transient_window_manager.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "ui/aura/client/window_tree_client.h"
@@ skipping 33 matching lines @@
  private:
   int add_count_;
   int remove_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTransientWindowObserver);
 };
 
 class WindowVisibilityObserver : public aura::WindowObserver {
  public:
   WindowVisibilityObserver(Window* observed_window,
-                           scoped_ptr<Window> owned_window)
+                           std::unique_ptr<Window> owned_window)
       : observed_window_(observed_window),
         owned_window_(std::move(owned_window)) {
     observed_window_->AddObserver(this);
   }
   ~WindowVisibilityObserver() override {
     observed_window_->RemoveObserver(this);
   }
 
   void OnWindowVisibilityChanged(Window* window, bool visible) override {
     owned_window_.reset();
   }
  private:
   Window* observed_window_;
-  scoped_ptr<Window> owned_window_;
+  std::unique_ptr<Window> owned_window_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowVisibilityObserver);
 };
 
 class TransientWindowManagerTest : public aura::test::AuraTestBase {
  public:
   TransientWindowManagerTest() {}
   ~TransientWindowManagerTest() override {}
 
   void SetUp() override {
@@ skipping 12 matching lines @@
     Window* window = new Window(NULL);
     window->set_id(id);
     window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
     window->Init(ui::LAYER_TEXTURED);
     AddTransientChild(parent, window);
     aura::client::ParentWindowWithContext(window, root_window(), gfx::Rect());
     return window;
   }
 
  private:
-  scoped_ptr<wm::WMState> wm_state_;
+  std::unique_ptr<wm::WMState> wm_state_;
 
   DISALLOW_COPY_AND_ASSIGN(TransientWindowManagerTest);
 };
 
 // Various assertions for transient children.
 TEST_F(TransientWindowManagerTest, TransientChildren) {
-  scoped_ptr<Window> parent(CreateTestWindowWithId(0, root_window()));
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, parent.get()));
-  scoped_ptr<Window> w3(CreateTestWindowWithId(3, parent.get()));
+  std::unique_ptr<Window> parent(CreateTestWindowWithId(0, root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, parent.get()));
+  std::unique_ptr<Window> w3(CreateTestWindowWithId(3, parent.get()));
   Window* w2 = CreateTestWindowWithId(2, parent.get());
   // w2 is now owned by w1.
   AddTransientChild(w1.get(), w2);
   // Stack w1 at the top (end), this should force w2 to be last (on top of w1).
   parent->StackChildAtTop(w1.get());
   ASSERT_EQ(3u, parent->children().size());
   EXPECT_EQ(w2, parent->children().back());
 
   // Destroy w1, which should also destroy w3 (since it's a transient child).
   w1.reset();
@@ skipping 54 matching lines @@
   w1->Hide();
   EXPECT_FALSE(w2->IsVisible());
   w2->Hide();
   EXPECT_FALSE(w2->IsVisible());
   w1->Show();
   EXPECT_TRUE(w2->IsVisible());
 }
 
 // Tests that transient children are stacked as a unit when using stack above.
 TEST_F(TransientWindowManagerTest, TransientChildrenGroupAbove) {
-  scoped_ptr<Window> parent(CreateTestWindowWithId(0, root_window()));
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, parent.get()));
+  std::unique_ptr<Window> parent(CreateTestWindowWithId(0, root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, parent.get()));
   Window* w11 = CreateTestWindowWithId(11, parent.get());
-  scoped_ptr<Window> w2(CreateTestWindowWithId(2, parent.get()));
+  std::unique_ptr<Window> w2(CreateTestWindowWithId(2, parent.get()));
   Window* w21 = CreateTestWindowWithId(21, parent.get());
   Window* w211 = CreateTestWindowWithId(211, parent.get());
   Window* w212 = CreateTestWindowWithId(212, parent.get());
   Window* w213 = CreateTestWindowWithId(213, parent.get());
   Window* w22 = CreateTestWindowWithId(22, parent.get());
   ASSERT_EQ(8u, parent->children().size());
 
   // w11 is now owned by w1.
   AddTransientChild(w1.get(), w11);
   // w21 is now owned by w2.
@@ skipping 52 matching lines @@
   EXPECT_EQ(w212, parent->children().back());
   EXPECT_EQ("1 11 2 22 21 213 211 212", ChildWindowIDsAsString(parent.get()));
 
   parent->StackChildAbove(w11, w213);
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get()));
 }
 
 // Tests that transient children are stacked as a unit when using stack below.
 TEST_F(TransientWindowManagerTest, TransientChildrenGroupBelow) {
-  scoped_ptr<Window> parent(CreateTestWindowWithId(0, root_window()));
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, parent.get()));
+  std::unique_ptr<Window> parent(CreateTestWindowWithId(0, root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, parent.get()));
   Window* w11 = CreateTestWindowWithId(11, parent.get());
-  scoped_ptr<Window> w2(CreateTestWindowWithId(2, parent.get()));
+  std::unique_ptr<Window> w2(CreateTestWindowWithId(2, parent.get()));
   Window* w21 = CreateTestWindowWithId(21, parent.get());
   Window* w211 = CreateTestWindowWithId(211, parent.get());
   Window* w212 = CreateTestWindowWithId(212, parent.get());
   Window* w213 = CreateTestWindowWithId(213, parent.get());
   Window* w22 = CreateTestWindowWithId(22, parent.get());
   ASSERT_EQ(8u, parent->children().size());
 
   // w11 is now owned by w1.
   AddTransientChild(w1.get(), w11);
   // w21 is now owned by w2.
@@ skipping 49 matching lines @@
   EXPECT_EQ(w212, parent->children().back());
   EXPECT_EQ("1 11 2 22 21 213 211 212", ChildWindowIDsAsString(parent.get()));
 
   parent->StackChildBelow(w213, w11);
   EXPECT_EQ(w11, parent->children().back());
   EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get()));
 }
 
 // Tests that transient windows are stacked properly when created.
 TEST_F(TransientWindowManagerTest, StackUponCreation) {
-  scoped_ptr<Window> window0(CreateTestWindowWithId(0, root_window()));
-  scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> window0(CreateTestWindowWithId(0, root_window()));
+  std::unique_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
 
-  scoped_ptr<Window> window2(CreateTransientChild(2, window0.get()));
+  std::unique_ptr<Window> window2(CreateTransientChild(2, window0.get()));
   EXPECT_EQ("0 2 1", ChildWindowIDsAsString(root_window()));
 }
 
 // Tests for a crash when window destroyed inside
 // UpdateTransientChildVisibility loop.
 TEST_F(TransientWindowManagerTest, CrashOnVisibilityChange) {
-  scoped_ptr<Window> window1(CreateTransientChild(1, root_window()));
-  scoped_ptr<Window> window2(CreateTransientChild(2, root_window()));
+  std::unique_ptr<Window> window1(CreateTransientChild(1, root_window()));
+  std::unique_ptr<Window> window2(CreateTransientChild(2, root_window()));
   window1->Show();
   window2->Show();
 
   WindowVisibilityObserver visibility_observer(window1.get(),
                                                std::move(window2));
   root_window()->Hide();
 }
 // Tests that windows are restacked properly after a call to AddTransientChild()
 // or RemoveTransientChild().
 TEST_F(TransientWindowManagerTest, RestackUponAddOrRemoveTransientChild) {
-  scoped_ptr<Window> windows[4];
+  std::unique_ptr<Window> windows[4];
   for (int i = 0; i < 4; i++)
     windows[i].reset(CreateTestWindowWithId(i, root_window()));
   EXPECT_EQ("0 1 2 3", ChildWindowIDsAsString(root_window()));
 
   AddTransientChild(windows[0].get(), windows[2].get());
   EXPECT_EQ("0 2 1 3", ChildWindowIDsAsString(root_window()));
 
   AddTransientChild(windows[0].get(), windows[3].get());
   EXPECT_EQ("0 2 3 1", ChildWindowIDsAsString(root_window()));
 
@@ skipping 27 matching lines @@
 };
 
 }  // namespace
 
 // Verifies the delegate is notified of destruction after transients are
 // destroyed.
 TEST_F(TransientWindowManagerTest, NotifyDelegateAfterDeletingTransients) {
   std::vector<std::string> destruction_order;
 
   DestroyedTrackingDelegate parent_delegate("parent", &destruction_order);
-  scoped_ptr<Window> parent(new Window(&parent_delegate));
+  std::unique_ptr<Window> parent(new Window(&parent_delegate));
   parent->Init(ui::LAYER_NOT_DRAWN);
 
   DestroyedTrackingDelegate transient_delegate("transient", &destruction_order);
   Window* transient = new Window(&transient_delegate);  // Owned by |parent|.
   transient->Init(ui::LAYER_NOT_DRAWN);
   AddTransientChild(parent.get(), transient);
   parent.reset();
 
   ASSERT_EQ(2u, destruction_order.size());
   EXPECT_EQ("transient", destruction_order[0]);
   EXPECT_EQ("parent", destruction_order[1]);
 }
 
 TEST_F(TransientWindowManagerTest,
        StackTransientsLayersRelativeToOtherTransients) {
   // Create a window with several transients, then a couple windows on top.
-  scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
-  scoped_ptr<Window> window11(CreateTransientChild(11, window1.get()));
-  scoped_ptr<Window> window12(CreateTransientChild(12, window1.get()));
-  scoped_ptr<Window> window13(CreateTransientChild(13, window1.get()));
+  std::unique_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
+  std::unique_ptr<Window> window11(CreateTransientChild(11, window1.get()));
+  std::unique_ptr<Window> window12(CreateTransientChild(12, window1.get()));
+  std::unique_ptr<Window> window13(CreateTransientChild(13, window1.get()));
 
   EXPECT_EQ("1 11 12 13", ChildWindowIDsAsString(root_window()));
 
   // Stack 11 above 12.
   root_window()->StackChildAbove(window11.get(), window12.get());
   EXPECT_EQ("1 12 11 13", ChildWindowIDsAsString(root_window()));
 
   // Stack 13 below 12.
   root_window()->StackChildBelow(window13.get(), window12.get());
   EXPECT_EQ("1 13 12 11", ChildWindowIDsAsString(root_window()));
 
   // Stack 11 above 1.
   root_window()->StackChildAbove(window11.get(), window1.get());
   EXPECT_EQ("1 11 13 12", ChildWindowIDsAsString(root_window()));
 
   // Stack 12 below 13.
   root_window()->StackChildBelow(window12.get(), window13.get());
   EXPECT_EQ("1 11 12 13", ChildWindowIDsAsString(root_window()));
 }
 
 // Verifies TransientWindowObserver is notified appropriately.
 TEST_F(TransientWindowManagerTest, TransientWindowObserverNotified) {
-  scoped_ptr<Window> parent(CreateTestWindowWithId(0, root_window()));
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, parent.get()));
+  std::unique_ptr<Window> parent(CreateTestWindowWithId(0, root_window()));
+  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, parent.get()));
 
   TestTransientWindowObserver test_observer;
   TransientWindowManager::Get(parent.get())->AddObserver(&test_observer);
 
   AddTransientChild(parent.get(), w1.get());
   EXPECT_EQ(1, test_observer.add_count());
   EXPECT_EQ(0, test_observer.remove_count());
 
   RemoveTransientChild(parent.get(), w1.get());
   EXPECT_EQ(1, test_observer.add_count());
   EXPECT_EQ(1, test_observer.remove_count());
 
   TransientWindowManager::Get(parent.get())->RemoveObserver(&test_observer);
 }
 
 }  // namespace wm