Convert //ash from scoped_ptr to std::unique_ptr

ash/metrics/desktop_task_switch_metric_recorder_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 "ash/metrics/desktop_task_switch_metric_recorder.h"
 
+#include <memory>
+
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/test/user_action_tester.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer_type.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/wm/public/activation_client.h"
 #include "ui/wm/public/window_types.h"
 
 using aura::client::ActivationChangeObserver;
 
@@ skipping 18 matching lines @@
 
   // Resets the recorded user action counts.
   void ResetActionCounts();
 
   // Returns the number of times the "Desktop_SwitchTask" user action was
   // recorded.
   int GetActionCount() const;
 
   // Creates a positionable window such that wm::IsWindowUserPositionable(...)
   // would retun true.
-  scoped_ptr<aura::Window> CreatePositionableWindow() const;
+  std::unique_ptr<aura::Window> CreatePositionableWindow() const;
 
   // Creates a non-positionable window such that
   // wm::IsWindowUserPositionable(...) would retun false.
-  scoped_ptr<aura::Window> CreateNonPositionableWindow() const;
+  std::unique_ptr<aura::Window> CreateNonPositionableWindow() const;
 
   // Wrapper to notify the test target's OnWindowActivated(...) method that
   // |window| was activated due to an INPUT_EVENT.
   void ActiveTaskWindowWithUserInput(aura::Window* window);
 
  protected:
   // Records UMA user action counts.
-  scoped_ptr<base::UserActionTester> user_action_tester_;
+  std::unique_ptr<base::UserActionTester> user_action_tester_;
 
   // The test target.
-  scoped_ptr<DesktopTaskSwitchMetricRecorder> metrics_recorder_;
+  std::unique_ptr<DesktopTaskSwitchMetricRecorder> metrics_recorder_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DesktopTaskSwitchMetricRecorderTest);
 };
 
 DesktopTaskSwitchMetricRecorderTest::DesktopTaskSwitchMetricRecorderTest() {
 }
 
 DesktopTaskSwitchMetricRecorderTest::~DesktopTaskSwitchMetricRecorderTest() {
 }
@@ skipping 17 matching lines @@
 }
 
 void DesktopTaskSwitchMetricRecorderTest::ResetActionCounts() {
   user_action_tester_->ResetCounts();
 }
 
 int DesktopTaskSwitchMetricRecorderTest::GetActionCount() const {
   return user_action_tester_->GetActionCount(kDesktopTaskSwitchUserAction);
 }
 
