Convert //components/[u-z]* from scoped_ptr to std::unique_ptr

components/variations/service/variations_service.cc

 // Copyright (c) 2012 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/variations/service/variations_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <utility>
 
 #include "base/build_time.h"
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/timer/elapsed_timer.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "build/build_config.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
@@ skipping 239 matching lines @@
              << "requested x-bm,gzip but received gzip,x-bm";
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
 VariationsService::VariationsService(
-    scoped_ptr<VariationsServiceClient> client,
-    scoped_ptr<web_resource::ResourceRequestAllowedNotifier> notifier,
+    std::unique_ptr<VariationsServiceClient> client,
+    std::unique_ptr<web_resource::ResourceRequestAllowedNotifier> notifier,
     PrefService* local_state,
     metrics::MetricsStateManager* state_manager,
     const UIStringOverrider& ui_string_overrider)
     : client_(std::move(client)),
       ui_string_overrider_(ui_string_overrider),
       local_state_(local_state),
       state_manager_(state_manager),
       policy_pref_service_(local_state),
       seed_store_(local_state),
       create_trials_from_seed_called_(false),
@@ skipping 187 matching lines @@
 // static
 void VariationsService::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   // This preference will only be written by the policy service, which will fill
   // it according to a value stored in the User Policy.
   registry->RegisterStringPref(prefs::kVariationsRestrictParameter,
                                std::string());
 }
 
 // static
-scoped_ptr<VariationsService> VariationsService::Create(
-    scoped_ptr<VariationsServiceClient> client,
+std::unique_ptr<VariationsService> VariationsService::Create(
+    std::unique_ptr<VariationsServiceClient> client,
     PrefService* local_state,
     metrics::MetricsStateManager* state_manager,
     const char* disable_network_switch,
     const UIStringOverrider& ui_string_overrider) {
-  scoped_ptr<VariationsService> result;
+  std::unique_ptr<VariationsService> result;
 #if !defined(GOOGLE_CHROME_BUILD)
   // Unless the URL was provided, unsupported builds should return NULL to
   // indicate that the service should not be used.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kVariationsServerURL)) {
     DVLOG(1) << "Not creating VariationsService in unofficial build without --"
              << switches::kVariationsServerURL << " specified.";
     return result;
   }
 #endif
   result.reset(new VariationsService(
       std::move(client),
-      make_scoped_ptr(new web_resource::ResourceRequestAllowedNotifier(
+      base::WrapUnique(new web_resource::ResourceRequestAllowedNotifier(
           local_state, disable_network_switch)),
       local_state, state_manager, ui_string_overrider));
   return result;
 }
 
 // static
-scoped_ptr<VariationsService> VariationsService::CreateForTesting(
-    scoped_ptr<VariationsServiceClient> client,
+std::unique_ptr<VariationsService> VariationsService::CreateForTesting(
+    std::unique_ptr<VariationsServiceClient> client,
     PrefService* local_state) {
-  return make_scoped_ptr(new VariationsService(
+  return base::WrapUnique(new VariationsService(
       std::move(client),
-      make_scoped_ptr(new web_resource::ResourceRequestAllowedNotifier(
+      base::WrapUnique(new web_resource::ResourceRequestAllowedNotifier(
           local_state, nullptr)),
       local_state, nullptr, UIStringOverrider()));
 }
 
 void VariationsService::DoActualFetch() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!pending_seed_request_);
 
   pending_seed_request_ = net::URLFetcher::Create(0, variations_server_url_,
                                                   net::URLFetcher::GET, this);
@@ skipping 41 matching lines @@
 }
 
 bool VariationsService::StoreSeed(const std::string& seed_data,
                                   const std::string& seed_signature,
                                   const std::string& country_code,
                                   const base::Time& date_fetched,
                                   bool is_delta_compressed,
                                   bool is_gzip_compressed) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  scoped_ptr<variations::VariationsSeed> seed(new variations::VariationsSeed);
+  std::unique_ptr<variations::VariationsSeed> seed(
+      new variations::VariationsSeed);
   if (!seed_store_.StoreSeedData(seed_data, seed_signature, country_code,
                                  date_fetched, is_delta_compressed,
                                  is_gzip_compressed, seed.get())) {
     return false;
   }
   RecordLastFetchTime();
 
   // Perform seed simulation only if |state_manager_| is not-NULL. The state
   // manager may be NULL for some unit tests.
   if (!state_manager_)
@@ skipping 39 matching lines @@
 }
 
 void VariationsService::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(pending_seed_request_.get(), source);
 
   const bool is_first_request = !initial_request_completed_;
   initial_request_completed_ = true;
 
   // The fetcher will be deleted when the request is handled.
-  scoped_ptr<const net::URLFetcher> request(pending_seed_request_.release());
+  std::unique_ptr<const net::URLFetcher> request(
+      pending_seed_request_.release());
   const net::URLRequestStatus& request_status = request->GetStatus();
   if (request_status.status() != net::URLRequestStatus::SUCCESS) {
     UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.FailedRequestErrorCode",
                                 -request_status.error());
     DVLOG(1) << "Variations server request failed with error: "
              << request_status.error() << ": "
              << net::ErrorToString(request_status.error());
     // It's common for the very first fetch attempt to fail (e.g. the network
     // may not yet be available). In such a case, try again soon, rather than
     // waiting the full time interval.
@@ skipping 74 matching lines @@
   RecordRequestsAllowedHistogram(RESOURCE_REQUESTS_ALLOWED_NOTIFIED);
   DVLOG(1) << "Retrying fetch.";
   DoActualFetch();
 
   // This service must have created a scheduler in order for this to be called.
   DCHECK(request_scheduler_.get());
   request_scheduler_->Reset();
 }
 
 void VariationsService::PerformSimulationWithVersion(
-    scoped_ptr<variations::VariationsSeed> seed,
+    std::unique_ptr<variations::VariationsSeed> seed,
     const base::Version& version) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!version.IsValid())
     return;
 
   const base::ElapsedTimer timer;
 
-  scoped_ptr<const base::FieldTrial::EntropyProvider> entropy_provider =
+  std::unique_ptr<const base::FieldTrial::EntropyProvider> entropy_provider =
       state_manager_->CreateEntropyProvider();
   variations::VariationsSeedSimulator seed_simulator(*entropy_provider);
 
   const std::string latest_country =
       local_state_->GetString(prefs::kVariationsCountry);
   const variations::VariationsSeedSimulator::Result result =
       seed_simulator.SimulateSeedStudies(
           *seed, client_->GetApplicationLocale(),
           GetReferenceDateForExpiryChecks(local_state_), version,
           GetChannelForVariations(client_->GetChannel()),
@@ skipping 133 matching lines @@
 
   if (got_stored_country && stored_country == country_override)
     return false;
 
   base::Version version(version_info::GetVersionNumber());
   StorePermanentCountry(version, country_override);
   return true;
 }
 
 }  // namespace variations