OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #ifndef NET_SPDY_SPDY_PROXY_CLIENT_SOCKET_H_ |
| 6 #define NET_SPDY_SPDY_PROXY_CLIENT_SOCKET_H_ |
| 7 #pragma once |
| 8 |
| 9 #include <string> |
| 10 #include <list> |
| 11 |
| 12 #include "base/basictypes.h" |
| 13 #include "base/ref_counted.h" |
| 14 #include "net/base/completion_callback.h" |
| 15 #include "net/base/host_port_pair.h" |
| 16 #include "net/base/net_log.h" |
| 17 #include "net/http/http_auth_controller.h" |
| 18 #include "net/http/http_request_headers.h" |
| 19 #include "net/http/http_request_info.h" |
| 20 #include "net/http/http_response_info.h" |
| 21 #include "net/socket/client_socket.h" |
| 22 #include "net/spdy/spdy_protocol.h" |
| 23 #include "net/spdy/spdy_session.h" |
| 24 #include "net/spdy/spdy_stream.h" |
| 25 |
| 26 |
| 27 class GURL; |
| 28 |
| 29 namespace net { |
| 30 |
| 31 class AddressList; |
| 32 class ClientSocketHandle; |
| 33 class HttpStream; |
| 34 class IOBuffer; |
| 35 class SpdySession; |
| 36 class SpdyStream; |
| 37 |
| 38 class SpdyProxyClientSocket : public ClientSocket, public SpdyStream::Delegate { |
| 39 public: |
| 40 // Create a socket on top of the |spdy_stream| by sending a SYN_STREAM |
| 41 // CONNECT frame for |endpoint|. After the SYN_REPLY is received, |
| 42 // any data read/written to the socket will be transferred in data |
| 43 // frames. |
| 44 SpdyProxyClientSocket(SpdyStream* spdy_stream, |
| 45 const std::string& user_agent, |
| 46 const HostPortPair& endpoint, |
| 47 const GURL& url, |
| 48 const HostPortPair& proxy_server, |
| 49 HttpAuthCache* auth_cache, |
| 50 HttpAuthHandlerFactory* auth_handler_factory); |
| 51 |
| 52 |
| 53 // On destruction Disconnect() is called. |
| 54 virtual ~SpdyProxyClientSocket(); |
| 55 |
| 56 const scoped_refptr<HttpAuthController>& auth_controller() { |
| 57 return auth_; |
| 58 } |
| 59 |
| 60 const HttpResponseInfo* GetConnectResponseInfo() const { |
| 61 return response_.headers ? &response_ : NULL; |
| 62 } |
| 63 |
| 64 // ClientSocket methods: |
| 65 |
| 66 virtual int Connect(CompletionCallback* callback); |
| 67 virtual void Disconnect(); |
| 68 virtual bool IsConnected() const; |
| 69 virtual bool IsConnectedAndIdle() const; |
| 70 virtual const BoundNetLog& NetLog() const { return net_log_; } |
| 71 virtual void SetSubresourceSpeculation(); |
| 72 virtual void SetOmniboxSpeculation(); |
| 73 virtual bool WasEverUsed() const; |
| 74 |
| 75 // Socket methods: |
| 76 |
| 77 virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback); |
| 78 virtual int Write(IOBuffer* buf, int buf_len, CompletionCallback* callback); |
| 79 |
| 80 virtual bool SetReceiveBufferSize(int32 size); |
| 81 virtual bool SetSendBufferSize(int32 size); |
| 82 |
| 83 virtual int GetPeerAddress(AddressList* address) const; |
| 84 |
| 85 // SpdyStream::Delegate methods: |
| 86 |
| 87 // Called when SYN frame has been sent. |
| 88 // Returns true if no more data to be sent after SYN frame. |
| 89 virtual bool OnSendHeadersComplete(int status); |
| 90 |
| 91 // Called when stream is ready to send data. |
| 92 // Returns network error code. OK when it successfully sent data. |
| 93 virtual int OnSendBody(); |
| 94 |
| 95 // Called when data has been sent. |status| indicates network error |
| 96 // or number of bytes has been sent. |
| 97 // Returns true if no more data to be sent. |
| 98 virtual bool OnSendBodyComplete(int status); |
| 99 |
| 100 // Called when SYN_STREAM or SYN_REPLY received. |status| indicates network |
| 101 // error. Returns network error code. |
| 102 virtual int OnResponseReceived(const spdy::SpdyHeaderBlock& response, |
| 103 base::Time response_time, |
| 104 int status); |
| 105 |
| 106 // Called when data is received. |
| 107 virtual void OnDataReceived(const char* data, int length); |
| 108 |
| 109 // Called when data is sent. |
| 110 virtual void OnDataSent(int length); |
| 111 |
| 112 // Called when SpdyStream is closed. |
| 113 virtual void OnClose(int status); |
| 114 |
| 115 private: |
| 116 enum State { |
| 117 STATE_NONE, |
| 118 STATE_GENERATE_AUTH_TOKEN, |
| 119 STATE_GENERATE_AUTH_TOKEN_COMPLETE, |
| 120 STATE_SEND_REQUEST, |
| 121 STATE_SEND_REQUEST_COMPLETE, |
| 122 STATE_READ_REPLY_COMPLETE, |
| 123 STATE_DONE, |
| 124 }; |
| 125 |
| 126 void OnIOComplete(int result); |
| 127 |
| 128 int DoLoop(int last_io_result); |
| 129 int DoGenerateAuthToken(); |
| 130 int DoGenerateAuthTokenComplete(int result); |
| 131 int DoSendRequest(); |
| 132 int DoSendRequestComplete(int result); |
| 133 int DoReadReplyComplete(int result); |
| 134 |
| 135 // Populates |user_buffer_| with as much read data as possible |
| 136 // and returns the number of bytes read. |
| 137 int PopulateUserReadBuffer(); |
| 138 |
| 139 CompletionCallbackImpl<SpdyProxyClientSocket> io_callback_; |
| 140 State next_state_; |
| 141 |
| 142 // Pointer to the SPDY Stream that this sits on top of. |
| 143 scoped_refptr<SpdyStream> spdy_stream_; |
| 144 |
| 145 // Stores the callback to the layer above, called on completing Read() or |
| 146 // Connect(). |
| 147 CompletionCallback* read_callback_; |
| 148 // Stores the callback to the layer above, called on completing Write(). |
| 149 CompletionCallback* write_callback_; |
| 150 |
| 151 // CONNECT request and response. |
| 152 HttpRequestInfo request_; |
| 153 HttpResponseInfo response_; |
| 154 |
| 155 // The hostname and port of the endpoint. This is not necessarily the one |
| 156 // specified by the URL, due to Alternate-Protocol or fixed testing ports. |
| 157 const HostPortPair endpoint_; |
| 158 scoped_refptr<HttpAuthController> auth_; |
| 159 |
| 160 // We buffer the response body as it arrives asynchronously from the stream. |
| 161 std::list<scoped_refptr<DrainableIOBuffer> > read_buffer_; |
| 162 |
| 163 // User provided buffer for the Read() response. |
| 164 scoped_refptr<DrainableIOBuffer> user_buffer_; |
| 165 |
| 166 // User specified number of bytes to be written. |
| 167 int write_buffer_len_; |
| 168 // Number of bytes written which have not been confirmed |
| 169 int write_bytes_outstanding_; |
| 170 |
| 171 // True if read has ever returned zero for eof. |
| 172 bool eof_has_been_read_; |
| 173 // True if the transport socket has ever sent data. |
| 174 bool was_ever_used_; |
| 175 |
| 176 const BoundNetLog net_log_; |
| 177 |
| 178 DISALLOW_COPY_AND_ASSIGN(SpdyProxyClientSocket); |
| 179 }; |
| 180 |
| 181 } // namespace net |
| 182 |
| 183 #endif // NET_SPDY_SPDY_PROXY_CLIENT_SOCKET_H_ |
OLD | NEW |