WebSocket over SPDY.

net/websockets/websocket_job.h

 // Copyright (c) 2011 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 NET_API WebSocketJob
     : public SocketStreamJob,
-      public SocketStream::Delegate {
+      public SocketStream::Delegate,
+      public SpdyWebSocketStream::Delegate {
  public:
   // This is state of WebSocket, not SocketStream.
   enum State {
     INITIALIZED = -1,
     CONNECTING = 0,
     OPEN = 1,
     CLOSING = 2,
     CLOSED = 3,
   };
 
@@ skipping 18 matching lines @@
   virtual int OnStartOpenConnection(
       SocketStream* socket, CompletionCallback* callback);
   virtual void OnConnected(SocketStream* socket, int max_pending_send_allowed);
   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);
 
+  // SpdyWebSocketStream::Delegate methods.
+  virtual void OnCreatedSpdyStream(int status);
+  virtual void OnSentSpdyHeaders(int status);
+  virtual int OnReceivedSpdyResponseHeader(
+      const spdy::SpdyHeaderBlock& headers, int status);
+  virtual void OnSentSpdyData(int amount_sent);
+  virtual void OnReceivedSpdyData(const char* data, int length);
+  virtual void OnCloseSpdyStream();
+
  private:
   friend class WebSocketThrottle;
   friend class WebSocketJobTest;
   virtual ~WebSocketJob();
 
   bool SendHandshakeRequest(const char* data, int len);
   void AddCookieHeaderAndSend();
 
   void OnSentHandshakeRequest(SocketStream* socket, int amount_sent);
   void OnReceivedHandshakeResponse(
@@ skipping 28 matching lines @@
   bool started_to_send_handshake_request_;
   size_t handshake_request_sent_;
 
   std::vector<std::string> response_cookies_;
   size_t response_cookies_save_index_;
 
   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_