Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/browser/cast_content_browser_client.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 "chromecast/browser/cast_content_browser_client.h"
 
 #include <stddef.h>
+
 #include <string>
 #include <utility>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/files/scoped_file.h"
 #include "base/i18n/rtl.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chromecast/base/cast_constants.h"
 #include "chromecast/base/cast_paths.h"
 #include "chromecast/base/chromecast_switches.h"
 #include "chromecast/browser/cast_browser_context.h"
 #include "chromecast/browser/cast_browser_main_parts.h"
 #include "chromecast/browser/cast_browser_process.h"
 #include "chromecast/browser/cast_network_delegate.h"
@@ skipping 33 matching lines @@
 #include "components/external_video_surface/browser/android/external_video_surface_container_impl.h"
 #else
 #include "chromecast/browser/media/cast_browser_cdm_factory.h"
 #endif  // defined(OS_ANDROID)
 
 namespace chromecast {
 namespace shell {
 
 namespace {
 #if defined(ENABLE_MOJO_MEDIA_IN_BROWSER_PROCESS)
-static scoped_ptr<mojo::ShellClient> CreateCastMojoMediaApplication(
+static std::unique_ptr<mojo::ShellClient> CreateCastMojoMediaApplication(
     CastContentBrowserClient* browser_client) {
-  scoped_ptr<media::CastMojoMediaClient> mojo_media_client(
+  std::unique_ptr<media::CastMojoMediaClient> mojo_media_client(
       new media::CastMojoMediaClient(
           base::Bind(&CastContentBrowserClient::CreateMediaPipelineBackend,
                      base::Unretained(browser_client))));
-  return scoped_ptr<mojo::ShellClient>(new media::CastMojoMediaApplication(
+  return std::unique_ptr<mojo::ShellClient>(new media::CastMojoMediaApplication(
       std::move(mojo_media_client), browser_client->GetMediaTaskRunner()));
 }
 #endif  // ENABLE_MOJO_MEDIA_IN_BROWSER_PROCESS
 }  // namespace
 
 CastContentBrowserClient::CastContentBrowserClient()
     : cast_browser_main_parts_(nullptr),
       url_request_context_factory_(new URLRequestContextFactory()) {}
 
 CastContentBrowserClient::~CastContentBrowserClient() {
   content::BrowserThread::DeleteSoon(
       content::BrowserThread::IO,
       FROM_HERE,
       url_request_context_factory_.release());
 }
 
 void CastContentBrowserClient::AppendExtraCommandLineSwitches(
     base::CommandLine* command_line) {
 }
 
 void CastContentBrowserClient::PreCreateThreads() {
 }
 
-scoped_ptr<CastService> CastContentBrowserClient::CreateCastService(
+std::unique_ptr<CastService> CastContentBrowserClient::CreateCastService(
     content::BrowserContext* browser_context,
     PrefService* pref_service,
     net::URLRequestContextGetter* request_context_getter,
     media::VideoPlaneController* video_plane_controller) {
-  return make_scoped_ptr(new CastServiceSimple(browser_context, pref_service));
+  return base::WrapUnique(new CastServiceSimple(browser_context, pref_service));
 }
 
 #if !defined(OS_ANDROID)
 scoped_refptr<base::SingleThreadTaskRunner>
 CastContentBrowserClient::GetMediaTaskRunner() {
   DCHECK(cast_browser_main_parts_);
   return cast_browser_main_parts_->GetMediaTaskRunner();
 }
 
-scoped_ptr<media::MediaPipelineBackend>
+std::unique_ptr<media::MediaPipelineBackend>
 CastContentBrowserClient::CreateMediaPipelineBackend(
     const media::MediaPipelineDeviceParams& params) {
   return media_pipeline_backend_manager()->CreateMediaPipelineBackend(params);
 }
 
 media::MediaResourceTracker*
 CastContentBrowserClient::media_resource_tracker() {
   return cast_browser_main_parts_->media_resource_tracker();
 }
 
@@ skipping 142 matching lines @@
   // to retrieve media data chunks while running in a https page. This pref
   // should be disabled once all the content providers are no longer doing that.
   prefs->allow_running_insecure_content = true;
 
   // Enable 5% margins for WebVTT cues to keep within title-safe area
   prefs->text_track_margin_percentage = 5;
 }
 
 void CastContentBrowserClient::ResourceDispatcherHostCreated() {
   CastBrowserProcess::GetInstance()->SetResourceDispatcherHostDelegate(
-      make_scoped_ptr(new CastResourceDispatcherHostDelegate));
+      base::WrapUnique(new CastResourceDispatcherHostDelegate));
   content::ResourceDispatcherHost::Get()->SetDelegate(
       CastBrowserProcess::GetInstance()->resource_dispatcher_host_delegate());
 }
 
 std::string CastContentBrowserClient::GetApplicationLocale() {
   const std::string locale(base::i18n::GetConfiguredLocale());
   return locale.empty() ? "en-US" : locale;
 }
 
 content::QuotaPermissionContext*
@@ skipping 14 matching lines @@
     content::CertificateRequestResultType* result) {
   // Allow developers to override certificate errors.
   // Otherwise, any fatal certificate errors will cause an abort.
   *result = content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL;
   return;
 }
 
 void CastContentBrowserClient::SelectClientCertificate(
     content::WebContents* web_contents,
     net::SSLCertRequestInfo* cert_request_info,
-    scoped_ptr<content::ClientCertificateDelegate> delegate) {
+    std::unique_ptr<content::ClientCertificateDelegate> delegate) {
   GURL requesting_url("https://" + cert_request_info->host_and_port.ToString());
 
   if (!requesting_url.is_valid()) {
     LOG(ERROR) << "Invalid URL string: "
                << requesting_url.possibly_invalid_spec();
     delegate->ContinueWithCertificate(nullptr);
     return;
   }
 
   // In our case there are no relevant certs in the cert_request_info. The cert
@@ skipping 86 matching lines @@
                  << "be disabled for this process.";
     } else {
       mappings->Transfer(kAndroidMinidumpDescriptor,
                          base::ScopedFD(minidump_file.TakePlatformFile()));
     }
   }
 }
 
 #else
 
-scoped_ptr<::media::CdmFactory> CastContentBrowserClient::CreateCdmFactory() {
+std::unique_ptr<::media::CdmFactory>
+CastContentBrowserClient::CreateCdmFactory() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableCmaMediaPipeline)) {
-    return make_scoped_ptr(new media::CastBrowserCdmFactory(
+    return base::WrapUnique(new media::CastBrowserCdmFactory(
         GetMediaTaskRunner(), media_resource_tracker()));
   }
 
   return nullptr;
 }
 
 void CastContentBrowserClient::GetAdditionalMappedFilesForChildProcess(
     const base::CommandLine& command_line,
     int child_process_id,
     content::FileDescriptorInfo* mappings) {
@@ skipping 54 matching lines @@
         process_type, dumps_path, false /* upload */);
   // StartUploaderThread() even though upload is diferred.
   // Breakpad-related memory is freed in the uploader thread.
   crash_handler->StartUploaderThread();
   return crash_handler;
 }
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace shell
 }  // namespace chromecast