-scoped_ptr<aura::Window>
+std::unique_ptr<aura::Window>
 DesktopTaskSwitchMetricRecorderTest::CreatePositionableWindow() const {
-  scoped_ptr<aura::Window> window(new aura::Window(
+  std::unique_ptr<aura::Window> window(new aura::Window(
       aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate()));
   window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
   window->Init(ui::LAYER_NOT_DRAWN);
   return window;
 }
 
-scoped_ptr<aura::Window>
+std::unique_ptr<aura::Window>
 DesktopTaskSwitchMetricRecorderTest::CreateNonPositionableWindow() const {
-  scoped_ptr<aura::Window> window(new aura::Window(
+  std::unique_ptr<aura::Window> window(new aura::Window(
       aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate()));
   window->SetType(ui::wm::WINDOW_TYPE_UNKNOWN);
   window->Init(ui::LAYER_NOT_DRAWN);
   return window;
 }
 
 // Verify user action is recorded when a positionable window is activated given
 // that a null window was activated last.
 TEST_F(DesktopTaskSwitchMetricRecorderTest,
        ActivatePositionableWindowWhenNullWindowWasActivatedLast) {
-  scoped_ptr<aura::Window> null_window;
-  scoped_ptr<aura::Window> positionable_window = CreatePositionableWindow();
+  std::unique_ptr<aura::Window> null_window;
+  std::unique_ptr<aura::Window> positionable_window =
+      CreatePositionableWindow();
 
   ActiveTaskWindowWithUserInput(null_window.get());
   ResetActionCounts();
 
   ActiveTaskWindowWithUserInput(positionable_window.get());
   EXPECT_EQ(1, GetActionCount());
 }
 
 // Verify user action is recorded whena positionable window is activated given
 // a different positionable window was activated last.
 TEST_F(
     DesktopTaskSwitchMetricRecorderTest,
     ActivatePositionableWindowWhenADifferentPositionableWindowWasActivatedLast) {
-  scoped_ptr<aura::Window> positionable_window_1 = CreatePositionableWindow();
-  scoped_ptr<aura::Window> positionable_window_2 = CreatePositionableWindow();
+  std::unique_ptr<aura::Window> positionable_window_1 =
+      CreatePositionableWindow();
+  std::unique_ptr<aura::Window> positionable_window_2 =
+      CreatePositionableWindow();
 
   ActiveTaskWindowWithUserInput(positionable_window_1.get());
   ResetActionCounts();
 
   ActiveTaskWindowWithUserInput(positionable_window_2.get());
   EXPECT_EQ(1, GetActionCount());
 }
 
 // Verify user action is not recorded when a positionable window is activated
 // given the same positionable window was activated last.
 TEST_F(
     DesktopTaskSwitchMetricRecorderTest,
     ActivatePositionableWindowWhenTheSamePositionableWindowWasActivatedLast) {
-  scoped_ptr<aura::Window> positionable_window = CreatePositionableWindow();
+  std::unique_ptr<aura::Window> positionable_window =
+      CreatePositionableWindow();
 
   ActiveTaskWindowWithUserInput(positionable_window.get());
   ResetActionCounts();
 
   ActiveTaskWindowWithUserInput(positionable_window.get());
   EXPECT_EQ(0, GetActionCount());
 }
 
 // Verify user action is recorded when a positionable window is activated given
 // a non-positionable window was activated last.
 TEST_F(DesktopTaskSwitchMetricRecorderTest,
        ActivatePositionableWindowWhenANonPositionableWindowWasActivatedLast) {
-  scoped_ptr<aura::Window> non_positionable_window =
+  std::unique_ptr<aura::Window> non_positionable_window =
       CreateNonPositionableWindow();
-  scoped_ptr<aura::Window> positionable_window = CreatePositionableWindow();
+  std::unique_ptr<aura::Window> positionable_window =
+      CreatePositionableWindow();
 
   ActiveTaskWindowWithUserInput(non_positionable_window.get());
   ResetActionCounts();
 
   ActiveTaskWindowWithUserInput(positionable_window.get());
   EXPECT_EQ(1, GetActionCount());
 }
 
 // Verify user action is not recorded when a non-positionable window is
 // activated between two activations of the same positionable window.
 TEST_F(DesktopTaskSwitchMetricRecorderTest,
        ActivateNonPositionableWindowBetweenTwoPositionableWindowActivations) {
-  scoped_ptr<aura::Window> positionable_window = CreatePositionableWindow();
-  scoped_ptr<aura::Window> non_positionable_window =
+  std::unique_ptr<aura::Window> positionable_window =
+      CreatePositionableWindow();
+  std::unique_ptr<aura::Window> non_positionable_window =
       CreateNonPositionableWindow();
 
   ActiveTaskWindowWithUserInput(positionable_window.get());
   ResetActionCounts();
 
   ActiveTaskWindowWithUserInput(non_positionable_window.get());
   EXPECT_EQ(0, GetActionCount());
 
   ActiveTaskWindowWithUserInput(positionable_window.get());
   EXPECT_EQ(0, GetActionCount());
 }
 
 // Verify user action is not recorded when a null window is activated.
 TEST_F(DesktopTaskSwitchMetricRecorderTest, ActivateNullWindow) {
-  scoped_ptr<aura::Window> positionable_window = CreatePositionableWindow();
-  scoped_ptr<aura::Window> null_window = nullptr;
+  std::unique_ptr<aura::Window> positionable_window =
+      CreatePositionableWindow();
+  std::unique_ptr<aura::Window> null_window = nullptr;
 
   ActiveTaskWindowWithUserInput(positionable_window.get());
   ResetActionCounts();
 
   ActiveTaskWindowWithUserInput(null_window.get());
   EXPECT_EQ(0, GetActionCount());
 }
 
 // Verify user action is not recorded when a non-positionable window is
 // activated.
 TEST_F(DesktopTaskSwitchMetricRecorderTest, ActivateNonPositionableWindow) {
-  scoped_ptr<aura::Window> positionable_window = CreatePositionableWindow();
-  scoped_ptr<aura::Window> non_positionable_window =
+  std::unique_ptr<aura::Window> positionable_window =
+      CreatePositionableWindow();
+  std::unique_ptr<aura::Window> non_positionable_window =
       CreateNonPositionableWindow();
 
   ActiveTaskWindowWithUserInput(positionable_window.get());
   ResetActionCounts();
 
   ActiveTaskWindowWithUserInput(non_positionable_window.get());
   EXPECT_EQ(0, GetActionCount());
 }
 
 // Verify user action is not recorded when the ActivationReason is not an
 // INPUT_EVENT.
 TEST_F(DesktopTaskSwitchMetricRecorderTest,
        ActivatePositionableWindowWithNonInputEventReason) {
-  scoped_ptr<aura::Window> positionable_window_1 = CreatePositionableWindow();
-  scoped_ptr<aura::Window> positionable_window_2 = CreatePositionableWindow();
+  std::unique_ptr<aura::Window> positionable_window_1 =
+      CreatePositionableWindow();
+  std::unique_ptr<aura::Window> positionable_window_2 =
+      CreatePositionableWindow();
 
   ActiveTaskWindowWithUserInput(positionable_window_1.get());
   ResetActionCounts();
 
   metrics_recorder_->OnWindowActivated(
       ActivationChangeObserver::ActivationReason::ACTIVATION_CLIENT,
       positionable_window_2.get(), nullptr);
   EXPECT_EQ(0, GetActionCount());
 }
 
@@ skipping 13 matching lines @@
   // recorded.
   int GetActionCount() const;
 
   // Creates a positionable window with the given |bounds| such that
   // wm::IsWindowUserPositionable(...) would retun true.
   aura::Window* CreatePositionableWindowInShellWithBounds(
       const gfx::Rect& bounds);
 
  protected:
   // Records UMA user action counts.
-  scoped_ptr<base::UserActionTester> user_action_tester_;
+  std::unique_ptr<base::UserActionTester> user_action_tester_;
 
   // Delegate used when creating new windows using the
   // CreatePositionableWindowInShellWithBounds(...) method.
   aura::test::TestWindowDelegate test_window_delegate_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(
       DesktopTaskSwitchMetricRecorderWithShellIntegrationTest);
 };
 
@@ skipping 48 matching lines @@
       CreatePositionableWindowInShellWithBounds(gfx::Rect(0, 0, 10, 10));
 
   Shell::GetInstance()->activation_client()->ActivateWindow(
       positionable_window);
 
   EXPECT_EQ(0, GetActionCount());
 }
 
 }  // namespace
 }  // namespace ash