Introduce RequestWebSocketStream into HttpStreamFactory

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"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 HttpStreamFactoryImpl::Request::Request(const GURL& url,
                                         HttpStreamFactoryImpl* factory,
                                         HttpStreamRequest::Delegate* delegate,
-                                        const BoundNetLog& net_log)
+                                        const BoundNetLog& net_log,
+                                        bool for_websocket)
     : url_(url),
       factory_(factory),
       delegate_(delegate),
       net_log_(net_log),
       completed_(false),
       was_npn_negotiated_(false),
       protocol_negotiated_(kProtoUnknown),
-      using_spdy_(false) {
+      using_spdy_(false),
+      for_websocket_(for_websocket) {
   DCHECK(factory_);
   DCHECK(delegate_);
 
   net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_REQUEST);
 }
 
 HttpStreamFactoryImpl::Request::~Request() {
   if (bound_job_.get())
     DCHECK(jobs_.empty());
   else
@@ skipping 81 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());
   }
   delegate_->OnStreamReady(used_ssl_config, used_proxy_info, stream);
 }
 
+void HttpStreamFactoryImpl::Request::OnSocketReady(
+    Job* job,
+    const SSLConfig& used_ssl_config,
+    const ProxyInfo& used_proxy_info,
+    ClientSocketHandle* connection) {
+  DCHECK(connection);
+  DCHECK(completed_);
+
+  // |job| should only be NULL if we're being serviced by a late bound
+  // SpdySession or HttpPipelinedConnection (one that was not created by a job
+  // in our |jobs_| set).
+  if (!job) {
+    DCHECK(!bound_job_.get());
+    DCHECK(!jobs_.empty());
+    // NOTE(willchan): We do *NOT* call OrphanJobs() here. The reason is because
+    // we *WANT* to cancel the unnecessary Jobs from other requests if another
+    // Job completes first.
+    // TODO(mbelshe): Revisit this when we implement ip connection pooling of
+    // SpdySessions. Do we want to orphan the jobs for a different hostname so
+    // they complete? Or do we want to prevent connecting a new SpdySession if
+    // we've already got one available for a different hostname where the ip
+    // address matches up?
+  } 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());
+  }
+  delegate_->OnSocketReady(used_ssl_config, used_proxy_info, connection);
+}
+
+void HttpStreamFactoryImpl::Request::OnSpdySessionReadyForWS(
+    Job* job,
+    const SSLConfig& used_ssl_config,
+    const ProxyInfo& used_proxy_info,
+    scoped_refptr<SpdySession> session) {
+  DCHECK(session);
+  DCHECK(completed_);
+
+  // |job| should only be NULL if we're being serviced by a late bound
+  // SpdySession or HttpPipelinedConnection (one that was not created by a job
+  // in our |jobs_| set).
+  if (!job) {
+    DCHECK(!bound_job_.get());
+    DCHECK(!jobs_.empty());
+    // NOTE(willchan): We do *NOT* call OrphanJobs() here. The reason is because
+    // we *WANT* to cancel the unnecessary Jobs from other requests if another
+    // Job completes first.
+    // TODO(mbelshe): Revisit this when we implement ip connection pooling of
+    // SpdySessions. Do we want to orphan the jobs for a different hostname so
+    // they complete? Or do we want to prevent connecting a new SpdySession if
+    // we've already got one available for a different hostname where the ip
+    // address matches up?
+  } 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());
+  }
+  delegate_->OnSpdySessionReady(used_ssl_config,
+                                used_proxy_info,
+                                session.get());
+}
+
 void HttpStreamFactoryImpl::Request::OnStreamFailed(
     Job* job,
     int status,
     const SSLConfig& used_ssl_config) {
   DCHECK_NE(OK, status);
   // |job| should only be NULL if we're being canceled by a late bound
   // HttpPipelinedConnection (one that was not created by a job in our |jobs_|
   // set).
   if (!job) {
     DCHECK(!bound_job_.get());
@@ skipping 144 matching lines @@
 void HttpStreamFactoryImpl::Request::OnSpdySessionReady(
     Job* job,
     scoped_refptr<SpdySession> spdy_session,
     bool direct) {
   DCHECK(job);
   DCHECK(job->using_spdy());
 
   // The first case is the usual case.
   if (!bound_job_.get()) {
     OrphanJobsExcept(job);
-  } else { // This is the case for HTTPS proxy tunneling.
+  } 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();
@@ skipping 32 matching lines @@
   RemoveRequestFromHttpPipeliningRequestMap();
 
   std::set<Job*> tmp;
   tmp.swap(jobs_);
 
   for (std::set<Job*>::iterator it = tmp.begin(); it != tmp.end(); ++it)
     factory_->OrphanJob(*it, this);
 }
 
 }  // namespace net