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

chrome/browser/ui/panels/panel_browsertest.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 <stddef.h>
 
 #include "base/bind.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
@@ skipping 256 matching lines @@
 
   // Create 3 docked panels that are in expanded, title-only or minimized states
   // respectively.
   Panel* panel1 = CreatePanelWithBounds("1", gfx::Rect(0, 0, 100, 100));
   Panel* panel2 = CreatePanelWithBounds("2", gfx::Rect(0, 0, 100, 100));
   Panel* panel3 = CreatePanelWithBounds("3", gfx::Rect(0, 0, 100, 100));
   panel2->SetExpansionState(Panel::TITLE_ONLY);
   EXPECT_EQ(Panel::TITLE_ONLY, panel2->expansion_state());
   panel3->SetExpansionState(Panel::MINIMIZED);
   EXPECT_EQ(Panel::MINIMIZED, panel3->expansion_state());
-  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));
 
   // Ensure that the layout message can get a chance to be processed so that
   // the button visibility can be updated.
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(3, panel_manager->num_panels());
   EXPECT_TRUE(docked_collection->HasPanel(panel1));
   EXPECT_TRUE(docked_collection->HasPanel(panel2));
   EXPECT_TRUE(docked_collection->HasPanel(panel3));
@@ skipping 215 matching lines @@
   EXPECT_EQ(original_height, panel->GetBounds().height());
   EXPECT_EQ(new_bounds.size(), panel->GetRestoredBounds().size());
 
   panel->Close();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, AnimateBounds) {
   // Create a detached panel, instead of docked panel because it cannot be
   // moved to any location.
   Panel* panel = CreateDetachedPanel("1", gfx::Rect(200, 100, 100, 100));
-  scoped_ptr<NativePanelTesting> panel_testing(
+  std::unique_ptr<NativePanelTesting> panel_testing(
       CreateNativePanelTesting(panel));
 
   // Validates that no animation should be triggered when the panel is being
   // dragged.
   gfx::Point mouse_location(panel->GetBounds().origin());
   panel_testing->PressLeftMouseButtonTitlebar(mouse_location);
   panel_testing->DragTitlebar(mouse_location + gfx::Vector2d(-100, 5));
   EXPECT_FALSE(panel_testing->IsAnimatingBounds());
   panel_testing->FinishDragTitlebar();
 
@@ skipping 153 matching lines @@
 #endif
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_RestoreAllWithTitlebarClick) {
   // Test with three panels.
   Panel* panel1 = CreatePanel("PanelTest1");
   Panel* panel2 = CreatePanel("PanelTest2");
   Panel* panel3 = CreatePanel("PanelTest3");
   EXPECT_FALSE(panel1->IsMinimized());
   EXPECT_FALSE(panel2->IsMinimized());
   EXPECT_FALSE(panel3->IsMinimized());
 
-  scoped_ptr<NativePanelTesting> test_panel1(
+  std::unique_ptr<NativePanelTesting> test_panel1(
       CreateNativePanelTesting(panel1));
-  scoped_ptr<NativePanelTesting> test_panel2(
+  std::unique_ptr<NativePanelTesting> test_panel2(
       CreateNativePanelTesting(panel2));
-  scoped_ptr<NativePanelTesting> test_panel3(
+  std::unique_ptr<NativePanelTesting> test_panel3(
       CreateNativePanelTesting(panel3));
 
   // Click on an expanded panel's titlebar using the apply-all modifier.
   // Verify expansion state is unchanged.
   test_panel2->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(),
                                             panel::APPLY_TO_ALL);
   test_panel2->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL);
   EXPECT_FALSE(panel1->IsMinimized());
   EXPECT_FALSE(panel2->IsMinimized());
   EXPECT_FALSE(panel3->IsMinimized());
@@ skipping 286 matching lines @@
 #define MAYBE_ActivateDeactivateBasic DISABLED_ActivateDeactivateBasic
 #endif
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_ActivateDeactivateBasic) {
   if (!WmSupportWindowActivation()) {
     LOG(WARNING) << "Skipping test due to WM problems.";
     return;
   }
 
   // Create an active panel.
   Panel* panel = CreatePanel("PanelTest");
-  scoped_ptr<NativePanelTesting> native_panel_testing(
+  std::unique_ptr<NativePanelTesting> native_panel_testing(
       CreateNativePanelTesting(panel));
 
   WaitForPanelActiveState(panel, SHOW_AS_ACTIVE);  // doublecheck active state
   EXPECT_TRUE(native_panel_testing->VerifyActiveState(true));
 
   // Deactivate the panel.
   panel->Deactivate();
   WaitForPanelActiveState(panel, SHOW_AS_INACTIVE);
 
   // On GTK there is no way to deactivate a window. So the Deactivate() call
@@ skipping 37 matching lines @@
   EXPECT_EQ(expected_active_states, GetAllPanelActiveStates());
 
   // Minimizing inactive panel P2 should not affect other panels' active states.
   panels[2]->SetExpansionState(Panel::MINIMIZED);
   EXPECT_EQ(expected_active_states, GetAllPanelActiveStates());
   EXPECT_FALSE(tabbed_window->IsActive());
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionBasic) {
   Panel* panel = CreateInactivePanel("P1");
-  scoped_ptr<NativePanelTesting> native_panel_testing(
+  std::unique_ptr<NativePanelTesting> native_panel_testing(
       CreateNativePanelTesting(panel));
 
   // Test that the attention is drawn when the expanded panel is not in focus.
   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
   EXPECT_FALSE(panel->IsActive());
   EXPECT_FALSE(panel->IsDrawingAttention());
   panel->FlashFrame(true);
   EXPECT_TRUE(panel->IsDrawingAttention());
   EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention());
 
@@ skipping 15 matching lines @@
   EXPECT_FALSE(panel->IsDrawingAttention());
   EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state());
 
   panel->Close();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionWhileMinimized) {
   Panel* panel1 = CreateInactivePanel("P1");
   Panel* panel2 = CreateInactivePanel("P2");
 
-  scoped_ptr<NativePanelTesting> native_panel1_testing(
+  std::unique_ptr<NativePanelTesting> native_panel1_testing(
       CreateNativePanelTesting(panel1));
 
   // Test that the attention is drawn and the title-bar is brought up when the
   // minimized panel is drawing attention.
   panel1->Minimize();
   EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state());
   panel1->FlashFrame(true);
   EXPECT_TRUE(panel1->IsDrawingAttention());
   EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state());
   EXPECT_TRUE(native_panel1_testing->VerifyDrawingAttention());
@@ skipping 88 matching lines @@
   MoveMouseAndWaitForExpansionStateChange(panel1, hover_point);
   EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state());
   EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state());
 
   PanelManager::GetInstance()->CloseAll();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionWhenActive) {
   // Create an active panel.
   Panel* panel = CreatePanel("P1");
-  scoped_ptr<NativePanelTesting> native_panel_testing(
+  std::unique_ptr<NativePanelTesting> native_panel_testing(
       CreateNativePanelTesting(panel));
 
   // Test that the attention should not be drawn if the expanded panel is in
   // focus.
   panel->FlashFrame(true);
   EXPECT_FALSE(panel->IsDrawingAttention());
   EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention());
 
   panel->Close();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionResetOnActivate) {
   Panel* panel = CreateInactivePanel("P1");
-  scoped_ptr<NativePanelTesting> native_panel_testing(
+  std::unique_ptr<NativePanelTesting> native_panel_testing(
       CreateNativePanelTesting(panel));
 
   panel->FlashFrame(true);
   EXPECT_TRUE(panel->IsDrawingAttention());
   EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention());
 
   // Test that the attention is cleared when panel gets focus.
   panel->Activate();
   WaitForPanelActiveState(panel, SHOW_AS_ACTIVE);
   EXPECT_FALSE(panel->IsDrawingAttention());
@@ skipping 23 matching lines @@
   EXPECT_TRUE(panel->IsDrawingAttention());  // Unchanged.
 
   panel->OnActiveStateChanged(true);
   EXPECT_FALSE(panel->IsDrawingAttention());  // Attention cleared.
 
   panel->Close();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionResetOnClick) {
   Panel* panel = CreateInactivePanel("P1");
-  scoped_ptr<NativePanelTesting> native_panel_testing(
+  std::unique_ptr<NativePanelTesting> native_panel_testing(
       CreateNativePanelTesting(panel));
 
   panel->FlashFrame(true);
   EXPECT_TRUE(panel->IsDrawingAttention());
   EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention());
 
   // Test that the attention is cleared when panel gets focus.
   native_panel_testing->PressLeftMouseButtonTitlebar(
       panel->GetBounds().origin());
   native_panel_testing->ReleaseMouseButtonTitlebar();
 
   WaitForPanelActiveState(panel, SHOW_AS_ACTIVE);
   EXPECT_FALSE(panel->IsDrawingAttention());
   EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention());
 
   panel->Close();
 }
 
 // http://crbug.com/175760; several panel tests failing regularly on mac.
 #if defined(OS_MACOSX)
 #define MAYBE_MinimizeImmediatelyAfterRestore \
   DISABLED_MinimizeImmediatelyAfterRestore
 #else
 #define MAYBE_MinimizeImmediatelyAfterRestore MinimizeImmediatelyAfterRestore
 #endif
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
                        MAYBE_MinimizeImmediatelyAfterRestore) {
   CreatePanelParams params("Panel Test", gfx::Rect(), SHOW_AS_ACTIVE);
   Panel* panel = CreatePanelWithParams(params);
-  scoped_ptr<NativePanelTesting> native_panel_testing(
+  std::unique_ptr<NativePanelTesting> native_panel_testing(
       CreateNativePanelTesting(panel));
 
   PanelActiveStateObserver signal(panel, false);
   panel->Minimize();  // this should deactivate.
   signal.Wait();
   EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state());
 
   panel->Restore();
   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
 
@@ skipping 394 matching lines @@
   content::NativeWebKeyboardEvent key_event(ui_event);
   panel->HandleKeyboardEvent(key_event);
   signal.Wait();
   EXPECT_EQ(0, panel_manager->num_panels());
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
                        HideDockedPanelCreatedBeforeFullScreenMode) {
   // Create a docked panel.
   Panel* panel = CreatePanel("PanelTest");
-  scoped_ptr<NativePanelTesting> panel_testing(CreateNativePanelTesting(panel));
+  std::unique_ptr<NativePanelTesting> panel_testing(
+      CreateNativePanelTesting(panel));
 
   // Panel should be visible at first.
   EXPECT_TRUE(panel_testing->IsWindowVisible());
 
   // Panel should become hidden when entering full-screen mode.
   mock_display_settings_provider()->EnableFullScreenMode(true);
   EXPECT_FALSE(panel_testing->IsWindowVisible());
 
   // Panel should become visible when leaving full-screen mode.
   mock_display_settings_provider()->EnableFullScreenMode(false);
   EXPECT_TRUE(panel_testing->IsWindowVisible());
 
   PanelManager::GetInstance()->CloseAll();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
                        HideDockedPanelCreatedOnFullScreenMode) {
   // Enable full-screen mode first.
   mock_display_settings_provider()->EnableFullScreenMode(true);
 
   // Create a docked panel without waiting for it to be shown since it is not
   // supposed to be shown on full-screen mode.
   CreatePanelParams params("1", gfx::Rect(0, 0, 250, 200), SHOW_AS_ACTIVE);
   params.wait_for_fully_created = false;
   Panel* panel = CreatePanelWithParams(params);
-  scoped_ptr<NativePanelTesting> panel_testing(
+  std::unique_ptr<NativePanelTesting> panel_testing(
       CreateNativePanelTesting(panel));
 
   // Panel should not be shown on full-screen mode.
   EXPECT_FALSE(panel_testing->IsWindowVisible());
 
   // Panel should become visible when leaving full-screen mode.
   mock_display_settings_provider()->EnableFullScreenMode(false);
   EXPECT_TRUE(panel_testing->IsWindowVisible());
 
   PanelManager::GetInstance()->CloseAll();
@@ skipping 104 matching lines @@
                                expected_prefix,
                                base::CompareCase::INSENSITIVE_ASCII));
 
   PanelManager::GetInstance()->CloseAll();
   EXPECT_EQ(1U, task_manager.tasks().size());
 }
 
 }  // namespace
 
 #endif  // defined(ENABLE_TASK_MANAGER)