Convert //ash from scoped_ptr to std::unique_ptr

ash/content/display/screen_orientation_controller_chromeos_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 "ash/display/screen_orientation_controller_chromeos.h"
+
+#include <memory>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/content/shell_content_state.h"
 #include "ash/display/display_info.h"
 #include "ash/display/display_manager.h"
-#include "ash/display/screen_orientation_controller_chromeos.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/ash_test_helper.h"
 #include "ash/test/content/test_shell_content_state.h"
 #include "ash/test/display_manager_test_api.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/test/test_system_tray_delegate.h"
 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
 #include "base/command_line.h"
-#include "base/memory/scoped_ptr.h"
 #include "chromeos/accelerometer/accelerometer_reader.h"
 #include "chromeos/accelerometer/accelerometer_types.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_context.h"
 #include "third_party/WebKit/public/platform/modules/screen_orientation/WebScreenOrientationLockType.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/display.h"
 #include "ui/message_center/message_center.h"
 #include "ui/views/test/webview_test_helper.h"
@@ skipping 85 matching lines @@
 
   // Creates a secondary content::WebContents, with a separate
   // content::BrowserContext.
   content::WebContents* CreateSecondaryWebContents();
 
   // test::AshTestBase:
   void SetUp() override;
 
  private:
   // Optional content::BrowserContext used for two window tests.
-  scoped_ptr<content::BrowserContext> secondary_browser_context_;
+  std::unique_ptr<content::BrowserContext> secondary_browser_context_;
 
   // Setups underlying content layer so that content::WebContents can be
   // generated.
-  scoped_ptr<views::WebViewTestHelper> webview_test_helper_;
+  std::unique_ptr<views::WebViewTestHelper> webview_test_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenOrientationControllerTest);
 };
 
 ScreenOrientationControllerTest::ScreenOrientationControllerTest() {
   webview_test_helper_.reset(new views::WebViewTestHelper());
 }
 
 ScreenOrientationControllerTest::~ScreenOrientationControllerTest() {
 }
