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

net/disk_cache/sparse_control.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/sparse_control.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 237 matching lines @@
   if (operation_ != kNoOperation)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   // We only support up to 64 GB.
   if (offset + buf_len >= 0x1000000000LL || offset + buf_len < 0)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
-  DCHECK(!user_buf_);
+  DCHECK(!user_buf_.get());
   DCHECK(user_callback_.is_null());
 
   if (!buf && (op == kReadOperation || op == kWriteOperation))
     return 0;
 
   // Copy the operation parameters.
   operation_ = op;
   offset_ = offset;
   user_buf_ = buf ? new net::DrainableIOBuffer(buf, buf_len) : NULL;
   buf_len_ = buf_len;
@@ skipping 107 matching lines @@
   memset(&sparse_header_, 0, sizeof(sparse_header_));
   sparse_header_.signature = Time::Now().ToInternalValue();
   sparse_header_.magic = kIndexMagic;
   sparse_header_.parent_key_len = entry_->GetKey().size();
   children_map_.Resize(kNumSparseBits, true);
 
   // Save the header. The bitmap is saved in the destructor.
   scoped_refptr<net::IOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_)));
 
-  int rv = entry_->WriteData(
-      kSparseIndex, 0, buf, sizeof(sparse_header_), CompletionCallback(),
-      false);
+  int rv = entry_->WriteData(kSparseIndex,
+                             0,
+                             buf.get(),
+                             sizeof(sparse_header_),
+                             CompletionCallback(),
+                             false);
   if (rv != sizeof(sparse_header_)) {
     DLOG(ERROR) << "Unable to save sparse_header_";
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
   }
 
   entry_->SetEntryFlags(PARENT_ENTRY);
   return net::OK;
 }
 
 // We are opening an entry from disk. Make sure that our control data is there.
@@ skipping 10 matching lines @@
   // Dont't go over board with the bitmap. 8 KB gives us offsets up to 64 GB.
   int map_len = data_len - sizeof(sparse_header_);
   if (map_len > kMaxMapSize || map_len % 4)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   scoped_refptr<net::IOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_)));
 
   // Read header.
   int rv = entry_->ReadData(
-      kSparseIndex, 0, buf, sizeof(sparse_header_), CompletionCallback());
+      kSparseIndex, 0, buf.get(), sizeof(sparse_header_), CompletionCallback());
   if (rv != static_cast<int>(sizeof(sparse_header_)))
     return net::ERR_CACHE_READ_FAILURE;
 
   // The real validation should be performed by the caller. This is just to
   // double check.
   if (sparse_header_.magic != kIndexMagic ||
       sparse_header_.parent_key_len !=
           static_cast<int>(entry_->GetKey().size()))
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   // Read the actual bitmap.
   buf = new net::IOBuffer(map_len);
-  rv = entry_->ReadData(kSparseIndex, sizeof(sparse_header_), buf, map_len,
+  rv = entry_->ReadData(kSparseIndex,
+                        sizeof(sparse_header_),
+                        buf.get(),
+                        map_len,
                         CompletionCallback());
   if (rv != map_len)
     return net::ERR_CACHE_READ_FAILURE;
 
   // Grow the bitmap to the current size and copy the bits.
   children_map_.Resize(map_len * 8, false);
   children_map_.SetMap(reinterpret_cast<uint32*>(buf->data()), map_len);
   return net::OK;
 }
 
@@ skipping 22 matching lines @@
   EntryImpl* child = static_cast<EntryImpl*>(child_);
   if (!(CHILD_ENTRY & child->GetEntryFlags()) ||
       child->GetDataSize(kSparseIndex) <
           static_cast<int>(sizeof(child_data_)))
     return KillChildAndContinue(key, false);
 
   scoped_refptr<net::WrappedIOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
 
   // Read signature.
-  int rv = child_->ReadData(kSparseIndex, 0, buf, sizeof(child_data_),
-                            CompletionCallback());
+  int rv = child_->ReadData(
+      kSparseIndex, 0, buf.get(), sizeof(child_data_), CompletionCallback());
   if (rv != sizeof(child_data_))
     return KillChildAndContinue(key, true);  // This is a fatal failure.
 
   if (child_data_.header.signature != sparse_header_.signature ||
       child_data_.header.magic != kIndexMagic)
     return KillChildAndContinue(key, false);
 
   if (child_data_.header.last_block_len < 0 ||
       child_data_.header.last_block_len > kBlockSize) {
     // Make sure these values are always within range.
     child_data_.header.last_block_len = 0;
     child_data_.header.last_block = -1;
   }
 
   return true;
 }
 
 void SparseControl::CloseChild() {
   scoped_refptr<net::WrappedIOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
 
   // Save the allocation bitmap before closing the child entry.
-  int rv = child_->WriteData(kSparseIndex, 0, buf, sizeof(child_data_),
+  int rv = child_->WriteData(kSparseIndex,
+                             0,
+                             buf.get(),
+                             sizeof(child_data_),
                              CompletionCallback(),
-      false);
+                             false);
   if (rv != sizeof(child_data_))
     DLOG(ERROR) << "Failed to save child data";
   child_->Release();
   child_ = NULL;
 }
 
 std::string SparseControl::GenerateChildKey() {
   return GenerateChildName(entry_->GetKey(), sparse_header_.signature,
                            offset_ >> 20);
 }
