Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

chrome/browser/ui/panels/stacked_panel_browsertest.cc

 // Copyright (c) 2013 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 "build/build_config.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/panels/base_panel_browser_test.h"
 #include "chrome/browser/ui/panels/detached_panel_collection.h"
 #include "chrome/browser/ui/panels/docked_panel_collection.h"
 #include "chrome/browser/ui/panels/native_panel.h"
@@ skipping 12 matching lines @@
 
   // Create 2 stacked panels.
   StackedPanelCollection* stack = panel_manager->CreateStack();
   gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150);
   Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack);
   gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100);
   Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack);
   gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 120, 110);
   Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack);
 
-  scoped_ptr<NativePanelTesting> panel1_testing(
+  std::unique_ptr<NativePanelTesting> panel1_testing(
       CreateNativePanelTesting(panel1));
-  scoped_ptr<NativePanelTesting> panel2_testing(
+  std::unique_ptr<NativePanelTesting> panel2_testing(
       CreateNativePanelTesting(panel2));
-  scoped_ptr<NativePanelTesting> panel3_testing(
+  std::unique_ptr<NativePanelTesting> panel3_testing(
       CreateNativePanelTesting(panel3));
 
   // Check that all 3 panels are in a stack.
   ASSERT_EQ(0, panel_manager->docked_collection()->num_panels());
   ASSERT_EQ(0, panel_manager->detached_collection()->num_panels());
   ASSERT_EQ(1, panel_manager->num_stacks());
   ASSERT_EQ(3, stack->num_panels());
   EXPECT_EQ(stack, panel1->stack());
   EXPECT_EQ(stack, panel2->stack());
   EXPECT_EQ(stack, panel3->stack());
@@ skipping 69 matching lines @@
 
   // Create 2 stacked panels.
   StackedPanelCollection* stack = panel_manager->CreateStack();
   gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150);
   Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack);
   gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100);
   Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack);
   gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 120, 110);
   Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack);
 
-  scoped_ptr<NativePanelTesting> panel1_testing(
+  std::unique_ptr<NativePanelTesting> panel1_testing(
       CreateNativePanelTesting(panel1));
-  scoped_ptr<NativePanelTesting> panel2_testing(
+  std::unique_ptr<NativePanelTesting> panel2_testing(
       CreateNativePanelTesting(panel2));
-  scoped_ptr<NativePanelTesting> panel3_testing(
+  std::unique_ptr<NativePanelTesting> panel3_testing(
       CreateNativePanelTesting(panel3));
 
   // Minimize these 2 panels.
   panel1->Minimize();
   WaitForBoundsAnimationFinished(panel1);
   panel2->Minimize();
   WaitForBoundsAnimationFinished(panel2);
   panel3->Minimize();
   WaitForBoundsAnimationFinished(panel3);
 
@@ skipping 71 matching lines @@
   PanelManager* panel_manager = PanelManager::GetInstance();
 
   // Create 2 stacked panels.
   StackedPanelCollection* stack = panel_manager->CreateStack();
   gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150);
   Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack);
   gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100);
   Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack);
   ASSERT_EQ(1, panel_manager->num_stacks());
 
-  scoped_ptr<NativePanelTesting> panel1_testing(
+  std::unique_ptr<NativePanelTesting> panel1_testing(
       CreateNativePanelTesting(panel1));
-  scoped_ptr<NativePanelTesting> panel2_testing(
+  std::unique_ptr<NativePanelTesting> panel2_testing(
       CreateNativePanelTesting(panel2));
 
   gfx::Point panel1_origin = panel2->GetBounds().origin();
   gfx::Point panel2_origin = panel2->GetBounds().origin();
 
   EXPECT_FALSE(panel1->IsMinimized());
   EXPECT_FALSE(panel2->IsMinimized());
 
   gfx::Rect panel1_expected_bounds(panel1_initial_bounds);
   EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds());
@@ skipping 213 matching lines @@
   gfx::Rect work_area =
       panel_manager->display_settings_provider()->GetPrimaryWorkArea();
 
   // Create 3 stacked panels.
   StackedPanelCollection* stack = panel_manager->CreateStack();
   Panel* panel1 = CreateStackedPanel("1", gfx::Rect(100, 150, 200, 200), stack);
   Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack);
   Panel* panel3 = CreateStackedPanel("3", gfx::Rect(0, 0, 150, 120), stack);
   ASSERT_EQ(3, stack->num_panels());
 
-  scoped_ptr<NativePanelTesting> panel2_testing(
+  std::unique_ptr<NativePanelTesting> panel2_testing(
       CreateNativePanelTesting(panel2));
 
   // Collapse all panels by clicking on P2's titlebar with APPLY_TO_ALL
   // modifier.
   panel2_testing->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(),
                                                panel::APPLY_TO_ALL);
   panel2_testing->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL);
   WaitForBoundsAnimationFinished(panel1);
   WaitForBoundsAnimationFinished(panel2);
   WaitForBoundsAnimationFinished(panel3);
@@ skipping 31 matching lines @@
   StackedPanelCollection* stack = panel_manager->CreateStack();
   gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150);
   Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack);
   gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100);
   Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack);
   gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 250, 120);
   Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack);
   ASSERT_EQ(1, panel_manager->num_stacks());
   ASSERT_EQ(3, stack->num_panels());
 
