Convert //chrome/browser/metrics from scoped_ptr to std::unique_ptr

chrome/browser/metrics/extensions_metrics_provider.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 "chrome/browser/metrics/extensions_metrics_provider.h"
 
 #include <stddef.h>
 
 #include <algorithm>
+#include <memory>
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/install_verifier.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "components/metrics/metrics_log.h"
 #include "components/metrics/metrics_state_manager.h"
 #include "components/metrics/proto/system_profile.pb.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension_set.h"
@@ skipping 126 matching lines @@
   // of creating a profile if it does not yet exist.
   cached_profile_ = profile_manager->GetProfileByPath(
       profile_manager->GetLastUsedProfileDir(profile_manager->user_data_dir()));
   if (cached_profile_) {
     // Ensure that the returned profile is not an incognito profile.
     cached_profile_ = cached_profile_->GetOriginalProfile();
   }
   return cached_profile_;
 }
 
-scoped_ptr<extensions::ExtensionSet>
+std::unique_ptr<extensions::ExtensionSet>
 ExtensionsMetricsProvider::GetInstalledExtensions(Profile* profile) {
   if (profile) {
     return extensions::ExtensionRegistry::Get(profile)
         ->GenerateInstalledExtensionsSet();
   }
-  return scoped_ptr<extensions::ExtensionSet>();
+  return std::unique_ptr<extensions::ExtensionSet>();
 }
 
 uint64_t ExtensionsMetricsProvider::GetClientID() {
   // TODO(blundell): Create a MetricsLog::ClientIDAsInt() API and call it
   // here as well as in MetricsLog's population of the client_id field of
   // the uma_proto.
   return metrics::MetricsLog::Hash(metrics_state_manager_->client_id());
 }
 
 void ExtensionsMetricsProvider::ProvideSystemProfileMetrics(
@@ skipping 10 matching lines @@
 
   ExtensionState state = NO_EXTENSIONS;
 
   // The off-store metric includes information from all loaded profiles at the
   // time when this metric is generated.
   std::vector<Profile*> profiles = profile_manager->GetLoadedProfiles();
   for (size_t i = 0u; i < profiles.size() && state < OFF_STORE; ++i) {
     extensions::InstallVerifier* verifier =
         extensions::InstallVerifier::Get(profiles[i]);
 
-    scoped_ptr<extensions::ExtensionSet> extensions(
+    std::unique_ptr<extensions::ExtensionSet> extensions(
         GetInstalledExtensions(profiles[i]));
     if (!extensions)
       continue;
 
     // Combine the state from each profile, always favoring the higher state as
     // defined by the order of ExtensionState.
     state = std::max(state, CheckForOffStore(*extensions.get(), *verifier));
   }
 
   system_profile->set_offstore_extensions_state(ExtensionStateAsProto(state));
 }
 
 void ExtensionsMetricsProvider::ProvideOccupiedBucketMetric(
     metrics::SystemProfileProto* system_profile) {
   // UMA reports do not support multiple profiles, but extensions are installed
   // per-profile.  We return the extensions installed in the primary profile.
   // In the future, we might consider reporting data about extensions in all
   // profiles.
   Profile* profile = GetMetricsProfile();
 
-  scoped_ptr<extensions::ExtensionSet> extensions(
+  std::unique_ptr<extensions::ExtensionSet> extensions(
       GetInstalledExtensions(profile));
   if (!extensions)
     return;
 
   const int client_key = GetClientID() % kExtensionListClientKeys;
 
   std::set<int> buckets;
   for (extensions::ExtensionSet::const_iterator it = extensions->begin();
        it != extensions->end();
        ++it) {
     buckets.insert(HashExtension((*it)->id(), client_key));
   }
 
   for (std::set<int>::const_iterator it = buckets.begin(); it != buckets.end();
        ++it) {
     system_profile->add_occupied_extension_bucket(*it);
   }
 }