Introduce RequestWebSocketStream into HttpStreamFactory

net/http/http_stream_factory.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_STREAM_FACTORY_H_
 #define NET_HTTP_HTTP_STREAM_FACTORY_H_
 
 #include <list>
 #include <string>
 #include <vector>
@@ skipping 11 matching lines @@
 class GURL;
 
 namespace base {
 class Value;
 }
 
 namespace net {
 
 class AuthCredentials;
 class BoundNetLog;
+class ClientSocketHandle;
 class HostMappingRules;
 class HostPortPair;
 class HttpAuthController;
 class HttpResponseInfo;
 class HttpServerProperties;
 class HttpStreamBase;
 class ProxyInfo;
 class SSLCertRequestInfo;
 class SSLInfo;
+class SpdySession;
 struct HttpRequestInfo;
 struct SSLConfig;
 
 // The HttpStreamRequest is the client's handle to the worker object which
 // handles the creation of an HttpStream.  While the HttpStream is being
 // created, this object is the creator's handle for interacting with the
 // HttpStream creation process.  The request is cancelled by deleting it, after
 // which no callbacks will be invoked.
 class NET_EXPORT_PRIVATE HttpStreamRequest {
  public:
   // The HttpStreamRequest::Delegate is a set of callback methods for a
   // HttpStreamRequestJob.  Generally, only one of these methods will be
   // called as a result of a stream request.
   class NET_EXPORT_PRIVATE Delegate {
    public:
     virtual ~Delegate() {}
 
-    // This is the success case.
+    // This is the success case for RequestStream.
     // |stream| is now owned by the delegate.
     // |used_ssl_config| indicates the actual SSL configuration used for this
     // stream, since the HttpStreamRequest may have modified the configuration
     // during stream processing.
     // |used_proxy_info| indicates the actual ProxyInfo used for this stream,
     // since the HttpStreamRequest performs the proxy resolution.
     virtual void OnStreamReady(
         const SSLConfig& used_ssl_config,
         const ProxyInfo& used_proxy_info,
         HttpStreamBase* stream) = 0;
 
+    // This is a success case for RequestStreamForWebSocket.
+    // |connection| is now owned by the delegate.
+    // |used_ssl_config| indicates the actual SSL configuration used for this
+    // stream, since the HttpStreamRequest may have modified the configuration
+    // during stream processing.
+    // |used_proxy_info| indicates the actual ProxyInfo used for this stream,
+    // since the HttpStreamRequest performs the proxy resolution.
+    virtual void OnSocketReadyForWebSocket(
+        const SSLConfig& used_ssl_config,
+        const ProxyInfo& used_proxy_info,
+        ClientSocketHandle* connection) = 0;
+
+    // This is a success case for RequestStreamForWebSocket.
+    // |session| is referenced by the caller.
+    // You should create and hold a scoped_refptr to retain it.
+    // |used_ssl_config| indicates the actual SSL configuration used for this
+    // stream, since the HttpStreamRequest may have modified the configuration
+    // during stream processing.
+    // |used_proxy_info| indicates the actual ProxyInfo used for this stream,
+    // since the HttpStreamRequest performs the proxy resolution.
+    virtual void OnSpdySessionReadyForWebSocket(
+        const SSLConfig& used_ssl_config,
+        const ProxyInfo& used_proxy_info,
+        SpdySession* session) = 0;
+
     // This is the failure to create a stream case.
     // |used_ssl_config| indicates the actual SSL configuration used for this
     // stream, since the HttpStreamRequest may have modified the configuration
     // during stream processing.
     virtual void OnStreamFailed(int status,
                                 const SSLConfig& used_ssl_config) = 0;
 
     // Called when we have a certificate error for the request.
     // |used_ssl_config| indicates the actual SSL configuration used for this
     // stream, since the HttpStreamRequest may have modified the configuration
@@ skipping 82 matching lines @@
   void ProcessAlternateProtocol(
       HttpServerProperties* http_server_properties,
       const std::string& alternate_protocol_str,
       const HostPortPair& http_host_port_pair);
 
   GURL ApplyHostMappingRules(const GURL& url, HostPortPair* endpoint);
 
   // Virtual interface methods.
 
   // Request a stream.
-  // Will callback to the HttpStreamRequestDelegate upon completion.
+  // Will call delegate->OnStreamReady upon completion.
   virtual HttpStreamRequest* RequestStream(
       const HttpRequestInfo& info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
       const BoundNetLog& net_log) = 0;
 
+  // Request a stream for a websocket connection.

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

We're not actually requesting an HttpStream, but rather a ClientSocketHandle
that could be used for a WebSocket, or a SpdySession that can be used to create
WebSocket.  Is there a reason we can't just create a WebSocketStream (Or
whatever) and return that to the delegate?

[Adam Rice, 2013/05/24 03:41:09]

iOS Chrome compiles libnet without WebSocket support. So, WebSocketStream is not
necessarily available. While of course we could make it available as a special
case, I think it is preferable to minimise the amount of WebSocket-related code
that needs to be compiled in when WebSockets are compiled out.

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

I talked with Adam and we agreed to add WebSocketStreamBase class which is the
base class of WebSocketStream. WebSocketStreamBase is placed on net/http and has
no dependency to net/websockets. When net/websockets code get a
WebSocketStreamBase, it should downcast the object into a derived class
depending on the object's type() property.

+  // Will call delegate->OnSocketReadyForWebSocket or
+  // delegate->OnSpdySessionReadyForWebSocket upon completion.
+  virtual HttpStreamRequest* RequestStreamForWebSocket(
+      const HttpRequestInfo& info,
+      RequestPriority priority,
+      const SSLConfig& server_ssl_config,
+      const SSLConfig& proxy_ssl_config,
+      HttpStreamRequest::Delegate* delegate,
+      const BoundNetLog& net_log) = 0;
+
   // Requests that enough connections for |num_streams| be opened.
   virtual void PreconnectStreams(int num_streams,
                                  const HttpRequestInfo& info,
                                  RequestPriority priority,
                                  const SSLConfig& server_ssl_config,
                                  const SSLConfig& proxy_ssl_config) = 0;
 
   // If pipelining is supported, creates a Value summary of the currently active
   // pipelines. Caller assumes ownership of the returned value. Otherwise,
   // returns an empty Value.
@@ skipping 74 matching lines @@
   static bool force_spdy_over_ssl_;
   static bool force_spdy_always_;
   static std::list<HostPortPair>* forced_spdy_exclusions_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpStreamFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_STREAM_FACTORY_H_