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
17namespace base {
18class FilePath;
19class SequencedTaskRunner;
20class SingleThreadTaskRunner;
21}
22
23namespace net {
24class URLRequestContextGetter;
25}
26
27namespace storage {
28class QuotaManagerProxy;
29}
30
31namespace content {
32
33class BrowserContext;
34class ChromeBlobStorageContext;
35class ServiceWorkerContextCore;
36class 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.
42class 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