content::ResourceDispatcherHostImpl changes for stale-while-revalidate

content/browser/loader/async_revalidation_manager.h

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 const ptr (or const ref)?

[Adam Rice, 2015/11/27 14:45:13]

Good point. I made it a const reference so it looks like an ordinary input
parameter (which it is).

+                              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_