1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// 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_JOB_H_
#define NET_WEBSOCKETS_WEBSOCKET_JOB_H_
#include <deque>
#include <string>
#include <vector>
#include "base/memory/weak_ptr.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_header_block.h"
#include "net/spdy/spdy_websocket_stream.h"
class GURL;
namespace net {
class DrainableIOBuffer;
class SSLInfo;
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_EXPORT WebSocketJob
: public SocketStreamJob,
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,
};
explicit WebSocketJob(SocketStream::Delegate* delegate);
static void EnsureInit();
// Enable or Disable WebSocket over SPDY feature.
// This function is intended to be called before I/O thread starts.
static void set_websocket_over_spdy_enabled(bool enabled);
State state() const { return state_; }
virtual void Connect() OVERRIDE;
virtual bool SendData(const char* data, int len) OVERRIDE;
virtual void Close() OVERRIDE;
virtual void RestartWithAuth(const AuthCredentials& credentials) OVERRIDE;
virtual void DetachDelegate() OVERRIDE;
// SocketStream::Delegate methods.
virtual int OnStartOpenConnection(
SocketStream* socket, const CompletionCallback& callback) OVERRIDE;
virtual void OnConnected(SocketStream* socket,
int max_pending_send_allowed) OVERRIDE;
virtual void OnSentData(SocketStream* socket, int amount_sent) OVERRIDE;
virtual void OnReceivedData(SocketStream* socket,
const char* data,
int len) OVERRIDE;
virtual void OnClose(SocketStream* socket) OVERRIDE;
virtual void OnAuthRequired(
SocketStream* socket, AuthChallengeInfo* auth_info) OVERRIDE;
virtual void OnSSLCertificateError(SocketStream* socket,
const SSLInfo& ssl_info,
bool fatal) OVERRIDE;
virtual void OnError(const SocketStream* socket, int error) OVERRIDE;
// SpdyWebSocketStream::Delegate methods.
virtual void OnCreatedSpdyStream(int status) OVERRIDE;
virtual void OnSentSpdyHeaders(int status) OVERRIDE;
virtual int OnReceivedSpdyResponseHeader(
const SpdyHeaderBlock& headers, int status) OVERRIDE;
virtual void OnSentSpdyData(int amount_sent) OVERRIDE;
virtual void OnReceivedSpdyData(const char* data, int length) OVERRIDE;
virtual void OnCloseSpdyStream() OVERRIDE;
private:
friend class WebSocketThrottle;
friend class WebSocketJobSpdy2Test;
friend class WebSocketJobSpdy3Test;
virtual ~WebSocketJob();
bool SendHandshakeRequest(const char* data, int len);
void AddCookieHeaderAndSend();
void LoadCookieCallback(const std::string& cookie);
void OnSentHandshakeRequest(SocketStream* socket, int amount_sent);
void OnReceivedHandshakeResponse(
SocketStream* socket, const char* data, int len);
void SaveCookiesAndNotifyHeaderComplete();
void SaveNextCookie();
void SaveCookieCallback(bool cookie_status);
void DoSendData();
GURL GetURLForCookies() const;
const AddressList& address_list() const;
int TrySpdyStream();
void SetWaiting();
bool IsWaiting() const;
void Wakeup();
void RetryPendingIO();
void CompleteIO(int result);
bool SendDataInternal(const char* data, int length);
void CloseInternal();
void SendPending();
static bool websocket_over_spdy_enabled_;
SocketStream::Delegate* delegate_;
State state_;
bool waiting_;
AddressList addresses_;
CompletionCallback callback_; // for throttling.
scoped_ptr<WebSocketHandshakeRequestHandler> handshake_request_;
scoped_ptr<WebSocketHandshakeResponseHandler> handshake_response_;
bool started_to_send_handshake_request_;
size_t handshake_request_sent_;
std::vector<std::string> response_cookies_;
size_t response_cookies_save_index_;
std::deque<scoped_refptr<IOBufferWithSize> > send_buffer_queue_;
scoped_refptr<DrainableIOBuffer> current_send_buffer_;
std::vector<char> received_data_after_handshake_;
int spdy_protocol_version_;
scoped_ptr<SpdyWebSocketStream> spdy_websocket_stream_;
std::string challenge_;
base::WeakPtrFactory<WebSocketJob> weak_ptr_factory_;
base::WeakPtrFactory<WebSocketJob> weak_ptr_factory_for_send_pending_;
DISALLOW_COPY_AND_ASSIGN(WebSocketJob);
};
} // namespace
#endif // NET_WEBSOCKETS_WEBSOCKET_JOB_H_
|
