OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 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 // HttpStreamBase is an interface for reading and writing data to an | |
6 // HTTP-like stream that keeps the client agnostic of the actual underlying | |
7 // transport layer. This provides an abstraction for HttpStream and | |
8 // WebSocketHandshakeStreamBase. | |
9 | |
10 #ifndef NET_HTTP_HTTP_STREAM_BASE_H_ | |
11 #define NET_HTTP_HTTP_STREAM_BASE_H_ | |
12 | |
13 #include <string> | |
14 | |
15 #include "base/basictypes.h" | |
16 #include "base/memory/scoped_ptr.h" | |
17 #include "net/base/completion_callback.h" | |
18 #include "net/base/net_export.h" | |
19 #include "net/base/request_priority.h" | |
20 #include "net/base/upload_progress.h" | |
21 | |
22 namespace net { | |
23 | |
24 class BoundNetLog; | |
25 class HttpNetworkSession; | |
26 class HttpRequestHeaders; | |
27 struct HttpRequestInfo; | |
28 class HttpResponseInfo; | |
29 class IOBuffer; | |
30 struct LoadTimingInfo; | |
31 class SSLCertRequestInfo; | |
32 class SSLInfo; | |
33 | |
34 class NET_EXPORT_PRIVATE HttpStreamBase { | |
35 public: | |
36 HttpStreamBase() {} | |
37 virtual ~HttpStreamBase() {} | |
38 | |
39 // Initialize stream. Must be called before calling SendRequest(). | |
40 // |request_info| must outlive the HttpStreamBase. | |
41 // Returns a net error code, possibly ERR_IO_PENDING. | |
42 virtual int InitializeStream(const HttpRequestInfo* request_info, | |
43 RequestPriority priority, | |
44 const BoundNetLog& net_log, | |
45 const CompletionCallback& callback) = 0; | |
46 | |
47 // Writes the headers and uploads body data to the underlying socket. | |
48 // ERR_IO_PENDING is returned if the operation could not be completed | |
49 // synchronously, in which case the result will be passed to the callback | |
50 // when available. Returns OK on success. | |
51 // | |
52 // The callback will only be invoked once the first full set of headers have | |
53 // been received, at which point |response| will have been populated with that | |
54 // set of headers, and is safe to read, until/unless ReadResponseHeaders is | |
55 // called. | |
56 // | |
57 // |response| must remain valid until all sets of headers has been read, or | |
58 // the HttpStreamBase is destroyed. There's typically only one set of | |
59 // headers, except in the case of 1xx responses (See ReadResponseHeaders). | |
60 virtual int SendRequest(const HttpRequestHeaders& request_headers, | |
61 HttpResponseInfo* response, | |
62 const CompletionCallback& callback) = 0; | |
63 | |
64 // Reads from the underlying socket until the next set of response headers | |
65 // have been completely received. This may only be called on 1xx responses | |
66 // after SendRequest has completed successfully, to read the next set of | |
67 // headers. | |
68 // | |
69 // ERR_IO_PENDING is returned if the operation could not be completed | |
70 // synchronously, in which case the result will be passed to the callback when | |
71 // available. Returns OK on success. The response headers are available in | |
72 // the HttpResponseInfo passed in to original call to SendRequest. | |
73 virtual int ReadResponseHeaders(const CompletionCallback& callback) = 0; | |
74 | |
75 // Reads response body data, up to |buf_len| bytes. |buf_len| should be a | |
76 // reasonable size (<2MB). The number of bytes read is returned, or an | |
77 // error is returned upon failure. 0 indicates that the request has been | |
78 // fully satisfied and there is no more data to read. | |
79 // ERR_CONNECTION_CLOSED is returned when the connection has been closed | |
80 // prematurely. ERR_IO_PENDING is returned if the operation could not be | |
81 // completed synchronously, in which case the result will be passed to the | |
82 // callback when available. If the operation is not completed immediately, | |
83 // the socket acquires a reference to the provided buffer until the callback | |
84 // is invoked or the socket is destroyed. | |
85 virtual int ReadResponseBody(IOBuffer* buf, int buf_len, | |
86 const CompletionCallback& callback) = 0; | |
87 | |
88 // Closes the stream. | |
89 // |not_reusable| indicates if the stream can be used for further requests. | |
90 // In the case of HTTP, where we re-use the byte-stream (e.g. the connection) | |
91 // this means we need to close the connection; in the case of SPDY, where the | |
92 // underlying stream is never reused, it has no effect. | |
93 // TODO(mbelshe): We should figure out how to fold the not_reusable flag | |
94 // into the stream implementation itself so that the caller | |
95 // does not need to pass it at all. We might also be able to | |
96 // eliminate the SetConnectionReused() below. | |
97 virtual void Close(bool not_reusable) = 0; | |
98 | |
99 // Indicates if the response body has been completely read. | |
100 virtual bool IsResponseBodyComplete() const = 0; | |
101 | |
102 // Indicates that the end of the response is detectable. This means that | |
103 // the response headers indicate either chunked encoding or content length. | |
104 // If neither is sent, the server must close the connection for us to detect | |
105 // the end of the response. | |
106 // TODO(rch): Rename this method, so that it is clear why it exists | |
107 // particularly as it applies to QUIC and SPDY for which the end of the | |
108 // response is always findable. | |
109 virtual bool CanFindEndOfResponse() const = 0; | |
110 | |
111 // A stream exists on top of a connection. If the connection has been used | |
112 // to successfully exchange data in the past, error handling for the | |
113 // stream is done differently. This method returns true if the underlying | |
114 // connection is reused or has been connected and idle for some time. | |
115 virtual bool IsConnectionReused() const = 0; | |
116 virtual void SetConnectionReused() = 0; | |
117 | |
118 // Checks whether the current state of the underlying connection | |
119 // allows it to be reused. | |
120 virtual bool IsConnectionReusable() const = 0; | |
121 | |
122 // Get the total number of bytes received from network for this stream. | |
123 virtual int64 GetTotalReceivedBytes() const = 0; | |
124 | |
125 // Populates the connection establishment part of |load_timing_info|, and | |
126 // socket ID. |load_timing_info| must have all null times when called. | |
127 // Returns false and does nothing if there is no underlying connection, either | |
128 // because one has yet to be assigned to the stream, or because the underlying | |
129 // socket has been closed. | |
130 // | |
131 // In practice, this means that this function will always succeed any time | |
132 // between when the full headers have been received and the stream has been | |
133 // closed. | |
134 virtual bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const = 0; | |
135 | |
136 // Get the SSLInfo associated with this stream's connection. This should | |
137 // only be called for streams over SSL sockets, otherwise the behavior is | |
138 // undefined. | |
139 virtual void GetSSLInfo(SSLInfo* ssl_info) = 0; | |
140 | |
141 // Get the SSLCertRequestInfo associated with this stream's connection. | |
142 // This should only be called for streams over SSL sockets, otherwise the | |
143 // behavior is undefined. | |
144 virtual void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) = 0; | |
145 | |
146 // HACK(willchan): Really, we should move the HttpResponseDrainer logic into | |
147 // the HttpStream implementation. This is just a quick hack. | |
148 virtual bool IsSpdyHttpStream() const = 0; | |
149 | |
150 // In the case of an HTTP error or redirect, flush the response body (usually | |
151 // a simple error or "this page has moved") so that we can re-use the | |
152 // underlying connection. This stream is responsible for deleting itself when | |
153 // draining is complete. | |
154 virtual void Drain(HttpNetworkSession* session) = 0; | |
155 | |
156 // Called when the priority of the parent transaction changes. | |
157 virtual void SetPriority(RequestPriority priority) = 0; | |
158 | |
159 private: | |
160 DISALLOW_COPY_AND_ASSIGN(HttpStreamBase); | |
161 }; | |
162 | |
163 } // namespace net | |
164 | |
165 #endif // NET_HTTP_HTTP_STREAM_BASE_H_ | |
OLD | NEW |