Implement ServiceWorkerFetchDispatcher::MaybeStartNavigationPreload().

content/browser/service_worker/service_worker_navigation_preload_fetcher.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 "content/browser/service_worker/service_worker_navigation_preload_fetcher.h"
+
+#include "base/callback.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/time/time.h"
+#include "base/values.h"
+#include "content/browser/loader/layered_resource_handler.h"
+#include "content/browser/loader/mojo_async_resource_handler.h"
+#include "content/browser/loader/resource_dispatcher_host_impl.h"
+#include "content/browser/loader/resource_handler.h"
+#include "content/browser/loader/resource_loader.h"
+#include "content/browser/loader/resource_request_info_impl.h"
+#include "content/common/url_loader.mojom.h"
+#include "content/public/common/resource_response.h"
+#include "net/log/net_log_event_type.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"
+
+namespace content {
+namespace {
+
+std::unique_ptr<base::Value> NetLogCallbackForURL(
+    const GURL* url,
+    net::NetLogCaptureMode /* capture_mode */) {
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  dict->SetString("url", url->possibly_invalid_spec());
+  return std::move(dict);
+}
+
+class PreloadResourceHandler : public LayeredResourceHandler {
+ public:
+  PreloadResourceHandler(net::URLRequest* request,
+                         std::unique_ptr<ResourceHandler> next_handler)
+      : LayeredResourceHandler(request, std::move(next_handler)) {}
+  ~PreloadResourceHandler() override {}
+
+  bool OnRequestRedirected(const net::RedirectInfo& redirect_info,
+                           ResourceResponse* response,
+                           bool* defer) override {
+    return false;
+  }
+  bool OnWillStart(const GURL& url, bool* defer) override {
+    request()->net_log().BeginEvent(
+        net::NetLogEventType::SERVICE_WORKER_NAVIGATION_PRELOAD,
+        base::Bind(&NetLogCallbackForURL, &url));
+    return LayeredResourceHandler::OnWillStart(url, defer);
+  }
+  void OnResponseCompleted(const net::URLRequestStatus& status,
+                           bool* defer) override {
+    request()->net_log().EndEvent(
+        net::NetLogEventType::SERVICE_WORKER_NAVIGATION_PRELOAD);

[falken, 2016/10/14 07:53:12]

Could be useful to log status.

[horo, 2016/10/14 16:09:05]

Done.

+    LayeredResourceHandler::OnResponseCompleted(status, defer);

[falken, 2016/10/14 07:53:12]

Is OnResponseCompleted definitely called for every OnWillStart? Might it make
sense to put the Begin/End in the ctor and dtor?

[horo, 2016/10/14 16:09:05]

Done.
Sounds good.
OnWillStart() is not called if the request is cancelled.

+  }
+};
+
+}  // namespace
+
+// static
+mojom::FetchEventPreloadHandlePtr ServiceWorkerNavigationPreloadFetcher::Start(
+    net::URLRequest* original_request) {
+  mojom::FetchEventPreloadHandlePtr preload_handle(
+      mojom::FetchEventPreloadHandle::New());
+  const ResourceRequestInfoImpl* original_info =
+      ResourceRequestInfoImpl::ForRequest(original_request);
+  ResourceContext* resource_context = original_info->GetContext();
+  std::unique_ptr<net::URLRequest> url_request(
+      original_request->context()->CreateRequest(
+          original_request->url(), original_request->priority(), nullptr));
+  ResourceDispatcherHostImpl::Get()->InitializeURLRequest(
+      url_request.get(), Referrer(GURL(original_request->referrer()),
+                                  original_info->GetReferrerPolicy()),
+      false /* download */, original_info->GetChildID(),
+      original_info->GetRouteID(), original_info->GetRenderFrameID(),
+      resource_context);
+
+  mojom::URLLoaderClientPtr url_loader_client;
+  preload_handle->url_loader_client_request = GetProxy(&url_loader_client);
+
+  std::unique_ptr<ResourceHandler> handler(new MojoAsyncResourceHandler(
+      url_request.get(), ResourceDispatcherHostImpl::Get(),
+      GetProxy(&preload_handle->url_loader), std::move(url_loader_client)));
+  handler.reset(
+      new PreloadResourceHandler(url_request.get(), std::move(handler)));
+
+  ResourceDispatcherHostImpl::Get()->BeginURLRequest(
+      std::move(url_request), std::move(handler), false /* download */,
+      false /* is_content_initiated */, true /* do_not_prompt_for_login */,
+      resource_context);
+  return preload_handle;
+}
+
+}  // namespace content