Convert //ios from scoped_ptr to std::unique_ptr.

ios/chrome/browser/metrics/ios_chrome_metrics_service_client.cc

 // Copyright 2015 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 "ios/chrome/browser/metrics/ios_chrome_metrics_service_client.h"
 
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process_metrics.h"
 #include "base/rand_util.h"
 #include "base/strings/string16.h"
 #include "base/threading/platform_thread.h"
 #include "components/crash/core/common/crash_keys.h"
 #include "components/metrics/call_stack_profile_metrics_provider.h"
 #include "components/metrics/drive_metrics_provider.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_service.h"
@@ skipping 57 matching lines @@
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
   RegisterForNotifications();
 }
 
 IOSChromeMetricsServiceClient::~IOSChromeMetricsServiceClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 // static
-scoped_ptr<IOSChromeMetricsServiceClient> IOSChromeMetricsServiceClient::Create(
+std::unique_ptr<IOSChromeMetricsServiceClient>
+IOSChromeMetricsServiceClient::Create(
     metrics::MetricsStateManager* state_manager,
     PrefService* local_state) {
   // Perform two-phase initialization so that |client->metrics_service_| only
   // receives pointers to fully constructed objects.
-  scoped_ptr<IOSChromeMetricsServiceClient> client(
+  std::unique_ptr<IOSChromeMetricsServiceClient> client(
       new IOSChromeMetricsServiceClient(state_manager));
   client->Initialize();
 
   return client;
 }
 
 // static
 void IOSChromeMetricsServiceClient::RegisterPrefs(
     PrefRegistrySimple* registry) {
   metrics::MetricsService::RegisterPrefs(registry);
@@ skipping 57 matching lines @@
   if (ShouldIncludeProfilerDataInLog()) {
     // Fetch profiler data. This will call into
     // |FinishedReceivingProfilerData()| when the task completes.
     metrics::TrackingSynchronizer::FetchProfilerDataAsynchronously(
         weak_ptr_factory_.GetWeakPtr());
   } else {
     CollectFinalHistograms();
   }
 }
 
-scoped_ptr<metrics::MetricsLogUploader>
+std::unique_ptr<metrics::MetricsLogUploader>
 IOSChromeMetricsServiceClient::CreateUploader(
     const base::Callback<void(int)>& on_upload_complete) {
-  return scoped_ptr<metrics::MetricsLogUploader>(
+  return std::unique_ptr<metrics::MetricsLogUploader>(
       new metrics::NetMetricsLogUploader(
           GetApplicationContext()->GetSystemURLRequestContext(),
           metrics::kDefaultMetricsServerUrl, metrics::kDefaultMetricsMimeType,
           on_upload_complete));
 }
 
 base::TimeDelta IOSChromeMetricsServiceClient::GetStandardUploadInterval() {
   if (IsCellularLogicEnabled())
     return base::TimeDelta::FromSeconds(kStandardUploadIntervalCellularSeconds);
   return base::TimeDelta::FromSeconds(kStandardUploadIntervalSeconds);
@@ skipping 16 matching lines @@
     web::WebState* web_state) {
   metrics_service_->OnApplicationNotIdle();
 }
 
 void IOSChromeMetricsServiceClient::Initialize() {
   metrics_service_.reset(new metrics::MetricsService(
       metrics_state_manager_, this, GetApplicationContext()->GetLocalState()));
 
   // Register metrics providers.
   metrics_service_->RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(new metrics::NetworkMetricsProvider(
-          web::WebThread::GetBlockingPool())));
+      std::unique_ptr<metrics::MetricsProvider>(
+          new metrics::NetworkMetricsProvider(
+              web::WebThread::GetBlockingPool())));
 
   // Currently, we configure OmniboxMetricsProvider to not log events to UMA
   // if there is a single incognito session visible. In the future, it may
   // be worth revisiting this to still log events from non-incognito sessions.
   metrics_service_->RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(new OmniboxMetricsProvider(
+      std::unique_ptr<metrics::MetricsProvider>(new OmniboxMetricsProvider(
           base::Bind(&::IsOffTheRecordSessionActive))));
 
   stability_metrics_provider_ = new IOSChromeStabilityMetricsProvider(
       GetApplicationContext()->GetLocalState());
   metrics_service_->RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(stability_metrics_provider_));
+      std::unique_ptr<metrics::MetricsProvider>(stability_metrics_provider_));
 
   metrics_service_->RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(
+      std::unique_ptr<metrics::MetricsProvider>(
           new metrics::ScreenInfoMetricsProvider));
 
   drive_metrics_provider_ = new metrics::DriveMetricsProvider(
       web::WebThread::GetTaskRunnerForThread(web::WebThread::FILE),
       ios::FILE_LOCAL_STATE);
   metrics_service_->RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(drive_metrics_provider_));
