Introduce RequestWebSocketStream into HttpStreamFactory

net/http/http_stream_factory_impl.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.h"
 
+#include <string>
+
 #include "base/string_number_conversions.h"
 #include "base/stl_util.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_pipelined_connection.h"
 #include "net/http/http_pipelined_host.h"
 #include "net/http/http_pipelined_stream.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/http/http_stream_factory_impl_request.h"
+#include "net/socket/client_socket_pool_manager.h"

[mmenke, 2013/06/10 20:26:03]

nit:  I don't believe this is used.

[yhirano, 2013/06/11 11:13:16]

Done.

 #include "net/spdy/spdy_http_stream.h"
 
 namespace net {
 
 namespace {
 
 const PortAlternateProtocolPair kNoAlternateProtocol = {
   0,  UNINITIALIZED_ALTERNATE_PROTOCOL
 };
 
 GURL UpgradeUrlToHttps(const GURL& original_url, int port) {
   GURL::Replacements replacements;
   // new_sheme and new_port need to be in scope here because GURL::Replacements
   // references the memory contained by them directly.
   const std::string new_scheme = "https";
   const std::string new_port = base::IntToString(port);
   replacements.SetSchemeStr(new_scheme);
   replacements.SetPortStr(new_port);
   return original_url.ReplaceComponents(replacements);
 }
 
 }  // namespace
 
-HttpStreamFactoryImpl::HttpStreamFactoryImpl(HttpNetworkSession* session)
+HttpStreamFactoryImpl::HttpStreamFactoryImpl(HttpNetworkSession* session,
+                                             bool for_websockets)
     : session_(session),
       http_pipelined_host_pool_(this, NULL,
                                 session_->http_server_properties(),
-                                session_->force_http_pipelining()) {}
+                                session_->force_http_pipelining()),
+      for_websockets_(for_websockets) {}
 
 HttpStreamFactoryImpl::~HttpStreamFactoryImpl() {
   DCHECK(request_map_.empty());
   DCHECK(spdy_session_request_map_.empty());
   DCHECK(http_pipelining_request_map_.empty());
 
   std::set<const Job*> tmp_job_set;
   tmp_job_set.swap(orphaned_job_set_);
   STLDeleteContainerPointers(tmp_job_set.begin(), tmp_job_set.end());
   DCHECK(orphaned_job_set_.empty());
 
   tmp_job_set.clear();
   tmp_job_set.swap(preconnect_job_set_);
   STLDeleteContainerPointers(tmp_job_set.begin(), tmp_job_set.end());
   DCHECK(preconnect_job_set_.empty());
 }
 
 HttpStreamRequest* HttpStreamFactoryImpl::RequestStream(
     const HttpRequestInfo& request_info,
     RequestPriority priority,
     const SSLConfig& server_ssl_config,
     const SSLConfig& proxy_ssl_config,
     HttpStreamRequest::Delegate* delegate,
     const BoundNetLog& net_log) {
-  Request* request = new Request(request_info.url, this, delegate, net_log);
+  DCHECK(!for_websockets_);
+  return RequestStreamInternal(request_info,
+                               priority,
+                               server_ssl_config,
+                               proxy_ssl_config,
+                               delegate,
+                               NULL,
+                               net_log);
+}
+
+HttpStreamRequest* HttpStreamFactoryImpl::RequestWebSocketStream(
+    const HttpRequestInfo& request_info,
+    RequestPriority priority,
+    const SSLConfig& server_ssl_config,
+    const SSLConfig& proxy_ssl_config,
+    HttpStreamRequest::Delegate* delegate,
+    WebSocketStreamBase::Factory* factory,
+    const BoundNetLog& net_log) {
+  DCHECK(for_websockets_);
+  return RequestStreamInternal(request_info,
+                               priority,
+                               server_ssl_config,
+                               proxy_ssl_config,
+                               delegate,
+                               factory,
+                               net_log);
+}
+
+HttpStreamRequest* HttpStreamFactoryImpl::RequestStreamInternal(
+    const HttpRequestInfo& request_info,
+    RequestPriority priority,
+    const SSLConfig& server_ssl_config,
+    const SSLConfig& proxy_ssl_config,
+    HttpStreamRequest::Delegate* delegate,
+    WebSocketStreamBase::Factory* websocket_stream_factory,
+    const BoundNetLog& net_log) {
+  Request* request =
+      new Request(request_info.url,
+                  this,
+                  delegate,
+                  websocket_stream_factory,
+                  net_log);
 
   GURL alternate_url;
   PortAlternateProtocolPair alternate =
       GetAlternateProtocolRequestFor(request_info.url, &alternate_url);
   Job* alternate_job = NULL;
   if (alternate.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL) {
     // Never share connection with other jobs for FTP requests.
     DCHECK(!request_info.url.SchemeIs("ftp"));
 
     HttpRequestInfo alternate_request_info = request_info;
@@ skipping 24 matching lines @@
   job->Start(request);
   return request;
 }
 
 void HttpStreamFactoryImpl::PreconnectStreams(
     int num_streams,
     const HttpRequestInfo& request_info,
     RequestPriority priority,
     const SSLConfig& server_ssl_config,
     const SSLConfig& proxy_ssl_config) {
+  DCHECK(!for_websockets_);
   GURL alternate_url;
   PortAlternateProtocolPair alternate =
       GetAlternateProtocolRequestFor(request_info.url, &alternate_url);
   Job* job = NULL;
   if (alternate.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL) {
     HttpRequestInfo alternate_request_info = request_info;
     alternate_request_info.url = alternate_url;
     job = new Job(this, session_, alternate_request_info, priority,
                   server_ssl_config, proxy_ssl_config, session_->net_log());
     job->MarkAsAlternate(request_info.url, alternate);
@@ skipping 65 matching lines @@
   } else {
     DCHECK_EQ(QUIC, alternate.protocol);
     if (!session_->params().enable_quic ||
         !original_url.SchemeIs("http"))
       return kNoAlternateProtocol;
     // TODO(rch):  Figure out how to make QUIC iteract with PAC
     // scripts.  By not re-writing the URL, we will query the PAC script
     // for the proxy to use to reach the original URL via TCP.  But
     // the alternate request will be going via UDP to a different port.
     *alternate_url = original_url;
-   }
+  }
   return alternate;
 }
 
 void HttpStreamFactoryImpl::OrphanJob(Job* job, const Request* request) {
   DCHECK(ContainsKey(request_map_, job));
   DCHECK_EQ(request_map_[job], request);
   DCHECK(!ContainsKey(orphaned_job_set_, job));
 
   request_map_.erase(job);
 
   orphaned_job_set_.insert(job);
   job->Orphan(request);
 }
 
