Remove references to WebContentsView::SizeContents from chrome/ and app/
[chromium-blink-merge.git] / net / http / http_cache.h
blobdd9d0cdfcae36cfcbff10cbbeacc6874179768c9
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.
5 // This file declares a HttpTransactionFactory implementation that can be
6 // layered on top of another HttpTransactionFactory to add HTTP caching. The
7 // caching logic follows RFC 2616 (any exceptions are called out in the code).
8 //
9 // The HttpCache takes a disk_cache::Backend as a parameter, and uses that for
10 // the cache storage.
12 // See HttpTransactionFactory and HttpTransaction for more details.
14 #ifndef NET_HTTP_HTTP_CACHE_H_
15 #define NET_HTTP_HTTP_CACHE_H_
17 #include <list>
18 #include <set>
19 #include <string>
21 #include "base/basictypes.h"
22 #include "base/containers/hash_tables.h"
23 #include "base/files/file_path.h"
24 #include "base/memory/scoped_ptr.h"
25 #include "base/memory/weak_ptr.h"
26 #include "base/message_loop/message_loop_proxy.h"
27 #include "base/threading/non_thread_safe.h"
28 #include "base/time/time.h"
29 #include "net/base/cache_type.h"
30 #include "net/base/completion_callback.h"
31 #include "net/base/load_states.h"
32 #include "net/base/net_export.h"
33 #include "net/base/request_priority.h"
34 #include "net/http/http_network_session.h"
35 #include "net/http/http_transaction_factory.h"
37 class GURL;
39 namespace disk_cache {
40 class Backend;
41 class Entry;
44 namespace net {
46 class CertVerifier;
47 class HostResolver;
48 class HttpAuthHandlerFactory;
49 class HttpNetworkSession;
50 class HttpResponseInfo;
51 class HttpServerProperties;
52 class IOBuffer;
53 class NetLog;
54 class NetworkDelegate;
55 class ServerBoundCertService;
56 class ProxyService;
57 class SSLConfigService;
58 class TransportSecurityState;
59 class ViewCacheHelper;
60 struct HttpRequestInfo;
62 class NET_EXPORT HttpCache : public HttpTransactionFactory,
63 public base::SupportsWeakPtr<HttpCache>,
64 NON_EXPORTED_BASE(public base::NonThreadSafe) {
65 public:
66 // The cache mode of operation.
67 enum Mode {
68 // Normal mode just behaves like a standard web cache.
69 NORMAL = 0,
70 // Record mode caches everything for purposes of offline playback.
71 RECORD,
72 // Playback mode replays from a cache without considering any
73 // standard invalidations.
74 PLAYBACK,
75 // Disables reads and writes from the cache.
76 // Equivalent to setting LOAD_DISABLE_CACHE on every request.
77 DISABLE
80 // A BackendFactory creates a backend object to be used by the HttpCache.
81 class NET_EXPORT BackendFactory {
82 public:
83 virtual ~BackendFactory() {}
85 // The actual method to build the backend. Returns a net error code. If
86 // ERR_IO_PENDING is returned, the |callback| will be notified when the
87 // operation completes, and |backend| must remain valid until the
88 // notification arrives.
89 // The implementation must not access the factory object after invoking the
90 // |callback| because the object can be deleted from within the callback.
91 virtual int CreateBackend(NetLog* net_log,
92 scoped_ptr<disk_cache::Backend>* backend,
93 const CompletionCallback& callback) = 0;
96 // A default backend factory for the common use cases.
97 class NET_EXPORT DefaultBackend : public BackendFactory {
98 public:
99 // |path| is the destination for any files used by the backend, and
100 // |cache_thread| is the thread where disk operations should take place. If
101 // |max_bytes| is zero, a default value will be calculated automatically.
102 DefaultBackend(CacheType type, BackendType backend_type,
103 const base::FilePath& path, int max_bytes,
104 base::MessageLoopProxy* thread);
105 virtual ~DefaultBackend();
107 // Returns a factory for an in-memory cache.
108 static BackendFactory* InMemory(int max_bytes);
110 // BackendFactory implementation.
111 virtual int CreateBackend(NetLog* net_log,
112 scoped_ptr<disk_cache::Backend>* backend,
113 const CompletionCallback& callback) OVERRIDE;
115 private:
116 CacheType type_;
117 BackendType backend_type_;
118 const base::FilePath path_;
119 int max_bytes_;
120 scoped_refptr<base::MessageLoopProxy> thread_;
123 // The disk cache is initialized lazily (by CreateTransaction) in this case.
124 // The HttpCache takes ownership of the |backend_factory|.
125 HttpCache(const net::HttpNetworkSession::Params& params,
126 BackendFactory* backend_factory);
128 // The disk cache is initialized lazily (by CreateTransaction) in this case.
129 // Provide an existing HttpNetworkSession, the cache can construct a
130 // network layer with a shared HttpNetworkSession in order for multiple
131 // network layers to share information (e.g. authentication data). The
132 // HttpCache takes ownership of the |backend_factory|.
133 HttpCache(HttpNetworkSession* session, BackendFactory* backend_factory);
135 // Initialize the cache from its component parts, which is useful for
136 // testing. The lifetime of the network_layer and backend_factory are managed
137 // by the HttpCache and will be destroyed using |delete| when the HttpCache is
138 // destroyed.
139 HttpCache(HttpTransactionFactory* network_layer,
140 NetLog* net_log,
141 BackendFactory* backend_factory);
143 virtual ~HttpCache();
145 HttpTransactionFactory* network_layer() { return network_layer_.get(); }
147 // Retrieves the cache backend for this HttpCache instance. If the backend
148 // is not initialized yet, this method will initialize it. The return value is
149 // a network error code, and it could be ERR_IO_PENDING, in which case the
150 // |callback| will be notified when the operation completes. The pointer that
151 // receives the |backend| must remain valid until the operation completes.
152 int GetBackend(disk_cache::Backend** backend,
153 const net::CompletionCallback& callback);
155 // Returns the current backend (can be NULL).
156 disk_cache::Backend* GetCurrentBackend() const;
158 // Given a header data blob, convert it to a response info object.
159 static bool ParseResponseInfo(const char* data, int len,
160 HttpResponseInfo* response_info,
161 bool* response_truncated);
163 // Writes |buf_len| bytes of metadata stored in |buf| to the cache entry
164 // referenced by |url|, as long as the entry's |expected_response_time| has
165 // not changed. This method returns without blocking, and the operation will
166 // be performed asynchronously without any completion notification.
167 void WriteMetadata(const GURL& url,
168 RequestPriority priority,
169 base::Time expected_response_time,
170 IOBuffer* buf,
171 int buf_len);
173 // Get/Set the cache's mode.
174 void set_mode(Mode value) { mode_ = value; }
175 Mode mode() { return mode_; }
177 // Close currently active sockets so that fresh page loads will not use any
178 // recycled connections. For sockets currently in use, they may not close
179 // immediately, but they will not be reusable. This is for debugging.
180 void CloseAllConnections();
182 // Close all idle connections. Will close all sockets not in active use.
183 void CloseIdleConnections();
185 // Called whenever an external cache in the system reuses the resource
186 // referred to by |url| and |http_method|.
187 void OnExternalCacheHit(const GURL& url, const std::string& http_method);
189 // Initializes the Infinite Cache, if selected by the field trial.
190 void InitializeInfiniteCache(const base::FilePath& path);
192 // HttpTransactionFactory implementation:
193 virtual int CreateTransaction(RequestPriority priority,
194 scoped_ptr<HttpTransaction>* trans) OVERRIDE;
195 virtual HttpCache* GetCache() OVERRIDE;
196 virtual HttpNetworkSession* GetSession() OVERRIDE;
198 // Resets the network layer to allow for tests that probe
199 // network changes (e.g. host unreachable). The old network layer is
200 // returned to allow for filter patterns that only intercept
201 // some creation requests. Note ownership exchange.
202 scoped_ptr<HttpTransactionFactory>
203 SetHttpNetworkTransactionFactoryForTesting(
204 scoped_ptr<HttpTransactionFactory> new_network_layer);
206 private:
207 // Types --------------------------------------------------------------------
209 // Disk cache entry data indices.
210 enum {
211 kResponseInfoIndex = 0,
212 kResponseContentIndex,
213 kMetadataIndex,
215 // Must remain at the end of the enum.
216 kNumCacheEntryDataIndices
219 class MetadataWriter;
220 class QuicServerInfoFactoryAdaptor;
221 class Transaction;
222 class WorkItem;
223 friend class Transaction;
224 friend class ViewCacheHelper;
225 struct PendingOp; // Info for an entry under construction.
227 typedef std::list<Transaction*> TransactionList;
228 typedef std::list<WorkItem*> WorkItemList;
230 struct ActiveEntry {
231 explicit ActiveEntry(disk_cache::Entry* entry);
232 ~ActiveEntry();
234 disk_cache::Entry* disk_entry;
235 Transaction* writer;
236 TransactionList readers;
237 TransactionList pending_queue;
238 bool will_process_pending_queue;
239 bool doomed;
242 typedef base::hash_map<std::string, ActiveEntry*> ActiveEntriesMap;
243 typedef base::hash_map<std::string, PendingOp*> PendingOpsMap;
244 typedef std::set<ActiveEntry*> ActiveEntriesSet;
245 typedef base::hash_map<std::string, int> PlaybackCacheMap;
247 // Methods ------------------------------------------------------------------
249 // Creates the |backend| object and notifies the |callback| when the operation
250 // completes. Returns an error code.
251 int CreateBackend(disk_cache::Backend** backend,
252 const net::CompletionCallback& callback);
254 // Makes sure that the backend creation is complete before allowing the
255 // provided transaction to use the object. Returns an error code. |trans|
256 // will be notified via its IO callback if this method returns ERR_IO_PENDING.
257 // The transaction is free to use the backend directly at any time after
258 // receiving the notification.
259 int GetBackendForTransaction(Transaction* trans);
261 // Generates the cache key for this request.
262 std::string GenerateCacheKey(const HttpRequestInfo*);
264 // Dooms the entry selected by |key|, if it is currently in the list of active
265 // entries.
266 void DoomActiveEntry(const std::string& key);
268 // Dooms the entry selected by |key|. |trans| will be notified via its IO
269 // callback if this method returns ERR_IO_PENDING. The entry can be
270 // currently in use or not.
271 int DoomEntry(const std::string& key, Transaction* trans);
273 // Dooms the entry selected by |key|. |trans| will be notified via its IO
274 // callback if this method returns ERR_IO_PENDING. The entry should not
275 // be currently in use.
276 int AsyncDoomEntry(const std::string& key, Transaction* trans);
278 // Dooms the entry associated with a GET for a given |url|.
279 void DoomMainEntryForUrl(const GURL& url);
281 // Closes a previously doomed entry.
282 void FinalizeDoomedEntry(ActiveEntry* entry);
284 // Returns an entry that is currently in use and not doomed, or NULL.
285 ActiveEntry* FindActiveEntry(const std::string& key);
287 // Creates a new ActiveEntry and starts tracking it. |disk_entry| is the disk
288 // cache entry.
289 ActiveEntry* ActivateEntry(disk_cache::Entry* disk_entry);
291 // Deletes an ActiveEntry.
292 void DeactivateEntry(ActiveEntry* entry);
294 // Deletes an ActiveEntry using an exhaustive search.
295 void SlowDeactivateEntry(ActiveEntry* entry);
297 // Returns the PendingOp for the desired |key|. If an entry is not under
298 // construction already, a new PendingOp structure is created.
299 PendingOp* GetPendingOp(const std::string& key);
301 // Deletes a PendingOp.
302 void DeletePendingOp(PendingOp* pending_op);
304 // Opens the disk cache entry associated with |key|, returning an ActiveEntry
305 // in |*entry|. |trans| will be notified via its IO callback if this method
306 // returns ERR_IO_PENDING.
307 int OpenEntry(const std::string& key, ActiveEntry** entry,
308 Transaction* trans);
310 // Creates the disk cache entry associated with |key|, returning an
311 // ActiveEntry in |*entry|. |trans| will be notified via its IO callback if
312 // this method returns ERR_IO_PENDING.
313 int CreateEntry(const std::string& key, ActiveEntry** entry,
314 Transaction* trans);
316 // Destroys an ActiveEntry (active or doomed).
317 void DestroyEntry(ActiveEntry* entry);
319 // Adds a transaction to an ActiveEntry. If this method returns ERR_IO_PENDING
320 // the transaction will be notified about completion via its IO callback. This
321 // method returns ERR_CACHE_RACE to signal the transaction that it cannot be
322 // added to the provided entry, and it should retry the process with another
323 // one (in this case, the entry is no longer valid).
324 int AddTransactionToEntry(ActiveEntry* entry, Transaction* trans);
326 // Called when the transaction has finished working with this entry. |cancel|
327 // is true if the operation was cancelled by the caller instead of running
328 // to completion.
329 void DoneWithEntry(ActiveEntry* entry, Transaction* trans, bool cancel);
331 // Called when the transaction has finished writing to this entry. |success|
332 // is false if the cache entry should be deleted.
333 void DoneWritingToEntry(ActiveEntry* entry, bool success);
335 // Called when the transaction has finished reading from this entry.
336 void DoneReadingFromEntry(ActiveEntry* entry, Transaction* trans);
338 // Converts the active writer transaction to a reader so that other
339 // transactions can start reading from this entry.
340 void ConvertWriterToReader(ActiveEntry* entry);
342 // Returns the LoadState of the provided pending transaction.
343 LoadState GetLoadStateForPendingTransaction(const Transaction* trans);
345 // Removes the transaction |trans|, from the pending list of an entry
346 // (PendingOp, active or doomed entry).
347 void RemovePendingTransaction(Transaction* trans);
349 // Removes the transaction |trans|, from the pending list of |entry|.
350 bool RemovePendingTransactionFromEntry(ActiveEntry* entry,
351 Transaction* trans);
353 // Removes the transaction |trans|, from the pending list of |pending_op|.
354 bool RemovePendingTransactionFromPendingOp(PendingOp* pending_op,
355 Transaction* trans);
357 // Resumes processing the pending list of |entry|.
358 void ProcessPendingQueue(ActiveEntry* entry);
360 // Events (called via PostTask) ---------------------------------------------
362 void OnProcessPendingQueue(ActiveEntry* entry);
364 // Callbacks ----------------------------------------------------------------
366 // Processes BackendCallback notifications.
367 void OnIOComplete(int result, PendingOp* entry);
369 // Helper to conditionally delete |pending_op| if the HttpCache object it
370 // is meant for has been deleted.
372 // TODO(ajwong): The PendingOp lifetime management is very tricky. It might
373 // be possible to simplify it using either base::Owned() or base::Passed()
374 // with the callback.
375 static void OnPendingOpComplete(const base::WeakPtr<HttpCache>& cache,
376 PendingOp* pending_op,
377 int result);
379 // Processes the backend creation notification.
380 void OnBackendCreated(int result, PendingOp* pending_op);
382 // Variables ----------------------------------------------------------------
384 NetLog* net_log_;
386 // Used when lazily constructing the disk_cache_.
387 scoped_ptr<BackendFactory> backend_factory_;
388 bool building_backend_;
390 Mode mode_;
392 const scoped_ptr<QuicServerInfoFactoryAdaptor> quic_server_info_factory_;
394 scoped_ptr<HttpTransactionFactory> network_layer_;
396 scoped_ptr<disk_cache::Backend> disk_cache_;
398 // The set of active entries indexed by cache key.
399 ActiveEntriesMap active_entries_;
401 // The set of doomed entries.
402 ActiveEntriesSet doomed_entries_;
404 // The set of entries "under construction".
405 PendingOpsMap pending_ops_;
407 scoped_ptr<PlaybackCacheMap> playback_cache_map_;
409 DISALLOW_COPY_AND_ASSIGN(HttpCache);
412 } // namespace net
414 #endif // NET_HTTP_HTTP_CACHE_H_