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

net/disk_cache/simple/simple_backend_impl.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_backend_impl.h"
 
 #include <algorithm>
 #include <cstdlib>
 #include <functional>
 
+#include "base/memory/ptr_util.h"
+
 #if defined(OS_POSIX)
 #include <sys/resource.h>
 #endif
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/macros.h"
@@ skipping 181 matching lines @@
 class SimpleBackendImpl::ActiveEntryProxy
     : public SimpleEntryImpl::ActiveEntryProxy {
  public:
   ~ActiveEntryProxy() override {
     if (backend_) {
       DCHECK_EQ(1U, backend_->active_entries_.count(entry_hash_));
       backend_->active_entries_.erase(entry_hash_);
     }
   }
 
-  static scoped_ptr<SimpleEntryImpl::ActiveEntryProxy> Create(
+  static std::unique_ptr<SimpleEntryImpl::ActiveEntryProxy> Create(
       int64_t entry_hash,
       SimpleBackendImpl* backend) {
-    scoped_ptr<SimpleEntryImpl::ActiveEntryProxy>
-        proxy(new ActiveEntryProxy(entry_hash, backend));
+    std::unique_ptr<SimpleEntryImpl::ActiveEntryProxy> proxy(
+        new ActiveEntryProxy(entry_hash, backend));
     return proxy;
   }
 
  private:
   ActiveEntryProxy(uint64_t entry_hash, SimpleBackendImpl* backend)
       : entry_hash_(entry_hash), backend_(backend->AsWeakPtr()) {}
 
   uint64_t entry_hash_;
   base::WeakPtr<SimpleBackendImpl> backend_;
 };
@@ skipping 16 matching lines @@
 }
 
 SimpleBackendImpl::~SimpleBackendImpl() {
   index_->WriteToDisk();
 }
 
 int SimpleBackendImpl::Init(const CompletionCallback& completion_callback) {
   worker_pool_ = g_sequenced_worker_pool.Get().GetTaskRunner();
 
   index_.reset(new SimpleIndex(
-      base::ThreadTaskRunnerHandle::Get(),
-      this,
-      cache_type_,
-      make_scoped_ptr(new SimpleIndexFile(
-          cache_thread_, worker_pool_.get(), cache_type_, path_))));
+      base::ThreadTaskRunnerHandle::Get(), this, cache_type_,
+      base::WrapUnique(new SimpleIndexFile(cache_thread_, worker_pool_.get(),
+                                           cache_type_, path_))));
   index_->ExecuteWhenReady(
       base::Bind(&RecordIndexLoad, cache_type_, base::TimeTicks::Now()));
 
   PostTaskAndReplyWithResult(
       cache_thread_.get(),
       FROM_HERE,
       base::Bind(
           &SimpleBackendImpl::InitCacheStructureOnDisk, path_, orig_max_size_),
       base::Bind(&SimpleBackendImpl::InitializeIndex,
                  AsWeakPtr(),
@@ skipping 26 matching lines @@
   std::vector<Closure> to_run_closures;
   to_run_closures.swap(it->second);
   entries_pending_doom_.erase(it);
 
   for (auto& closure : to_run_closures)
     closure.Run();
 }
 
 void SimpleBackendImpl::DoomEntries(std::vector<uint64_t>* entry_hashes,
                                     const net::CompletionCallback& callback) {
-  scoped_ptr<std::vector<uint64_t>> mass_doom_entry_hashes(
+  std::unique_ptr<std::vector<uint64_t>> mass_doom_entry_hashes(
       new std::vector<uint64_t>());
   mass_doom_entry_hashes->swap(*entry_hashes);
 
   std::vector<uint64_t> to_doom_individually_hashes;
 
   // For each of the entry hashes, there are two cases:
   // 1. The entry is either open or pending doom, and so it should be doomed
   //    individually to avoid flakes.
   // 2. The entry is not in use at all, so we can call
   //    SimpleSynchronousEntry::DoomEntrySet and delete the files en masse.
@@ skipping 208 matching lines @@
                                  int error_code) {
     if (error_code == net::ERR_FAILED) {
       OpenNextEntry(entry, callback);
       return;
     }
     callback.Run(error_code);
   }
 
  private:
   base::WeakPtr<SimpleBackendImpl> backend_;
-  scoped_ptr<std::vector<uint64_t>> hashes_to_enumerate_;
+  std::unique_ptr<std::vector<uint64_t>> hashes_to_enumerate_;
   base::WeakPtrFactory<SimpleIterator> weak_factory_;
 };
 
-scoped_ptr<Backend::Iterator> SimpleBackendImpl::CreateIterator() {
-  return scoped_ptr<Iterator>(new SimpleIterator(AsWeakPtr()));
+std::unique_ptr<Backend::Iterator> SimpleBackendImpl::CreateIterator() {
+  return std::unique_ptr<Iterator>(new SimpleIterator(AsWeakPtr()));
 }
 
 void SimpleBackendImpl::GetStats(base::StringPairs* stats) {
   std::pair<std::string, std::string> item;
   item.first = "Cache type";
   item.second = "Simple Cache";
   stats->push_back(item);
 }
 
 void SimpleBackendImpl::OnExternalCacheHit(const std::string& key) {
@@ skipping 10 matching lines @@
 }
 
 void SimpleBackendImpl::IndexReadyForDoom(Time initial_time,
                                           Time end_time,
                                           const CompletionCallback& callback,
                                           int result) {
   if (result != net::OK) {
     callback.Run(result);
     return;
   }
-  scoped_ptr<std::vector<uint64_t>> removed_key_hashes(
+  std::unique_ptr<std::vector<uint64_t>> removed_key_hashes(
       index_->GetEntriesBetween(initial_time, end_time).release());
   DoomEntries(removed_key_hashes.get(), callback);
 }
 
 void SimpleBackendImpl::IndexReadyForSizeCalculation(
     const CompletionCallback& callback,
     int result) {
   if (result == net::OK)
     result = static_cast<int>(index_->GetCacheSize());
   callback.Run(result);
@@ skipping 71 matching lines @@
       cache_type_, path_, entry_hash, entry_operations_mode_, this, net_log_);
   CompletionCallback backend_callback =
       base::Bind(&SimpleBackendImpl::OnEntryOpenedFromHash,
                  AsWeakPtr(), entry_hash, entry, simple_entry, callback);
   return simple_entry->OpenEntry(entry, backend_callback);
 }
 
 int SimpleBackendImpl::DoomEntryFromHash(uint64_t entry_hash,
                                          const CompletionCallback& callback) {
   Entry** entry = new Entry*();
-  scoped_ptr<Entry*> scoped_entry(entry);
+  std::unique_ptr<Entry*> scoped_entry(entry);
 
   base::hash_map<uint64_t, std::vector<Closure>>::iterator pending_it =
       entries_pending_doom_.find(entry_hash);
   if (pending_it != entries_pending_doom_.end()) {
     Callback<int(const net::CompletionCallback&)> operation =
         base::Bind(&SimpleBackendImpl::DoomEntryFromHash,
                    base::Unretained(this), entry_hash);
     pending_it->second.push_back(base::Bind(&RunOperationAndCallback,
                                     operation, callback));
     return net::ERR_IO_PENDING;
@@ skipping 58 matching lines @@
       final_code = net::ERR_FAILED;
     } else {
       DCHECK_EQ(simple_entry->entry_hash(), simple_util::GetEntryHashKey(key));
     }
     SIMPLE_CACHE_UMA(BOOLEAN, "KeyMatchedOnOpen", cache_type_, key_matches);
   }
   callback.Run(final_code);
 }
 
 void SimpleBackendImpl::DoomEntriesComplete(
-    scoped_ptr<std::vector<uint64_t>> entry_hashes,
+    std::unique_ptr<std::vector<uint64_t>> entry_hashes,
     const net::CompletionCallback& callback,
     int result) {
   for (const uint64_t& entry_hash : *entry_hashes)
     OnDoomComplete(entry_hash);
   callback.Run(result);
 }
 
 // static
 void SimpleBackendImpl::FlushWorkerPoolForTesting() {
   // We only need to do this if we there is an active task runner.
   if (base::ThreadTaskRunnerHandle::IsSet())
     g_sequenced_worker_pool.Get().FlushForTesting();
 }
 
 }  // namespace disk_cache