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

chrome/browser/extensions/install_signer.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_signer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 74 matching lines @@
 // |result|.
 bool HashWithMachineId(const std::string& salt, std::string* result) {
   std::string machine_id;
 #if defined(ENABLE_RLZ)
   if (!rlz_lib::GetMachineId(&machine_id))
     return false;
 #else
   machine_id = "unknown";
 #endif
 
-  scoped_ptr<crypto::SecureHash> hash(
+  std::unique_ptr<crypto::SecureHash> hash(
       crypto::SecureHash::Create(crypto::SecureHash::SHA256));
 
   hash->Update(machine_id.data(), machine_id.size());
   hash->Update(salt.data(), salt.size());
 
   std::string result_bytes(crypto::kSHA256Length, 0);
   hash->Finish(string_as_array(&result_bytes), result_bytes.size());
 
   base::Base64Encode(result_bytes, result);
   return true;
@@ skipping 68 matching lines @@
   std::string signature_base64;
   base::Base64Encode(salt, &salt_base64);
   base::Base64Encode(signature, &signature_base64);
   value->SetString(kSaltKey, salt_base64);
   value->SetString(kSignatureKey, signature_base64);
   value->SetString(kTimestampKey,
                    base::Int64ToString(timestamp.ToInternalValue()));
 }
 
 // static
-scoped_ptr<InstallSignature> InstallSignature::FromValue(
+std::unique_ptr<InstallSignature> InstallSignature::FromValue(
     const base::DictionaryValue& value) {
-
-  scoped_ptr<InstallSignature> result(new InstallSignature);
+  std::unique_ptr<InstallSignature> result(new InstallSignature);
 
   // For now we don't want to support any backwards compability, but in the
   // future if we do, we would want to put the migration code here.
   int format_version = 0;
   if (!value.GetInteger(kSignatureFormatVersionKey, &format_version) ||
       format_version != kSignatureFormatVersion) {
     result.reset();
     return result;
   }
 
@@ skipping 146 matching lines @@
 void InstallSigner::GetSignature(const SignatureCallback& callback) {
   CHECK(!url_fetcher_.get());
   CHECK(callback_.is_null());
   CHECK(salt_.empty());
   callback_ = callback;
 
   // If the set of ids is empty, just return an empty signature and skip the
   // call to the server.
   if (ids_.empty()) {
     if (!callback_.is_null())
-      callback_.Run(scoped_ptr<InstallSignature>(new InstallSignature()));
+      callback_.Run(std::unique_ptr<InstallSignature>(new InstallSignature()));
     return;
   }
 
   salt_ = std::string(kSaltBytes, 0);
   DCHECK_EQ(kSaltBytes, salt_.size());
   crypto::RandBytes(string_as_array(&salt_), salt_.size());
 
   std::string hash_base64;
   if (!HashWithMachineId(salt_, &hash_base64)) {
     ReportErrorViaCallback();
@@ skipping 15 matching lines @@
 
   // The request protocol is JSON of the form:
   // {
   //   "protocol_version": "1",
   //   "hash": "<base64-encoded hash value here>",
   //   "ids": [ "<id1>", "id2" ]
   // }
   base::DictionaryValue dictionary;
   dictionary.SetInteger(kProtocolVersionKey, 1);
   dictionary.SetString(kHashKey, hash_base64);
-  scoped_ptr<base::ListValue> id_list(new base::ListValue);
+  std::unique_ptr<base::ListValue> id_list(new base::ListValue);
   for (ExtensionIdSet::const_iterator i = ids_.begin(); i != ids_.end(); ++i) {
     id_list->AppendString(*i);
   }
   dictionary.Set(kIdsKey, id_list.release());
   std::string json;
   base::JSONWriter::Write(dictionary, &json);
   if (json.empty()) {
     ReportErrorViaCallback();
     return;
   }
   url_fetcher_->SetUploadData("application/json", json);
   LogRequestStartHistograms();
   request_start_time_ = base::Time::Now();
   VLOG(1) << "Sending request: " << json;
   url_fetcher_->Start();
 }
 
 void InstallSigner::ReportErrorViaCallback() {
   InstallSignature* null_signature = NULL;
   if (!callback_.is_null())
-    callback_.Run(scoped_ptr<InstallSignature>(null_signature));
+    callback_.Run(std::unique_ptr<InstallSignature>(null_signature));
 }
 
 void InstallSigner::ParseFetchResponse() {
   bool fetch_success = url_fetcher_->GetStatus().is_success();
   UMA_HISTOGRAM_BOOLEAN("ExtensionInstallSigner.FetchSuccess", fetch_success);
 
   std::string response;
   if (fetch_success) {
     if (!url_fetcher_->GetResponseAsString(&response))
       response.clear();
@@ skipping 10 matching lines @@
   // {
   //   "protocol_version": "1",
   //   "signature": "<base64-encoded signature>",
   //   "expiry": "<date in YYYY-MM-DD form>",
   //   "invalid_ids": [ "<id3>", "<id4>" ]
   // }
   // where |invalid_ids| is a list of ids from the original request that
   // could not be verified to be in the webstore.
 
   base::DictionaryValue* dictionary = NULL;
-  scoped_ptr<base::Value> parsed = base::JSONReader::Read(response);
+  std::unique_ptr<base::Value> parsed = base::JSONReader::Read(response);
   bool json_success = parsed.get() && parsed->GetAsDictionary(&dictionary);
   UMA_HISTOGRAM_BOOLEAN("ExtensionInstallSigner.ParseJsonSuccess",
                         json_success);
   if (!json_success) {
     ReportErrorViaCallback();
     return;
   }
 
   int protocol_version = 0;
   std::string signature_base64;
@@ skipping 30 matching lines @@
 
   HandleSignatureResult(signature, expire_date, invalid_ids);
 }
 
 void InstallSigner::HandleSignatureResult(const std::string& signature,
                                           const std::string& expire_date,
                                           const ExtensionIdSet& invalid_ids) {
   ExtensionIdSet valid_ids =
       base::STLSetDifference<ExtensionIdSet>(ids_, invalid_ids);
 
-  scoped_ptr<InstallSignature> result;
+  std::unique_ptr<InstallSignature> result;
   if (!signature.empty()) {
     result.reset(new InstallSignature);
     result->ids = valid_ids;
     result->invalid_ids = invalid_ids;
     result->salt = salt_;
     result->signature = signature;
     result->expire_date = expire_date;
     result->timestamp = request_start_time_;
     bool verified = VerifySignature(*result);
     UMA_HISTOGRAM_BOOLEAN("ExtensionInstallSigner.ResultWasValid", verified);
     UMA_HISTOGRAM_COUNTS_100("ExtensionInstallSigner.InvalidCount",
                              invalid_ids.size());
     if (!verified)
       result.reset();
   }
 
   if (!callback_.is_null())
     callback_.Run(std::move(result));
 }
 
 
 }  // namespace extensions