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

chrome/browser/automation/url_request_automation_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 "chrome/browser/automation/url_request_automation_job.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/time.h"
@@ skipping 90 matching lines @@
       id_(0),
       tab_(tab),
       message_filter_(filter),
       pending_buf_size_(0),
       redirect_status_(0),
       request_id_(request_id),
       is_pending_(is_pending),
       upload_size_(0),
       weak_factory_(this) {
   DVLOG(1) << "URLRequestAutomationJob create. Count: " << ++instance_count_;
-  DCHECK(message_filter_ != NULL);
+  DCHECK(message_filter_.get() != NULL);
 
-  if (message_filter_) {
+  if (message_filter_.get()) {
     id_ = message_filter_->NewAutomationRequestId();
     DCHECK_NE(id_, 0);
   }
 }
 
 URLRequestAutomationJob::~URLRequestAutomationJob() {
   DVLOG(1) << "URLRequestAutomationJob delete. Count: " << --instance_count_;
   Cleanup();
 }
 
@@ skipping 21 matching lines @@
   // Returning null here just means that the built-in handler will be used.
   if (scheme_is_http || scheme_is_https) {
     const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
     if (info) {
       int child_id = info->GetChildID();
       int route_id = info->GetRouteID();
       AutomationResourceMessageFilter::AutomationDetails details;
       if (AutomationResourceMessageFilter::LookupRegisteredRenderView(
               child_id, route_id, &details)) {
         URLRequestAutomationJob* job = new URLRequestAutomationJob(
-            request, network_delegate,
+            request,
+            network_delegate,
             request->context()->http_user_agent_settings(),
-            details.tab_handle, info->GetRequestID(), details.filter,
+            details.tab_handle,
+            info->GetRequestID(),
+            details.filter.get(),
             details.is_pending_render_view);
         return job;
       }
     }
 
     if (scheme_is_http && old_http_factory_)
       return old_http_factory_(request, network_delegate, scheme);
     else if (scheme_is_https && old_https_factory_)
       return old_https_factory_(request, network_delegate, scheme);
   }
@@ skipping 33 matching lines @@
     net::IOBuffer* buf, int buf_size, int* bytes_read) {
   DVLOG(1) << "URLRequestAutomationJob: " << request_->url().spec()
            << " - read pending: " << buf_size;
 
   // We should not receive a read request for a pending job.
   DCHECK(!is_pending());
 
   pending_buf_ = buf;
   pending_buf_size_ = buf_size;
 
-  if (message_filter_) {
+  if (message_filter_.get()) {
     message_filter_->Send(new AutomationMsg_RequestRead(tab_, id_, buf_size));
     SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
   } else {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&URLRequestAutomationJob::NotifyJobCompletionTask,
                    weak_factory_.GetWeakPtr()));
   }
   return false;
 }
 
 bool URLRequestAutomationJob::GetMimeType(std::string* mime_type) const {
   if (!mime_type_.empty()) {
     *mime_type = mime_type_;
-  } else if (headers_) {
+  } else if (headers_.get()) {
     headers_->GetMimeType(mime_type);
   }
 
   return (!mime_type->empty());
 }
 
 bool URLRequestAutomationJob::GetCharset(std::string* charset) {
-  if (headers_)
+  if (headers_.get())
     return headers_->GetCharset(charset);
   return false;
 }
 
 void URLRequestAutomationJob::GetResponseInfo(net::HttpResponseInfo* info) {
-  if (headers_)
+  if (headers_.get())
     info->headers = headers_;
   if (request_->url().SchemeIsSecure()) {
     // Make up a fake certificate for this response since we don't have
     // access to the real SSL info.
     const char* kCertIssuer = "Chrome Internal";
     const int kLifetimeDays = 100;
 
     info->ssl_info.cert =
         new net::X509Certificate(request_->url().GetWithEmptyPath().spec(),
                                  kCertIssuer,
                                  Time::Now(),
                                  Time::Now() +
                                      TimeDelta::FromDays(kLifetimeDays));
     info->ssl_info.cert_status = 0;
     info->ssl_info.security_bits = -1;
   }
 }
 
 int URLRequestAutomationJob::GetResponseCode() const {
-  if (headers_)
+  if (headers_.get())
     return headers_->response_code();
 
   static const int kDefaultResponseCode = 200;
   return kDefaultResponseCode;
 }
 
 bool URLRequestAutomationJob::IsRedirectResponse(
     GURL* location, int* http_status_code) {
   if (!net::HttpResponseHeaders::IsRedirectResponseCode(redirect_status_))
     return false;
@@ skipping 81 matching lines @@
 void URLRequestAutomationJob::OnDataAvailable(
     int id, const std::string& bytes) {
   DVLOG(1) << "URLRequestAutomationJob: " << request_->url().spec()
            << " - data available, Size: " << bytes.size();
   DCHECK(!bytes.empty());
 
   // The request completed, and we have all the data.
   // Clear any IO pending status.
   SetStatus(net::URLRequestStatus());
 
-  if (pending_buf_ && pending_buf_->data()) {
+  if (pending_buf_.get() && pending_buf_->data()) {
     DCHECK_GE(pending_buf_size_, bytes.size());
     const int bytes_to_copy = std::min(bytes.size(), pending_buf_size_);
     memcpy(pending_buf_->data(), &bytes[0], bytes_to_copy);
 
     pending_buf_ = NULL;
     pending_buf_size_ = 0;
 
     NotifyReadComplete(bytes_to_copy);
   } else {
     NOTREACHED() << "Received unexpected data of length:" << bytes.size();
@@ skipping 23 matching lines @@
   // NotifyDone may have been called on the job if the original request was
   // redirected.
   if (!is_done()) {
     // We can complete the job if we have a valid response or a pending read.
     // An end request can be received in the following cases
     // 1. We failed to connect to the server, in which case we did not receive
     //    a valid response.
     // 2. In response to a read request.
     if (!has_response_started()) {
       NotifyStartError(status);
-    } else if (pending_buf_) {
+    } else if (pending_buf_.get()) {
       pending_buf_ = NULL;
       pending_buf_size_ = 0;
       NotifyDone(status);
       NotifyReadComplete(0);
     } else {
       // Wait for the http stack to issue a Read request where we will notify
       // that the job has completed.
       request_status_ = status;
     }
   }
   // Note
   // The job could have been destroyed above. Please don't attempt to access
   // member variables here.
 }
 
 void URLRequestAutomationJob::Cleanup() {
   headers_ = NULL;
   mime_type_.erase();
 
   id_ = 0;
   tab_ = 0;
 
-  DCHECK(!message_filter_);
+  DCHECK(!message_filter_.get());
   DisconnectFromMessageFilter();
 
   pending_buf_ = NULL;
   pending_buf_size_ = 0;
 }
 
 void URLRequestAutomationJob::StartAsync() {
   DVLOG(1) << "URLRequestAutomationJob: start request: "
            << (request_ ? request_->url().spec() : "NULL request");
 
@@ skipping 59 matching lines @@
   // Ask automation to start this request.
   AutomationURLRequest automation_request;
   automation_request.url = request_->url().spec();
   automation_request.method = request_->method();
   automation_request.referrer = referrer.spec();
   automation_request.extra_request_headers = new_request_headers.ToString();
   automation_request.upload_data = upload_data;
   automation_request.resource_type = resource_type;
   automation_request.load_flags = request_->load_flags();
 
-  DCHECK(message_filter_);
-  message_filter_->Send(new AutomationMsg_RequestStart(
-      tab_, id_, automation_request));
+  DCHECK(message_filter_.get());
+  message_filter_->Send(
+      new AutomationMsg_RequestStart(tab_, id_, automation_request));
 }
 
 void URLRequestAutomationJob::DisconnectFromMessageFilter() {
-  if (message_filter_) {
+  if (message_filter_.get()) {
     message_filter_->UnRegisterRequest(this);
     message_filter_ = NULL;
   }
 }
 
 void URLRequestAutomationJob::StartPendingJob(
     int new_tab_handle,
     AutomationResourceMessageFilter* new_filter) {
   DCHECK(new_filter != NULL);
   tab_ = new_tab_handle;
   message_filter_ = new_filter;
   is_pending_ = false;
   Start();
 }
 
 void URLRequestAutomationJob::NotifyJobCompletionTask() {
   if (!is_done()) {
     NotifyDone(request_status_);
   }
   // Reset any pending reads.
-  if (pending_buf_) {
+  if (pending_buf_.get()) {
     pending_buf_ = NULL;
     pending_buf_size_ = 0;
     NotifyReadComplete(0);
   }
 }