Index: content/browser/loader/async_revalidation_manager.h |
diff --git a/content/browser/loader/async_revalidation_manager.h b/content/browser/loader/async_revalidation_manager.h |
new file mode 100644 |
index 0000000000000000000000000000000000000000..fdefff8aa35a4329b624c28c2f3f6dc96b2b0fbe |
--- /dev/null |
+++ b/content/browser/loader/async_revalidation_manager.h |
@@ -0,0 +1,108 @@ |
+// Copyright 2015 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#ifndef CONTENT_BROWSER_LOADER_ASYNC_REVALIDATION_MANAGER_H_ |
+#define CONTENT_BROWSER_LOADER_ASYNC_REVALIDATION_MANAGER_H_ |
+ |
+#include <map> |
+#include <string> |
+ |
+#include "base/macros.h" |
+#include "base/memory/scoped_ptr.h" |
+ |
+class GURL; |
+struct ResourceHostMsg_Request; |
+ |
+namespace net { |
+class URLRequest; |
+class HttpCache; |
+} |
+ |
+namespace content { |
+ |
+class AsyncRevalidationDriver; |
+class ResourceContext; |
+class ResourceScheduler; |
+ |
+// One instance of this class manages all active AsyncRevalidationDriver objects |
+// for all profiles. It is created by and owned by |
+// ResourceDispatcherHostImpl. It also implements the creation of a new |
+// net::URLRequest and AsyncRevalidationDriver from an existing net::URLRequest |
+// that has had the stale-while-revalidate algorithm applied to it. |
+class AsyncRevalidationManager { |
+ public: |
+ AsyncRevalidationManager(); |
+ ~AsyncRevalidationManager(); |
+ |
+ // Starts an async revalidation by copying |for_request|. |scheduler| must |
+ // remain valid until this object is destroyed. |
+ void BeginAsyncRevalidation(net::URLRequest* for_request, |
kinuko
2015/11/27 08:50:01
if it's just to be copie-from could for_request be
Adam Rice
2015/11/27 14:45:13
Good point. I made it a const reference so it look
|
+ ResourceScheduler* scheduler); |
+ |
+ // Cancel all pending async revalidations that use ResourceContext. |
+ void CancelAsyncRevalidationsForResourceContext( |
+ ResourceContext* resource_context); |
+ |
+ static bool QualifiesForAsyncRevalidation( |
+ const ResourceHostMsg_Request& request); |
+ |
+ private: |
+ // The key of the map of pending async revalidations. This key has a distinct |
+ // value for every in-progress async revalidation. It is used to avoid |
+ // duplicate async revalidations, and also to cancel affected async |
+ // revalidations when a ResourceContext is removed. |
+ // |
+ // Request headers are intentionally not included in the key as they usually |
+ // don't affect caching, and could cause effectively identical revalidations |
+ // to be considered different because they have a different "Referer" |
+ // header. In rare cases where a "Vary" header leads to us to access different |
+ // resources at the same URL, they fight over a single cache slot and so |
+ // performing additional async revalidations will not improve matters. |
+ struct AsyncRevalidationKey { |
+ AsyncRevalidationKey(const ResourceContext* resource_context, |
+ const net::HttpCache* http_cache, |
+ const GURL& url); |
+ |
+ // Create a prefix key that is used to match all of the |
+ // AsyncRevalidationDrivers using |resource_context| in the map. |
+ explicit AsyncRevalidationKey(const ResourceContext* resource_context); |
+ |
+ // The key for a map needs to be copyable. |
+ AsyncRevalidationKey(const AsyncRevalidationKey& rhs) = default; |
+ ~AsyncRevalidationKey(); |
+ |
+ // No operator= is generated because the struct members are immutable. |
+ |
+ // |resource_context| and |http_cache| are never dereferenced; they are only |
+ // compared to other values. |
+ const ResourceContext* const resource_context; |
+ |
+ // There are multiple independent HttpCache objects per ResourceContext. |
+ const net::HttpCache* const http_cache; |
+ |
+ // Derived from the url via net::HttpUtil::SpecForRequest(). |
+ const std::string url_key; |
+ |
+ struct LessThan { |
+ bool operator()(const AsyncRevalidationKey& lhs, |
+ const AsyncRevalidationKey& rhs) const; |
+ }; |
+ }; |
+ |
+ using AsyncRevalidationMap = std::map<AsyncRevalidationKey, |
+ scoped_ptr<AsyncRevalidationDriver>, |
+ AsyncRevalidationKey::LessThan>; |
+ |
+ void OnAsyncRevalidationComplete(AsyncRevalidationMap::iterator it); |
+ |
+ // Map of AsyncRevalidationDriver instances that are currently in-flight: |
+ // either waiting to be scheduled or active on the network. |
+ AsyncRevalidationMap in_progress_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(AsyncRevalidationManager); |
+}; |
+ |
+} // namespace content |
+ |
+#endif // CONTENT_BROWSER_LOADER_ASYNC_REVALIDATION_MANAGER_H_ |