Add RetainedRef uses where needed.

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 771 matching lines @@
         } else {
           crc32s_to_write->push_back(CRCRecord(i, false, 0));
         }
       }
     }
   } else {
     DCHECK(STATE_UNINITIALIZED == state_ || STATE_FAILURE == state_);
   }
 
   if (synchronous_entry_) {
-    Closure task =
-        base::Bind(&SimpleSynchronousEntry::Close,
-                   base::Unretained(synchronous_entry_),
-                   SimpleEntryStat(last_used_, last_modified_, data_size_,
-                                   sparse_data_size_),
-                   base::Passed(&crc32s_to_write),
-                   stream_0_data_);
+    Closure task = base::Bind(
+        &SimpleSynchronousEntry::Close, base::Unretained(synchronous_entry_),
+        SimpleEntryStat(last_used_, last_modified_, data_size_,
+                        sparse_data_size_),
+        base::Passed(&crc32s_to_write), base::RetainedRef(stream_0_data_));
     Closure reply = base::Bind(&SimpleEntryImpl::CloseOperationComplete, this);
     synchronous_entry_ = NULL;
     worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 
     for (int i = 0; i < kSimpleEntryStreamCount; ++i) {
       if (!have_written_[i]) {
         SIMPLE_CACHE_UMA(ENUMERATION,
                          "CheckCRCResult", cache_type_,
                          crc_check_state_[i], CRC_CHECK_MAX);
       }
@@ skipping 60 matching lines @@
   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_));
   Closure task = base::Bind(
-      &SimpleSynchronousEntry::ReadData,
-      base::Unretained(synchronous_entry_),
+      &SimpleSynchronousEntry::ReadData, base::Unretained(synchronous_entry_),
       SimpleSynchronousEntry::EntryOperationData(stream_index, offset, buf_len),
-      make_scoped_refptr(buf),
-      read_crc32.get(),
-      entry_stat.get(),
-      result.get());
+      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),
                              base::Passed(&entry_stat),
                              base::Passed(&result));
   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 }
@@ skipping 74 matching lines @@
   // |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());
-  Closure task = base::Bind(&SimpleSynchronousEntry::WriteData,
-                            base::Unretained(synchronous_entry_),
-                            SimpleSynchronousEntry::EntryOperationData(
-                                stream_index, offset, buf_len, truncate,
-                                doomed_),
-                            make_scoped_refptr(buf),
-                            entry_stat.get(),
-                            result.get());
+  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),
                              base::Passed(&result));
   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 }
 
 void SimpleEntryImpl::ReadSparseDataInternal(
     int64_t sparse_offset,
     net::IOBuffer* buf,
     int buf_len,
     const CompletionCallback& callback) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   ScopedOperationRunner operation_runner(this);
 
   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());
-  Closure task = base::Bind(&SimpleSynchronousEntry::ReadSparseData,
-                            base::Unretained(synchronous_entry_),
-                            SimpleSynchronousEntry::EntryOperationData(
-                                sparse_offset, buf_len),
-                            make_scoped_refptr(buf),
-                            last_used.get(),
-                            result.get());
+  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));
   worker_pool_->PostTaskAndReply(FROM_HERE, task, reply);
 }
 
 void SimpleEntryImpl::WriteSparseDataInternal(
     int64_t sparse_offset,
@@ skipping 18 matching lines @@
     max_sparse_data_size = max_cache_size / kMaxSparseDataSizeDivisor;
   }
 
   scoped_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());
-  Closure task = base::Bind(&SimpleSynchronousEntry::WriteSparseData,
-                            base::Unretained(synchronous_entry_),
-                            SimpleSynchronousEntry::EntryOperationData(
-                                sparse_offset, buf_len),
-                            make_scoped_refptr(buf),
-                            max_sparse_data_size,
-                            entry_stat.get(),
-                            result.get());
+  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,
@@ skipping 472 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