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

net/disk_cache/simple/simple_index.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.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 126 matching lines @@
     return false;
   SetLastUsedTime(base::Time::FromInternalValue(tmp_last_used_time));
   entry_size_ = static_cast<int32_t>(tmp_entry_size);
   return true;
 }
 
 SimpleIndex::SimpleIndex(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_thread,
     SimpleIndexDelegate* delegate,
     net::CacheType cache_type,
-    scoped_ptr<SimpleIndexFile> index_file)
+    std::unique_ptr<SimpleIndexFile> index_file)
     : delegate_(delegate),
       cache_type_(cache_type),
       cache_size_(0),
       max_size_(0),
       high_watermark_(0),
       low_watermark_(0),
       eviction_in_progress_(false),
       initialized_(false),
       init_method_(INITIALIZE_METHOD_MAX),
       index_file_(std::move(index_file)),
@@ skipping 17 matching lines @@
   DCHECK(io_thread_checker_.CalledOnValidThread());
 
 #if defined(OS_ANDROID)
   if (base::android::IsVMInitialized()) {
     app_status_listener_.reset(new base::android::ApplicationStatusListener(
         base::Bind(&SimpleIndex::OnApplicationStateChange, AsWeakPtr())));
   }
 #endif
 
   SimpleIndexLoadResult* load_result = new SimpleIndexLoadResult();
-  scoped_ptr<SimpleIndexLoadResult> load_result_scoped(load_result);
+  std::unique_ptr<SimpleIndexLoadResult> load_result_scoped(load_result);
   base::Closure reply = base::Bind(
       &SimpleIndex::MergeInitializingSet,
       AsWeakPtr(),
       base::Passed(&load_result_scoped));
   index_file_->LoadIndexEntries(cache_mtime, reply, load_result);
 }
 
 void SimpleIndex::SetMaxSize(uint64_t max_bytes) {
   // Zero size means use the default.
   if (max_bytes) {
     max_size_ = max_bytes;
     high_watermark_ = max_size_ - max_size_ / kEvictionMarginDivisor;
     low_watermark_ = max_size_ - 2 * (max_size_ / kEvictionMarginDivisor);
   }
 }
 
 int SimpleIndex::ExecuteWhenReady(const net::CompletionCallback& task) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   if (initialized_)
     io_thread_->PostTask(FROM_HERE, base::Bind(task, net::OK));
   else
     to_run_when_initialized_.push_back(task);
   return net::ERR_IO_PENDING;
 }
 
-scoped_ptr<SimpleIndex::HashList> SimpleIndex::GetEntriesBetween(
-    base::Time initial_time, base::Time end_time) {
+std::unique_ptr<SimpleIndex::HashList> SimpleIndex::GetEntriesBetween(
+    base::Time initial_time,
+    base::Time end_time) {
   DCHECK_EQ(true, initialized_);
 
   if (!initial_time.is_null())
     initial_time -= EntryMetadata::GetLowerEpsilonForTimeComparisons();
   if (end_time.is_null())
     end_time = base::Time::Max();
   else
     end_time += EntryMetadata::GetUpperEpsilonForTimeComparisons();
   const base::Time extended_end_time =
       end_time.is_null() ? base::Time::Max() : end_time;
   DCHECK(extended_end_time >= initial_time);
-  scoped_ptr<HashList> ret_hashes(new HashList());
+  std::unique_ptr<HashList> ret_hashes(new HashList());
   for (EntrySet::iterator it = entries_set_.begin(), end = entries_set_.end();
        it != end; ++it) {
     EntryMetadata& metadata = it->second;
     base::Time entry_time = metadata.GetLastUsedTime();
     if (initial_time <= entry_time && entry_time < extended_end_time)
       ret_hashes->push_back(it->first);
   }
   return ret_hashes;
 }
 
-scoped_ptr<SimpleIndex::HashList> SimpleIndex::GetAllHashes() {
+std::unique_ptr<SimpleIndex::HashList> SimpleIndex::GetAllHashes() {
   return GetEntriesBetween(base::Time(), base::Time());
 }
 
 int32_t SimpleIndex::GetEntryCount() const {
   // TODO(pasko): return a meaningful initial estimate before initialized.
   return entries_set_.size();
 }
 
 uint64_t SimpleIndex::GetCacheSize() const {
   DCHECK(initialized_);
@@ skipping 142 matching lines @@
                                           int64_t entry_size) {
   // Update the total cache size with the new entry size.
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK_GE(cache_size_, (*it)->second.GetEntrySize());
   cache_size_ -= (*it)->second.GetEntrySize();
   cache_size_ += entry_size;
   (*it)->second.SetEntrySize(entry_size);
 }
 
 void SimpleIndex::MergeInitializingSet(
-    scoped_ptr<SimpleIndexLoadResult> load_result) {
+    std::unique_ptr<SimpleIndexLoadResult> load_result) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(load_result->did_load);
 
   EntrySet* index_file_entries = &load_result->entries;
 
   for (base::hash_set<uint64_t>::const_iterator it = removed_entries_.begin();
        it != removed_entries_.end(); ++it) {
     index_file_entries->erase(*it);
   }
   removed_entries_.clear();
@@ skipping 70 matching lines @@
                        start - last_write_to_disk_);
     }
   }
   last_write_to_disk_ = start;
 
   index_file_->WriteToDisk(entries_set_, cache_size_,
                            start, app_on_background_, base::Closure());
 }
 
 }  // namespace disk_cache