@@ skipping 48 matching lines @@
     children_map_.Resize(Bitmap::RequiredArraySize(child_bit + 1) * 32, true);
 
   children_map_.Set(child_bit, value);
 }
 
 void SparseControl::WriteSparseData() {
   scoped_refptr<net::IOBuffer> buf(new net::WrappedIOBuffer(
       reinterpret_cast<const char*>(children_map_.GetMap())));
 
   int len = children_map_.ArraySize() * 4;
-  int rv = entry_->WriteData(kSparseIndex, sizeof(sparse_header_), buf, len,
-                             CompletionCallback(), false);
+  int rv = entry_->WriteData(kSparseIndex,
+                             sizeof(sparse_header_),
+                             buf.get(),
+                             len,
+                             CompletionCallback(),
+                             false);
   if (rv != len) {
     DLOG(ERROR) << "Unable to save sparse map";
   }
 }
 
 bool SparseControl::VerifyRange() {
   DCHECK_GE(result_, 0);
 
   child_offset_ = static_cast<int>(offset_) & (kMaxEntrySize - 1);
   child_len_ = std::min(buf_len_, kMaxEntrySize - child_offset_);
@@ skipping 82 matching lines @@
   // We know the real type of child_.
   EntryImpl* child = static_cast<EntryImpl*>(child_);
   child->SetEntryFlags(CHILD_ENTRY);
 
   memset(&child_data_, 0, sizeof(child_data_));
   child_data_.header = sparse_header_;
 
   scoped_refptr<net::WrappedIOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
 
-  int rv = child_->WriteData(kSparseIndex, 0, buf, sizeof(child_data_),
-                             CompletionCallback(), false);
+  int rv = child_->WriteData(kSparseIndex,
+                             0,
+                             buf.get(),
+                             sizeof(child_data_),
+                             CompletionCallback(),
+                             false);
   if (rv != sizeof(child_data_))
     DLOG(ERROR) << "Failed to save child data";
   SetChildBit(true);
 }
 
 void SparseControl::DoChildrenIO() {
   while (DoChildIO()) continue;
 
   // Range operations are finished synchronously, often without setting
   // |finished_| to true.
@@ skipping 34 matching lines @@
 
   int rv = 0;
   switch (operation_) {
     case kReadOperation:
       if (entry_->net_log().IsLoggingAllEvents()) {
         entry_->net_log().BeginEvent(
             net::NetLog::TYPE_SPARSE_READ_CHILD_DATA,
             CreateNetLogSparseReadWriteCallback(child_->net_log().source(),
                                                 child_len_));
       }
-      rv = child_->ReadDataImpl(kSparseData, child_offset_, user_buf_,
-                                child_len_, callback);
+      rv = child_->ReadDataImpl(
+          kSparseData, child_offset_, user_buf_.get(), child_len_, callback);
       break;
     case kWriteOperation:
       if (entry_->net_log().IsLoggingAllEvents()) {
         entry_->net_log().BeginEvent(
             net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA,
             CreateNetLogSparseReadWriteCallback(child_->net_log().source(),
                                                 child_len_));
       }
-      rv = child_->WriteDataImpl(kSparseData, child_offset_, user_buf_,
-                                 child_len_, callback, false);
+      rv = child_->WriteDataImpl(kSparseData,
+                                 child_offset_,
+                                 user_buf_.get(),
+                                 child_len_,
+                                 callback,
+                                 false);
       break;
     case kGetRangeOperation:
       rv = DoGetAvailableRange();
       break;
     default:
       NOTREACHED();
   }
 
   if (rv == net::ERR_IO_PENDING) {
     if (!pending_) {
@@ skipping 68 matching lines @@
     return;
   }
 
   UpdateRange(result);
 
   result_ += result;
   offset_ += result;
   buf_len_ -= result;
 
   // We'll be reusing the user provided buffer for the next chunk.
-  if (buf_len_ && user_buf_)
+  if (buf_len_ && user_buf_.get())
     user_buf_->DidConsume(result);
 }
 
 void SparseControl::OnChildIOCompleted(int result) {
   DCHECK_NE(net::ERR_IO_PENDING, result);
   DoChildIOCompleted(result);
 
   if (abort_) {
     // We'll return the current result of the operation, which may be less than
     // the bytes to read or write, but the user cancelled the operation.
@@ skipping 36 matching lines @@
     CompletionCallback cb = abort_callbacks_[i];
     if (i == abort_callbacks_.size() - 1)
       abort_callbacks_.clear();
 
     entry_->Release();  // Don't touch object after this line.
     cb.Run(net::OK);
   }
 }
 
 }  // namespace disk_cache