Convert chrome/common to std::unique_ptr

chrome/common/component_flash_hint_file_linux.cc

 // Copyright 2015 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/common/component_flash_hint_file_linux.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/mman.h>
 
+#include <memory>
+
 #include "base/base64.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/files/scoped_file.h"
 #include "base/json/json_string_value_serializer.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/common/chrome_paths.h"
 #include "crypto/secure_hash.h"
 #include "crypto/secure_util.h"
 #include "crypto/sha2.h"
 
 namespace component_flash_hint_file {
@@ skipping 28 matching lines @@
 
 // Hashes the plugin file and returns the result in the out params.
 // |mapped_file| is the file to be hashed.
 // |result| is the buffer, which must be of size crypto::kSHA256Length, which
 // will contain the hash.
 // |len| is the size of the buffer, which must be crypto::kSHA256Length.
 void SHA256Hash(const base::MemoryMappedFile& mapped_file,
                 void* result,
                 size_t len) {
   CHECK_EQ(crypto::kSHA256Length, len);
-  scoped_ptr<crypto::SecureHash> secure_hash(
+  std::unique_ptr<crypto::SecureHash> secure_hash(
       crypto::SecureHash::Create(crypto::SecureHash::SHA256));
   secure_hash->Update(mapped_file.data(), mapped_file.length());
   secure_hash->Finish(result, len);
 }
 
 // This will serialize the file to disk as JSON. The format is:
 // {
 //  "Version": 0x10,
 //  "HashAlgorithm": SecureHash::SHA256,
 //  "Hash": <Base64 Encoded Hash>,
@@ skipping 31 matching lines @@
 
 }  // namespace
 
 bool TestExecutableMapping(const base::FilePath& path) {
   const base::ScopedFD fd(
       HANDLE_EINTR(open(path.value().c_str(), O_RDONLY | O_CLOEXEC)));
   if (!fd.is_valid())
     return false;
   const size_t map_size = sizeof(uint8_t);
   const MmapDeleter deleter(map_size);
-  scoped_ptr<uint8_t, MmapDeleter> buf_ptr(
+  std::unique_ptr<uint8_t, MmapDeleter> buf_ptr(
       reinterpret_cast<uint8_t*>(mmap(nullptr, map_size, PROT_READ | PROT_EXEC,
                                       MAP_PRIVATE, fd.get(), 0)),
       deleter);
   return buf_ptr.get() != MAP_FAILED;
 }
 
 bool RecordFlashUpdate(const base::FilePath& unpacked_plugin,
                        const base::FilePath& moved_plugin,
                        const std::string& version) {
   base::MemoryMappedFile mapped_file;
@@ skipping 21 matching lines @@
   if (!PathService::Get(chrome::FILE_COMPONENT_FLASH_HINT, &hint_file_path))
     return false;
 
   std::string json_string;
   if (!base::ReadFileToString(hint_file_path, &json_string))
     return false;
 
   int error_code;
   std::string error_message;
   JSONStringValueDeserializer deserializer(json_string);
-  const scoped_ptr<base::Value> value =
+  const std::unique_ptr<base::Value> value =
       deserializer.Deserialize(&error_code, &error_message);
 
   if (!value) {
     LOG(ERROR)
         << "Could not deserialize the component updated Flash hint file. Error "
         << error_code << ": " << error_message;
     return false;
   }
 
   base::DictionaryValue* dict = nullptr;
@@ skipping 43 matching lines @@
            "component flash plugin will not be loaded.";
     return false;
   }
 
   *path = plugin_path;
   flash_version->assign(plugin_version_str);
   return true;
 }
 
 }  // namespace component_flash_hint_file