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

content/browser/webui/url_data_manager_backend.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 "content/browser/webui/url_data_manager_backend.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 228 matching lines @@
 bool URLRequestChromeJob::GetMimeType(std::string* mime_type) const {
   *mime_type = mime_type_;
   return !mime_type_.empty();
 }
 
 int URLRequestChromeJob::GetResponseCode() const {
   return net::HTTP_OK;
 }
 
 void URLRequestChromeJob::GetResponseInfo(net::HttpResponseInfo* info) {
-  DCHECK(!info->headers);
+  DCHECK(!info->headers.get());
   // Set the headers so that requests serviced by ChromeURLDataManager return a
   // status code of 200. Without this they return a 0, which makes the status
   // indistiguishable from other error types. Instant relies on getting a 200.
   info->headers = new net::HttpResponseHeaders("HTTP/1.1 200 OK");
 
   // Determine the least-privileged content security policy header, if any,
   // that is compatible with a given WebUI URL, and append it to the existing
   // response headers.
   if (add_content_security_policy_) {
     std::string base = kChromeURLContentSecurityPolicyHeaderBase;
@@ skipping 16 matching lines @@
 
 void URLRequestChromeJob::DataAvailable(base::RefCountedMemory* bytes) {
   TRACE_EVENT_ASYNC_END0("browser", "DataManager:Request", this);
   if (bytes) {
     // The request completed, and we have all the data.
     // Clear any IO pending status.
     SetStatus(net::URLRequestStatus());
 
     data_ = bytes;
     int bytes_read;
-    if (pending_buf_) {
+    if (pending_buf_.get()) {
       CHECK(pending_buf_->data());
-      CompleteRead(pending_buf_, pending_buf_size_, &bytes_read);
+      CompleteRead(pending_buf_.get(), pending_buf_size_, &bytes_read);
       pending_buf_ = NULL;
       NotifyReadComplete(bytes_read);
     }
   } else {
     // The request failed.
     NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                      net::ERR_FAILED));
   }
 }
 
 bool URLRequestChromeJob::ReadRawData(net::IOBuffer* buf, int buf_size,
                                       int* bytes_read) {
-  if (!data_) {
+  if (!data_.get()) {
     SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
     DCHECK(!pending_buf_.get());
     CHECK(buf->data());
     pending_buf_ = buf;
     pending_buf_size_ = buf_size;
     return false;  // Tell the caller we're still waiting for data.
   }
 
   // Otherwise, the data is available.
   CompleteRead(buf, buf_size, bytes_read);
@@ skipping 173 matching lines @@
   // Parse the URL into a request for a source and path.
   std::string source_name;
   std::string path;
   URLToRequest(request->url(), &source_name, &path);
 
   // Look up the data source for the request.
   DataSourceMap::iterator i = data_sources_.find(source_name);
   if (i == data_sources_.end())
     return false;
 
-  URLDataSourceImpl* source = i->second;
+  URLDataSourceImpl* source = i->second.get();
 
   if (!source->source()->ShouldServiceRequest(request))
     return false;
   source->source()->WillServiceRequest(request, &path);
 
   // Save this request so we know where to send the data.
   RequestID request_id = next_request_id_++;
   pending_requests_.insert(std::make_pair(request_id, job));
 
   job->set_allow_caching(source->source()->AllowCaching());
@@ skipping 139 matching lines @@
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler*
 CreateDevToolsProtocolHandler(content::ResourceContext* resource_context,
                               bool is_incognito) {
   return new DevToolsJobFactory(resource_context, is_incognito);
 }
 
 }  // namespace content