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

webkit/appcache/appcache_response.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 "webkit/appcache/appcache_response.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 186 matching lines @@
   if (!entry_)  {
     ScheduleIOCompletionCallback(net::ERR_CACHE_MISS);
     return;
   }
 
   if (read_position_ + buffer_len_ > range_length_) {
     // TODO(michaeln): What about integer overflows?
     DCHECK(range_length_ >= read_position_);
     buffer_len_ = range_length_ - read_position_;
   }
-  ReadRaw(kResponseContentIndex, range_offset_ + read_position_,
-          buffer_, buffer_len_);
+  ReadRaw(kResponseContentIndex,
+          range_offset_ + read_position_,
+          buffer_.get(),
+          buffer_len_);
 }
 
 void AppCacheResponseReader::SetReadRange(int offset, int length) {
   DCHECK(!IsReadPending() && !read_position_);
   range_offset_ = offset;
   range_length_ = length;
 }
 
 void AppCacheResponseReader::OnIOComplete(int result) {
   if (result >= 0) {
-    if (info_buffer_) {
+    if (info_buffer_.get()) {
       // Deserialize the http info structure, ensuring we got headers.
       Pickle pickle(buffer_->data(), result);
       scoped_ptr<net::HttpResponseInfo> info(new net::HttpResponseInfo);
       bool response_truncated = false;
       if (!info->InitFromPickle(pickle, &response_truncated) ||
-          !info->headers) {
+          !info->headers.get()) {
         InvokeUserCompletionCallback(net::ERR_FAILED);
         return;
       }
       DCHECK(!response_truncated);
       info_buffer_->http_info.reset(info.release());
 
       // Also return the size of the response body
       DCHECK(entry_);
       info_buffer_->response_data_size =
           entry_->GetSize(kResponseContentIndex);
@@ skipping 28 matching lines @@
   DCHECK(info_buffer_.get() || buffer_.get());
 
   if (!open_callback_.is_null()) {
     if (rv == net::OK) {
       DCHECK(entry);
       entry_ = *entry;
     }
     open_callback_.Reset();
   }
 
-  if (info_buffer_)
+  if (info_buffer_.get())
     ContinueReadInfo();
   else
     ContinueReadData();
 }
 
 // AppCacheResponseWriter ----------------------------------------------
 
 AppCacheResponseWriter::AppCacheResponseWriter(
     int64 response_id, int64 group_id, AppCacheDiskCacheInterface* disk_cache)
     : AppCacheResponseIO(response_id, group_id, disk_cache),
       info_size_(0),
       write_position_(0),
       write_amount_(0),
       creation_phase_(INITIAL_ATTEMPT),
       weak_factory_(this) {
 }
 
 AppCacheResponseWriter::~AppCacheResponseWriter() {
 }
 
 void AppCacheResponseWriter::WriteInfo(
     HttpResponseInfoIOBuffer* info_buf,
     const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   DCHECK(!IsWritePending());
   DCHECK(info_buf);
   DCHECK(info_buf->http_info.get());
   DCHECK(!buffer_.get());
   DCHECK(!info_buffer_.get());
-  DCHECK(info_buf->http_info->headers);
+  DCHECK(info_buf->http_info->headers.get());
 
   info_buffer_ = info_buf;
   callback_ = callback;  // cleared on completion
   CreateEntryIfNeededAndContinue();
 }
 
 void AppCacheResponseWriter::ContinueWriteInfo() {
   if (!entry_) {
     ScheduleIOCompletionCallback(net::ERR_FAILED);
     return;
   }
 
   const bool kSkipTransientHeaders = true;
   const bool kTruncated = false;
   Pickle* pickle = new Pickle;
   info_buffer_->http_info->Persist(pickle, kSkipTransientHeaders, kTruncated);
   write_amount_ = static_cast<int>(pickle->size());
   buffer_ = new WrappedPickleIOBuffer(pickle);  // takes ownership of pickle
-  WriteRaw(kResponseInfoIndex, 0, buffer_, write_amount_);
+  WriteRaw(kResponseInfoIndex, 0, buffer_.get(), write_amount_);
 }
 
 void AppCacheResponseWriter::WriteData(
     net::IOBuffer* buf, int buf_len, const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   DCHECK(!IsWritePending());
   DCHECK(buf);
   DCHECK(buf_len >= 0);
   DCHECK(!buffer_.get());
   DCHECK(!info_buffer_.get());
 
   buffer_ = buf;
   write_amount_ = buf_len;
   callback_ = callback;  // cleared on completion
   CreateEntryIfNeededAndContinue();
 }
 
 void AppCacheResponseWriter::ContinueWriteData() {
   if (!entry_) {
     ScheduleIOCompletionCallback(net::ERR_FAILED);
     return;
   }
-  WriteRaw(kResponseContentIndex, write_position_, buffer_, write_amount_);
+  WriteRaw(
+      kResponseContentIndex, write_position_, buffer_.get(), write_amount_);
 }
 
 void AppCacheResponseWriter::OnIOComplete(int result) {
   if (result >= 0) {
     DCHECK(write_amount_ == result);
-    if (!info_buffer_)
+    if (!info_buffer_.get())
       write_position_ += result;
     else
       info_size_ = result;
   }
   InvokeUserCompletionCallback(result);
 }
 
 void AppCacheResponseWriter::CreateEntryIfNeededAndContinue() {
   int rv;
   AppCacheDiskCacheInterface::Entry** entry_ptr = NULL;
@@ skipping 41 matching lines @@
     return;
   }
 
   if (!create_callback_.is_null()) {
     if (rv == net::OK)
       entry_ = *entry;
 
     create_callback_.Reset();
   }
 
-  if (info_buffer_)
+  if (info_buffer_.get())
     ContinueWriteInfo();
   else
     ContinueWriteData();
 }
 
 }  // namespace appcache