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

net/disk_cache/simple/simple_entry_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_entry_impl.h"
 
 #include <algorithm>
 #include <cstring>
 #include <limits>
 #include <utility>
@@ skipping 182 matching lines @@
   static_assert(arraysize(data_size_) == arraysize(have_written_),
                 "arrays should be the same size");
   static_assert(arraysize(data_size_) == arraysize(crc_check_state_),
                 "arrays should be the same size");
   MakeUninitialized();
   net_log_.BeginEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY,
       CreateNetLogSimpleEntryConstructionCallback(this));
 }
 
 void SimpleEntryImpl::SetActiveEntryProxy(
-    scoped_ptr<ActiveEntryProxy> active_entry_proxy) {
+    std::unique_ptr<ActiveEntryProxy> active_entry_proxy) {
   DCHECK(!active_entry_proxy_);
   active_entry_proxy_.reset(active_entry_proxy.release());
 }
 
 int SimpleEntryImpl::OpenEntry(Entry** out_entry,
                                const CompletionCallback& callback) {
   DCHECK(backend_.get());
 
   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_CALL);
 
@@ skipping 379 matching lines @@
   backend_->index()->Remove(entry_hash_);
   active_entry_proxy_.reset();
 }
 
 void SimpleEntryImpl::RunNextOperationIfNeeded() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   SIMPLE_CACHE_UMA(CUSTOM_COUNTS,
                    "EntryOperationsPending", cache_type_,
                    pending_operations_.size(), 0, 100, 20);
   if (!pending_operations_.empty() && state_ != STATE_IO_PENDING) {
-    scoped_ptr<SimpleEntryOperation> operation(
+    std::unique_ptr<SimpleEntryOperation> operation(
         new SimpleEntryOperation(pending_operations_.front()));
     pending_operations_.pop();
     switch (operation->type()) {
       case SimpleEntryOperation::TYPE_OPEN:
         OpenEntryInternal(operation->have_index(),
                           operation->callback(),
                           operation->out_entry());
         break;
       case SimpleEntryOperation::TYPE_CREATE:
         CreateEntryInternal(operation->have_index(),
@@ skipping 72 matching lines @@
     net_log_.AddEvent(
         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_OPEN_END,
         CreateNetLogSimpleEntryCreationCallback(this, net::ERR_FAILED));
     return;
   }
 
   DCHECK_EQ(STATE_UNINITIALIZED, state_);
   DCHECK(!synchronous_entry_);
   state_ = STATE_IO_PENDING;
   const base::TimeTicks start_time = base::TimeTicks::Now();
-  scoped_ptr<SimpleEntryCreationResults> results(
-      new SimpleEntryCreationResults(
-          SimpleEntryStat(last_used_, last_modified_, data_size_,
-                          sparse_data_size_)));
+  std::unique_ptr<SimpleEntryCreationResults> results(
+      new SimpleEntryCreationResults(SimpleEntryStat(
+          last_used_, last_modified_, data_size_, sparse_data_size_)));
   Closure task = base::Bind(&SimpleSynchronousEntry::OpenEntry,
                             cache_type_,
                             path_,
                             entry_hash_,
                             have_index,
                             results.get());
   Closure reply = base::Bind(&SimpleEntryImpl::CreationOperationComplete,
                              this,
                              callback,
                              start_time,
@@ skipping 25 matching lines @@
 
   // Since we don't know the correct values for |last_used_| and
   // |last_modified_| yet, we make this approximation.
   last_used_ = last_modified_ = base::Time::Now();
 
   // If creation succeeds, we should mark all streams to be saved on close.
   for (int i = 0; i < kSimpleEntryStreamCount; ++i)
     have_written_[i] = true;
 
   const base::TimeTicks start_time = base::TimeTicks::Now();
-  scoped_ptr<SimpleEntryCreationResults> results(
-      new SimpleEntryCreationResults(
-          SimpleEntryStat(last_used_, last_modified_, data_size_,
-                          sparse_data_size_)));
+  std::unique_ptr<SimpleEntryCreationResults> results(
+      new SimpleEntryCreationResults(SimpleEntryStat(
+          last_used_, last_modified_, data_size_, sparse_data_size_)));
   Closure task = base::Bind(&SimpleSynchronousEntry::CreateEntry,
                             cache_type_,
                             path_,
                             key_,
                             entry_hash_,
                             have_index,
                             results.get());
   Closure reply = base::Bind(&SimpleEntryImpl::CreationOperationComplete,
                              this,
                              callback,
                              start_time,
                              base::Passed(&results),
                              out_entry,
                              net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CREATE_END);
   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 }
 
 void SimpleEntryImpl::CloseInternal() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   typedef SimpleSynchronousEntry::CRCRecord CRCRecord;
-  scoped_ptr<std::vector<CRCRecord> >
-      crc32s_to_write(new std::vector<CRCRecord>());
+  std::unique_ptr<std::vector<CRCRecord>> crc32s_to_write(
+      new std::vector<CRCRecord>());
 
   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CLOSE_BEGIN);
 
   if (state_ == STATE_READY) {
     DCHECK(synchronous_entry_);
     state_ = STATE_IO_PENDING;
     for (int i = 0; i < kSimpleEntryStreamCount; ++i) {
       if (have_written_[i]) {
         if (GetDataSize(i) == crc32s_end_offset_[i]) {
           int32_t crc = GetDataSize(i) == 0 ? crc32(0, Z_NULL, 0) : crc32s_[i];
@@ skipping 80 matching lines @@
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(callback, ret_value));
     }
     return;
   }
 
   state_ = STATE_IO_PENDING;
   if (!doomed_ && backend_.get())
     backend_->index()->UseIfExists(entry_hash_);
 
-  scoped_ptr<uint32_t> read_crc32(new uint32_t());
-  scoped_ptr<int> result(new int());
-  scoped_ptr<SimpleEntryStat> entry_stat(
-      new SimpleEntryStat(last_used_, last_modified_, data_size_,
-                          sparse_data_size_));
+  std::unique_ptr<uint32_t> read_crc32(new uint32_t());
+  std::unique_ptr<int> result(new int());
+  std::unique_ptr<SimpleEntryStat> entry_stat(new SimpleEntryStat(
+      last_used_, last_modified_, data_size_, sparse_data_size_));
   Closure task = base::Bind(
       &SimpleSynchronousEntry::ReadData, base::Unretained(synchronous_entry_),
       SimpleSynchronousEntry::EntryOperationData(stream_index, offset, buf_len),
       base::RetainedRef(buf), read_crc32.get(), entry_stat.get(), result.get());
   Closure reply = base::Bind(&SimpleEntryImpl::ReadOperationComplete,
                              this,
                              stream_index,
                              offset,
                              callback,
                              base::Passed(&read_crc32),
@@ skipping 57 matching lines @@
       return;
     }
   }
   state_ = STATE_IO_PENDING;
   if (!doomed_ && backend_.get())
     backend_->index()->UseIfExists(entry_hash_);
 
   AdvanceCrc(buf, offset, buf_len, stream_index);
 
   // |entry_stat| needs to be initialized before modifying |data_size_|.
-  scoped_ptr<SimpleEntryStat> entry_stat(
-      new SimpleEntryStat(last_used_, last_modified_, data_size_,
-                          sparse_data_size_));
+  std::unique_ptr<SimpleEntryStat> entry_stat(new SimpleEntryStat(
+      last_used_, last_modified_, data_size_, sparse_data_size_));
   if (truncate) {
     data_size_[stream_index] = offset + buf_len;
   } else {
     data_size_[stream_index] = std::max(offset + buf_len,
                                         GetDataSize(stream_index));
   }
 
   // Since we don't know the correct values for |last_used_| and
   // |last_modified_| yet, we make this approximation.
   last_used_ = last_modified_ = base::Time::Now();
 
   have_written_[stream_index] = true;
   // Writing on stream 1 affects the placement of stream 0 in the file, the EOF
   // record will have to be rewritten.
   if (stream_index == 1)
     have_written_[0] = true;
 
-  scoped_ptr<int> result(new int());
+  std::unique_ptr<int> result(new int());
   Closure task = base::Bind(
       &SimpleSynchronousEntry::WriteData, base::Unretained(synchronous_entry_),
       SimpleSynchronousEntry::EntryOperationData(stream_index, offset, buf_len,
                                                  truncate, doomed_),
       base::RetainedRef(buf), entry_stat.get(), result.get());
   Closure reply = base::Bind(&SimpleEntryImpl::WriteOperationComplete,
                              this,
                              stream_index,
                              callback,
                              base::Passed(&entry_stat),
@@ skipping 11 matching lines @@
 
   if (net_log_.IsCapturing()) {
     net_log_.AddEvent(
         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_SPARSE_BEGIN,
         CreateNetLogSparseOperationCallback(sparse_offset, buf_len));
   }
 
   DCHECK_EQ(STATE_READY, state_);
   state_ = STATE_IO_PENDING;
 
-  scoped_ptr<int> result(new int());
-  scoped_ptr<base::Time> last_used(new base::Time());
+  std::unique_ptr<int> result(new int());
+  std::unique_ptr<base::Time> last_used(new base::Time());
   Closure task = base::Bind(
       &SimpleSynchronousEntry::ReadSparseData,
       base::Unretained(synchronous_entry_),
       SimpleSynchronousEntry::EntryOperationData(sparse_offset, buf_len),
       base::RetainedRef(buf), last_used.get(), result.get());
   Closure reply = base::Bind(&SimpleEntryImpl::ReadSparseOperationComplete,
                              this,
                              callback,
                              base::Passed(&last_used),
                              base::Passed(&result));
@@ skipping 16 matching lines @@
 
   DCHECK_EQ(STATE_READY, state_);
   state_ = STATE_IO_PENDING;
 
   uint64_t max_sparse_data_size = std::numeric_limits<int64_t>::max();
   if (backend_.get()) {
     uint64_t max_cache_size = backend_->index()->max_size();
     max_sparse_data_size = max_cache_size / kMaxSparseDataSizeDivisor;
   }
 
-  scoped_ptr<SimpleEntryStat> entry_stat(
-      new SimpleEntryStat(last_used_, last_modified_, data_size_,
-                          sparse_data_size_));
+  std::unique_ptr<SimpleEntryStat> entry_stat(new SimpleEntryStat(
+      last_used_, last_modified_, data_size_, sparse_data_size_));
 
   last_used_ = last_modified_ = base::Time::Now();
 
-  scoped_ptr<int> result(new int());
+  std::unique_ptr<int> result(new int());
   Closure task = base::Bind(
       &SimpleSynchronousEntry::WriteSparseData,
       base::Unretained(synchronous_entry_),
       SimpleSynchronousEntry::EntryOperationData(sparse_offset, buf_len),
       base::RetainedRef(buf), max_sparse_data_size, entry_stat.get(),
       result.get());
   Closure reply = base::Bind(&SimpleEntryImpl::WriteSparseOperationComplete,
                              this,
                              callback,
                              base::Passed(&entry_stat),
                              base::Passed(&result));
   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 }
 
 void SimpleEntryImpl::GetAvailableRangeInternal(
     int64_t sparse_offset,
     int len,
     int64_t* out_start,
     const CompletionCallback& callback) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   ScopedOperationRunner operation_runner(this);
 
   DCHECK_EQ(STATE_READY, state_);
   state_ = STATE_IO_PENDING;
 
-  scoped_ptr<int> result(new int());
+  std::unique_ptr<int> result(new int());
   Closure task = base::Bind(&SimpleSynchronousEntry::GetAvailableRange,
                             base::Unretained(synchronous_entry_),
                             SimpleSynchronousEntry::EntryOperationData(
                                 sparse_offset, len),
                             out_start,
                             result.get());
   Closure reply = base::Bind(
       &SimpleEntryImpl::GetAvailableRangeOperationComplete,
       this,
       callback,
@@ skipping 26 matching lines @@
       FROM_HERE,
       base::Bind(&SimpleSynchronousEntry::DoomEntry, path_, entry_hash_),
       base::Bind(
           &SimpleEntryImpl::DoomOperationComplete, this, callback, state_));
   state_ = STATE_IO_PENDING;
 }
 
 void SimpleEntryImpl::CreationOperationComplete(
     const CompletionCallback& completion_callback,
     const base::TimeTicks& start_time,
-    scoped_ptr<SimpleEntryCreationResults> in_results,
+    std::unique_ptr<SimpleEntryCreationResults> in_results,
     Entry** out_entry,
     net::NetLog::EventType end_event_type) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, STATE_IO_PENDING);
   DCHECK(in_results);
   ScopedOperationRunner operation_runner(this);
   SIMPLE_CACHE_UMA(BOOLEAN,
                    "EntryCreationResult", cache_type_,
                    in_results->result == net::OK);
   if (in_results->result != net::OK) {
@@ skipping 32 matching lines @@
                    (base::TimeTicks::Now() - start_time));
   AdjustOpenEntryCountBy(cache_type_, 1);
 
   net_log_.AddEvent(end_event_type);
   PostClientCallback(completion_callback, net::OK);
 }
 
 void SimpleEntryImpl::EntryOperationComplete(
     const CompletionCallback& completion_callback,
     const SimpleEntryStat& entry_stat,
-    scoped_ptr<int> result) {
+    std::unique_ptr<int> result) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(synchronous_entry_);
   DCHECK_EQ(STATE_IO_PENDING, state_);
   DCHECK(result);
   if (*result < 0) {
     state_ = STATE_FAILURE;
     MarkAsDoomed();
   } else {
     state_ = STATE_READY;
     UpdateDataFromEntryStat(entry_stat);
   }
 
   if (!completion_callback.is_null()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(completion_callback, *result));
   }
   RunNextOperationIfNeeded();
 }
 
 void SimpleEntryImpl::ReadOperationComplete(
     int stream_index,
     int offset,
     const CompletionCallback& completion_callback,
-    scoped_ptr<uint32_t> read_crc32,
-    scoped_ptr<SimpleEntryStat> entry_stat,
-    scoped_ptr<int> result) {
+    std::unique_ptr<uint32_t> read_crc32,
+    std::unique_ptr<SimpleEntryStat> entry_stat,
+    std::unique_ptr<int> result) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(synchronous_entry_);
   DCHECK_EQ(STATE_IO_PENDING, state_);
   DCHECK(read_crc32);
   DCHECK(result);
 
   if (*result > 0 &&
       crc_check_state_[stream_index] == CRC_CHECK_NEVER_READ_AT_ALL) {
     crc_check_state_[stream_index] = CRC_CHECK_NEVER_READ_TO_END;
   }
 
   if (*result > 0 && crc32s_end_offset_[stream_index] == offset) {
     uint32_t current_crc =
         offset == 0 ? crc32(0, Z_NULL, 0) : crc32s_[stream_index];
     crc32s_[stream_index] = crc32_combine(current_crc, *read_crc32, *result);
     crc32s_end_offset_[stream_index] += *result;
     if (!have_written_[stream_index] &&
         GetDataSize(stream_index) == crc32s_end_offset_[stream_index]) {
       // We have just read a file from start to finish, and so we have
       // computed a crc of the entire file. We can check it now. If a cache
       // entry has a single reader, the normal pattern is to read from start
       // to finish.
 
       net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CHECKSUM_BEGIN);
 
-      scoped_ptr<int> new_result(new int());
+      std::unique_ptr<int> new_result(new int());
       Closure task = base::Bind(&SimpleSynchronousEntry::CheckEOFRecord,
                                 base::Unretained(synchronous_entry_),
                                 stream_index,
                                 *entry_stat,
                                 crc32s_[stream_index],
                                 new_result.get());
       Closure reply = base::Bind(&SimpleEntryImpl::ChecksumOperationComplete,
                                  this, *result, stream_index,
                                  completion_callback,
                                  base::Passed(&new_result));
@@ skipping 21 matching lines @@
         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_END,
         CreateNetLogReadWriteCompleteCallback(*result));
   }
 
   EntryOperationComplete(completion_callback, *entry_stat, std::move(result));
 }
 
 void SimpleEntryImpl::WriteOperationComplete(
     int stream_index,
     const CompletionCallback& completion_callback,
-    scoped_ptr<SimpleEntryStat> entry_stat,
-    scoped_ptr<int> result) {
+    std::unique_ptr<SimpleEntryStat> entry_stat,
+    std::unique_ptr<int> result) {
   if (*result >= 0)
     RecordWriteResult(cache_type_, WRITE_RESULT_SUCCESS);
   else
     RecordWriteResult(cache_type_, WRITE_RESULT_SYNC_WRITE_FAILURE);
   if (net_log_.IsCapturing()) {
     net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_END,
         CreateNetLogReadWriteCompleteCallback(*result));
   }
 
   if (*result < 0) {
     crc32s_end_offset_[stream_index] = 0;
   }
 
   EntryOperationComplete(completion_callback, *entry_stat, std::move(result));
 }
 
 void SimpleEntryImpl::ReadSparseOperationComplete(
     const CompletionCallback& completion_callback,
-    scoped_ptr<base::Time> last_used,
-    scoped_ptr<int> result) {
+    std::unique_ptr<base::Time> last_used,
+    std::unique_ptr<int> result) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(synchronous_entry_);
   DCHECK(result);
 
   if (net_log_.IsCapturing()) {
     net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_READ_SPARSE_END,
                       CreateNetLogReadWriteCompleteCallback(*result));
   }
 
   SimpleEntryStat entry_stat(*last_used, last_modified_, data_size_,
                              sparse_data_size_);
   EntryOperationComplete(completion_callback, entry_stat, std::move(result));
 }
 
 void SimpleEntryImpl::WriteSparseOperationComplete(
     const CompletionCallback& completion_callback,
-    scoped_ptr<SimpleEntryStat> entry_stat,
-    scoped_ptr<int> result) {
+    std::unique_ptr<SimpleEntryStat> entry_stat,
+    std::unique_ptr<int> result) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(synchronous_entry_);
   DCHECK(result);
 
   if (net_log_.IsCapturing()) {
     net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_WRITE_SPARSE_END,
                       CreateNetLogReadWriteCompleteCallback(*result));
   }
 
   EntryOperationComplete(completion_callback, *entry_stat, std::move(result));
 }
 
 void SimpleEntryImpl::GetAvailableRangeOperationComplete(
     const CompletionCallback& completion_callback,
-    scoped_ptr<int> result) {
+    std::unique_ptr<int> result) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(synchronous_entry_);
   DCHECK(result);
 
   SimpleEntryStat entry_stat(last_used_, last_modified_, data_size_,
                              sparse_data_size_);
   EntryOperationComplete(completion_callback, entry_stat, std::move(result));
 }
 
 void SimpleEntryImpl::DoomOperationComplete(
     const CompletionCallback& callback,
     State state_to_restore,
     int result) {
   state_ = state_to_restore;
   net_log_.AddEvent(net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_DOOM_END);
   PostClientCallback(callback, result);
   RunNextOperationIfNeeded();
   if (backend_)
     backend_->OnDoomComplete(entry_hash_);
 }
 
 void SimpleEntryImpl::ChecksumOperationComplete(
     int orig_result,
     int stream_index,
     const CompletionCallback& completion_callback,
-    scoped_ptr<int> result) {
+    std::unique_ptr<int> result) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(synchronous_entry_);
   DCHECK_EQ(STATE_IO_PENDING, state_);
   DCHECK(result);
 
   if (net_log_.IsCapturing()) {
     net_log_.AddEventWithNetErrorCode(
         net::NetLog::TYPE_SIMPLE_CACHE_ENTRY_CHECKSUM_END,
         *result);
   }
@@ skipping 197 matching lines @@
     }
     crc32s_end_offset_[stream_index] = offset + length;
   } else if (offset < crc32s_end_offset_[stream_index]) {
     // If a range for which the crc32 was already computed is rewritten, the
     // computation of the crc32 need to start from 0 again.
     crc32s_end_offset_[stream_index] = 0;
   }
 }
 
 }  // namespace disk_cache