Revert of Fix SPDY error-handling if the connection gets closed just after use.

net/http/http_stream_factory_impl_request.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_request.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/http/http_stream_factory_impl_job.h"
@@ skipping 273 matching lines @@
       }
     }
     if (request_vector.empty())
       http_pipelining_request_map.erase(*http_pipelining_key_);
     http_pipelining_key_.reset();
   }
 }
 
 void HttpStreamFactoryImpl::Request::OnNewSpdySessionReady(
     Job* job,
-    scoped_ptr<HttpStream> stream,
     const base::WeakPtr<SpdySession>& spdy_session,
     bool direct) {
   DCHECK(job);
   DCHECK(job->using_spdy());
 
-  // Note: |spdy_session| may be NULL. In that case, |delegate_| should still
-  // receive |stream| so the error propogates up correctly, however there is no
-  // point in broadcasting |spdy_session| to other requests.
-
   // The first case is the usual case.
   if (!bound_job_.get()) {
     OrphanJobsExcept(job);
   } else {  // This is the case for HTTPS proxy tunneling.
     DCHECK_EQ(bound_job_.get(), job);
     DCHECK(jobs_.empty());
   }
 
   // Cache these values in case the job gets deleted.
   const SSLConfig used_ssl_config = job->server_ssl_config();
   const ProxyInfo used_proxy_info = job->proxy_info();
   const bool was_npn_negotiated = job->was_npn_negotiated();
   const NextProto protocol_negotiated =
       job->protocol_negotiated();
   const bool using_spdy = job->using_spdy();
   const BoundNetLog net_log = job->net_log();
 
   Complete(was_npn_negotiated, protocol_negotiated, using_spdy, net_log);
 
   // Cache this so we can still use it if the request is deleted.
   HttpStreamFactoryImpl* factory = factory_;
   if (factory->for_websockets_) {
     // TODO(ricea): Re-instate this code when WebSockets over SPDY is
     // implemented.
     NOTREACHED();
   } else {
-    delegate_->OnStreamReady(job->server_ssl_config(), job->proxy_info(),
-                             stream.release());
+    bool use_relative_url = direct || url().SchemeIs("https");
+    delegate_->OnStreamReady(
+        job->server_ssl_config(),
+        job->proxy_info(),
+        new SpdyHttpStream(spdy_session, use_relative_url));
   }
   // |this| may be deleted after this point.
-  if (spdy_session) {
-    factory->OnNewSpdySessionReady(spdy_session,
-                                   direct,
-                                   used_ssl_config,
-                                   used_proxy_info,
-                                   was_npn_negotiated,
-                                   protocol_negotiated,
-                                   using_spdy,
-                                   net_log);
-  }
+  factory->OnNewSpdySessionReady(spdy_session,
+                                 direct,
+                                 used_ssl_config,
+                                 used_proxy_info,
+                                 was_npn_negotiated,
+                                 protocol_negotiated,
+                                 using_spdy,
+                                 net_log);
 }
 
 void HttpStreamFactoryImpl::Request::OrphanJobsExcept(Job* job) {
   DCHECK(job);
   DCHECK(!bound_job_.get());
   DCHECK(ContainsKey(jobs_, job));
   bound_job_.reset(job);
   jobs_.erase(job);
   factory_->request_map_.erase(job);
 
@@ skipping 29 matching lines @@
   } else if (!bound_job_.get()) {
     // We may have other jobs in |jobs_|. For example, if we start multiple jobs
     // for Alternate-Protocol.
     OrphanJobsExcept(job);
   } else {
     DCHECK(jobs_.empty());
   }
 }
 
 }  // namespace net