Replace scoped_ptr with std::unique_ptr in //ui

ui/wm/core/focus_controller_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/wm/core/focus_controller.h"
 
 #include <map>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/client/focus_change_observer.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/events/event.h"
@@ skipping 442 matching lines @@
   virtual void ActivationRulesOverride() = 0;
   virtual void ShiftFocusOnActivation() {}
   virtual void ShiftFocusOnActivationDueToHide() {}
   virtual void NoShiftActiveOnActivation() {}
   virtual void FocusChangeDuringDrag() {}
   virtual void ChangeFocusWhenNothingFocusedAndCaptured() {}
   virtual void DontPassDeletedWindow() {}
   virtual void StackWindowAtTopOnActivation() {}
 
  private:
-  scoped_ptr<FocusController> focus_controller_;
+  std::unique_ptr<FocusController> focus_controller_;
   TestFocusRules* test_focus_rules_;
-  scoped_ptr<wm::WMState> wm_state_;
+  std::unique_ptr<wm::WMState> wm_state_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerTestBase);
 };
 
 // Test base for tests where focus is directly set to a target window.
 class FocusControllerDirectTestBase : public FocusControllerTestBase {
  protected:
   FocusControllerDirectTestBase() {}
 
   // Different test types shift focus in different ways.
@@ skipping 200 matching lines @@
     EXPECT_EQ(2, GetFocusedWindowId());
     ActivateWindowById(1);
     EXPECT_EQ(1, GetFocusedWindowId());
 
     ActivateWindowById(2);
 
     aura::Window* target = root_window()->GetChildById(1);
     aura::client::ActivationClient* client =
         aura::client::GetActivationClient(root_window());
 
-    scoped_ptr<FocusShiftingActivationObserver> observer(
+    std::unique_ptr<FocusShiftingActivationObserver> observer(
         new FocusShiftingActivationObserver(target));
     observer->set_shift_focus_to(target->GetChildById(11));
     client->AddObserver(observer.get());
 
     ActivateWindowById(1);
 
     // w1's ActivationChangeObserver shifted focus to this child, pre-empting
     // FocusController's default setting.
     EXPECT_EQ(11, GetFocusedWindowId());
 
@@ skipping 20 matching lines @@
     EXPECT_EQ(1, GetFocusedWindowId());
 
     // Removes window 3 as candidate for next activatable window.
     root_window()->GetChildById(3)->Hide();
     EXPECT_EQ(1, GetFocusedWindowId());
 
     aura::Window* target = root_window()->GetChildById(2);
     aura::client::ActivationClient* client =
         aura::client::GetActivationClient(root_window());
 
-    scoped_ptr<FocusShiftingActivationObserver> observer(
+    std::unique_ptr<FocusShiftingActivationObserver> observer(
         new FocusShiftingActivationObserver(target));
     observer->set_shift_focus_to(target->GetChildById(21));
     client->AddObserver(observer.get());
 
     // Hide the active window.
     root_window()->GetChildById(1)->Hide();
 
     EXPECT_EQ(21, GetFocusedWindowId());
 
     client->RemoveObserver(observer.get());
   }
   void NoShiftActiveOnActivation() override {
     // When a window is activated, we need to prevent any change to activation
     // from being made in response to an activation change notification.
   }
 
   void FocusChangeDuringDrag() override {
-    scoped_ptr<aura::client::DefaultCaptureClient> capture_client(
+    std::unique_ptr<aura::client::DefaultCaptureClient> capture_client(
         new aura::client::DefaultCaptureClient(root_window()));
     // Activating an inactive window during drag should activate the window.
     // This emulates the behavior of tab dragging which is merged into the
     // window below.
     ActivateWindowById(1);
 
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(1, GetFocusedWindowId());
 
     aura::Window* w2 = root_window()->GetChildById(2);
@@ skipping 11 matching lines @@
     aura::client::GetActivationClient(root_window())->ActivateWindow(w1);
     EXPECT_EQ(1, GetActiveWindowId());
     EXPECT_EQ(1, GetFocusedWindowId());
 
     generator.ReleaseLeftButton();
     aura::client::GetCaptureClient(root_window())->ReleaseCapture(w1);
   }
 
   // Verifies focus change is honored while capture held.
   void ChangeFocusWhenNothingFocusedAndCaptured() override {
-    scoped_ptr<aura::client::DefaultCaptureClient> capture_client(
+    std::unique_ptr<aura::client::DefaultCaptureClient> capture_client(
         new aura::client::DefaultCaptureClient(root_window()));
     aura::Window* w1 = root_window()->GetChildById(1);
     aura::client::GetCaptureClient(root_window())->SetCapture(w1);
 
     EXPECT_EQ(-1, GetActiveWindowId());
     EXPECT_EQ(-1, GetFocusedWindowId());
 
     FocusWindowById(1);
 
     EXPECT_EQ(1, GetActiveWindowId());
@@ skipping 38 matching lines @@
 
       EXPECT_EQ(to_delete, observer1.GetDeletedWindow());
       EXPECT_FALSE(observer2.was_notified_with_deleted_window());
     }
   }
 
   // Test that the activation of the current active window will bring the window
   // to the top of the window stack.
   void StackWindowAtTopOnActivation() override {
     // Create a window, show it and then activate it.
-    scoped_ptr<aura::Window> window1 =
-        make_scoped_ptr(new aura::Window(nullptr));
+    std::unique_ptr<aura::Window> window1 =
+        base::WrapUnique(new aura::Window(nullptr));
     window1->SetType(ui::wm::WINDOW_TYPE_NORMAL);
     window1->Init(ui::LAYER_TEXTURED);
     root_window()->AddChild(window1.get());
     window1->Show();
     ActivateWindow(window1.get());
     EXPECT_EQ(window1.get(), root_window()->children().back());
     EXPECT_EQ(window1.get(), GetActiveWindow());
 
     // Create another window, show it but don't activate it. The window is not
     // the active window but is placed on top of window stack.
-    scoped_ptr<aura::Window> window2 =
-        make_scoped_ptr(new aura::Window(nullptr));
+    std::unique_ptr<aura::Window> window2 =
+        base::WrapUnique(new aura::Window(nullptr));
     window2->SetType(ui::wm::WINDOW_TYPE_NORMAL);
     window2->Init(ui::LAYER_TEXTURED);
     root_window()->AddChild(window2.get());
     window2->Show();
     EXPECT_EQ(window2.get(), root_window()->children().back());
     EXPECT_EQ(window1.get(), GetActiveWindow());
 
     // Try to reactivate the active window. It should bring the active window
     // to the top of the window stack.
     ActivateWindow(window1.get());
@@ skipping 331 matching lines @@
     aura::Window* disposition_window = GetDispositionWindow(window);
     disposition_window->parent()->RemoveChild(disposition_window);
     window_owner_.reset(disposition_window);
   }
   void TearDown() override {
     window_owner_.reset();
     FocusControllerImplicitTestBase::TearDown();
   }
 
  private:
-  scoped_ptr<aura::Window> window_owner_;
+  std::unique_ptr<aura::Window> window_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusControllerRemovalTest);
 };
 
 // Focus and Activation changes in response to window parent removal.
 class FocusControllerParentRemovalTest : public FocusControllerRemovalTest {
  public:
   FocusControllerParentRemovalTest() : FocusControllerRemovalTest(true) {}
 
  private:
@@ skipping 99 matching lines @@
 FOCUS_CONTROLLER_TEST(FocusControllerApiTest, StackWindowAtTopOnActivation);
 
 // See description above TransientChildWindowActivationTest() for details.
 FOCUS_CONTROLLER_TEST(FocusControllerParentHideTest,
                       TransientChildWindowActivationTest);
 
 // If a mouse event was handled, it should not activate a window.
 FOCUS_CONTROLLER_TEST(FocusControllerMouseEventTest, IgnoreHandledEvent);
 
 }  // namespace wm