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

chrome/browser/extensions/extension_creator.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 "chrome/browser/extensions/extension_creator.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 130 matching lines @@
         l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_INVALID);
     return NULL;
   }
 
   return crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(
       std::vector<uint8_t>(private_key_bytes.begin(), private_key_bytes.end()));
 }
 
 crypto::RSAPrivateKey* ExtensionCreator::GenerateKey(const base::FilePath&
     output_private_key_path) {
-  scoped_ptr<crypto::RSAPrivateKey> key_pair(
+  std::unique_ptr<crypto::RSAPrivateKey> key_pair(
       crypto::RSAPrivateKey::Create(kRSAKeySize));
   if (!key_pair) {
     error_message_ =
         l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_FAILED_TO_GENERATE);
     return NULL;
   }
 
   std::vector<uint8_t> private_key_vector;
   if (!key_pair->ExportPrivateKey(&private_key_vector)) {
     error_message_ =
@@ skipping 43 matching lines @@
         l10n_util::GetStringUTF8(IDS_EXTENSION_FAILED_DURING_PACKAGING);
     return false;
   }
 
   return true;
 }
 
 bool ExtensionCreator::SignZip(const base::FilePath& zip_path,
                                crypto::RSAPrivateKey* private_key,
                                std::vector<uint8_t>* signature) {
-  scoped_ptr<crypto::SignatureCreator> signature_creator(
+  std::unique_ptr<crypto::SignatureCreator> signature_creator(
       crypto::SignatureCreator::Create(private_key,
                                        crypto::SignatureCreator::SHA1));
   base::ScopedFILE zip_handle(base::OpenFile(zip_path, "rb"));
   size_t buffer_size = 1 << 16;
-  scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
+  std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
   int bytes_read = -1;
   while ((bytes_read = fread(buffer.get(), 1, buffer_size,
        zip_handle.get())) > 0) {
     if (!signature_creator->Update(buffer.get(), bytes_read)) {
       error_message_ =
           l10n_util::GetStringUTF8(IDS_EXTENSION_ERROR_WHILE_SIGNING);
       return false;
     }
   }
   zip_handle.reset();
@@ skipping 15 matching lines @@
   base::ScopedFILE crx_handle(base::OpenFile(crx_path, "wb"));
   if (!crx_handle.get()) {
     error_message_ = l10n_util::GetStringUTF8(IDS_EXTENSION_SHARING_VIOLATION);
     return false;
   }
 
   std::vector<uint8_t> public_key;
   CHECK(private_key->ExportPublicKey(&public_key));
 
   crx_file::CrxFile::Error error;
-  scoped_ptr<crx_file::CrxFile> crx(
+  std::unique_ptr<crx_file::CrxFile> crx(
       crx_file::CrxFile::Create(public_key.size(), signature.size(), &error));
   if (!crx) {
     LOG(ERROR) << "cannot create CrxFileHeader: " << error;
   }
   const crx_file::CrxFile::Header header = crx->header();
 
   if (fwrite(&header, sizeof(header), 1, crx_handle.get()) != 1) {
     PLOG(ERROR) << "fwrite failed to write header";
   }
   if (fwrite(&public_key.front(), sizeof(uint8_t), public_key.size(),
              crx_handle.get()) != public_key.size()) {
     PLOG(ERROR) << "fwrite failed to write public_key.front";
   }
   if (fwrite(&signature.front(), sizeof(uint8_t), signature.size(),
              crx_handle.get()) != signature.size()) {
     PLOG(ERROR) << "fwrite failed to write signature.front";
   }
 
   size_t buffer_size = 1 << 16;
-  scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
+  std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
   size_t bytes_read = 0;
   base::ScopedFILE zip_handle(base::OpenFile(zip_path, "rb"));
   while ((bytes_read = fread(buffer.get(), 1, buffer_size,
                              zip_handle.get())) > 0) {
     if (fwrite(buffer.get(), sizeof(char), bytes_read, crx_handle.get()) !=
         bytes_read) {
       PLOG(ERROR) << "fwrite failed to write buffer";
     }
   }
 
   return true;
 }
 
 bool ExtensionCreator::Run(const base::FilePath& extension_dir,
                            const base::FilePath& crx_path,
                            const base::FilePath& private_key_path,
                            const base::FilePath& output_private_key_path,
                            int run_flags) {
   // Check input diretory and read manifest.
   if (!InitializeInput(extension_dir, crx_path, private_key_path,
                        output_private_key_path, run_flags)) {
     return false;
   }
 
   // Initialize Key Pair
-  scoped_ptr<crypto::RSAPrivateKey> key_pair;
+  std::unique_ptr<crypto::RSAPrivateKey> key_pair;
   if (!private_key_path.value().empty())
     key_pair.reset(ReadInputKey(private_key_path));
   else
     key_pair.reset(GenerateKey(output_private_key_path));
   if (!key_pair)
     return false;
 
   // Perform some extra validation by loading the extension.
   // TODO(aa): Can this go before creating the key pair? This would mean not
   // passing ID into LoadExtension which seems OK.
@@ skipping 12 matching lines @@
       SignZip(zip_path, key_pair.get(), &signature) &&
       WriteCRX(zip_path, key_pair.get(), signature, crx_path)) {
     result = true;
   }
 
   base::DeleteFile(zip_path, false);
   return result;
 }
 
 }  // namespace extensions