Convert //components/[o-t]* from scoped_ptr to std::unique_ptr

components/rappor/rappor_service.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 "components/rappor/rappor_service.h"
 
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/metrics_hashes.h"
 #include "base/stl_util.h"
 #include "base/time/time.h"
 #include "components/rappor/log_uploader.h"
 #include "components/rappor/proto/rappor_metric.pb.h"
 #include "components/rappor/rappor_metric.h"
 #include "components/rappor/rappor_pref_names.h"
 #include "components/rappor/rappor_prefs.h"
 #include "components/variations/variations_associated_data.h"
@@ skipping 42 matching lines @@
                    prefs::kRapporLastDailySample,
                    kRapporDailyEventHistogram),
       recording_groups_(0) {
 }
 
 RapporService::~RapporService() {
   STLDeleteValues(&metrics_map_);
 }
 
 void RapporService::AddDailyObserver(
-    scoped_ptr<metrics::DailyEvent::Observer> observer) {
+    std::unique_ptr<metrics::DailyEvent::Observer> observer) {
   daily_event_.AddObserver(std::move(observer));
 }
 
 void RapporService::Initialize(net::URLRequestContextGetter* request_context) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!IsInitialized());
   const GURL server_url = GetServerUrl();
   if (!server_url.is_valid()) {
     DVLOG(1) << server_url.spec() << " is invalid. "
              << "RapporService not started.";
     return;
   }
   DVLOG(1) << "RapporService reporting to " << server_url.spec();
-  InitializeInternal(make_scoped_ptr(new LogUploader(server_url,
-                                                     kMimeType,
-                                                     request_context)),
-                     internal::LoadCohort(pref_service_),
-                     internal::LoadSecret(pref_service_));
+  InitializeInternal(
+      base::WrapUnique(new LogUploader(server_url, kMimeType, request_context)),
+      internal::LoadCohort(pref_service_), internal::LoadSecret(pref_service_));
 }
 
 void RapporService::Update(int recording_groups, bool may_upload) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsInitialized());
   if (recording_groups_ != recording_groups) {
     if (recording_groups == 0) {
       DVLOG(1) << "Rappor service stopped because all groups were disabled.";
       recording_groups_ = 0;
       CancelNextLogRotation();
@@ skipping 17 matching lines @@
     uploader_->Stop();
   }
 }
 
 // static
 void RapporService::RegisterPrefs(PrefRegistrySimple* registry) {
   internal::RegisterPrefs(registry);
 }
 
 void RapporService::InitializeInternal(
-    scoped_ptr<LogUploaderInterface> uploader,
+    std::unique_ptr<LogUploaderInterface> uploader,
     int32_t cohort,
     const std::string& secret) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!IsInitialized());
   DCHECK(secret_.empty());
   uploader_.swap(uploader);
   cohort_ = cohort;
   secret_ = secret;
 }
 
@@ skipping 104 matching lines @@
     RapporMetric* metric = it->second;
     DCHECK_EQ(parameters.ToString(), metric->parameters().ToString());
     return metric;
   }
 
   RapporMetric* new_metric = new RapporMetric(metric_name, parameters, cohort_);
   metrics_map_[metric_name] = new_metric;
   return new_metric;
 }
 
-scoped_ptr<Sample> RapporService::CreateSample(RapporType type) {
+std::unique_ptr<Sample> RapporService::CreateSample(RapporType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsInitialized());
-  return scoped_ptr<Sample>(
+  return base::WrapUnique(
       new Sample(cohort_, internal::kRapporParametersForType[type]));
 }
 
 void RapporService::RecordSampleObj(const std::string& metric_name,
-                                    scoped_ptr<Sample> sample) {
+                                    std::unique_ptr<Sample> sample) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!RecordingAllowed(sample->parameters()))
     return;
   DVLOG(1) << "Recording sample of metric \"" << metric_name << "\"";
   sampler_.AddSample(metric_name, std::move(sample));
 }
 
 }  // namespace rappor