Add WebSocketStream factory function

net/websockets/websocket_stream.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_WEBSOCKETS_WEBSOCKET_STREAM_H_
 #define NET_WEBSOCKETS_WEBSOCKET_STREAM_H_
 
+#include <string>
+
 #include "base/basictypes.h"
+#include "base/callback_forward.h"
 #include "base/memory/scoped_vector.h"
 #include "net/base/completion_callback.h"
+#include "net/base/net_export.h"
 #include "net/websockets/websocket_stream_base.h"
 
+class GURL;
+
 namespace net {
 
-class BoundNetLog;
 class HttpRequestHeaders;
-struct HttpRequestInfo;
 class HttpResponseInfo;
+class URLRequestContext;
 struct WebSocketFrameChunk;
 
 // WebSocketStream is a transport-agnostic interface for reading and writing
 // WebSocket frames. This class provides an abstraction for WebSocket streams
-// based on various transport layer, such as normal WebSocket connections
+// based on various transport layers, such as normal WebSocket connections
 // (WebSocket protocol upgraded from HTTP handshake), SPDY transports, or
 // WebSocket connections with multiplexing extension. Subtypes of
 // WebSocketStream are responsible for managing the underlying transport
 // appropriately.
 //
 // All functions except Close() can be asynchronous. If an operation cannot
 // be finished synchronously, the function returns ERR_IO_PENDING, and
 // |callback| will be called when the operation is finished. Non-null |callback|
 // must be provided to these functions.
 
-class WebSocketStream : public WebSocketStreamBase {
+class NET_EXPORT_PRIVATE WebSocketStream : public WebSocketStreamBase {
  public:
-  WebSocketStream() {}
+  // The type the callback that should be supplied to handle successful
+  // connection. This must be supplied by the caller. It must take a scoped_ptr
+  // to a WebSocketStream as a parameter.
+  typedef base::Callback<void(scoped_ptr<WebSocketStream>)> SuccessCallback;
+
+  // The type of the callback that should be supplied to handle failed
+  // connection. The parameter is a net::WebSocketError, but it is passed as
+  // unsigned short as it is not guaranteed to actually be defined in that enum.
+  typedef base::Callback<void(unsigned short)> FailureCallback;

[mmenke, 2013/06/26 20:30:38]

Rather than having two callbacks, I suggest a delegate interface - that's more
common in the network stack, when we have multiple callbacks.

[Adam Rice, 2013/06/27 15:10:49]

Done.

+
+  // Create and connect a WebSocketStream of an appropriate type. The actual
+  // concrete type returned depends on whether multiplexing or SPDY are being
+  // used to communicate with the remote server. If the handshake completed
+  // successfully, then the on_success callback is called with a subclass of
+  // WebSocketStream. If it failed, then the on_failure callback is called with
+  // a WebSocket result code corresponding to the error.
+  static void CreateAndConnectStream(
+      const GURL& socket_url,
+      const std::vector<std::string>& requested_protocols,

[mmenke, 2013/06/26 20:30:38]

subprotocols, maybe?  (Particularly for those who, not being familiar with the
spec, turn to Google..."websocket protocol" doesn't work too well).

[Adam Rice, 2013/06/27 15:10:49]

Good point, thank you.

+      const GURL& origin,
+      URLRequestContext* url_request_context,
+      const SuccessCallback& on_success,
+      const FailureCallback& on_failure);

[mmenke, 2013/06/26 20:30:38]

There doesn't seem to be any way to cancel this.

[mmenke, 2013/06/26 20:30:38]

We're also going to want a BoundNetLog.

[Adam Rice, 2013/06/27 15:10:49]

That's... very embarrassing. I have added a simple cancellation mechanism. PTAL.

[Adam Rice, 2013/06/27 15:10:49]

I was sort of hoping I could get away with the net_log from the
URLRequestContext. Never mind. Added.

[mmenke, 2013/06/27 15:25:09]

We need the BoundNetLog to say "This is the thing that issued the WebSocket
request".

 
   // Derived classes must make sure Close() is called when the stream is not
   // closed on destruction.
-  virtual ~WebSocketStream() {}
-
-  // Initializes stream. Must be called before calling SendHandshakeRequest().
-  // Returns a net error code, possibly ERR_IO_PENDING, as stated above.
-  //
-  // |request_info.url| must be a URL starting with "ws://" or "wss://".
-  // |request_info.method| must be "GET". |request_info.upload_data| is
-  // ignored.
-  virtual int InitializeStream(const HttpRequestInfo& request_info,
-                               const BoundNetLog& net_log,
-                               const CompletionCallback& callback) = 0;
-
-  // Writes WebSocket handshake request to the underlying socket. Must be
-  // called after InitializeStream() completes and before
-  // ReadHandshakeResponse() is called.
-  //
-  // |response_info| must remain valid until the stream is destroyed.
-  virtual int SendHandshakeRequest(const HttpRequestHeaders& headers,
-                                   HttpResponseInfo* response_info,
-                                   const CompletionCallback& callback) = 0;
-
-  // Reads WebSocket handshake response from the underlying socket. This
-  // function completes when the response headers have been completely
-  // received. Must be called after SendHandshakeRequest() completes.
-  virtual int ReadHandshakeResponse(const CompletionCallback& callback) = 0;
+  virtual ~WebSocketStream();
 
   // Reads WebSocket frame data. This operation finishes when new frame data
   // becomes available. Each frame message might be chopped off in the middle
   // as specified in the description of WebSocketFrameChunk struct.
-  // |frame_chunks| must be valid until the operation completes or Close()
-  // is called.
+  // |frame_chunks| remains owned by the caller and must be valid until the
+  // operation completes or Close() is called. |frame_chunks| must be empty on
+  // calling.
   //
-  // This function can be called after ReadHandshakeResponse(). This function
-  // should not be called while the previous call of ReadFrames() is still
-  // pending.
+  // This function should not be called while the previous call of ReadFrames()
+  // is still pending.
+  //
+  // Returns net::OK or one of the net::ERR_* codes.
+  //
+  // frame_chunks->size() >= 1 if the result is OK.
+  //
+  // A frame with an incomplete header will never be inserted into
+  // |frame_chunks|. If the currently available bytes of a new frame do not form
+  // a complete frame header, then the implementation will buffer them until all
+  // the fields in the WebSocketFrameHeader object can be filled. If
+  // ReadFrames() is freshly called in this situation, it will return
+  // ERR_IO_PENDING exactly as if no data was available.
+  //
+  // Every WebSocketFrameChunk in the vector except the first and last is
+  // guaranteed to be a complete frame. The first chunk may be the final part
+  // of the previous frame. The last chunk may be the first part of a new
+  // frame. If there is only one chunk, then it may consist of data from the
+  // middle part of a frame.
+  //
+  // When the socket is closed on the remote side, this method will return
+  // ERR_CONNECTION_CLOSED. It will not return OK with an empty vector.
+  //
+  // If the connection is closed in the middle of receiving an incomplete frame,
+  // ReadFrames may discard the incomplete frame. Since the renderer will
+  // discard any incomplete messages when the connection is closed, this makes
+  // no difference to the overall semantics.
   virtual int ReadFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
                          const CompletionCallback& callback) = 0;
 
   // Writes WebSocket frame data. |frame_chunks| must obey the rule specified
   // in the documentation of WebSocketFrameChunk struct: the first chunk of
   // a WebSocket frame must contain non-NULL |header|, and the last chunk must
   // have |final_chunk| field set to true. Series of chunks representing a
   // WebSocket frame must be consistent (the total length of |data| fields must
   // match |header->payload_length|). |frame_chunks| must be valid until the
   // operation completes or Close() is called.
   //
-  // This function can be called after ReadHandshakeResponse(). This function
-  // should not be called while previous call of WriteFrames() is still pending.
+  // This function should not be called while previous call of WriteFrames() is
+  // still pending.
+  //
+  // Support for incomplete frames is not guaranteed and may be removed from
+  // future iterations of the API.
+  //
+  // This method will only return OK if all frames were written completely.
+  // Otherwise it will return an appropriate ERR_ code.
   virtual int WriteFrames(ScopedVector<WebSocketFrameChunk>* frame_chunks,
                           const CompletionCallback& callback) = 0;
 
-  // Closes the stream. All pending I/O operations (if any) are canceled
+  // Closes the stream. All pending I/O operations (if any) are cancelled

[mmenke, 2013/06/26 20:30:38]

Poor canceled, so unloved, though the correct American spelling (No, I don't
care, either way).

   // at this point, so |frame_chunks| can be freed.
   virtual void Close() = 0;
 
+  // The protocol that was negotiated for the stream. If no protocol was
+  // negotiated, then the empty string is returned.
+  virtual std::string GetProtocol() = 0;

[mmenke, 2013/06/26 20:30:38]

Subprotocol?

[mmenke, 2013/06/26 20:30:38]

virtual const std::string& GetProtocol() const?

[Adam Rice, 2013/06/27 15:10:49]

Done.

[Adam Rice, 2013/06/27 15:10:49]

At first I didn't use a reference simple because it's hard to make guarantees
about lifetime from an abstract base class.

Having thought about it a bit more, I don't think there's a lifetime issue,
because any implementation is going to have to keep the information around. I
would still like to keep the option of storing it in something other than a
std::string, at least until we have several working implementations.

I made the method const as you suggested, since it is an accessor.

+
+  // The extensions that were negotiated for the stream. Since WebSocketStreams
+  // can be layered, this may be different from what this particular
+  // WebSocketStream implements.
+  virtual std::string GetExtensions() = 0;

[mmenke, 2013/06/26 20:30:38]

virtual const std::string& GetExtensions() const?

[mmenke, 2013/06/26 20:30:38]

Also, is this a comma delimited list without spaces, or what?

[Adam Rice, 2013/06/27 15:10:49]

See my justification above for keeping return-by-value semantics for the time
being.

[Adam Rice, 2013/06/27 15:10:49]

I added a clarifying comment. Let me know if it actually clarifies anything.

+
   // TODO(yutak): Add following interfaces:
   // - RenewStreamForAuth for authentication (is this necessary?)
-  // - GetSSLInfo, GetSSLCertRequsetInfo for SSL
+  // - GetSSLInfo, GetSSLCertRequestInfo for SSL
 
   // WebSocketStreamBase derived functions
-  virtual WebSocketStream* AsWebSocketStream() { return this; }
+  virtual WebSocketStream* AsWebSocketStream() OVERRIDE;
+
+  ////////////////////////////////////////////////////////////////////////////
+  // Methods used during the stream handshake. These must not be called once a
+  // WebSocket protocol stream has been established (ie. after the
+  // SuccessCallback or FailureCallback has been called.)
+
+  // Writes WebSocket handshake request to the underlying socket. Must be called
+  // before ReadHandshakeResponse().
+  //
+  // |callback| will only be called if this method returns ERR_IO_PENDING.
+  //
+  // |response_info| must remain valid until the callback from
+  // ReadHandshakeResponse has been called.
+  //
+  // TODO(ricea): This function is only used during the handshake and is
+  // probably only applicable to certain subclasses of WebSocketStream. Move it
+  // somewhere else? Also applies to ReadHandshakeResponse.
+  virtual int SendHandshakeRequest(const GURL& url,
+                                   const HttpRequestHeaders& headers,
+                                   HttpResponseInfo* response_info,
+                                   const CompletionCallback& callback) = 0;
+
+  // Reads WebSocket handshake response from the underlying socket. Must be
+  // called after SendHandshakeRequest() completes.
+  //
+  // |callback| will only be called if this method returns ERR_IO_PENDING.
+  virtual int ReadHandshakeResponse(const CompletionCallback& callback) = 0;
+
+ protected:
+  WebSocketStream();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebSocketStream);
 };
 
 }  // namespace net
 
 #endif  // NET_WEBSOCKETS_WEBSOCKET_STREAM_H_