@@ skipping 13 matching lines @@
 void ScreenOrientationControllerTest::SetUp() {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kAshUseFirstDisplayAsInternal);
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kAshEnableTouchViewTesting);
   test::AshTestBase::SetUp();
 }
 
 // Tests that a content::WebContents can lock rotation.
 TEST_F(ScreenOrientationControllerTest, LockOrientation) {
-  scoped_ptr<content::WebContents> content(CreateWebContents());
-  scoped_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<content::WebContents> content(CreateWebContents());
+  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
   ASSERT_NE(nullptr, content->GetNativeView());
   ASSERT_EQ(gfx::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
   ASSERT_FALSE(RotationLocked());
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   EXPECT_EQ(gfx::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
   EXPECT_TRUE(RotationLocked());
 }
 
 // Tests that a content::WebContents can unlock rotation.
 TEST_F(ScreenOrientationControllerTest, Unlock) {
-  scoped_ptr<content::WebContents> content(CreateWebContents());
-  scoped_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<content::WebContents> content(CreateWebContents());
+  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
   ASSERT_NE(nullptr, content->GetNativeView());
   ASSERT_EQ(gfx::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
   ASSERT_FALSE(RotationLocked());
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   EXPECT_EQ(gfx::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
   EXPECT_TRUE(RotationLocked());
 
   delegate()->Unlock(content.get());
   EXPECT_FALSE(RotationLocked());
 }
 
 // Tests that a content::WebContents is able to change the orientation of the
 // display after having locked rotation.
 TEST_F(ScreenOrientationControllerTest, OrientationChanges) {
-  scoped_ptr<content::WebContents> content(CreateWebContents());
-  scoped_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<content::WebContents> content(CreateWebContents());
+  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
   ASSERT_NE(nullptr, content->GetNativeView());
   ASSERT_EQ(gfx::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
   ASSERT_FALSE(RotationLocked());
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockPortrait);
   EXPECT_EQ(gfx::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
   EXPECT_TRUE(RotationLocked());
 
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   EXPECT_EQ(gfx::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that orientation can only be set by the first content::WebContents that
 // has set a rotation lock.
 TEST_F(ScreenOrientationControllerTest, SecondContentCannotChangeOrientation) {
-  scoped_ptr<content::WebContents> content1(CreateWebContents());
-  scoped_ptr<content::WebContents> content2(CreateSecondaryWebContents());
-  scoped_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
-  scoped_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
+  std::unique_ptr<content::WebContents> content1(CreateWebContents());
+  std::unique_ptr<content::WebContents> content2(CreateSecondaryWebContents());
+  std::unique_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
   ASSERT_NE(content1->GetNativeView(), content2->GetNativeView());
 
   AttachAndActivateWebContents(content1.get(), focus_window1.get());
   AttachWebContents(content2.get(), focus_window2.get());
   delegate()->Lock(content1.get(), blink::WebScreenOrientationLockLandscape);
   delegate()->Lock(content2.get(), blink::WebScreenOrientationLockPortrait);
   EXPECT_EQ(gfx::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that only the content::WebContents that set a rotation lock can perform
 // an unlock.
 TEST_F(ScreenOrientationControllerTest, SecondContentCannotUnlock) {
-  scoped_ptr<content::WebContents> content1(CreateWebContents());
-  scoped_ptr<content::WebContents> content2(CreateSecondaryWebContents());
-  scoped_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
-  scoped_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
+  std::unique_ptr<content::WebContents> content1(CreateWebContents());
+  std::unique_ptr<content::WebContents> content2(CreateSecondaryWebContents());
+  std::unique_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
   ASSERT_NE(content1->GetNativeView(), content2->GetNativeView());
 
   AttachAndActivateWebContents(content1.get(), focus_window1.get());
   AttachWebContents(content2.get(), focus_window2.get());
   delegate()->Lock(content1.get(), blink::WebScreenOrientationLockLandscape);
   delegate()->Unlock(content2.get());
   EXPECT_TRUE(RotationLocked());
 }
 
 // Tests that a rotation lock is applied only while the content::WebContents are
 // a part of the active window.
 TEST_F(ScreenOrientationControllerTest, ActiveWindowChangesUpdateLock) {
-  scoped_ptr<content::WebContents> content(CreateWebContents());
-  scoped_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
-  scoped_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
+  std::unique_ptr<content::WebContents> content(CreateWebContents());
+  std::unique_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
 
   AttachAndActivateWebContents(content.get(), focus_window1.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   ASSERT_TRUE(RotationLocked());
 
   aura::client::ActivationClient* activation_client =
       Shell::GetInstance()->activation_client();
   activation_client->ActivateWindow(focus_window2.get());
   EXPECT_FALSE(RotationLocked());
 
   activation_client->ActivateWindow(focus_window1.get());
   EXPECT_TRUE(RotationLocked());
 }
 
 // Tests that switching between windows with different orientation locks change
 // the orientation.
 TEST_F(ScreenOrientationControllerTest, ActiveWindowChangesUpdateOrientation) {
-  scoped_ptr<content::WebContents> content1(CreateWebContents());
-  scoped_ptr<content::WebContents> content2(CreateSecondaryWebContents());
-  scoped_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
-  scoped_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
+  std::unique_ptr<content::WebContents> content1(CreateWebContents());
+  std::unique_ptr<content::WebContents> content2(CreateSecondaryWebContents());
+  std::unique_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
   AttachAndActivateWebContents(content1.get(), focus_window1.get());
   AttachWebContents(content2.get(), focus_window2.get());
 
   delegate()->Lock(content1.get(), blink::WebScreenOrientationLockLandscape);
   delegate()->Lock(content2.get(), blink::WebScreenOrientationLockPortrait);
   EXPECT_EQ(gfx::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
 
   aura::client::ActivationClient* activation_client =
       Shell::GetInstance()->activation_client();
   activation_client->ActivateWindow(focus_window2.get());
   EXPECT_TRUE(RotationLocked());
   EXPECT_EQ(gfx::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
 
   activation_client->ActivateWindow(focus_window1.get());
   EXPECT_TRUE(RotationLocked());
   EXPECT_EQ(gfx::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that a rotation lock is removed when the setting window is hidden, and
 // that it is reapplied when the window becomes visible.
 TEST_F(ScreenOrientationControllerTest, VisibilityChangesLock) {
-  scoped_ptr<content::WebContents> content(CreateWebContents());
-  scoped_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<content::WebContents> content(CreateWebContents());
+  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   EXPECT_TRUE(RotationLocked());
 
   aura::Window* window = content->GetNativeView();
   window->Hide();
   EXPECT_FALSE(RotationLocked());
 
   window->Show();
   EXPECT_TRUE(RotationLocked());
 }
 
 // Tests that when a window is destroyed that its rotation lock is removed, and
 // window activations no longer change the lock
 TEST_F(ScreenOrientationControllerTest, WindowDestructionRemovesLock) {
-  scoped_ptr<content::WebContents> content(CreateWebContents());
-  scoped_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
-  scoped_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
+  std::unique_ptr<content::WebContents> content(CreateWebContents());
+  std::unique_ptr<aura::Window> focus_window1(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<aura::Window> focus_window2(CreateTestWindowInShellWithId(1));
 
   AttachAndActivateWebContents(content.get(), focus_window1.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   ASSERT_TRUE(RotationLocked());
 
   focus_window1->RemoveChild(content->GetNativeView());
   content.reset();
   EXPECT_FALSE(RotationLocked());
 
   aura::client::ActivationClient* activation_client =
@@ skipping 180 matching lines @@
   // User sets rotation to the same rotation that the display was at when
   // maximize mode was activated.
   SetInternalDisplayRotation(gfx::Display::ROTATE_0);
   EnableMaximizeMode(false);
   EXPECT_EQ(gfx::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that when the orientation lock is set to Landscape, that rotation can
 // be done between the two angles of the orientation.
 TEST_F(ScreenOrientationControllerTest, LandscapeOrientationAllowsRotation) {
-  scoped_ptr<content::WebContents> content(CreateWebContents());
-  scoped_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<content::WebContents> content(CreateWebContents());
+  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
   EnableMaximizeMode(true);
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   EXPECT_EQ(gfx::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
   EXPECT_TRUE(RotationLocked());
 
   // Inverse of orientation is allowed
   TriggerLidUpdate(gfx::Vector3dF(0.0f, kMeanGravity, 0.0f));
   EXPECT_EQ(gfx::Display::ROTATE_180, GetCurrentInternalDisplayRotation());
 
   // Display rotations between are not allowed
   TriggerLidUpdate(gfx::Vector3dF(kMeanGravity, 0.0f, 0.0f));
   EXPECT_EQ(gfx::Display::ROTATE_180, GetCurrentInternalDisplayRotation());
   TriggerLidUpdate(gfx::Vector3dF(-kMeanGravity, 0.0f, 0.0f));
   EXPECT_EQ(gfx::Display::ROTATE_180, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that when the orientation lock is set to Portrait, that rotaiton can be
 // done between the two angles of the orientation.
 TEST_F(ScreenOrientationControllerTest, PortraitOrientationAllowsRotation) {
-  scoped_ptr<content::WebContents> content(CreateWebContents());
-  scoped_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<content::WebContents> content(CreateWebContents());
+  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
   EnableMaximizeMode(true);
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockPortrait);
   EXPECT_EQ(gfx::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
   EXPECT_TRUE(RotationLocked());
 
   // Inverse of orientation is allowed
   TriggerLidUpdate(gfx::Vector3dF(kMeanGravity, 0.0f, 0.0f));
   EXPECT_EQ(gfx::Display::ROTATE_270, GetCurrentInternalDisplayRotation());
 
   // Display rotations between are not allowed
   TriggerLidUpdate(gfx::Vector3dF(0.0f, kMeanGravity, 0.0f));
   EXPECT_EQ(gfx::Display::ROTATE_270, GetCurrentInternalDisplayRotation());
   TriggerLidUpdate(gfx::Vector3dF(0.0f, -kMeanGravity, 0.0f));
   EXPECT_EQ(gfx::Display::ROTATE_270, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that for an orientation lock which does not allow rotation, that the
 // display rotation remains constant.
 TEST_F(ScreenOrientationControllerTest, OrientationLockDisallowsRotation) {
-  scoped_ptr<content::WebContents> content(CreateWebContents());
-  scoped_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<content::WebContents> content(CreateWebContents());
+  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
   EnableMaximizeMode(true);
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(),
                    blink::WebScreenOrientationLockPortraitPrimary);
   EXPECT_EQ(gfx::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
   EXPECT_TRUE(RotationLocked());
 
   // Rotation does not change.
   TriggerLidUpdate(gfx::Vector3dF(kMeanGravity, 0.0f, 0.0f));
   EXPECT_EQ(gfx::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
   TriggerLidUpdate(gfx::Vector3dF(0.0f, kMeanGravity, 0.0f));
   EXPECT_EQ(gfx::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
   TriggerLidUpdate(gfx::Vector3dF(0.0f, -kMeanGravity, 0.0f));
   EXPECT_EQ(gfx::Display::ROTATE_90, GetCurrentInternalDisplayRotation());
 }
 
 // Tests that after a content::WebContents has applied an orientation lock which
 // supports rotation, that a user rotation lock does not allow rotation.
 TEST_F(ScreenOrientationControllerTest, UserRotationLockDisallowsRotation) {
-  scoped_ptr<content::WebContents> content(CreateWebContents());
-  scoped_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
+  std::unique_ptr<content::WebContents> content(CreateWebContents());
+  std::unique_ptr<aura::Window> focus_window(CreateTestWindowInShellWithId(0));
   EnableMaximizeMode(true);
 
   AttachAndActivateWebContents(content.get(), focus_window.get());
   delegate()->Lock(content.get(), blink::WebScreenOrientationLockLandscape);
   delegate()->Unlock(content.get());
 
   SetRotationLocked(true);
   EXPECT_TRUE(RotationLocked());
   EXPECT_EQ(gfx::Display::ROTATE_0, GetCurrentInternalDisplayRotation());
 
@@ skipping 58 matching lines @@
                               .GetActiveRotation());
 
   Shell::GetInstance()->screen_orientation_controller()->SetDisplayRotation(
       kNewRotation, gfx::Display::ROTATION_SOURCE_ACTIVE);
 
   EXPECT_EQ(kNewRotation, display_manager->GetDisplayInfo(kInternalDisplayId)
                               .GetActiveRotation());
 }
 
 }  // namespace ash