network service: Create URLLoader for service worker navigation case

content/browser/service_worker/service_worker_controllee_url_loader_factory.h

+// Copyright 2017 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_SERVICE_WORKER_SERVICE_WORKER_CONTROLLEE_URL_LOADER_FACTORY_H_
+#define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTROLLEE_URL_LOADER_FACTORY_H_
+
+#include "content/browser/service_worker/service_worker_fetch_dispatcher.h"
+#include "content/browser/service_worker/service_worker_url_loader_factory.h"
+#include "content/browser/service_worker/service_worker_version.h"
+#include "content/common/service_worker/service_worker_types.h"
+#include "storage/browser/blob/blob_reader.h"
+
+namespace content {
+
+// TODO(scottmg): Bind the other end of this to the acive SWVersion when it's
+// created in ServiceWorkerControlleeRequestHandler. Currently, this is a simple
+// passthrough to the network service.
+class ServiceWorkerControlleeURLLoaderFactory
+    : public ServiceWorkerURLLoaderFactory {
+ public:
+  class CONTENT_EXPORT Delegate {
+   public:
+    virtual ~Delegate() {}
+
+    virtual ServiceWorkerVersion* GetServiceWorkerVersion(
+        ServiceWorkerMetrics::URLRequestJobResult* result) = 0;
+  };
+
+  ServiceWorkerControlleeURLLoaderFactory(
+      std::unique_ptr<ServiceWorkerRequestHandler> handler,
+      const std::string& client_id,
+      base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
+      const ResourceContext* resource_context,
+      FetchRequestMode request_mode,
+      FetchCredentialsMode credentials_mode,
+      FetchRedirectMode redirect_mode,
+      ResourceType resource_type,
+      RequestContextType request_context_type,
+      RequestContextFrameType frame_type,
+      scoped_refptr<ResourceRequestBodyImpl> body,
+      ServiceWorkerFetchType fetch_type,
+      const base::Optional<base::TimeDelta>& timeout,
+      Delegate* delegate)
+      : ServiceWorkerURLLoaderFactory(std::move(handler)),
+        response_type_(ResponseType::kNotDetermined),
+        client_id_(client_id),
+        blob_storage_context_(blob_storage_context),
+        resource_context_(resource_context),
+        request_mode_(request_mode),
+        credentials_mode_(credentials_mode),
+        redirect_mode_(redirect_mode),
+        resource_type_(resource_type),
+        request_context_type_(request_context_type),
+        frame_type_(frame_type),
+        body_(body),
+        fetch_type_(fetch_type),
+        timeout_(timeout),
+        delegate_(delegate),
+        weak_factory_(this) {}
+  ~ServiceWorkerControlleeURLLoaderFactory() override;
+
+  void CreateLoaderAndStart(mojom::URLLoaderAssociatedRequest request,
+                            int32_t routing_id,
+                            int32_t request_id,
+                            uint32_t options,
+                            const ResourceRequest& url_request,
+                            mojom::URLLoaderClientPtr client) override;
+  void SyncLoad(int32_t routing_id,
+                int32_t request_id,
+                const ResourceRequest& request,
+                SyncLoadCallback callback) override;
+
+  void FallbackToNetwork();
+  bool ShouldFallbackToNetwork();
+  ui::PageTransition GetPageTransition();
+  size_t GetURLChainSize();
+  void ForwardToServiceWorker();
+  void FallbackToNetworkOrRenderer();
+  void FailToNetworkOrRenderer();
+  void FailDueToLostController();
+  bool WasCanceled() const;
+
+ private:
+  std::unique_ptr<ServiceWorkerFetchRequest> CreateFetchRequest();
+  void StartRequest();
+
+  // For kForwardToServiceWorker case.
+  void DidPrepareFetchEvent(scoped_refptr<ServiceWorkerVersion> version);
+  void DidDispatchFetchEvent(
+      ServiceWorkerStatusCode status,
+      ServiceWorkerFetchEventResult fetch_result,
+      const ServiceWorkerResponse& response,
+      blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream,
+      const scoped_refptr<ServiceWorkerVersion>& version);
+  void AfterRead(scoped_refptr<net::IOBuffer> buffer, int bytes);
+
+  enum class ResponseType {
+    kNotDetermined,
+    kFailDueToLostController,
+    kFallbackToNetwork,
+    kFallbackToRenderer,  // Use this when falling back with CORS check
+    kForwardToServiceWorker,
+  };
+  ResponseType response_type_;
+
+  mojom::URLLoaderAssociatedRequest request_;
+  ResourceRequest url_request_;
+  mojom::URLLoaderClientPtr client_;
+
+  std::unique_ptr<ServiceWorkerFetchDispatcher> fetch_dispatcher_;
+  std::string client_id_;
+  base::WeakPtr<storage::BlobStorageContext> blob_storage_context_;
+  const ResourceContext* resource_context_;
+  FetchRequestMode request_mode_;
+  FetchCredentialsMode credentials_mode_;
+  FetchRedirectMode redirect_mode_;
+  const ResourceType resource_type_;
+  RequestContextType request_context_type_;
+  RequestContextFrameType frame_type_;
+  scoped_refptr<ResourceRequestBodyImpl> body_;
+  ServiceWorkerFetchType fetch_type_;
+  base::Optional<base::TimeDelta> timeout_;
+  Delegate* delegate_;
+  std::unique_ptr<storage::BlobReader> blob_reader_;
+  mojo::DataPipe data_pipe_;
+
+  base::WeakPtrFactory<ServiceWorkerControlleeURLLoaderFactory> weak_factory_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTROLLEE_URL_LOADER_FACTORY_H_