WebSocket over SPDY.

net/websockets/websocket_job.h

 // Copyright (c) 2010 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_JOB_H_
 #define NET_WEBSOCKETS_WEBSOCKET_JOB_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/string16.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/socket_stream/socket_stream_job.h"
+#include "net/spdy/spdy_websocket_stream.h"
 
 class GURL;
 
 namespace net {
 
 class DrainableIOBuffer;
 class WebSocketFrameHandler;
 class WebSocketHandshakeRequestHandler;
 class WebSocketHandshakeResponseHandler;
 
 // WebSocket protocol specific job on SocketStream.
 // It captures WebSocket handshake message and handles cookie operations.
 // Chrome security policy doesn't allow renderer process (except dev tools)
 // see HttpOnly cookies, so it injects cookie header in handshake request and
 // strips set-cookie headers in handshake response.
 // TODO(ukai): refactor websocket.cc to use this.
-class WebSocketJob : public SocketStreamJob, public SocketStream::Delegate {
+class WebSocketJob : public SocketStreamJob,
+                     public SocketStream::Delegate,
+                     public SpdyWebSocketStreamDelegate {
  public:
   // This is state of WebSocket, not SocketStream.
   enum State {
     INITIALIZED = -1,
     CONNECTING = 0,
     OPEN = 1,
     CLOSING = 2,
     CLOSED = 3,
   };
   static void EnsureInit();
@@ skipping 17 matching lines @@
   virtual void OnSentData(
       SocketStream* socket, int amount_sent);
   virtual void OnReceivedData(
       SocketStream* socket, const char* data, int len);
   virtual void OnClose(SocketStream* socket);
   virtual void OnAuthRequired(
       SocketStream* socket, AuthChallengeInfo* auth_info);
   virtual void OnError(
       const SocketStream* socket, int error);
 
+  // SpdyWebSocketStreamDelegate methods.
+  virtual void OnCreatedSpdyStream(
+      SpdyWebSocketStream* spdy_websocket_stream, int status);
+  virtual void OnSentSpdyHeaders(
+      SpdyWebSocketStream* spdy_websocket_stream);
+  virtual int OnReceivedSpdyResponseHeader(
+      SpdyWebSocketStream* spdy_websocket_stream,
+      const spdy::SpdyHeaderBlock& headers,
+      int status);
+  virtual void OnSentSpdyData(
+      SpdyWebSocketStream* spdy_websocket_stream, int amount_sent);
+  virtual void OnReceivedSpdyData(
+      SpdyWebSocketStream* spdy_websocket_stream, const char* data, int length);
+  virtual void OnCloseSpdyStream(
+      SpdyWebSocketStream* spdy_websocket_stream);
+
  private:
   friend class WebSocketThrottle;
   friend class WebSocketJobTest;
   virtual ~WebSocketJob();
 
   bool SendHandshakeRequest(const char* data, int len);
   void AddCookieHeaderAndSend();
   void OnCanGetCookiesCompleted(int policy);
 
   void OnSentHandshakeRequest(SocketStream* socket, int amount_sent);
   void OnReceivedHandshakeResponse(
       SocketStream* socket, const char* data, int len);
   void SaveCookiesAndNotifyHeaderComplete();
   void SaveNextCookie();
   void OnCanSetCookieCompleted(int policy);
 
   GURL GetURLForCookies() const;
 
   const AddressList& address_list() const;
+  int TrySpdyStream();
   void SetWaiting();
   bool IsWaiting() const;
   void Wakeup();
-  void DoCallback();
+  void DoCallback(int result);
 
+  void SendDataInternal(const char* data, int length);
+  void CloseInternal();
   void SendPending();
 
   SocketStream::Delegate* delegate_;
   State state_;
   bool waiting_;
   AddressList addresses_;
   CompletionCallback* callback_;  // for throttling.
 
   scoped_ptr<WebSocketHandshakeRequestHandler> handshake_request_;
   scoped_ptr<WebSocketHandshakeResponseHandler> handshake_response_;
 
   size_t handshake_request_sent_;
 
   std::vector<std::string> response_cookies_;
   size_t response_cookies_save_index_;
 
   CompletionCallbackImpl<WebSocketJob> can_get_cookies_callback_;
   CompletionCallbackImpl<WebSocketJob> can_set_cookie_callback_;
 
   scoped_ptr<WebSocketFrameHandler> send_frame_handler_;
   scoped_refptr<DrainableIOBuffer> current_buffer_;
   scoped_ptr<WebSocketFrameHandler> receive_frame_handler_;
 
+  scoped_ptr<SpdyWebSocketStream> spdy_websocket_stream_;
+  std::string challenge_;
+
   DISALLOW_COPY_AND_ASSIGN(WebSocketJob);
 };
 
 }  // namespace
 
 #endif  // NET_WEBSOCKETS_WEBSOCKET_JOB_H_