OLD | NEW |
| (Empty) |
1 // Copyright 2013 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 // Protobuf ZeroCopy[Input/Output]Stream implementations capable of using a | |
6 // net::StreamSocket. Built to work with Protobuf CodedStreams. | |
7 | |
8 #ifndef GOOGLE_APIS_GCM_BASE_SOCKET_STREAM_H_ | |
9 #define GOOGLE_APIS_GCM_BASE_SOCKET_STREAM_H_ | |
10 | |
11 #include "base/basictypes.h" | |
12 #include "base/callback_forward.h" | |
13 #include "base/compiler_specific.h" | |
14 #include "base/memory/ref_counted.h" | |
15 #include "base/memory/weak_ptr.h" | |
16 #include "google/protobuf/io/zero_copy_stream.h" | |
17 #include "google_apis/gcm/base/gcm_export.h" | |
18 #include "net/base/net_errors.h" | |
19 | |
20 namespace net { | |
21 class DrainableIOBuffer; | |
22 class IOBuffer; | |
23 class StreamSocket; | |
24 } // namespace net | |
25 | |
26 namespace gcm { | |
27 | |
28 // A helper class for interacting with a net::StreamSocket that is receiving | |
29 // protobuf encoded messages. A SocketInputStream does not take ownership of | |
30 // the socket itself, and it is expected that the life of the input stream | |
31 // should match the life of the socket itself (while the socket remains | |
32 // connected). If an error is encounters, the input stream will store the error | |
33 // in |last_error_|, and GetState() will be set to CLOSED. | |
34 // Typical usage: | |
35 // 1. Check the GetState() of the input stream before using it. If CLOSED, the | |
36 // input stream must be rebuilt (and the socket likely needs to be | |
37 // reconnected as an error was encountered). | |
38 // 2. If GetState() is EMPTY, call Refresh(..), passing the maximum byte size | |
39 // for a message, and wait until completion. It is invalid to attempt to | |
40 // Refresh an input stream or read data from the stream while a Refresh is | |
41 // pending. | |
42 // 3. Check GetState() again to ensure the Refresh was successful. | |
43 // 4. Use a CodedInputStream to read from the ZeroCopyInputStream interface of | |
44 // the SocketInputStream. Next(..) will return true until there is no data | |
45 // remaining. | |
46 // 5. Call RebuildBuffer when done reading, to shift any unread data to the | |
47 // start of the buffer. | |
48 // 6. Repeat as necessary. | |
49 class GCM_EXPORT SocketInputStream | |
50 : public google::protobuf::io::ZeroCopyInputStream { | |
51 public: | |
52 enum State { | |
53 // No valid data to read. This means the buffer is either empty or all data | |
54 // in the buffer has already been consumed. | |
55 EMPTY, | |
56 // Valid data to read. | |
57 READY, | |
58 // In the process of reading new data from the socket. | |
59 READING, | |
60 // An permanent error occurred and the stream is now closed. | |
61 CLOSED, | |
62 }; | |
63 | |
64 // |socket| should already be connected. | |
65 explicit SocketInputStream(net::StreamSocket* socket); | |
66 virtual ~SocketInputStream(); | |
67 | |
68 // ZeroCopyInputStream implementation. | |
69 virtual bool Next(const void** data, int* size) OVERRIDE; | |
70 virtual void BackUp(int count) OVERRIDE; | |
71 virtual bool Skip(int count) OVERRIDE; // Not implemented. | |
72 virtual int64 ByteCount() const OVERRIDE; | |
73 | |
74 // The remaining amount of valid data available to be read. | |
75 size_t UnreadByteCount() const; | |
76 | |
77 // Reads from the socket, appending a max of |byte_limit| bytes onto the read | |
78 // buffer. net::ERR_IO_PENDING is returned if the refresh can't complete | |
79 // synchronously, in which case the callback is invoked upon completion. If | |
80 // the refresh can complete synchronously, even in case of an error, returns | |
81 // net::OK without invoking callback. | |
82 // Note: GetState() (and possibly last_error()) should be checked upon | |
83 // completion to determine whether the Refresh encountered an error. | |
84 net::Error Refresh(const base::Closure& callback, int byte_limit); | |
85 | |
86 // Rebuilds the buffer state by copying over any unread data to the beginning | |
87 // of the buffer and resetting the buffer read/write positions. | |
88 // Note: it is not valid to call Rebuild() if GetState() == CLOSED. The stream | |
89 // must be recreated from scratch in such a scenario. | |
90 void RebuildBuffer(); | |
91 | |
92 // Returns the last fatal error encountered. Only valid if GetState() == | |
93 // CLOSED. | |
94 net::Error last_error() const; | |
95 | |
96 // Returns the current state. | |
97 State GetState() const; | |
98 | |
99 private: | |
100 // Clears the local state. | |
101 void ResetInternal(); | |
102 | |
103 // Callback for Socket::Read calls. | |
104 void RefreshCompletionCallback(const base::Closure& callback, int result); | |
105 | |
106 // Permanently closes the stream. | |
107 void CloseStream(net::Error error, const base::Closure& callback); | |
108 | |
109 // Internal net components. | |
110 net::StreamSocket* const socket_; | |
111 const scoped_refptr<net::IOBuffer> io_buffer_; | |
112 // IOBuffer implementation that wraps the data within |io_buffer_| that hasn't | |
113 // been written to yet by Socket::Read calls. | |
114 const scoped_refptr<net::DrainableIOBuffer> read_buffer_; | |
115 | |
116 // Starting position of the data within |io_buffer_| to consume on subsequent | |
117 // Next(..) call. 0 <= next_pos_ <= read_buffer_.BytesConsumed() | |
118 // Note: next_pos == read_buffer_.BytesConsumed() implies GetState() == EMPTY. | |
119 int next_pos_; | |
120 | |
121 // If < net::ERR_IO_PENDING, the last net error received. | |
122 // Note: last_error_ == net::ERR_IO_PENDING implies GetState() == READING. | |
123 net::Error last_error_; | |
124 | |
125 base::WeakPtrFactory<SocketInputStream> weak_ptr_factory_; | |
126 | |
127 DISALLOW_COPY_AND_ASSIGN(SocketInputStream); | |
128 }; | |
129 | |
130 // A helper class for writing to a SocketStream with protobuf encoded data. | |
131 // A SocketOutputStream does not take ownership of the socket itself, and it is | |
132 // expected that the life of the output stream should match the life of the | |
133 // socket itself (while the socket remains connected). | |
134 // Typical usage: | |
135 // 1. Check the GetState() of the output stream before using it. If CLOSED, the | |
136 // output stream must be rebuilt (and the socket likely needs to be | |
137 // reconnected, as an error was encountered). | |
138 // 2. If EMPTY, the output stream can be written via a CodedOutputStream using | |
139 // the ZeroCopyOutputStream interface. | |
140 // 3. Once done writing, GetState() should be READY, so call Flush(..) to write | |
141 // the buffer into the StreamSocket. Wait for the callback to be invoked | |
142 // (it's invalid to write to an output stream while it's flushing). | |
143 // 4. Check the GetState() again to ensure the Flush was successful. GetState() | |
144 // should be EMPTY again. | |
145 // 5. Repeat. | |
146 class GCM_EXPORT SocketOutputStream | |
147 : public google::protobuf::io::ZeroCopyOutputStream { | |
148 public: | |
149 enum State { | |
150 // No valid data yet. | |
151 EMPTY, | |
152 // Ready for flushing (some data is present). | |
153 READY, | |
154 // In the process of flushing into the socket. | |
155 FLUSHING, | |
156 // A permanent error occurred, and the stream is now closed. | |
157 CLOSED, | |
158 }; | |
159 | |
160 // |socket| should already be connected. | |
161 explicit SocketOutputStream(net::StreamSocket* socket); | |
162 virtual ~SocketOutputStream(); | |
163 | |
164 // ZeroCopyOutputStream implementation. | |
165 virtual bool Next(void** data, int* size) OVERRIDE; | |
166 virtual void BackUp(int count) OVERRIDE; | |
167 virtual int64 ByteCount() const OVERRIDE; | |
168 | |
169 // Writes the buffer into the Socket. | |
170 net::Error Flush(const base::Closure& callback); | |
171 | |
172 // Returns the last fatal error encountered. Only valid if GetState() == | |
173 // CLOSED. | |
174 net::Error last_error() const; | |
175 | |
176 // Returns the current state. | |
177 State GetState() const; | |
178 | |
179 private: | |
180 void FlushCompletionCallback(const base::Closure& callback, int result); | |
181 | |
182 // Internal net components. | |
183 net::StreamSocket* const socket_; | |
184 const scoped_refptr<net::IOBuffer> io_buffer_; | |
185 // IOBuffer implementation that wraps the data within |io_buffer_| that hasn't | |
186 // been written to the socket yet. | |
187 const scoped_refptr<net::DrainableIOBuffer> write_buffer_; | |
188 | |
189 // Starting position of the data within |io_buffer_| to consume on subsequent | |
190 // Next(..) call. 0 <= write_buffer_.BytesConsumed() <= next_pos_ | |
191 // Note: next_pos == 0 implies GetState() == EMPTY. | |
192 int next_pos_; | |
193 | |
194 // If < net::ERR_IO_PENDING, the last net error received. | |
195 // Note: last_error_ == net::ERR_IO_PENDING implies GetState() == FLUSHING. | |
196 net::Error last_error_; | |
197 | |
198 base::WeakPtrFactory<SocketOutputStream> weak_ptr_factory_; | |
199 | |
200 DISALLOW_COPY_AND_ASSIGN(SocketOutputStream); | |
201 }; | |
202 | |
203 } // namespace gcm | |
204 | |
205 #endif // GOOGLE_APIS_GCM_BASE_SOCKET_STREAM_H_ | |
OLD | NEW |