Update net/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

net/disk_cache/in_flight_backend_io.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/in_flight_backend_io.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 269 matching lines @@
       result_ = net::ERR_UNEXPECTED;
   }
   DCHECK_NE(net::ERR_IO_PENDING, result_);
   NotifyController();
 }
 
 // Runs on the background thread.
 void BackendIO::ExecuteEntryOperation() {
   switch (operation_) {
     case OP_READ:
-      result_ = entry_->ReadDataImpl(
-          index_, offset_, buf_, buf_len_,
-          base::Bind(&BackendIO::OnIOComplete, this));
+      result_ =
+          entry_->ReadDataImpl(index_,
+                               offset_,
+                               buf_.get(),
+                               buf_len_,
+                               base::Bind(&BackendIO::OnIOComplete, this));
       break;
     case OP_WRITE:
-      result_ = entry_->WriteDataImpl(
-          index_, offset_, buf_, buf_len_,
-          base::Bind(&BackendIO::OnIOComplete, this),
-          truncate_);
+      result_ =
+          entry_->WriteDataImpl(index_,
+                                offset_,
+                                buf_.get(),
+                                buf_len_,
+                                base::Bind(&BackendIO::OnIOComplete, this),
+                                truncate_);
       break;
     case OP_READ_SPARSE:
       result_ = entry_->ReadSparseDataImpl(
-          offset64_, buf_, buf_len_,
+          offset64_,
+          buf_.get(),
+          buf_len_,
           base::Bind(&BackendIO::OnIOComplete, this));
       break;
     case OP_WRITE_SPARSE:
       result_ = entry_->WriteSparseDataImpl(
-          offset64_, buf_, buf_len_,
+          offset64_,
+          buf_.get(),
+          buf_len_,
           base::Bind(&BackendIO::OnIOComplete, this));
       break;
     case OP_GET_RANGE:
       result_ = entry_->GetAvailableRangeImpl(offset64_, buf_len_, start_);
       break;
     case OP_CANCEL_IO:
       entry_->CancelSparseIOImpl();
       result_ = net::OK;
       break;
     case OP_IS_READY:
@@ skipping 15 matching lines @@
       background_thread_(background_thread),
       ptr_factory_(this) {
 }
 
 InFlightBackendIO::~InFlightBackendIO() {
 }
 
 void InFlightBackendIO::Init(const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->Init();
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::OpenEntry(const std::string& key, Entry** entry,
                                   const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->OpenEntry(key, entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::CreateEntry(const std::string& key, Entry** entry,
                                     const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->CreateEntry(key, entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomEntry(const std::string& key,
                                   const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->DoomEntry(key);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomAllEntries(
     const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->DoomAllEntries();
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomEntriesBetween(const base::Time initial_time,
                         const base::Time end_time,
                         const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->DoomEntriesBetween(initial_time, end_time);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomEntriesSince(
     const base::Time initial_time, const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->DoomEntriesSince(initial_time);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::OpenNextEntry(void** iter, Entry** next_entry,
                                       const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->OpenNextEntry(iter, next_entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::OpenPrevEntry(void** iter, Entry** prev_entry,
                                       const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->OpenPrevEntry(iter, prev_entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::EndEnumeration(void* iterator) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->EndEnumeration(iterator);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::OnExternalCacheHit(const std::string& key) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->OnExternalCacheHit(key);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::CloseEntryImpl(EntryImpl* entry) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->CloseEntryImpl(entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomEntryImpl(EntryImpl* entry) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->DoomEntryImpl(entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::FlushQueue(const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->FlushQueue();
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::RunTask(
     const base::Closure& task, const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->RunTask(task);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::ReadData(EntryImpl* entry, int index, int offset,
                                  net::IOBuffer* buf, int buf_len,
                                  const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->ReadData(entry, index, offset, buf, buf_len);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::WriteData(EntryImpl* entry, int index, int offset,
                                   net::IOBuffer* buf, int buf_len,
                                   bool truncate,
                                   const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->WriteData(entry, index, offset, buf, buf_len, truncate);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::ReadSparseData(
     EntryImpl* entry, int64 offset, net::IOBuffer* buf, int buf_len,
     const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->ReadSparseData(entry, offset, buf, buf_len);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::WriteSparseData(
     EntryImpl* entry, int64 offset, net::IOBuffer* buf, int buf_len,
     const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->WriteSparseData(entry, offset, buf, buf_len);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::GetAvailableRange(
     EntryImpl* entry, int64 offset, int len, int64* start,
     const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->GetAvailableRange(entry, offset, len, start);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::CancelSparseIO(EntryImpl* entry) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->CancelSparseIO(entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::ReadyForSparseIO(
     EntryImpl* entry, const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->ReadyForSparseIO(entry);
-  PostOperation(operation);
+  PostOperation(operation.get());
 }
 
 void InFlightBackendIO::WaitForPendingIO() {
   InFlightIO::WaitForPendingIO();
 }
 
 void InFlightBackendIO::OnOperationComplete(BackgroundIO* operation,
                                             bool cancel) {
   BackendIO* op = static_cast<BackendIO*>(operation);
   op->OnDone(cancel);
 
   if (!op->callback().is_null() && (!cancel || op->IsEntryOperation()))
     op->callback().Run(op->result());
 }
 
 void InFlightBackendIO::PostOperation(BackendIO* operation) {
   background_thread_->PostTask(FROM_HERE,
       base::Bind(&BackendIO::ExecuteOperation, operation));
   OnOperationPosted(operation);
 }
 
 base::WeakPtr<InFlightBackendIO> InFlightBackendIO::GetWeakPtr() {
   return ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace