Server push cancellation: add a new class HttpCacheLookupManager which implements ServerPushDelegate

net/http/http_cache_lookup_manager.cc

+// Copyright 2016 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.
+
+#include "net/http/http_cache_lookup_manager.h"
+
+#include "net/base/load_flags.h"
+
+namespace net {
+
+HttpCacheLookupManager::LookupTransaction::LookupTransaction(
+    std::unique_ptr<ServerPushHelper> server_push_helper)
+    : push_helper(std::move(server_push_helper)),
+      request(new HttpRequestInfo()),
+      transaction(nullptr) {}
+
+HttpCacheLookupManager::LookupTransaction::~LookupTransaction() {}
+
+int HttpCacheLookupManager::LookupTransaction::StartLookup(
+    HttpCache* cache,
+    const CompletionCallback& callback,
+    const NetLogWithSource& net_log) {
+  request->url = push_helper->GetURL();
+  request->method = "GET";
+  request->load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;

[jkarlin, 2016/11/21 14:40:41]

So, if the resource is in the cache (valid or not) then you want to cancel the
push? If so, these are the right flags.

Why is it you want to cancel the push if the resource is stale in the cache?
Because it's better to do a validation request than push all of the bytes?

[Zhongyi Shi, 2016/11/22 00:09:29]

Yup, we want to cancel the server push if the url is found in cached. 
For the time being, the cancel rule is aggressive: just url matching. Server
push is not used
widely. To move forward, we want to use this rule first, and it turns out that
we cancel too aggressive,
we will then move forward with extra validation to cancel less often. We have
the design doc here: http://goo.gl/OgWqwO

+  cache->CreateTransaction(DEFAULT_PRIORITY, &transaction);
+  return transaction->Start(request.get(), callback, net_log);
+}
+
+void HttpCacheLookupManager::LookupTransaction::CancelPush() {
+  DCHECK(push_helper.get());
+  push_helper->Cancel();
+}
+
+HttpCacheLookupManager::HttpCacheLookupManager(HttpCache* http_cache,
+                                               const NetLogWithSource& net_log)
+    : net_log_(net_log), http_cache_(http_cache), weak_factory_(this) {}
+
+HttpCacheLookupManager::~HttpCacheLookupManager() {}
+
+void HttpCacheLookupManager::OnPush(
+    std::unique_ptr<ServerPushHelper> push_helper) {
+  GURL pushed_url = push_helper->GetURL();
+
+  // There's a pending lookup transaction sent over already.
+  if (base::ContainsKey(lookup_transactions_, pushed_url))
+    return;
+
+  auto lookup = base::MakeUnique<LookupTransaction>(std::move(push_helper));
+
+  int rv = lookup->StartLookup(
+      http_cache_, base::Bind(&HttpCacheLookupManager::OnLookupComplete,
+                              weak_factory_.GetWeakPtr(), pushed_url),
+      net_log_);
+
+  if (rv == ERR_IO_PENDING)
+    lookup_transactions_[pushed_url] = std::move(lookup);
+}
+
+void HttpCacheLookupManager::OnLookupComplete(const GURL& url, int rv) {
+  auto it = lookup_transactions_.find(url);
+  DCHECK(it != lookup_transactions_.end());
+
+  if (rv == OK)
+    it->second->CancelPush();
+
+  lookup_transactions_.erase(it);
+}
+
+}  // namespace net