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

net/http/http_stream_factory_impl_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 "net/http/http_stream_factory_impl_job.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 381 matching lines @@
   if (IsOrphaned())
     stream_factory_->OnOrphanedJobComplete(this);
   else
     request_->OnHttpsProxyTunnelResponse(
         this, response_info, server_ssl_config_, proxy_info_, stream);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnPreconnectsComplete() {
   DCHECK(!request_);
-  if (new_spdy_session_) {
-    stream_factory_->OnNewSpdySessionReady(
-        new_spdy_session_, spdy_session_direct_, server_ssl_config_,
-        proxy_info_, was_npn_negotiated(), protocol_negotiated(), using_spdy(),
-        net_log_);
+  if (new_spdy_session_.get()) {
+    stream_factory_->OnNewSpdySessionReady(new_spdy_session_,
+                                           spdy_session_direct_,
+                                           server_ssl_config_,
+                                           proxy_info_,
+                                           was_npn_negotiated(),
+                                           protocol_negotiated(),
+                                           using_spdy(),
+                                           net_log_);
   }
   stream_factory_->OnPreconnectsComplete(this);
   // |this| may be deleted after this call.
 }
 
 // static
 int HttpStreamFactoryImpl::Job::OnHostResolution(
     SpdySessionPool* spdy_session_pool,
     const SpdySessionKey& spdy_session_key,
     const AddressList& addresses,
@@ skipping 88 matching lines @@
             base::Bind(
                 &Job::OnHttpsProxyTunnelResponseCallback,
                 ptr_factory_.GetWeakPtr(),
                 *proxy_socket->GetConnectResponseInfo(),
                 proxy_socket->CreateConnectResponseStream()));
         return ERR_IO_PENDING;
       }
 
     case OK:
       next_state_ = STATE_DONE;
-      if (new_spdy_session_) {
+      if (new_spdy_session_.get()) {
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
-            base::Bind(
-                &Job::OnNewSpdySessionReadyCallback,
-                ptr_factory_.GetWeakPtr()));
+            base::Bind(&Job::OnNewSpdySessionReadyCallback,
+                       ptr_factory_.GetWeakPtr()));
       } else if (stream_factory_->for_websockets_) {
         DCHECK(websocket_stream_);
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(
                 &Job::OnWebSocketStreamReadyCallback,
                 ptr_factory_.GetWeakPtr()));
       } else {
         DCHECK(stream_.get());
         base::MessageLoop::current()->PostTask(
@@ skipping 588 matching lines @@
   // TODO(willchan): Delete this code, because eventually, the
   // HttpStreamFactoryImpl will be creating all the SpdyHttpStreams, since it
   // will know when SpdySessions become available.
 
   if (stream_factory_->for_websockets_) {
     DCHECK(request_);
     DCHECK(request_->websocket_stream_factory());
     bool use_relative_url = direct || request_info_.url.SchemeIs("wss");
     websocket_stream_.reset(
         request_->websocket_stream_factory()->CreateSpdyStream(
-            spdy_session, use_relative_url));
+            spdy_session.get(), use_relative_url));
   } else {
     bool use_relative_url = direct || request_info_.url.SchemeIs("https");
-    stream_.reset(new SpdyHttpStream(spdy_session, use_relative_url));
+    stream_.reset(new SpdyHttpStream(spdy_session.get(), use_relative_url));
   }
   return OK;
 }
 
 int HttpStreamFactoryImpl::Job::DoCreateStreamComplete(int result) {
   if (result < 0)
     return result;
 
   session_->proxy_service()->ReportSuccess(proxy_info_);
   next_state_ = STATE_NONE;
@@ skipping 307 matching lines @@
       (net::LOAD_MAIN_FRAME | net::LOAD_SUB_FRAME | net::LOAD_PREFETCH |
        net::LOAD_IS_DOWNLOAD)) {
     // Avoid pipelining resources that may be streamed for a long time.
     return false;
   }
   return stream_factory_->http_pipelined_host_pool_.IsKeyEligibleForPipelining(
       *http_pipelining_key_.get());
 }
 
 }  // namespace net