+      std::unique_ptr<metrics::MetricsProvider>(drive_metrics_provider_));
 
   profiler_metrics_provider_ =
       new metrics::ProfilerMetricsProvider(base::Bind(&IsCellularLogicEnabled));
   metrics_service_->RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(profiler_metrics_provider_));
+      std::unique_ptr<metrics::MetricsProvider>(profiler_metrics_provider_));
 
   metrics_service_->RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(
+      std::unique_ptr<metrics::MetricsProvider>(
           new metrics::CallStackProfileMetricsProvider));
 
   metrics_service_->RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(
-          SigninStatusMetricsProvider::CreateInstance(make_scoped_ptr(
+      std::unique_ptr<metrics::MetricsProvider>(
+          SigninStatusMetricsProvider::CreateInstance(base::WrapUnique(
               new IOSChromeSigninStatusMetricsProviderDelegate))));
 
   metrics_service_->RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(
+      std::unique_ptr<metrics::MetricsProvider>(
           new MobileSessionShutdownMetricsProvider(metrics_service_.get())));
 
   metrics_service_->RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(
+      std::unique_ptr<metrics::MetricsProvider>(
           new sync_driver::DeviceCountMetricsProvider(
               base::Bind(&IOSChromeSyncClient::GetDeviceInfoTrackers))));
 }
 
 void IOSChromeMetricsServiceClient::OnInitTaskGotDriveMetrics() {
   finished_init_task_callback_.Run();
 }
 
 bool IOSChromeMetricsServiceClient::ShouldIncludeProfilerDataInLog() {
   // Upload profiler data at most once per session.
@@ skipping 29 matching lines @@
   CollectFinalHistograms();
 }
 
 void IOSChromeMetricsServiceClient::CollectFinalHistograms() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(ios): Try to extract the flow below into a utility function that is
   // shared between the iOS port's usage and
   // ChromeMetricsServiceClient::CollectFinalHistograms()'s usage of
   // MetricsMemoryDetails.
-  scoped_ptr<base::ProcessMetrics> process_metrics(
+  std::unique_ptr<base::ProcessMetrics> process_metrics(
       base::ProcessMetrics::CreateProcessMetrics(
           base::GetCurrentProcessHandle()));
   UMA_HISTOGRAM_MEMORY_KB("Memory.Browser",
                           process_metrics->GetWorkingSetSize() / 1024);
   collect_final_metrics_done_callback_.Run();
 }
 
 void IOSChromeMetricsServiceClient::RegisterForNotifications() {
   tab_parented_subscription_ =
       TabParentingGlobalObserver::GetInstance()->RegisterCallback(
           base::Bind(&IOSChromeMetricsServiceClient::OnTabParented,
                      base::Unretained(this)));
   omnibox_url_opened_subscription_ =
       OmniboxEventGlobalTracker::GetInstance()->RegisterCallback(
           base::Bind(&IOSChromeMetricsServiceClient::OnURLOpenedFromOmnibox,
                      base::Unretained(this)));
 }
 
 void IOSChromeMetricsServiceClient::OnTabParented(web::WebState* web_state) {
   metrics_service_->OnApplicationNotIdle();
 }
 
 void IOSChromeMetricsServiceClient::OnURLOpenedFromOmnibox(OmniboxLog* log) {
   metrics_service_->OnApplicationNotIdle();
 }