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

webkit/appcache/view_appcache_internals_job.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 <algorithm>
 #include <string>
 
 #include "webkit/appcache/view_appcache_internals_job.h"
 
 #include "base/base64.h"
@@ skipping 317 matching lines @@
               net::NetworkDelegate* network_delegate,
               AppCacheService* service)
       : BaseInternalsJob(request, network_delegate, service),
         weak_factory_(this) {
   }
 
   virtual void Start() OVERRIDE {
     DCHECK(request_);
     info_collection_ = new AppCacheInfoCollection;
     appcache_service_->GetAllAppCacheInfo(
-        info_collection_, base::Bind(&MainPageJob::OnGotInfoComplete,
-                                     weak_factory_.GetWeakPtr()));
+        info_collection_.get(),
+        base::Bind(&MainPageJob::OnGotInfoComplete,
+                   weak_factory_.GetWeakPtr()));
   }
 
   // Produces a page containing the listing
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* out,
                       const net::CompletionCallback& callback) const OVERRIDE {
     mime_type->assign("text/html");
     charset->assign("UTF-8");
 
     out->clear();
     EmitPageStart(out);
-    if (!info_collection_) {
+    if (!info_collection_.get()) {
       out->append(kErrorMessage);
     } else if (info_collection_->infos_by_origin.empty()) {
       out->append(kEmptyAppCachesMessage);
     } else {
       typedef std::map<GURL, AppCacheInfoVector> InfoByOrigin;
       AppCacheInfoVector appcaches;
       for (InfoByOrigin::const_iterator origin =
                info_collection_->infos_by_origin.begin();
            origin != info_collection_->infos_by_origin.end(); ++origin) {
         appcaches.insert(appcaches.end(),
@@ skipping 178 matching lines @@
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* out,
                       const net::CompletionCallback& callback) const OVERRIDE {
     mime_type->assign("text/html");
     charset->assign("UTF-8");
     out->clear();
     EmitPageStart(out);
     EmitAnchor(entry_url_.spec(), entry_url_.spec(), out);
     out->append("<br/>\n");
-    if (response_info_) {
+    if (response_info_.get()) {
       if (response_info_->http_response_info())
-        EmitResponseHeaders(response_info_->http_response_info()->headers, out);
+        EmitResponseHeaders(response_info_->http_response_info()->headers.get(),
+                            out);
       else
         out->append("Failed to read response headers.<br>");
 
-      if (response_data_) {
-        EmitHexDump(response_data_->data(), amount_read_,
-                    response_info_->response_data_size(), out);
+      if (response_data_.get()) {
+        EmitHexDump(response_data_->data(),
+                    amount_read_,
+                    response_info_->response_data_size(),
+                    out);
       } else {
         out->append("Failed to read response data.<br>");
       }
     } else {
       out->append("Failed to read response headers and data.<br>");
     }
     EmitPageEnd(out);
     return net::OK;
   }
 
@@ skipping 12 matching lines @@
 
     // Read the response data, truncating if its too large.
     const int64 kLimit = 100 * 1000;
     int64 amount_to_read =
         std::min(kLimit, response_info->response_data_size());
     response_data_ = new net::IOBuffer(amount_to_read);
 
     reader_.reset(appcache_service_->storage()->CreateResponseReader(
         manifest_url_, group_id_, response_id_));
     reader_->ReadData(
-        response_data_, amount_to_read,
+        response_data_.get(),
+        amount_to_read,
         base::Bind(&ViewEntryJob::OnReadComplete, base::Unretained(this)));
   }
 
   void OnReadComplete(int result) {
     reader_.reset();
     amount_read_ = result;
     if (result < 0)
       response_data_ = NULL;
     StartAsync();
   }
@@ skipping 38 matching lines @@
     return new ViewEntryJob(request, network_delegate, service,
                             DecodeBase64URL(tokens[0]),  // manifest url
                             DecodeBase64URL(tokens[1]),  // entry url
                             response_id, group_id);
   }
 
   return new RedirectToMainPageJob(request, network_delegate, service);
 }
 
 }  // namespace appcache