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 #ifndef WEBKIT_BROWSER_APPCACHE_APPCACHE_RESPONSE_H_ | |
6 #define WEBKIT_BROWSER_APPCACHE_APPCACHE_RESPONSE_H_ | |
7 | |
8 #include "base/compiler_specific.h" | |
9 #include "base/memory/ref_counted.h" | |
10 #include "base/memory/scoped_ptr.h" | |
11 #include "base/memory/weak_ptr.h" | |
12 #include "net/base/completion_callback.h" | |
13 #include "net/http/http_response_info.h" | |
14 #include "url/gurl.h" | |
15 #include "webkit/browser/webkit_storage_browser_export.h" | |
16 #include "webkit/common/appcache/appcache_interfaces.h" | |
17 | |
18 namespace net { | |
19 class IOBuffer; | |
20 } | |
21 | |
22 namespace content { | |
23 class MockAppCacheStorage; | |
24 } | |
25 | |
26 namespace appcache { | |
27 | |
28 class AppCacheStorage; | |
29 | |
30 static const int kUnkownResponseDataSize = -1; | |
31 | |
32 // Response info for a particular response id. Instances are tracked in | |
33 // the working set. | |
34 class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheResponseInfo | |
35 : public base::RefCounted<AppCacheResponseInfo> { | |
36 public: | |
37 // AppCacheResponseInfo takes ownership of the http_info. | |
38 AppCacheResponseInfo(AppCacheStorage* storage, const GURL& manifest_url, | |
39 int64 response_id, net::HttpResponseInfo* http_info, | |
40 int64 response_data_size); | |
41 | |
42 const GURL& manifest_url() const { return manifest_url_; } | |
43 int64 response_id() const { return response_id_; } | |
44 const net::HttpResponseInfo* http_response_info() const { | |
45 return http_response_info_.get(); | |
46 } | |
47 int64 response_data_size() const { return response_data_size_; } | |
48 | |
49 private: | |
50 friend class base::RefCounted<AppCacheResponseInfo>; | |
51 virtual ~AppCacheResponseInfo(); | |
52 | |
53 const GURL manifest_url_; | |
54 const int64 response_id_; | |
55 const scoped_ptr<net::HttpResponseInfo> http_response_info_; | |
56 const int64 response_data_size_; | |
57 AppCacheStorage* storage_; | |
58 }; | |
59 | |
60 // A refcounted wrapper for HttpResponseInfo so we can apply the | |
61 // refcounting semantics used with IOBuffer with these structures too. | |
62 struct WEBKIT_STORAGE_BROWSER_EXPORT HttpResponseInfoIOBuffer | |
63 : public base::RefCountedThreadSafe<HttpResponseInfoIOBuffer> { | |
64 scoped_ptr<net::HttpResponseInfo> http_info; | |
65 int response_data_size; | |
66 | |
67 HttpResponseInfoIOBuffer(); | |
68 explicit HttpResponseInfoIOBuffer(net::HttpResponseInfo* info); | |
69 | |
70 protected: | |
71 friend class base::RefCountedThreadSafe<HttpResponseInfoIOBuffer>; | |
72 virtual ~HttpResponseInfoIOBuffer(); | |
73 }; | |
74 | |
75 // Low level storage API used by the response reader and writer. | |
76 class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheDiskCacheInterface { | |
77 public: | |
78 class Entry { | |
79 public: | |
80 virtual int Read(int index, int64 offset, net::IOBuffer* buf, int buf_len, | |
81 const net::CompletionCallback& callback) = 0; | |
82 virtual int Write(int index, int64 offset, net::IOBuffer* buf, int buf_len, | |
83 const net::CompletionCallback& callback) = 0; | |
84 virtual int64 GetSize(int index) = 0; | |
85 virtual void Close() = 0; | |
86 protected: | |
87 virtual ~Entry() {} | |
88 }; | |
89 | |
90 virtual int CreateEntry(int64 key, Entry** entry, | |
91 const net::CompletionCallback& callback) = 0; | |
92 virtual int OpenEntry(int64 key, Entry** entry, | |
93 const net::CompletionCallback& callback) = 0; | |
94 virtual int DoomEntry(int64 key, const net::CompletionCallback& callback) = 0; | |
95 | |
96 protected: | |
97 friend class base::RefCounted<AppCacheDiskCacheInterface>; | |
98 virtual ~AppCacheDiskCacheInterface() {} | |
99 }; | |
100 | |
101 // Common base class for response reader and writer. | |
102 class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheResponseIO { | |
103 public: | |
104 virtual ~AppCacheResponseIO(); | |
105 int64 response_id() const { return response_id_; } | |
106 | |
107 protected: | |
108 AppCacheResponseIO(int64 response_id, | |
109 int64 group_id, | |
110 AppCacheDiskCacheInterface* disk_cache); | |
111 | |
112 virtual void OnIOComplete(int result) = 0; | |
113 | |
114 bool IsIOPending() { return !callback_.is_null(); } | |
115 void ScheduleIOCompletionCallback(int result); | |
116 void InvokeUserCompletionCallback(int result); | |
117 void ReadRaw(int index, int offset, net::IOBuffer* buf, int buf_len); | |
118 void WriteRaw(int index, int offset, net::IOBuffer* buf, int buf_len); | |
119 | |
120 const int64 response_id_; | |
121 const int64 group_id_; | |
122 AppCacheDiskCacheInterface* disk_cache_; | |
123 AppCacheDiskCacheInterface::Entry* entry_; | |
124 scoped_refptr<HttpResponseInfoIOBuffer> info_buffer_; | |
125 scoped_refptr<net::IOBuffer> buffer_; | |
126 int buffer_len_; | |
127 net::CompletionCallback callback_; | |
128 base::WeakPtrFactory<AppCacheResponseIO> weak_factory_; | |
129 | |
130 private: | |
131 void OnRawIOComplete(int result); | |
132 }; | |
133 | |
134 // Reads existing response data from storage. If the object is deleted | |
135 // and there is a read in progress, the implementation will return | |
136 // immediately but will take care of any side effect of cancelling the | |
137 // operation. In other words, instances are safe to delete at will. | |
138 class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheResponseReader | |
139 : public AppCacheResponseIO { | |
140 public: | |
141 virtual ~AppCacheResponseReader(); | |
142 | |
143 // Reads http info from storage. Always returns the result of the read | |
144 // asynchronously through the 'callback'. Returns the number of bytes read | |
145 // or a net:: error code. Guaranteed to not perform partial reads of | |
146 // the info data. The reader acquires a reference to the 'info_buf' until | |
147 // completion at which time the callback is invoked with either a negative | |
148 // error code or the number of bytes read. The 'info_buf' argument should | |
149 // contain a NULL http_info when ReadInfo is called. The 'callback' is a | |
150 // required parameter. | |
151 // Should only be called where there is no Read operation in progress. | |
152 // (virtual for testing) | |
153 virtual void ReadInfo(HttpResponseInfoIOBuffer* info_buf, | |
154 const net::CompletionCallback& callback); | |
155 | |
156 // Reads data from storage. Always returns the result of the read | |
157 // asynchronously through the 'callback'. Returns the number of bytes read | |
158 // or a net:: error code. EOF is indicated with a return value of zero. | |
159 // The reader acquires a reference to the provided 'buf' until completion | |
160 // at which time the callback is invoked with either a negative error code | |
161 // or the number of bytes read. The 'callback' is a required parameter. | |
162 // Should only be called where there is no Read operation in progress. | |
163 // (virtual for testing) | |
164 virtual void ReadData(net::IOBuffer* buf, int buf_len, | |
165 const net::CompletionCallback& callback); | |
166 | |
167 // Returns true if there is a read operation, for data or info, pending. | |
168 bool IsReadPending() { return IsIOPending(); } | |
169 | |
170 // Used to support range requests. If not called, the reader will | |
171 // read the entire response body. If called, this must be called prior | |
172 // to the first call to the ReadData method. | |
173 void SetReadRange(int offset, int length); | |
174 | |
175 protected: | |
176 friend class AppCacheStorageImpl; | |
177 friend class content::MockAppCacheStorage; | |
178 | |
179 // Should only be constructed by the storage class and derivatives. | |
180 AppCacheResponseReader(int64 response_id, | |
181 int64 group_id, | |
182 AppCacheDiskCacheInterface* disk_cache); | |
183 | |
184 virtual void OnIOComplete(int result) OVERRIDE; | |
185 void ContinueReadInfo(); | |
186 void ContinueReadData(); | |
187 void OpenEntryIfNeededAndContinue(); | |
188 void OnOpenEntryComplete(AppCacheDiskCacheInterface::Entry** entry, int rv); | |
189 | |
190 int range_offset_; | |
191 int range_length_; | |
192 int read_position_; | |
193 net::CompletionCallback open_callback_; | |
194 base::WeakPtrFactory<AppCacheResponseReader> weak_factory_; | |
195 }; | |
196 | |
197 // Writes new response data to storage. If the object is deleted | |
198 // and there is a write in progress, the implementation will return | |
199 // immediately but will take care of any side effect of cancelling the | |
200 // operation. In other words, instances are safe to delete at will. | |
201 class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheResponseWriter | |
202 : public AppCacheResponseIO { | |
203 public: | |
204 virtual ~AppCacheResponseWriter(); | |
205 | |
206 // Writes the http info to storage. Always returns the result of the write | |
207 // asynchronously through the 'callback'. Returns the number of bytes written | |
208 // or a net:: error code. The writer acquires a reference to the 'info_buf' | |
209 // until completion at which time the callback is invoked with either a | |
210 // negative error code or the number of bytes written. The 'callback' is a | |
211 // required parameter. The contents of 'info_buf' are not modified. | |
212 // Should only be called where there is no Write operation in progress. | |
213 void WriteInfo(HttpResponseInfoIOBuffer* info_buf, | |
214 const net::CompletionCallback& callback); | |
215 | |
216 // Writes data to storage. Always returns the result of the write | |
217 // asynchronously through the 'callback'. Returns the number of bytes written | |
218 // or a net:: error code. Guaranteed to not perform partial writes. | |
219 // The writer acquires a reference to the provided 'buf' until completion at | |
220 // which time the callback is invoked with either a negative error code or | |
221 // the number of bytes written. The 'callback' is a required parameter. | |
222 // The contents of 'buf' are not modified. | |
223 // Should only be called where there is no Write operation in progress. | |
224 void WriteData(net::IOBuffer* buf, int buf_len, | |
225 const net::CompletionCallback& callback); | |
226 | |
227 // Returns true if there is a write pending. | |
228 bool IsWritePending() { return IsIOPending(); } | |
229 | |
230 // Returns the amount written, info and data. | |
231 int64 amount_written() { return info_size_ + write_position_; } | |
232 | |
233 protected: | |
234 // Should only be constructed by the storage class and derivatives. | |
235 AppCacheResponseWriter(int64 response_id, | |
236 int64 group_id, | |
237 AppCacheDiskCacheInterface* disk_cache); | |
238 | |
239 private: | |
240 friend class AppCacheStorageImpl; | |
241 friend class content::MockAppCacheStorage; | |
242 | |
243 enum CreationPhase { | |
244 NO_ATTEMPT, | |
245 INITIAL_ATTEMPT, | |
246 DOOM_EXISTING, | |
247 SECOND_ATTEMPT | |
248 }; | |
249 | |
250 virtual void OnIOComplete(int result) OVERRIDE; | |
251 void ContinueWriteInfo(); | |
252 void ContinueWriteData(); | |
253 void CreateEntryIfNeededAndContinue(); | |
254 void OnCreateEntryComplete(AppCacheDiskCacheInterface::Entry** entry, int rv); | |
255 | |
256 int info_size_; | |
257 int write_position_; | |
258 int write_amount_; | |
259 CreationPhase creation_phase_; | |
260 net::CompletionCallback create_callback_; | |
261 base::WeakPtrFactory<AppCacheResponseWriter> weak_factory_; | |
262 }; | |
263 | |
264 } // namespace appcache | |
265 | |
266 #endif // WEBKIT_BROWSER_APPCACHE_APPCACHE_RESPONSE_H_ | |
OLD | NEW |