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

net/disk_cache/blockfile/backend_impl_v3.cc

 // Copyright (c) 2012 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/backend_impl_v3.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 667 matching lines @@
       return net::ERR_FAILED;
     background_queue_->OpenNextEntry(&data_, next_entry, callback);
     return net::ERR_IO_PENDING;
   }
 
  private:
   const base::WeakPtr<InFlightBackendIO> background_queue_;
   void* data_;
 };
 
-scoped_ptr<Backend::Iterator> BackendImplV3::CreateIterator() {
-  return scoped_ptr<Backend::Iterator>(new IteratorImpl(GetBackgroundQueue()));
+std::unique_ptr<Backend::Iterator> BackendImplV3::CreateIterator() {
+  return std::unique_ptr<Backend::Iterator>(
+      new IteratorImpl(GetBackgroundQueue()));
 }
 
 void BackendImplV3::GetStats(StatsItems* stats) {
   if (disabled_)
     return;
 
   std::pair<std::string, std::string> item;
 
   item.first = "Entries";
   item.second = base::IntToString(data_->header.num_entries);
@@ skipping 88 matching lines @@
     NOTREACHED();
     return false;
   }
 
   // Load the required data.
   size = address.num_blocks() * address.BlockSize();
   MappedFile* file = File(address);
   if (!file)
     return false;
 
-  scoped_ptr<char[]> data(new char[size]);
+  std::unique_ptr<char[]> data(new char[size]);
   size_t offset = address.start_block() * address.BlockSize() +
                   kBlockHeaderSize;
   if (!file->Read(data.get(), size, offset))
     return false;
 
   if (!stats_.Init(data.get(), size, address))
     return false;
   if (cache_type_ == net::DISK_CACHE && ShouldReportAgain())
     stats_.InitSizeHistogram();
   return true;
 }
 
 void BackendImplV3::StoreStats() {
   int size = stats_.StorageSize();
-  scoped_ptr<char[]> data(new char[size]);
+  std::unique_ptr<char[]> data(new char[size]);
   Addr address;
   size = stats_.SerializeStats(data.get(), size, &address);
   DCHECK(size);
   if (!address.is_initialized())
     return;
 
   MappedFile* file = File(address);
   if (!file)
     return;
 
@@ skipping 558 matching lines @@
 
   if (data_->header.num_entries < 0) {
     LOG(ERROR) << "Invalid number of entries";
     return false;
   }
 
   if (!mask_)
     mask_ = data_->header.table_len - 1;
 
   // Load the table into memory with a single read.
-  scoped_ptr<char[]> buf(new char[current_size]);
+  std::unique_ptr<char[]> buf(new char[current_size]);
   return index_->Read(buf.get(), current_size, 0);
 }
 
 int BackendImplV3::CheckAllEntries() {
   int num_dirty = 0;
   int num_entries = 0;
   DCHECK(mask_ < std::numeric_limits<uint32_t>::max());
   for (unsigned int i = 0; i <= mask_; i++) {
     Addr address(data_->table[i]);
     if (!address.is_initialized())
@@ skipping 116 matching lines @@
 }
 
 class BackendImplV3::NotImplementedIterator : public Backend::Iterator {
  public:
   int OpenNextEntry(disk_cache::Entry** next_entry,
                     const net::CompletionCallback& callback) override {
     return net::ERR_NOT_IMPLEMENTED;
   }
 };
 
-scoped_ptr<Backend::Iterator> BackendImplV3::CreateIterator() {
-  return scoped_ptr<Iterator>(new NotImplementedIterator());
+std::unique_ptr<Backend::Iterator> BackendImplV3::CreateIterator() {
+  return std::unique_ptr<Iterator>(new NotImplementedIterator());
 }
 
 void BackendImplV3::GetStats(StatsItems* stats) {
   NOTIMPLEMENTED();
 }
 
 void BackendImplV3::OnExternalCacheHit(const std::string& key) {
   NOTIMPLEMENTED();
 }
 
 void BackendImplV3::CleanupCache() {
 }
 
 }  // namespace disk_cache