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

extensions/browser/computed_hashes.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 "extensions/browser/computed_hashes.h"
 
 #include "base/base64.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 19 matching lines @@
 
 ComputedHashes::Reader::~Reader() {
 }
 
 bool ComputedHashes::Reader::InitFromFile(const base::FilePath& path) {
   std::string contents;
   if (!base::ReadFileToString(path, &contents))
     return false;
 
   base::DictionaryValue* top_dictionary = NULL;
-  scoped_ptr<base::Value> value(base::JSONReader::Read(contents));
+  std::unique_ptr<base::Value> value(base::JSONReader::Read(contents));
   if (!value.get() || !value->GetAsDictionary(&top_dictionary))
     return false;
 
   // For now we don't support forwards or backwards compatability in the
   // format, so we return false on version mismatch.
   int version = 0;
   if (!top_dictionary->GetInteger(kVersionKey, &version) || version != kVersion)
     return false;
 
   base::ListValue* all_hashes = NULL;
@@ skipping 119 matching lines @@
 void ComputedHashes::ComputeHashesForContent(const std::string& contents,
                                              size_t block_size,
                                              std::vector<std::string>* hashes) {
   size_t offset = 0;
   // Even when the contents is empty, we want to output at least one hash
   // block (the hash of the empty string).
   do {
     const char* block_start = contents.data() + offset;
     DCHECK(offset <= contents.size());
     size_t bytes_to_read = std::min(contents.size() - offset, block_size);
-    scoped_ptr<crypto::SecureHash> hash(
+    std::unique_ptr<crypto::SecureHash> hash(
         crypto::SecureHash::Create(crypto::SecureHash::SHA256));
     hash->Update(block_start, bytes_to_read);
 
     hashes->push_back(std::string());
     std::string* buffer = &(hashes->back());
     buffer->resize(crypto::kSHA256Length);
     hash->Finish(string_as_array(buffer), buffer->size());
 
     // If |contents| is empty, then we want to just exit here.
     if (bytes_to_read == 0)
       break;
 
     offset += bytes_to_read;
   } while (offset < contents.size());
 }
 
 }  // namespace extensions