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..d60f7f81b30b582bfad3a8a5fb311e413c8a2499
--- /dev/null
+++ b/content/browser/loader/async_revalidation_manager.h
@@ -0,0 +1,106 @@
+// 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"
+
+class GURL;
+struct ResourceHostMsg_Request;
+
+namespace net {
+class URLRequest;
+class HttpCache;
+}
+
+namespace content {
+
+class AsyncRevalidationDriver;
+class ResourceContext;
+class ResourceScheduler;
+
+// This class manages all active AsyncRevalidationDriver objects for the whole
+// process. It also implements the creation of a new net::URLRequest and

[kinuko, 2015/11/19 07:00:29]

nit: process -> renderer process?

[kinuko, 2015/11/19 08:01:32]

oops, sorry please ignore this

+// AsyncRevalidationDriver from an existing net::URLRequest that has had the
+// stale-while-revalidate algorithm applied to it.

[kinuko, 2015/11/19 07:00:29]

It'd be probably easier to understand its lifetime & ownership semantics if it's
also noted that it's owned by RDH

[Adam Rice, 2015/11/19 21:13:52]

Comment updated. PTAL.

+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,
+                              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,
+                                        AsyncRevalidationDriver*,
+                                        AsyncRevalidationKey::LessThan>;

[kinuko, 2015/11/19 07:00:29]

I think we could use ScopedPtrMap here

[Adam Rice, 2015/11/19 21:13:52]

It's deprecated. But I can use scoped_ptr<AsyncRevalidationDriver> instead.

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