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

net/disk_cache/blockfile/index_table_v3.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 "net/disk_cache/blockfile/index_table_v3.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 440 matching lines @@
 //  - Doubling the size of the main table
 //  - Adding more entries to the extra table
 //
 // For example, consider a 64k main table with 8k cells on the extra table (for
 // a total of 72k cells). Init can be called to add another 8k cells at the end
 // (grow to 80k cells). When the size of the extra table approaches 64k, Init
 // can be called to double the main table (to 128k) and go back to a small extra
 // table.
 void IndexTable::Init(IndexTableInitData* params) {
   bool growing = header_ != NULL;
-  scoped_ptr<IndexBucket[]> old_extra_table;
+  std::unique_ptr<IndexBucket[]> old_extra_table;
   header_ = &params->index_bitmap->header;
 
   if (params->main_table) {
     if (main_table_) {
       // This is doubling the size of main table.
       DCHECK_EQ(base::bits::Log2Floor(header_->table_len),
                 base::bits::Log2Floor(backup_header_->table_len) + 1);
       int extra_size = (header()->max_bucket - mask_) * kCellsPerBucket;
       DCHECK_GE(extra_size, 0);
 
@@ skipping 49 matching lines @@
     DCHECK_GT(old_num_words, old_main_table_bit_words);
     memset(backup_bitmap_storage_.get() + old_main_table_bit_words, 0,
            (old_num_words - old_main_table_bit_words) * sizeof(int32_t));
   }
   bitmap_.reset(new Bitmap(params->index_bitmap->bitmap, header_->table_len,
                            num_words));
 
   if (growing) {
     int old_num_words = (backup_header_.get()->table_len + 31) / 32;
     DCHECK_GE(num_words, old_num_words);
-    scoped_ptr<uint32_t[]> storage(new uint32_t[num_words]);
+    std::unique_ptr<uint32_t[]> storage(new uint32_t[num_words]);
     memcpy(storage.get(), backup_bitmap_storage_.get(),
            old_num_words * sizeof(int32_t));
     memset(storage.get() + old_num_words, 0,
            (num_words - old_num_words) * sizeof(int32_t));
 
     backup_bitmap_storage_.swap(storage);
     backup_header_->table_len = header_->table_len;
   } else {
     backup_bitmap_storage_.reset(params->backup_bitmap.release());
     backup_header_.reset(params->backup_header.release());
@@ skipping 413 matching lines @@
   int max_bucket = header()->max_bucket;
   header()->max_bucket = mask_;
   int used_cells = header()->used_cells;
 
   // Consider a large cache: a cell stores the upper 18 bits of the hash
   // (h >> 14). If the table is say 8 times the original size (growing from 4x),
   // the bit that we are interested in would be the 3rd bit of the stored value,
   // in other words 'multiplier' >> 1.
   uint32_t new_bit = (1 << extra_bits_) >> 1;
 
-  scoped_ptr<IndexBucket[]> old_main_table;
+  std::unique_ptr<IndexBucket[]> old_main_table;
   IndexBucket* source_table = main_table_;
   bool upgrade_format = !extra_bits_;
   if (upgrade_format) {
     // This method should deal with migrating a small table to a big one. Given
     // that the first thing to do is read the old table, set small_table_ for
     // the size of the old table. Now, when moving a cell, the result cannot be
     // placed in the old table or we will end up reading it again and attempting
     // to move it, so we have to copy the whole table at once.
     DCHECK(!small_table_);
     small_table_ = true;
@@ skipping 167 matching lines @@
 bool IndexTable::MisplacedHash(const IndexCell& cell, uint32_t hash) {
   if (!extra_bits_)
     return false;
 
   uint32_t mask = (1 << extra_bits_) - 1;
   hash = small_table_ ? hash >> kSmallTableHashShift : hash >> kHashShift;
   return (GetHashValue(cell) & mask) != (hash & mask);
 }
 
 }  // namespace disk_cache