Remove implicit scoped_refptr operator T*

content/browser/renderer_host/resource_loader.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/renderer_host/resource_loader.h"
 
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/renderer_host/doomed_resource_handler.h"
@@ skipping 48 matching lines @@
       delegate_(delegate),
       last_upload_position_(0),
       waiting_for_upload_progress_ack_(false),
       is_transferring_(false),
       weak_ptr_factory_(this) {
   request_->set_delegate(this);
   handler_->SetController(this);
 }
 
 ResourceLoader::~ResourceLoader() {
-  if (login_delegate_)
+  if (login_delegate_.get())
     login_delegate_->OnRequestCancelled();
-  if (ssl_client_auth_handler_)
+  if (ssl_client_auth_handler_.get())
     ssl_client_auth_handler_->OnRequestCancelled();
 
   // Run ResourceHandler destructor before we tear-down the rest of our state
   // as the ResourceHandler may want to inspect the URLRequest and other state.
   handler_.reset();
 }
 
 void ResourceLoader::StartRequest() {
   if (delegate_->HandleExternalProtocol(this, request_->url())) {
     CancelAndIgnore();
@@ skipping 131 matching lines @@
 
   delegate_->DidReceiveRedirect(this, new_url);
 
   if (delegate_->HandleExternalProtocol(this, new_url)) {
     // The request is complete so we can remove it.
     CancelAndIgnore();
     return;
   }
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse());
-  PopulateResourceResponse(request_.get(), response);
+  PopulateResourceResponse(request_.get(), response.get());
 
-  if (!handler_->OnRequestRedirected(info->GetRequestID(), new_url, response,
-                                     defer)) {
+  if (
+      !handler_->
+      OnRequestRedirected(info->GetRequestID(), new_url, response.get(),
+                          defer)) {
     Cancel();
   } else if (*defer) {
     deferred_stage_ = DEFERRED_REDIRECT;  // Follow redirect when resumed.
   }
 }
 
 void ResourceLoader::OnAuthRequired(net::URLRequest* unused,
                                     net::AuthChallengeInfo* auth_info) {
   DCHECK_EQ(request_.get(), unused);
 
   if (request_->load_flags() & net::LOAD_DO_NOT_PROMPT_FOR_LOGIN) {
     request_->CancelAuth();
     return;
   }
 
   if (!delegate_->AcceptAuthRequest(this, auth_info)) {
     request_->CancelAuth();
     return;
   }
 
   // Create a login dialog on the UI thread to get authentication data, or pull
   // from cache and continue on the IO thread.
 
-  DCHECK(!login_delegate_) <<
+  DCHECK(!login_delegate_.get()) <<
       "OnAuthRequired called with login_delegate pending";
   login_delegate_ = delegate_->CreateLoginDelegate(this, auth_info);
-  if (!login_delegate_)
+  if (!login_delegate_.get())
     request_->CancelAuth();
 }
 
 void ResourceLoader::OnCertificateRequested(
     net::URLRequest* unused,
     net::SSLCertRequestInfo* cert_info) {
   DCHECK_EQ(request_.get(), unused);
 
   if (!delegate_->AcceptSSLClientCertificateRequest(this, cert_info)) {
     request_->Cancel();
     return;
   }
 
   if (cert_info->client_certs.empty()) {
     // No need to query the user if there are no certs to choose from.
     request_->ContinueWithCertificate(NULL);
     return;
   }
 
-  DCHECK(!ssl_client_auth_handler_) <<
+  DCHECK(!ssl_client_auth_handler_.get()) <<
       "OnCertificateRequested called with ssl_client_auth_handler pending";
   ssl_client_auth_handler_ = new SSLClientAuthHandler(request_.get(),
                                                       cert_info);
   ssl_client_auth_handler_->SelectCertificate();
 }
 
 void ResourceLoader::OnSSLCertificateError(net::URLRequest* request,
                                            const net::SSLInfo& ssl_info,
                                            bool fatal) {
   ResourceRequestInfoImpl* info = GetRequestInfo();
@@ skipping 141 matching lines @@
   // WebKit will send us a cancel for downloads since it no longer handles
   // them.  In this case, ignore the cancel since we handle downloads in the
   // browser.
   if (from_renderer && info->is_download())
     return;
 
   // TODO(darin): Perhaps we should really be looking to see if the status is
   // IO_PENDING?
   bool was_pending = request_->is_pending();
 
-  if (login_delegate_) {
+  if (login_delegate_.get()) {
     login_delegate_->OnRequestCancelled();
     login_delegate_ = NULL;
   }
-  if (ssl_client_auth_handler_) {
+  if (ssl_client_auth_handler_.get()) {
     ssl_client_auth_handler_->OnRequestCancelled();
     ssl_client_auth_handler_ = NULL;
   }
 
   request_->CancelWithError(error);
 
   if (!was_pending) {
     // If the request isn't in flight, then we won't get an asynchronous
     // notification from the request, so we have to signal ourselves to finish
     // this request.
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&ResourceLoader::ResponseCompleted,
                               weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void ResourceLoader::CompleteResponseStarted() {
   ResourceRequestInfoImpl* info = GetRequestInfo();
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse());
-  PopulateResourceResponse(request_.get(), response);
+  PopulateResourceResponse(request_.get(), response.get());
 
-  if (request_->ssl_info().cert) {
+  if (request_->ssl_info().cert.get()) {
     int cert_id =
-        CertStore::GetInstance()->StoreCert(request_->ssl_info().cert,
+        CertStore::GetInstance()->StoreCert(request_->ssl_info().cert.get(),
                                             info->GetChildID());
     response->head.security_info = SerializeSecurityInfo(
         cert_id,
         request_->ssl_info().cert_status,
         request_->ssl_info().security_bits,
         request_->ssl_info().connection_status);
   } else {
     // We should not have any SSL state.
     DCHECK(!request_->ssl_info().cert_status &&
            request_->ssl_info().security_bits == -1 &&
            !request_->ssl_info().connection_status);
   }
 
   delegate_->DidReceiveResponse(this);
 
   bool defer = false;
-  if (!handler_->OnResponseStarted(info->GetRequestID(), response, &defer)) {
+  if (
+      !handler_->
+      OnResponseStarted(info->GetRequestID(), response.get(), &defer)) {
     Cancel();
   } else if (defer) {
     deferred_stage_ = DEFERRED_READ;  // Read first chunk when resumed.
   }
 }
 
 void ResourceLoader::StartReading(bool is_continuation) {
   int bytes_read = 0;
   ReadMore(&bytes_read);
 
@@ skipping 57 matching lines @@
     deferred_stage_ = DEFERRED_READ;  // Read next chunk when resumed.
   }
 }
 
 void ResourceLoader::ResponseCompleted() {
   VLOG(1) << "ResponseCompleted: " << request_->url().spec();
   ResourceRequestInfoImpl* info = GetRequestInfo();
 
   std::string security_info;
   const net::SSLInfo& ssl_info = request_->ssl_info();
-  if (ssl_info.cert != NULL) {
-    int cert_id = CertStore::GetInstance()->StoreCert(ssl_info.cert,
+  if (ssl_info.cert.get() != NULL) {
+    int cert_id = CertStore::GetInstance()->StoreCert(ssl_info.cert.get(),
                                                       info->GetChildID());
     security_info = SerializeSecurityInfo(
         cert_id, ssl_info.cert_status, ssl_info.security_bits,
         ssl_info.connection_status);
   }
 
   if (handler_->OnResponseCompleted(info->GetRequestID(), request_->status(),
                                     security_info)) {
     // This will result in our destruction.
     CallDidFinishLoading();
   } else {
     // The handler is not ready to die yet.  We will call DidFinishLoading when
     // we resume.
     deferred_stage_ = DEFERRED_FINISH;
   }
 }
 
 void ResourceLoader::CallDidFinishLoading() {
   delegate_->DidFinishLoading(this);
 }
 
 }  // namespace content