-void HttpStreamFactoryImpl::OnSpdySessionReady(
+void HttpStreamFactoryImpl::OnNewSpdySessionReady(
     scoped_refptr<SpdySession> spdy_session,
     bool direct,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     bool was_npn_negotiated,
     NextProto protocol_negotiated,
     bool using_spdy,
     const BoundNetLog& net_log) {
   const SpdySessionKey& spdy_session_key =
       spdy_session->spdy_session_key();
   while (!spdy_session->IsClosed()) {
     // Each iteration may empty out the RequestSet for |spdy_session_key_ in
     // |spdy_session_request_map_|. So each time, check for RequestSet and use
     // the first one.
     //
     // TODO(willchan): If it's important, switch RequestSet out for a FIFO
     // pqueue (Order by priority first, then FIFO within same priority). Unclear
     // that it matters here.
     if (!ContainsKey(spdy_session_request_map_, spdy_session_key))
       break;
     Request* request = *spdy_session_request_map_[spdy_session_key].begin();
     request->Complete(was_npn_negotiated,
                       protocol_negotiated,
                       using_spdy,
                       net_log);
-    bool use_relative_url = direct || request->url().SchemeIs("https");
-    request->OnStreamReady(
-        NULL,
-        used_ssl_config,
-        used_proxy_info,
-        new SpdyHttpStream(spdy_session.get(), use_relative_url));
+    if (for_websockets_) {
+      WebSocketStreamBase::Factory* factory =
+          request->websocket_stream_factory();
+      DCHECK(factory);
+      bool use_relative_url = direct || request->url().SchemeIs("wss");
+      request->OnWebSocketStreamReady(
+          NULL, used_ssl_config, used_proxy_info,
+          factory->CreateSpdyStream(spdy_session, use_relative_url));
+    } else {
+      bool use_relative_url = direct || request->url().SchemeIs("https");
+      request->OnStreamReady(NULL, used_ssl_config, used_proxy_info,
+                             new SpdyHttpStream(spdy_session,
+                                                use_relative_url));
+    }
   }
   // TODO(mbelshe): Alert other valid requests.
 }
 
 void HttpStreamFactoryImpl::OnOrphanedJobComplete(const Job* job) {
   orphaned_job_set_.erase(job);
   delete job;
 }
 
 void HttpStreamFactoryImpl::OnPreconnectsComplete(const Job* job) {
@@ skipping 32 matching lines @@
        it != requests_to_fail.end(); ++it) {
     Request* request = *it;
     if (request == request_map_[job]) {
       continue;
     }
     request->OnStreamFailed(NULL, status, used_ssl_config);
   }
 }
 
 }  // namespace net