1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_WRAPPER_H_ 6 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_WRAPPER_H_ 7 8 #include <vector> 9 10 #include "base/files/file_path.h" 11 #include "base/memory/ref_counted.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "content/browser/service_worker/service_worker_context_core.h" 14 #include "content/common/content_export.h" 15 #include "content/public/browser/service_worker_context.h" 16 17 namespace base { 18 class FilePath; 19 class SequencedTaskRunner; 20 class SingleThreadTaskRunner; 21 } 22 23 namespace net { 24 class URLRequestContextGetter; 25 } 26 27 namespace storage { 28 class QuotaManagerProxy; 29 } 30 31 namespace content { 32 33 class BrowserContext; 34 class ChromeBlobStorageContext; 35 class ServiceWorkerContextCore; 36 class ServiceWorkerContextObserver; 37 38 // A refcounted wrapper class for our core object. Higher level content lib 39 // classes keep references to this class on mutliple threads. The inner core 40 // instance is strictly single threaded and is not refcounted, the core object 41 // is what is used internally in the service worker lib. 42 class CONTENT_EXPORT ServiceWorkerContextWrapper NON_EXPORTED_BASE(public ServiceWorkerContext)43 : NON_EXPORTED_BASE(public ServiceWorkerContext), 44 public base::RefCountedThreadSafe<ServiceWorkerContextWrapper> { 45 public: 46 ServiceWorkerContextWrapper(BrowserContext* browser_context); 47 48 // Init and Shutdown are for use on the UI thread when the profile, 49 // storagepartition is being setup and torn down. 50 void Init(const base::FilePath& user_data_directory, 51 storage::QuotaManagerProxy* quota_manager_proxy); 52 void Shutdown(); 53 54 // Deletes all files on disk and restarts the system asynchronously. This 55 // leaves the system in a disabled state until it's done. This should be 56 // called on the IO thread. 57 void DeleteAndStartOver(); 58 59 // The core context is only for use on the IO thread. 60 ServiceWorkerContextCore* context(); 61 62 // The process manager can be used on either UI or IO. 63 ServiceWorkerProcessManager* process_manager() { 64 return process_manager_.get(); 65 } 66 67 // ServiceWorkerContext implementation: 68 virtual void RegisterServiceWorker( 69 const GURL& pattern, 70 const GURL& script_url, 71 const ResultCallback& continuation) OVERRIDE; 72 virtual void UnregisterServiceWorker(const GURL& pattern, 73 const ResultCallback& continuation) 74 OVERRIDE; 75 virtual void Terminate() OVERRIDE; 76 virtual void GetAllOriginsInfo(const GetUsageInfoCallback& callback) OVERRIDE; 77 virtual void DeleteForOrigin(const GURL& origin_url) OVERRIDE; 78 79 void AddObserver(ServiceWorkerContextObserver* observer); 80 void RemoveObserver(ServiceWorkerContextObserver* observer); 81 82 bool is_incognito() const { return is_incognito_; } 83 84 // The URLRequestContext doesn't exist until after the StoragePartition is 85 // made (which is after this object is made). This function must be called 86 // after this object is created but before any ServiceWorkerCache operations. 87 // It must be called on the IO thread. If either parameter is NULL the 88 // function immediately returns without forwarding to the 89 // ServiceWorkerCacheStorageManager. 90 void SetBlobParametersForCache( 91 net::URLRequestContextGetter* request_context, 92 ChromeBlobStorageContext* blob_storage_context); 93 94 private: 95 friend class base::RefCountedThreadSafe<ServiceWorkerContextWrapper>; 96 friend class EmbeddedWorkerTestHelper; 97 friend class ServiceWorkerProcessManager; 98 virtual ~ServiceWorkerContextWrapper(); 99 100 void InitInternal( 101 const base::FilePath& user_data_directory, 102 const scoped_refptr<base::SequencedTaskRunner>& stores_task_runner, 103 const scoped_refptr<base::SequencedTaskRunner>& database_task_runner, 104 const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread, 105 storage::QuotaManagerProxy* quota_manager_proxy); 106 void ShutdownOnIO(); 107 108 void DidDeleteAndStartOver(ServiceWorkerStatusCode status); 109 110 void DidGetAllRegistrationsForGetAllOrigins( 111 const GetUsageInfoCallback& callback, 112 const std::vector<ServiceWorkerRegistrationInfo>& registrations); 113 void DidGetAllRegistrationsForDeleteForOrigin( 114 const GURL& origin, 115 const std::vector<ServiceWorkerRegistrationInfo>& registrations); 116 117 const scoped_refptr<ObserverListThreadSafe<ServiceWorkerContextObserver> > 118 observer_list_; 119 const scoped_ptr<ServiceWorkerProcessManager> process_manager_; 120 // Cleared in Shutdown(): 121 scoped_ptr<ServiceWorkerContextCore> context_core_; 122 123 // Initialized in Init(); true of the user data directory is empty. 124 bool is_incognito_; 125 }; 126 127 } // namespace content 128 129 #endif // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CONTEXT_WRAPPER_H_ 130