Implement dumb URLLoader{Factory} for ServiceWorker script loading (for try)

content/browser/service_worker/service_worker_context_core.h

 // Copyright 2013 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_CONTEXT_CORE_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_CORE_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 17 matching lines @@
 #include "content/public/browser/service_worker_context.h"
 
 class GURL;
 
 namespace base {
 class FilePath;
 class SingleThreadTaskRunner;
 }
 
 namespace storage {
+class BlobStorageContext;
 class QuotaManagerProxy;
 class SpecialStoragePolicy;
 }
 
 namespace content {
 
 class EmbeddedWorkerRegistry;
 class ServiceWorkerContextCoreObserver;
 class ServiceWorkerContextWrapper;
 class ServiceWorkerDatabaseTaskManager;
 class ServiceWorkerDispatcherHost;
 class ServiceWorkerJobCoordinator;
 class ServiceWorkerNavigationHandleCore;
 class ServiceWorkerProviderHost;
 class ServiceWorkerRegistration;
 class ServiceWorkerStorage;
+class URLLoaderFactoryGetter;
 
 // This class manages data associated with service workers.
 // The class is single threaded and should only be used on the IO thread.
 // In chromium, there is one instance per storagepartition. This class
 // is the root of the containment hierarchy for service worker data
 // associated with a particular partition.
 class CONTENT_EXPORT ServiceWorkerContextCore
     : NON_EXPORTED_BASE(public ServiceWorkerVersion::Listener) {
  public:
   using BoolCallback = base::Callback<void(bool)>;
@@ skipping 40 matching lines @@
 
     DISALLOW_COPY_AND_ASSIGN(ProviderHostIterator);
   };
 
   // This is owned by the StoragePartition, which will supply it with
   // the local path on disk. Given an empty |user_data_directory|,
   // nothing will be stored on disk. |observer_list| is created in
   // ServiceWorkerContextWrapper. When Notify() of |observer_list| is called in
   // ServiceWorkerContextCore, the methods of ServiceWorkerContextCoreObserver
   // will be called on the thread which called AddObserver() of |observer_list|.
+  // |blob_context| and |url_loader_factory_getter| are used only
+  // when IsServicificationEnabled is true.
   ServiceWorkerContextCore(
       const base::FilePath& user_data_directory,
       std::unique_ptr<ServiceWorkerDatabaseTaskManager>
           database_task_runner_manager,
       const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread,
       storage::QuotaManagerProxy* quota_manager_proxy,
       storage::SpecialStoragePolicy* special_storage_policy,
+      base::WeakPtr<storage::BlobStorageContext> blob_context,
+      URLLoaderFactoryGetter* url_loader_factory_getter,
       base::ObserverListThreadSafe<ServiceWorkerContextCoreObserver>*
           observer_list,
       ServiceWorkerContextWrapper* wrapper);
   ServiceWorkerContextCore(
       ServiceWorkerContextCore* old_context,
       ServiceWorkerContextWrapper* wrapper);
   ~ServiceWorkerContextCore() override;
 
   void OnStorageWiped();
 
@@ skipping 169 matching lines @@
   int GetVersionFailureCount(int64_t version_id);
 
   // Binds the ServiceWorkerWorkerClient of a dedicated (or shared) worker to
   // the parent frame's ServiceWorkerProviderHost. (This is used only when
   // off-main-thread-fetch is enabled.)
   void BindWorkerFetchContext(
       int render_process_id,
       int service_worker_provider_id,
       mojom::ServiceWorkerWorkerClientAssociatedPtrInfo client_ptr_info);
 
+  base::WeakPtr<storage::BlobStorageContext> blob_storage_context() {
+    return blob_storage_context_;
+  }
+
+  URLLoaderFactoryGetter* loader_factory_getter() {
+    return loader_factory_getter_.get();
+  }
+
   base::WeakPtr<ServiceWorkerContextCore> AsWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
 
  private:
   friend class ServiceWorkerContextCoreTest;
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerContextCoreTest, FailureInfo);
 
   typedef std::map<int64_t, ServiceWorkerRegistration*> RegistrationsMap;
   typedef std::map<int64_t, ServiceWorkerVersion*> VersionMap;
@@ skipping 53 matching lines @@
   std::map<int64_t, ServiceWorkerVersion*> live_versions_;
   std::map<int64_t, scoped_refptr<ServiceWorkerVersion>> protected_versions_;
 
   std::map<int64_t /* version_id */, FailureInfo> failure_counts_;
 
   // PlzNavigate
   // Map of ServiceWorkerNavigationHandleCores used for navigation requests.
   std::map<int, ServiceWorkerNavigationHandleCore*>
       navigation_handle_cores_map_;
 
+  // IsServicificationEnabled
+  base::WeakPtr<storage::BlobStorageContext> blob_storage_context_;
+  scoped_refptr<URLLoaderFactoryGetter> loader_factory_getter_;
+
   bool force_update_on_page_load_;
   int next_handle_id_;
   int next_registration_handle_id_;
   // Set in RegisterServiceWorker(), cleared in ClearAllServiceWorkersForTest().
   // This is used to avoid unnecessary disk read operation in tests. This value
   // is false if Chrome was relaunched after service workers were registered.
   bool was_service_worker_registered_;
   scoped_refptr<base::ObserverListThreadSafe<ServiceWorkerContextCoreObserver>>
       observer_list_;
   base::WeakPtrFactory<ServiceWorkerContextCore> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerContextCore);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_CORE_H_