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

chrome/browser/chromeos/power/renderer_freezer_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 "chrome/browser/chromeos/power/renderer_freezer.h"
 
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
@@ skipping 104 matching lines @@
 };
 
 }  // namespace
 
 class RendererFreezerTest : public testing::Test {
  public:
   RendererFreezerTest()
       : power_manager_client_(new FakePowerManagerClient()),
         test_delegate_(new TestDelegate()) {
     DBusThreadManager::GetSetterForTesting()->SetPowerManagerClient(
-        scoped_ptr<PowerManagerClient>(power_manager_client_));
+        std::unique_ptr<PowerManagerClient>(power_manager_client_));
   }
 
   ~RendererFreezerTest() override {
     renderer_freezer_.reset();
 
     DBusThreadManager::Shutdown();
   }
 
  protected:
   void Init() {
     renderer_freezer_.reset(new RendererFreezer(
-        scoped_ptr<RendererFreezer::Delegate>(test_delegate_)));
+        std::unique_ptr<RendererFreezer::Delegate>(test_delegate_)));
   }
 
   // Owned by DBusThreadManager.
   FakePowerManagerClient* power_manager_client_;
 
   // Owned by |renderer_freezer_|.
   TestDelegate* test_delegate_;
-  scoped_ptr<RendererFreezer> renderer_freezer_;
+  std::unique_ptr<RendererFreezer> renderer_freezer_;
 
  private:
   content::TestBrowserThreadBundle browser_thread_bundle_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererFreezerTest);
 };
 
 // Tests that the RendererFreezer freezes renderers on suspend and thaws them on
 // resume.
 TEST_F(RendererFreezerTest, SuspendResume) {
@@ skipping 74 matching lines @@
 
     base::RunLoop().RunUntilIdle();
 
     profile_manager_.reset();
 
     RendererFreezerTest::TearDown();
   }
 
  protected:
   void CreateRenderProcessForExtension(extensions::Extension* extension) {
-    scoped_ptr<content::MockRenderProcessHostFactory> rph_factory(
+    std::unique_ptr<content::MockRenderProcessHostFactory> rph_factory(
         new content::MockRenderProcessHostFactory());
     scoped_refptr<content::SiteInstance> site_instance(
         extensions::ProcessManager::Get(profile_)->GetSiteInstanceForURL(
             extensions::BackgroundInfo::GetBackgroundURL(extension)));
-    scoped_ptr<content::RenderProcessHost> rph(
+    std::unique_ptr<content::RenderProcessHost> rph(
         rph_factory->CreateRenderProcessHost(profile_, site_instance.get()));
 
     // Fake that the RenderProcessHost is hosting the gcm app.
     extensions::ProcessMap::Get(profile_)
         ->Insert(extension->id(), rph->GetID(), site_instance->GetId());
 
     // Send the notification that the RenderProcessHost has been created.
     content::NotificationService::current()->Notify(
         content::NOTIFICATION_RENDERER_PROCESS_CREATED,
         content::Source<content::RenderProcessHost>(rph.get()),
         content::NotificationService::NoDetails());
   }
 
   // Owned by |profile_manager_|.
   TestingProfile* profile_;
-  scoped_ptr<TestingProfileManager> profile_manager_;
+  std::unique_ptr<TestingProfileManager> profile_manager_;
 
  private:
   // Chrome OS needs extra services to run in the following order.
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   chromeos::ScopedTestUserManager test_user_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererFreezerTestWithExtensions);
 };
 
 // Tests that the RendererFreezer freezes renderers that are not hosting
 // GCM extensions.
 TEST_F(RendererFreezerTestWithExtensions, FreezesNonExtensionRenderers) {
   Init();
 
   // Create the mock RenderProcessHost.
-  scoped_ptr<content::MockRenderProcessHostFactory> rph_factory(
+  std::unique_ptr<content::MockRenderProcessHostFactory> rph_factory(
       new content::MockRenderProcessHostFactory());
   scoped_refptr<content::SiteInstance> site_instance(
       content::SiteInstance::Create(profile_));
-  scoped_ptr<content::RenderProcessHost> rph(
+  std::unique_ptr<content::RenderProcessHost> rph(
       rph_factory->CreateRenderProcessHost(profile_, site_instance.get()));
 
   // Send the notification that the RenderProcessHost has been created.
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDERER_PROCESS_CREATED,
       content::Source<content::RenderProcessHost>(rph.get()),
       content::NotificationService::NoDetails());
 
   EXPECT_EQ(kSetShouldFreezeRenderer, test_delegate_->GetActions());
 }
@@ skipping 62 matching lines @@
   // Now install it and give it a renderer.
   extensions::ExtensionSystem::Get(profile_)
       ->extension_service()
       ->AddExtension(background_app.get());
   CreateRenderProcessForExtension(background_app.get());
 
   EXPECT_EQ(kSetShouldFreezeRenderer, test_delegate_->GetActions());
 }
 
 }  // namespace chromeos