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

chrome/browser/extensions/install_verifier.cc

 // Copyright 2013 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/extensions/install_verifier.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 216 matching lines @@
 
 void InstallVerifier::Init() {
   TRACE_EVENT0("browser,startup", "extensions::InstallVerifier::Init");
   UMA_HISTOGRAM_ENUMERATION("ExtensionInstallVerifier.ExperimentStatus",
                             GetExperimentStatus(), VERIFY_STATUS_MAX);
   UMA_HISTOGRAM_ENUMERATION("ExtensionInstallVerifier.ActualStatus",
                             GetStatus(), VERIFY_STATUS_MAX);
 
   const base::DictionaryValue* pref = prefs_->GetInstallSignature();
   if (pref) {
-    scoped_ptr<InstallSignature> signature_from_prefs =
+    std::unique_ptr<InstallSignature> signature_from_prefs =
         InstallSignature::FromValue(*pref);
     if (!signature_from_prefs.get()) {
       LogInitResultHistogram(INIT_UNPARSEABLE_PREF);
     } else if (!InstallSigner::VerifySignature(*signature_from_prefs.get())) {
       LogInitResultHistogram(INIT_INVALID_SIGNATURE);
       DVLOG(1) << "Init - ignoring invalid signature";
     } else {
       signature_ = std::move(signature_from_prefs);
       LogInitResultHistogram(INIT_VALID_SIGNATURE);
       UMA_HISTOGRAM_COUNTS_100("ExtensionInstallVerifier.InitSignatureCount",
@@ skipping 197 matching lines @@
 }
 
 InstallVerifier::PendingOperation::PendingOperation(OperationType type)
     : type(type) {}
 
 InstallVerifier::PendingOperation::~PendingOperation() {
 }
 
 ExtensionIdSet InstallVerifier::GetExtensionsToVerify() const {
   ExtensionIdSet result;
-  scoped_ptr<ExtensionSet> extensions =
+  std::unique_ptr<ExtensionSet> extensions =
       ExtensionRegistry::Get(context_)->GenerateInstalledExtensionsSet();
   for (ExtensionSet::const_iterator iter = extensions->begin();
        iter != extensions->end();
        ++iter) {
     if (NeedsVerification(*iter->get()))
       result.insert((*iter)->id());
   }
   return result;
 }
 
@@ skipping 120 matching lines @@
   if (!signature_.get() || signature_->ids.empty()) {
     DVLOG(1) << "SaveToPrefs - saving NULL";
     prefs_->SetInstallSignature(NULL);
   } else {
     base::DictionaryValue pref;
     signature_->ToValue(&pref);
     if (VLOG_IS_ON(1)) {
       DVLOG(1) << "SaveToPrefs - saving";
 
       DCHECK(InstallSigner::VerifySignature(*signature_.get()));
-      scoped_ptr<InstallSignature> rehydrated =
+      std::unique_ptr<InstallSignature> rehydrated =
           InstallSignature::FromValue(pref);
       DCHECK(InstallSigner::VerifySignature(*rehydrated.get()));
     }
     prefs_->SetInstallSignature(&pref);
   }
 }
 
 namespace {
 
 enum CallbackResult {
   CALLBACK_NO_SIGNATURE = 0,
   CALLBACK_INVALID_SIGNATURE,
   CALLBACK_VALID_SIGNATURE,
 
   // This is used in histograms - do not remove or reorder entries above! Also
   // the "MAX" item below should always be the last element.
 
   CALLBACK_RESULT_MAX
 };
 
 void GetSignatureResultHistogram(CallbackResult result) {
   UMA_HISTOGRAM_ENUMERATION("ExtensionInstallVerifier.GetSignatureResult",
                             result, CALLBACK_RESULT_MAX);
 }
 
 }  // namespace
 
 void InstallVerifier::SignatureCallback(
-    scoped_ptr<InstallSignature> signature) {
-
+    std::unique_ptr<InstallSignature> signature) {
   linked_ptr<PendingOperation> operation = operation_queue_.front();
   operation_queue_.pop();
 
   bool success = false;
   if (!signature.get()) {
     GetSignatureResultHistogram(CALLBACK_NO_SIGNATURE);
   } else if (!InstallSigner::VerifySignature(*signature)) {
     GetSignatureResultHistogram(CALLBACK_INVALID_SIGNATURE);
   } else {
     GetSignatureResultHistogram(CALLBACK_VALID_SIGNATURE);
@@ skipping 30 matching lines @@
 ScopedInstallVerifierBypassForTest::~ScopedInstallVerifierBypassForTest() {
   g_bypass_for_test = old_value_;
 }
 
 // static
 bool ScopedInstallVerifierBypassForTest::ShouldBypass() {
   return g_bypass_for_test;
 }
 
 }  // namespace extensions