Convert //components/[a-e]* from scoped_ptr to std::unique_ptr

components/crx_file/crx_file.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 "components/crx_file/crx_file.h"
 
 #include "base/base64.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "components/crx_file/id_util.h"
 #include "crypto/secure_hash.h"
 #include "crypto/sha2.h"
 #include "crypto/signature_verifier.h"
 
 namespace crx_file {
 
@@ skipping 47 matching lines @@
     return CrxFile::ValidateError::NONE;
   }
 }
 
 }  // namespace
 
 // The magic string embedded in the header.
 const char kCrxFileHeaderMagic[] = "Cr24";
 const char kCrxDiffFileHeaderMagic[] = "CrOD";
 
-scoped_ptr<CrxFile> CrxFile::Parse(const CrxFile::Header& header,
-                                   CrxFile::Error* error) {
+std::unique_ptr<CrxFile> CrxFile::Parse(const CrxFile::Header& header,
+                                        CrxFile::Error* error) {
   if (HeaderIsValid(header, error))
-    return scoped_ptr<CrxFile>(new CrxFile(header));
-  return scoped_ptr<CrxFile>();
+    return base::WrapUnique(new CrxFile(header));
+  return nullptr;
 }
 
-scoped_ptr<CrxFile> CrxFile::Create(const uint32_t key_size,
-                                    const uint32_t signature_size,
-                                    CrxFile::Error* error) {
+std::unique_ptr<CrxFile> CrxFile::Create(const uint32_t key_size,
+                                         const uint32_t signature_size,
+                                         CrxFile::Error* error) {
   CrxFile::Header header;
   memcpy(&header.magic, kCrxFileHeaderMagic, kCrxFileHeaderMagicSize);
   header.version = kCurrentVersion;
   header.key_size = key_size;
   header.signature_size = signature_size;
   if (HeaderIsValid(header, error))
-    return scoped_ptr<CrxFile>(new CrxFile(header));
-  return scoped_ptr<CrxFile>();
+    return base::WrapUnique(new CrxFile(header));
+  return nullptr;
 }
 
 bool CrxFile::HeaderIsDelta(const CrxFile::Header& header) {
   return !strncmp(kCrxDiffFileHeaderMagic, header.magic, sizeof(header.magic));
 }
 
 // static
 CrxFile::ValidateError CrxFile::ValidateSignature(
     const base::FilePath& crx_path,
     const std::string& expected_hash,
     std::string* public_key,
     std::string* extension_id,
     CrxFile::Header* header_out) {
   base::ScopedFILE file(base::OpenFile(crx_path, "rb"));
-  scoped_ptr<crypto::SecureHash> hash;
+  std::unique_ptr<crypto::SecureHash> hash;
   if (!expected_hash.empty())
     hash.reset(crypto::SecureHash::Create(crypto::SecureHash::SHA256));
 
   if (!file.get())
     return ValidateError::CRX_FILE_NOT_READABLE;
 
   CrxFile::Header header;
   size_t len = ReadAndHash(&header, sizeof(header), 1, file.get(), hash.get());
   if (len != sizeof(header))
     return ValidateError::CRX_HEADER_INVALID;
   if (header_out)
     *header_out = header;
 
   CrxFile::Error error;
-  scoped_ptr<CrxFile> crx(CrxFile::Parse(header, &error));
+  std::unique_ptr<CrxFile> crx(CrxFile::Parse(header, &error));
   if (!crx) {
     switch (error) {
       case CrxFile::kWrongMagic:
         return ValidateError::CRX_MAGIC_NUMBER_INVALID;
       case CrxFile::kInvalidVersion:
         return ValidateError::CRX_VERSION_NUMBER_INVALID;
 
       case CrxFile::kInvalidKeyTooLarge:
       case CrxFile::kInvalidSignatureTooLarge:
         return ValidateError::CRX_EXCESSIVELY_LARGE_KEY_OR_SIGNATURE;
@@ skipping 73 matching lines @@
   else if (header.signature_size > kMaxSignatureSize)
     *error = kInvalidSignatureTooLarge;
   else if (header.signature_size == 0)
     *error = kInvalidSignatureTooSmall;
   else
     valid = true;
   return valid;
 }
 
 }  // namespace crx_file