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

net/disk_cache/blockfile/index_table_v3.h

 // 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.
 
 #ifndef NET_DISK_CACHE_BLOCKFILE_INDEX_TABLE_V3_H_
 #define NET_DISK_CACHE_BLOCKFILE_INDEX_TABLE_V3_H_
 
 // The IndexTable class is in charge of handling all the details about the main
 // index table of the cache. It provides methods to locate entries in the cache,
 // create new entries and modify existing entries. It hides the fact that the
 // table is backed up across multiple physical files, and that the files can
 // grow and be remapped while the cache is in use. However, note that this class
 // doesn't do any direct management of the backing files, and it operates only
 // with the tables in memory.
 //
 // When the current index needs to grow, the backend is notified so that files
 // are extended and remapped as needed. After that, the IndexTable should be
 // re-initialized with the new structures. Note that the IndexTable instance is
 // still functional while the backend performs file IO.
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"
 #include "net/disk_cache/blockfile/addr.h"
 #include "net/disk_cache/blockfile/bitmap.h"
 #include "net/disk_cache/blockfile/disk_format_v3.h"
 
 namespace net {
 class IOBuffer;
 }
 
@@ skipping 120 matching lines @@
 
 // The data required to initialize an index. Note that not all fields have to
 // be provided when growing the tables.
 struct NET_EXPORT_PRIVATE IndexTableInitData {
   IndexTableInitData();
   ~IndexTableInitData();
 
   IndexBitmap* index_bitmap;
   IndexBucket* main_table;
   IndexBucket* extra_table;
-  scoped_ptr<IndexHeaderV3> backup_header;
-  scoped_ptr<uint32_t[]> backup_bitmap;
+  std::unique_ptr<IndexHeaderV3> backup_header;
+  std::unique_ptr<uint32_t[]> backup_bitmap;
 };
 
 // See the description at the top of this file.
 class NET_EXPORT_PRIVATE IndexTable {
  public:
   explicit IndexTable(IndexTableBackend* backend);
   ~IndexTable();
 
   // Initializes the object, or re-initializes it when the backing files grow.
   // Note that the only supported way to initialize this objeect is using
@@ skipping 79 matching lines @@
   void CheckBucketList(int bucket_id);
 
   uint32_t GetLocation(const IndexCell& cell);
   uint32_t GetHashValue(const IndexCell& cell);
   uint32_t GetFullHash(const IndexCell& cell, uint32_t lower_part);
   bool IsHashMatch(const IndexCell& cell, uint32_t hash);
   bool MisplacedHash(const IndexCell& cell, uint32_t hash);
 
   IndexTableBackend* backend_;
   IndexHeaderV3* header_;
-  scoped_ptr<Bitmap> bitmap_;
-  scoped_ptr<Bitmap> backup_bitmap_;
-  scoped_ptr<uint32_t[]> backup_bitmap_storage_;
-  scoped_ptr<IndexHeaderV3> backup_header_;
+  std::unique_ptr<Bitmap> bitmap_;
+  std::unique_ptr<Bitmap> backup_bitmap_;
+  std::unique_ptr<uint32_t[]> backup_bitmap_storage_;
+  std::unique_ptr<IndexHeaderV3> backup_header_;
   IndexBucket* main_table_;
   IndexBucket* extra_table_;
   uint32_t mask_;   // Binary mask to map a hash to the hash table.
   int extra_bits_;  // How many bits are in mask_ above the default value.
   bool modified_;
   bool small_table_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexTable);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BLOCKFILE_INDEX_TABLE_V3_H_