Change scoped_ptr to std::unique_ptr in //net/disk_cache.

net/disk_cache/simple/simple_index_file.cc

 // Copyright (c) 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 "net/disk_cache/simple/simple_index_file.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/files/file.h"
@@ skipping 171 matching lines @@
   return it->ReadUInt64(&magic_number_) &&
       it->ReadUInt32(&version_) &&
       it->ReadUInt64(&number_of_entries_)&&
       it->ReadUInt64(&cache_size_);
 }
 
 void SimpleIndexFile::SyncWriteToDisk(net::CacheType cache_type,
                                       const base::FilePath& cache_directory,
                                       const base::FilePath& index_filename,
                                       const base::FilePath& temp_index_filename,
-                                      scoped_ptr<base::Pickle> pickle,
+                                      std::unique_ptr<base::Pickle> pickle,
                                       const base::TimeTicks& start_time,
                                       bool app_on_background) {
   DCHECK_EQ(index_filename.DirName().value(),
             temp_index_filename.DirName().value());
   base::FilePath index_file_directory = temp_index_filename.DirName();
   if (!base::DirectoryExists(index_file_directory) &&
       !base::CreateDirectory(index_file_directory)) {
     LOG(ERROR) << "Could not create a directory to hold the index file";
     return;
   }
@@ skipping 64 matching lines @@
                                   index_file_, out_result);
   worker_pool_->PostTaskAndReply(FROM_HERE, task, callback);
 }
 
 void SimpleIndexFile::WriteToDisk(const SimpleIndex::EntrySet& entry_set,
                                   uint64_t cache_size,
                                   const base::TimeTicks& start,
                                   bool app_on_background,
                                   const base::Closure& callback) {
   IndexMetadata index_metadata(entry_set.size(), cache_size);
-  scoped_ptr<base::Pickle> pickle = Serialize(index_metadata, entry_set);
+  std::unique_ptr<base::Pickle> pickle = Serialize(index_metadata, entry_set);
   base::Closure task =
       base::Bind(&SimpleIndexFile::SyncWriteToDisk,
                  cache_type_, cache_directory_, index_file_, temp_index_file_,
                  base::Passed(&pickle), start, app_on_background);
   if (callback.is_null())
     cache_thread_->PostTask(FROM_HERE, task);
   else
     cache_thread_->PostTaskAndReply(FROM_HERE, task, callback);
 }
 
@@ skipping 70 matching lines @@
       reinterpret_cast<const char*>(index_file_map.data()),
       index_file_map.length(),
       out_last_cache_seen_by_index,
       out_result);
 
   if (!out_result->did_load)
     simple_util::SimpleCacheDeleteFile(index_filename);
 }
 
 // static
-scoped_ptr<base::Pickle> SimpleIndexFile::Serialize(
+std::unique_ptr<base::Pickle> SimpleIndexFile::Serialize(
     const SimpleIndexFile::IndexMetadata& index_metadata,
     const SimpleIndex::EntrySet& entries) {
-  scoped_ptr<base::Pickle> pickle(
+  std::unique_ptr<base::Pickle> pickle(
       new base::Pickle(sizeof(SimpleIndexFile::PickleHeader)));
 
   index_metadata.Serialize(pickle.get());
   for (SimpleIndex::EntrySet::const_iterator it = entries.begin();
        it != entries.end(); ++it) {
     pickle->WriteUInt64(it->first);
     it->second.Serialize(pickle.get());
   }
   return pickle;
 }
@@ skipping 85 matching lines @@
 bool SimpleIndexFile::LegacyIsIndexFileStale(
     base::Time cache_last_modified,
     const base::FilePath& index_file_path) {
   base::Time index_mtime;
   if (!simple_util::GetMTime(index_file_path, &index_mtime))
     return true;
   return index_mtime < cache_last_modified;
 }
 
 }  // namespace disk_cache