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

webkit/appcache/appcache_service.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_service.h"
 
 #include <functional>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 356 matching lines @@
     delete this;
     return;
   }
 
   // Verify that we can read the response info and data.
   expected_total_size_ = entry->response_size();
   response_reader_.reset(service_->storage()->CreateResponseReader(
       manifest_url_, group->group_id(), response_id_));
   info_buffer_ = new HttpResponseInfoIOBuffer();
   response_reader_->ReadInfo(
-      info_buffer_, base::Bind(&CheckResponseHelper::OnReadInfoComplete,
-                               base::Unretained(this)));
+      info_buffer_.get(),
+      base::Bind(&CheckResponseHelper::OnReadInfoComplete,
+                 base::Unretained(this)));
 }
 
 void AppCacheService::CheckResponseHelper::OnReadInfoComplete(int result) {
   if (result < 0) {
     AppCacheHistograms::CountCheckResponseResult(
         AppCacheHistograms::READ_HEADERS_ERROR);
     service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
     delete this;
     return;
   }
   amount_headers_read_ = result;
 
   // Start reading the data.
   data_buffer_ = new net::IOBuffer(kIOBufferSize);
   response_reader_->ReadData(
-      data_buffer_, kIOBufferSize,
+      data_buffer_.get(),
+      kIOBufferSize,
       base::Bind(&CheckResponseHelper::OnReadDataComplete,
                  base::Unretained(this)));
 }
 
 void AppCacheService::CheckResponseHelper::OnReadDataComplete(int result) {
   if (result > 0) {
     // Keep reading until we've read thru everything or failed to read.
     amount_data_read_ += result;
     response_reader_->ReadData(
-        data_buffer_, kIOBufferSize,
+        data_buffer_.get(),
+        kIOBufferSize,
         base::Bind(&CheckResponseHelper::OnReadDataComplete,
                    base::Unretained(this)));
     return;
   }
 
   AppCacheHistograms::CheckResponseResultType check_result;
   if (result < 0)
     check_result = AppCacheHistograms::READ_DATA_ERROR;
   else if (info_buffer_->response_data_size != amount_data_read_ ||
            expected_total_size_ != amount_data_read_ + amount_headers_read_)
     check_result = AppCacheHistograms::UNEXPECTED_DATA_SIZE;
   else
     check_result = AppCacheHistograms::RESPONSE_OK;
   AppCacheHistograms::CountCheckResponseResult(check_result);
 
   if (check_result != AppCacheHistograms::RESPONSE_OK)
     service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
   delete this;
 }
 
 
 // AppCacheService -------
 
 AppCacheService::AppCacheService(quota::QuotaManagerProxy* quota_manager_proxy)
     : appcache_policy_(NULL), quota_client_(NULL),
       quota_manager_proxy_(quota_manager_proxy),
       request_context_(NULL),
       force_keep_session_state_(false) {
-  if (quota_manager_proxy_) {
+  if (quota_manager_proxy_.get()) {
     quota_client_ = new AppCacheQuotaClient(this);
     quota_manager_proxy_->RegisterClient(quota_client_);
   }
 }
 
 AppCacheService::~AppCacheService() {
   DCHECK(backends_.empty());
   std::for_each(pending_helpers_.begin(),
                 pending_helpers_.end(),
                 std::mem_fun(&AsyncHelper::Cancel));
@@ skipping 64 matching lines @@
   backends_.insert(
       BackendMap::value_type(backend_impl->process_id(), backend_impl));
 }
 
 void AppCacheService::UnregisterBackend(
     AppCacheBackendImpl* backend_impl) {
   backends_.erase(backend_impl->process_id());
 }
 
 }  // namespace appcache