-  scoped_ptr<NativePanelTesting> panel1_testing(
+  std::unique_ptr<NativePanelTesting> panel1_testing(
       CreateNativePanelTesting(panel1));
-  scoped_ptr<NativePanelTesting> panel2_testing(
+  std::unique_ptr<NativePanelTesting> panel2_testing(
       CreateNativePanelTesting(panel2));
-  scoped_ptr<NativePanelTesting> panel3_testing(
+  std::unique_ptr<NativePanelTesting> panel3_testing(
       CreateNativePanelTesting(panel3));
 
   // Only P1 shows minimize button.
   if (PanelManager::CanUseSystemMinimize())
     EXPECT_TRUE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON));
   else
     EXPECT_FALSE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON));
   EXPECT_FALSE(panel2_testing->IsButtonVisible(panel::MINIMIZE_BUTTON));
   EXPECT_FALSE(panel3_testing->IsButtonVisible(panel::MINIMIZE_BUTTON));
 
@@ skipping 47 matching lines @@
   PanelManager* panel_manager = PanelManager::GetInstance();
 
   // Create 2 stacked panels.
   StackedPanelCollection* stack = panel_manager->CreateStack();
   gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150);
   Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack);
   gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100);
   Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack);
   ASSERT_EQ(1, panel_manager->num_stacks());
 
-  scoped_ptr<NativePanelTesting> panel1_testing(
+  std::unique_ptr<NativePanelTesting> panel1_testing(
       CreateNativePanelTesting(panel1));
 
   EXPECT_FALSE(panel1->IsMinimized());
   EXPECT_FALSE(panel2->IsMinimized());
 
   // Collapsing P1 by calling its Minimize API.
   panel1->OnMinimizeButtonClicked(panel::NO_MODIFIER);
   EXPECT_FALSE(panel1->IsMinimized());
   EXPECT_FALSE(panel2->IsMinimized());
   EXPECT_TRUE(panel1_testing->VerifySystemMinimizeState());
 
   panel_manager->CloseAll();
 }
 
 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, UngroupMinimizedPanels) {
   PanelManager* panel_manager = PanelManager::GetInstance();
 
   // Create 3 stacked panels.
   StackedPanelCollection* stack = panel_manager->CreateStack();
   gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150);
   Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack);
   gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100);
   Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack);
   gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 250, 120);
   Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack);
   ASSERT_EQ(1, panel_manager->num_stacks());
   ASSERT_EQ(3, stack->num_panels());
 
-  scoped_ptr<NativePanelTesting> panel2_testing(
+  std::unique_ptr<NativePanelTesting> panel2_testing(
       CreateNativePanelTesting(panel2));
-  scoped_ptr<NativePanelTesting> panel3_testing(
+  std::unique_ptr<NativePanelTesting> panel3_testing(
       CreateNativePanelTesting(panel3));
 
   // Minimize these 3 panels.
   panel1->Minimize();
   WaitForBoundsAnimationFinished(panel1);
   panel2->Minimize();
   WaitForBoundsAnimationFinished(panel3);
   panel3->Minimize();
   WaitForBoundsAnimationFinished(panel3);
 
@@ skipping 417 matching lines @@
 
   panel_manager->CloseAll();
 }
 
 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest,
                        AddNewPanelFromDifferentProfile) {
   PanelManager* panel_manager = PanelManager::GetInstance();
 
   // Create a new profile.
   Profile* profile1 = browser()->profile();
-  scoped_ptr<TestingProfile> profile2(new TestingProfile());
+  std::unique_ptr<TestingProfile> profile2(new TestingProfile());
 
   // Create 2 panels from profile1. Expect that these 2 panels stack together.
   CreatePanelParams params1(
       "1", gfx::Rect(50, 50, 100, 100), SHOW_AS_ACTIVE);
   params1.create_mode = PanelManager::CREATE_AS_DETACHED;
   params1.profile = profile1;
   Panel* panel1 = CreatePanelWithParams(params1);
   CreatePanelParams params2(
       "2", gfx::Rect(100, 100, 200, 100), SHOW_AS_ACTIVE);
   params2.create_mode = PanelManager::CREATE_AS_DETACHED;
@@ skipping 375 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest,
                        KeepShowingStackedPanelCreatedBeforeFullScreenMode) {
   PanelManager* panel_manager = PanelManager::GetInstance();
 
   // Create 2 stacked panels.
   StackedPanelCollection* stack = panel_manager->CreateStack();
   Panel* panel1 = CreateStackedPanel("1", gfx::Rect(100, 50, 200, 150), stack);
   Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack);
-  scoped_ptr<NativePanelTesting> panel1_testing(
+  std::unique_ptr<NativePanelTesting> panel1_testing(
       CreateNativePanelTesting(panel1));
-  scoped_ptr<NativePanelTesting> panel2_testing(
+  std::unique_ptr<NativePanelTesting> panel2_testing(
       CreateNativePanelTesting(panel2));
 
   // Panels should be visible at first.
   EXPECT_TRUE(panel1_testing->IsWindowVisible());
   EXPECT_TRUE(panel2_testing->IsWindowVisible());
 
   // Panels' visibility should not be affected when entering full-screen mode.
   mock_display_settings_provider()->EnableFullScreenMode(true);
   EXPECT_TRUE(panel1_testing->IsWindowVisible());
   EXPECT_TRUE(panel2_testing->IsWindowVisible());
 
   // Panels' visibility should not be affected when leaving full-screen mode.
   mock_display_settings_provider()->EnableFullScreenMode(false);
   EXPECT_TRUE(panel1_testing->IsWindowVisible());
   EXPECT_TRUE(panel2_testing->IsWindowVisible());
 
   panel_manager->CloseAll();
 }