Convert //chromecast from scoped_ptr to std::unique_ptr

chromecast/browser/metrics/cast_metrics_service_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/metrics/cast_metrics_service_client.h"
 
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chromecast/base/cast_sys_info_util.h"
 #include "chromecast/base/chromecast_switches.h"
 #include "chromecast/base/path_utils.h"
 #include "chromecast/base/pref_names.h"
 #include "chromecast/base/version.h"
 #include "chromecast/browser/cast_browser_process.h"
 #include "chromecast/browser/cast_content_browser_client.h"
@@ skipping 59 matching lines @@
   }
 
   // Any non-empty channel name is considered beta channel
   return ::metrics::SystemProfileProto::CHANNEL_BETA;
 }
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 
 // static
-scoped_ptr<CastMetricsServiceClient> CastMetricsServiceClient::Create(
+std::unique_ptr<CastMetricsServiceClient> CastMetricsServiceClient::Create(
     base::TaskRunner* io_task_runner,
     PrefService* pref_service,
     net::URLRequestContextGetter* request_context) {
-  return make_scoped_ptr(new CastMetricsServiceClient(
+  return base::WrapUnique(new CastMetricsServiceClient(
       io_task_runner, pref_service, request_context));
 }
 
 void CastMetricsServiceClient::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(kMetricsOldClientID, std::string());
 }
 
 ::metrics::MetricsService* CastMetricsServiceClient::GetMetricsService() {
   return metrics_service_.get();
 }
@@ skipping 13 matching lines @@
 }
 
 void CastMetricsServiceClient::StoreClientInfo(
     const ::metrics::ClientInfo& client_info) {
   const std::string& client_id = client_info.client_id;
   DCHECK(client_id.empty() || base::IsValidGUID(client_id));
   // backup client_id or reset to empty.
   SetMetricsClientId(client_id);
 }
 
-scoped_ptr< ::metrics::ClientInfo> CastMetricsServiceClient::LoadClientInfo() {
-  scoped_ptr< ::metrics::ClientInfo> client_info(new ::metrics::ClientInfo);
+std::unique_ptr<::metrics::ClientInfo>
+CastMetricsServiceClient::LoadClientInfo() {
+  std::unique_ptr<::metrics::ClientInfo> client_info(new ::metrics::ClientInfo);
   client_info_loaded_ = true;
 
   // kMetricsIsNewClientID would be missing if either the device was just
   // FDR'ed, or it is on pre-v1.2 build.
   if (!pref_service_->GetBoolean(prefs::kMetricsIsNewClientID)) {
     // If the old client id exists, the device must be on pre-v1.2 build,
     // instead of just being FDR'ed.
     if (!pref_service_->GetString(kMetricsOldClientID).empty()) {
       // Force old client id to be regenerated. See b/9487011.
       client_info->client_id = base::GenerateGUID();
       pref_service_->SetBoolean(prefs::kMetricsIsNewClientID, true);
       return client_info;
     }
     // else the device was just FDR'ed, pass through.
   }
 
   // Use "forced" client ID if available.
   if (!force_client_id_.empty() && base::IsValidGUID(force_client_id_)) {
     client_info->client_id = force_client_id_;
     return client_info;
   }
 
   if (force_client_id_.empty()) {
     LOG(WARNING) << "Empty client id from platform,"
                  << " assuming this is the first boot up of a new device.";
   } else {
     LOG(ERROR) << "Invalid client id from platform: " << force_client_id_
                << " from platform.";
   }
-  return scoped_ptr< ::metrics::ClientInfo>();
+  return std::unique_ptr<::metrics::ClientInfo>();
 }
 
 bool CastMetricsServiceClient::IsOffTheRecordSessionActive() {
   // Chromecast behaves as "off the record" w/r/t recording browsing state,
   // but this value is about not disabling metrics because of it.
   return false;
 }
 
 int32_t CastMetricsServiceClient::GetProduct() {
   // Chromecast currently uses the same product identifier as Chrome.
   return ::metrics::ChromeUserMetricsExtension::CHROME;
 }
 
 std::string CastMetricsServiceClient::GetApplicationLocale() {
   return base::i18n::GetConfiguredLocale();
 }
 
 bool CastMetricsServiceClient::GetBrand(std::string* brand_code) {
   return false;
 }
 
 ::metrics::SystemProfileProto::Channel CastMetricsServiceClient::GetChannel() {
-  scoped_ptr<CastSysInfo> sys_info = CreateSysInfo();
+  std::unique_ptr<CastSysInfo> sys_info = CreateSysInfo();
 
 #if defined(OS_ANDROID)
   switch (sys_info->GetBuildType()) {
     case CastSysInfo::BUILD_ENG:
       return ::metrics::SystemProfileProto::CHANNEL_UNKNOWN;
     case CastSysInfo::BUILD_BETA:
       return ::metrics::SystemProfileProto::CHANNEL_BETA;
     case CastSysInfo::BUILD_PRODUCTION:
       return ::metrics::SystemProfileProto::CHANNEL_STABLE;
   }
@@ skipping 38 matching lines @@
 void CastMetricsServiceClient::InitializeSystemProfileMetrics(
     const base::Closure& done_callback) {
   done_callback.Run();
 }
 
 void CastMetricsServiceClient::CollectFinalMetricsForLog(
     const base::Closure& done_callback) {
   done_callback.Run();
 }
 
-scoped_ptr< ::metrics::MetricsLogUploader>
+std::unique_ptr<::metrics::MetricsLogUploader>
 CastMetricsServiceClient::CreateUploader(
     const base::Callback<void(int)>& on_upload_complete) {
   std::string uma_server_url(::metrics::kDefaultMetricsServerUrl);
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kOverrideMetricsUploadUrl)) {
     uma_server_url.assign(
         command_line->GetSwitchValueASCII(switches::kOverrideMetricsUploadUrl));
   }
   DCHECK(!uma_server_url.empty());
-  return scoped_ptr< ::metrics::MetricsLogUploader>(
-      new ::metrics::NetMetricsLogUploader(request_context_,
-                                           uma_server_url,
+  return std::unique_ptr<::metrics::MetricsLogUploader>(
+      new ::metrics::NetMetricsLogUploader(request_context_, uma_server_url,
                                            ::metrics::kDefaultMetricsMimeType,
                                            on_upload_complete));
 }
 
 base::TimeDelta CastMetricsServiceClient::GetStandardUploadInterval() {
   return base::TimeDelta::FromMinutes(kStandardUploadIntervalMinutes);
 }
 
 void CastMetricsServiceClient::EnableMetricsService(bool enabled) {
   if (!task_runner_->BelongsToCurrentThread()) {
@@ skipping 76 matching lines @@
   // For UMA and crash reporting, associated opt-in settings will control
   // sending reports as directed by the user.
   // For Setup (which also communicates the user's opt-in preferences),
   // report the client-id and expect that setup will handle the current opt-in
   // value.
   metrics_state_manager_->ForceClientIdCreation();
 
   CastStabilityMetricsProvider* stability_provider =
       new CastStabilityMetricsProvider(metrics_service_.get());
   metrics_service_->RegisterMetricsProvider(
-      scoped_ptr< ::metrics::MetricsProvider>(stability_provider));
+      std::unique_ptr<::metrics::MetricsProvider>(stability_provider));
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (!command_line->HasSwitch(switches::kDisableGpu)) {
     metrics_service_->RegisterMetricsProvider(
-        scoped_ptr< ::metrics::MetricsProvider>(
+        std::unique_ptr<::metrics::MetricsProvider>(
             new ::metrics::GPUMetricsProvider));
 
     // TODO(gfhuang): Does ChromeCast actually need metrics about screen info?
     // crbug.com/541577
     metrics_service_->RegisterMetricsProvider(
-        scoped_ptr< ::metrics::MetricsProvider>(
+        std::unique_ptr<::metrics::MetricsProvider>(
             new ::metrics::ScreenInfoMetricsProvider));
   }
   metrics_service_->RegisterMetricsProvider(
-      scoped_ptr< ::metrics::MetricsProvider>(
+      std::unique_ptr<::metrics::MetricsProvider>(
           new ::metrics::NetworkMetricsProvider(io_task_runner_)));
   metrics_service_->RegisterMetricsProvider(
-      scoped_ptr< ::metrics::MetricsProvider>(
+      std::unique_ptr<::metrics::MetricsProvider>(
           new ::metrics::ProfilerMetricsProvider));
   shell::CastBrowserProcess::GetInstance()->browser_client()->
       RegisterMetricsProviders(metrics_service_.get());
 
   metrics_service_->InitializeMetricsRecordingState();
 #if !defined(OS_ANDROID)
   // Reset clean_shutdown bit after InitializeMetricsRecordingState().
   metrics_service_->LogNeedForCleanShutdown();
 #endif  // !defined(OS_ANDROID)
 
@@ skipping 29 matching lines @@
 #endif  // defined(OS_LINUX)
   metrics_service_->Stop();
 }
 
 bool CastMetricsServiceClient::IsReportingEnabled() {
   return pref_service_->GetBoolean(prefs::kOptInStats);
 }
 
 }  // namespace metrics
 }  // namespace chromecast