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/base/net_errors.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 {

[mmenke, 2016/10/14 16:31:33]

While this class is really simple (Which is good), the ResourceHandler API is
pretty horrible, and I'd rather not make another one unless we really need to. 
I don't think we have any ResourceHandlers that exist only for logging purposes.

Is this just to tag the request with SERVICE_WORKER_NAVIGATION_PRELOAD for
tracing?  If the purpose is just net-internals, I'd suggest adding a singleton
event, with not end event.

[horo, 2016/10/15 00:55:46]

Done.

+ public:
+  PreloadResourceHandler(net::URLRequest* request,
+                         std::unique_ptr<ResourceHandler> next_handler)
+      : LayeredResourceHandler(request, std::move(next_handler)) {
+    request->net_log().BeginEvent(
+        net::NetLogEventType::SERVICE_WORKER_NAVIGATION_PRELOAD,
+        base::Bind(&NetLogCallbackForURL, &request->url()));
+  }
+
+  ~PreloadResourceHandler() override {
+    request()->net_log().EndEventWithNetErrorCode(
+        net::NetLogEventType::SERVICE_WORKER_NAVIGATION_PRELOAD, net_error_);
+  }
+
+  bool OnRequestRedirected(const net::RedirectInfo& redirect_info,
+                           ResourceResponse* response,
+                           bool* defer) override {
+    // NavigationPreload doesn't support redirect.
+    return false;
+  }
+
+  void OnResponseCompleted(const net::URLRequestStatus& status,
+                           bool* defer) override {
+    net_error_ = status.error();
+    LayeredResourceHandler::OnResponseCompleted(status, defer);
+  }
+
+ private:
+  int net_error_ = net::Error::ERR_ABORTED;
+};
+
+}  // 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));
+  // TODO(horo): Set "Service-Worker-Navigation-Preload" header.
+  // See: https://github.com/w3c/ServiceWorker/issues/920#issuecomment-251150270
+  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);

[mmenke, 2016/10/14 16:31:33]

What's going on here?  What class is driving the url_loader_client, any why
can't it use the main mojo URLRequest factory thing?

[horo, 2016/10/15 00:55:46]

This preload_handle will be passed to the service worker in the renderer
process.
https://codereview.chromium.org/2416843002/ implements the renderer process side
logic.

NavigationRequests are initiated by the browser process, not the renderer
process.
It must be started even if the service worker is not started yet.

So the browser process starts the request here.
The browser process creates URLLoaderClientRequest here and pass it to the
service worker in the renderer process after starting the service worker.
https://codereview.chromium.org/2417793002/diff/60001/content/browser/service...

When the service worker receives the URLLoaderClientRequest, it creates the
URLLoaderClient which will drive the request.
https://codereview.chromium.org/2416843002/diff/110001/content/renderer/servi...

+
+  std::unique_ptr<ResourceHandler> handler(new MojoAsyncResourceHandler(

[mmenke, 2016/10/14 16:31:33]

MojoAsyncResourceHandler isn't ready for prime time yet - it doesn't support
redirects, among many other things.  Not handling meaning it DCHECKs.  I'm also
not really sure we should be creating them outside RDH.

[horo, 2016/10/15 00:55:46]

NavigationPreload is still an experimental feature.
And we don't need to support redirects.

I think there is no problem to use MojoAsyncResourceHandler for
NavigationPreloads.

yhirano@
What do you think as the author of 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