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

net/disk_cache/simple/simple_index_file.h

 // 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.
 
 #ifndef NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_FILE_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_FILE_H_
 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_export.h"
 #include "net/disk_cache/simple/simple_index.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 class TaskRunner;
 }
 
@@ skipping 86 matching lines @@
   // Load the index file from disk returning an EntrySet.
   static void SyncLoadFromDisk(const base::FilePath& index_filename,
                                base::Time* out_last_cache_seen_by_index,
                                SimpleIndexLoadResult* out_result);
 
   // Returns a scoped_ptr for a newly allocated base::Pickle containing the
   // serialized
   // data to be written to a file. Note: the pickle is not in a consistent state
   // immediately after calling this menthod, one needs to call
   // SerializeFinalData to make it ready to write to a file.
-  static scoped_ptr<base::Pickle> Serialize(
+  static std::unique_ptr<base::Pickle> Serialize(
       const SimpleIndexFile::IndexMetadata& index_metadata,
       const SimpleIndex::EntrySet& entries);
 
   // Appends cache modification time data to the serialized format. This is
   // performed on a thread accessing the disk. It is not combined with the main
   // serialization path to avoid extra thread hops or copying the pickle to the
   // worker thread.
   static bool SerializeFinalData(base::Time cache_modified,
                                  base::Pickle* pickle);
 
@@ skipping 10 matching lines @@
   // succeeded.
   static bool TraverseCacheDirectory(
       const base::FilePath& cache_path,
       const EntryFileCallback& entry_file_callback);
 
   // Writes the index file to disk atomically.
   static void 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);
 
   // Scan the index directory for entries, returning an EntrySet of all entries
   // found.
   static void SyncRestoreFromDisk(const base::FilePath& cache_directory,
                                   const base::FilePath& index_file_path,
                                   SimpleIndexLoadResult* out_result);
 
   // Determines if an index file is stale relative to the time of last
@@ skipping 18 matching lines @@
   static const char kIndexFileName[];
   static const char kTempIndexFileName[];
 
   DISALLOW_COPY_AND_ASSIGN(SimpleIndexFile);
 };
 
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_FILE_H_