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 49 matching lines @@
   protocol_negotiated_ = protocol_negotiated;
   using_spdy_ = using_spdy;
   net_log_.AddEvent(
       NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_JOB,
       job_net_log.source().ToEventParametersCallback());
   job_net_log.AddEvent(
       NetLog::TYPE_HTTP_STREAM_JOB_BOUND_TO_REQUEST,
       net_log_.source().ToEventParametersCallback());
 }
 
-void HttpStreamFactoryImpl::Request::OnStreamReady(
-    Job* job,
-    const SSLConfig& used_ssl_config,
-    const ProxyInfo& used_proxy_info,
-    HttpStreamBase* stream) {
-  DCHECK(stream);
-  DCHECK(completed_);
-
+void HttpStreamFactoryImpl::Request::Orphan(Job* job) {
   // |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());
   }
+}
+
+void HttpStreamFactoryImpl::Request::OnStreamReady(
+    Job* job,
+    const SSLConfig& used_ssl_config,
+    const ProxyInfo& used_proxy_info,
+    HttpStreamBase* stream) {
+  DCHECK(stream);
+  DCHECK(completed_);

[mmenke, 2013/05/23 20:26:20]

I'd like a some more DCHECKs on for_websocket_ in these functions.

[yhirano, 2013/05/24 14:11:16]

Done.

+
+  Orphan(job);
   delegate_->OnStreamReady(used_ssl_config, used_proxy_info, stream);
 }
 
+void HttpStreamFactoryImpl::Request::OnSocketReadyForWebSocket(
+    Job* job,
+    const SSLConfig& used_ssl_config,
+    const ProxyInfo& used_proxy_info,
+    ClientSocketHandle* connection) {
+  DCHECK(connection);
+  DCHECK(completed_);
+
+  Orphan(job);
+  delegate_->OnSocketReadyForWebSocket(used_ssl_config,
+                                       used_proxy_info,
+                                       connection);
+}
+
+void HttpStreamFactoryImpl::Request::OnSpdySessionReadyForWebSocket(
+    Job* job,
+    const SSLConfig& used_ssl_config,
+    const ProxyInfo& used_proxy_info,
+    scoped_refptr<SpdySession> session) {
+  DCHECK(session);
+  DCHECK(completed_);
+
+  Orphan(job);
+  delegate_->OnSpdySessionReadyForWebSocket(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 134 matching lines @@
         request_vector.erase(it);
         break;
       }
     }
     if (request_vector.empty())
       http_pipelining_request_map.erase(*http_pipelining_key_);
     http_pipelining_key_.reset();
   }
 }
 
-void HttpStreamFactoryImpl::Request::OnSpdySessionReady(
+void HttpStreamFactoryImpl::Request::OnNewSpdySessionReady(
     Job* job,
     scoped_refptr<SpdySession> spdy_session,
     bool direct) {

[mmenke, 2013/05/23 20:26:20]

For functions that cannot be called when using websockets, I'd like to see
DCHECKs for documentation purposes.

[yhirano, 2013/05/24 14:11:16]

In PS13 (or newer), OnNewSpdySessionReady is called even for_websocket is true.

   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();
   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_;
 
   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.
-  factory->OnSpdySessionReady(
+  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);
 
   OrphanJobs();
 }
 
 void HttpStreamFactoryImpl::Request::OrphanJobs() {
   RemoveRequestFromSpdySessionRequestMap();
   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