Home | History | Annotate | Download | only in service_worker 
      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
     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