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_CHILD_SERVICE_WORKER_SERVICE_WORKER_DISPATCHER_H_
      6 #define CONTENT_CHILD_SERVICE_WORKER_SERVICE_WORKER_DISPATCHER_H_
      7 
      8 #include <map>
      9 #include <vector>
     10 
     11 #include "base/id_map.h"
     12 #include "base/memory/ref_counted.h"
     13 #include "base/strings/string16.h"
     14 #include "content/child/worker_task_runner.h"
     15 #include "third_party/WebKit/public/platform/WebServiceWorkerError.h"
     16 #include "third_party/WebKit/public/platform/WebServiceWorkerProvider.h"
     17 #include "third_party/WebKit/public/platform/WebServiceWorkerState.h"
     18 
     19 class GURL;
     20 
     21 namespace blink {
     22 class WebURL;
     23 }
     24 
     25 namespace IPC {
     26 class Message;
     27 }
     28 
     29 namespace content {
     30 
     31 class ServiceWorkerMessageFilter;
     32 class ServiceWorkerProviderContext;
     33 class ThreadSafeSender;
     34 class WebServiceWorkerImpl;
     35 class WebServiceWorkerRegistrationImpl;
     36 struct ServiceWorkerObjectInfo;
     37 struct ServiceWorkerRegistrationObjectInfo;
     38 struct ServiceWorkerVersionAttributes;
     39 
     40 // This class manages communication with the browser process about
     41 // registration of the service worker, exposed to renderer and worker
     42 // scripts through methods like navigator.registerServiceWorker().
     43 class ServiceWorkerDispatcher : public WorkerTaskRunner::Observer {
     44  public:
     45   typedef blink::WebServiceWorkerProvider::WebServiceWorkerRegistrationCallbacks
     46       WebServiceWorkerRegistrationCallbacks;
     47   typedef
     48       blink::WebServiceWorkerProvider::WebServiceWorkerUnregistrationCallbacks
     49       WebServiceWorkerUnregistrationCallbacks;
     50   typedef
     51       blink::WebServiceWorkerProvider::WebServiceWorkerGetRegistrationCallbacks
     52       WebServiceWorkerGetRegistrationCallbacks;
     53 
     54   explicit ServiceWorkerDispatcher(ThreadSafeSender* thread_safe_sender);
     55   virtual ~ServiceWorkerDispatcher();
     56 
     57   void OnMessageReceived(const IPC::Message& msg);
     58   bool Send(IPC::Message* msg);
     59 
     60   // Corresponds to navigator.serviceWorker.register()
     61   void RegisterServiceWorker(
     62       int provider_id,
     63       const GURL& pattern,
     64       const GURL& script_url,
     65       WebServiceWorkerRegistrationCallbacks* callbacks);
     66   // Corresponds to navigator.serviceWorker.unregister()
     67   void UnregisterServiceWorker(
     68       int provider_id,
     69       const GURL& pattern,
     70       WebServiceWorkerUnregistrationCallbacks* callbacks);
     71   // Corresponds to navigator.serviceWorker.getRegistration()
     72   void GetRegistration(
     73       int provider_id,
     74       const GURL& document_url,
     75       WebServiceWorkerRegistrationCallbacks* callbacks);
     76 
     77   // Called when a new provider context for a document is created. Usually
     78   // this happens when a new document is being loaded, and is called much
     79   // earlier than AddScriptClient.
     80   // (This is attached only to the document thread's ServiceWorkerDispatcher)
     81   void AddProviderContext(ServiceWorkerProviderContext* provider_context);
     82   void RemoveProviderContext(ServiceWorkerProviderContext* provider_context);
     83 
     84   // Called when navigator.serviceWorker is instantiated or detached
     85   // for a document whose provider can be identified by |provider_id|.
     86   void AddScriptClient(int provider_id,
     87                        blink::WebServiceWorkerProviderClient* client);
     88   void RemoveScriptClient(int provider_id);
     89 
     90   // If an existing WebServiceWorkerImpl exists for the Service
     91   // Worker, it is returned; otherwise a WebServiceWorkerImpl is
     92   // created and its ownership is transferred to the caller. If
     93   // |adopt_handle| is true, a ServiceWorkerHandleReference will be
     94   // adopted for the specified Service Worker.
     95   //
     96   // TODO(dominicc): The lifetime of WebServiceWorkerImpl is too tricky; this
     97   // method can return an existing WebServiceWorkerImpl, in which case
     98   // it is owned by a WebCore::ServiceWorker and the lifetime is not
     99   // being transferred to the owner; or it can create a
    100   // WebServiceWorkerImpl, in which case ownership is transferred to
    101   // the caller who must bounce it to a method that will associate it
    102   // with a WebCore::ServiceWorker.
    103   WebServiceWorkerImpl* GetServiceWorker(
    104       const ServiceWorkerObjectInfo& info,
    105       bool adopt_handle);
    106 
    107   // Finds a WebServiceWorkerRegistrationImpl for the specified registration.
    108   // If it's not found, returns NULL. If |adopt_handle| is true,
    109   // a ServiceWorkerRegistrationHandleReference will be adopted for the
    110   // registration.
    111   WebServiceWorkerRegistrationImpl* FindServiceWorkerRegistration(
    112       const ServiceWorkerRegistrationObjectInfo& info,
    113       bool adopt_handle);
    114 
    115   // Creates a WebServiceWorkerRegistrationImpl for the specified registration
    116   // and transfers its ownership to the caller. If |adopt_handle| is true, a
    117   // ServiceWorkerRegistrationHandleReference will be adopted for the
    118   // registration.
    119   WebServiceWorkerRegistrationImpl* CreateServiceWorkerRegistration(
    120       const ServiceWorkerRegistrationObjectInfo& info,
    121       bool adopt_handle);
    122 
    123   // |thread_safe_sender| needs to be passed in because if the call leads to
    124   // construction it will be needed.
    125   static ServiceWorkerDispatcher* GetOrCreateThreadSpecificInstance(
    126       ThreadSafeSender* thread_safe_sender);
    127 
    128   // Unlike GetOrCreateThreadSpecificInstance() this doesn't create a new
    129   // instance if thread-local instance doesn't exist.
    130   static ServiceWorkerDispatcher* GetThreadSpecificInstance();
    131 
    132  private:
    133   typedef IDMap<WebServiceWorkerRegistrationCallbacks,
    134       IDMapOwnPointer> RegistrationCallbackMap;
    135   typedef IDMap<WebServiceWorkerUnregistrationCallbacks,
    136       IDMapOwnPointer> UnregistrationCallbackMap;
    137   typedef IDMap<WebServiceWorkerGetRegistrationCallbacks,
    138       IDMapOwnPointer> GetRegistrationCallbackMap;
    139   typedef std::map<int, blink::WebServiceWorkerProviderClient*> ScriptClientMap;
    140   typedef std::map<int, ServiceWorkerProviderContext*> ProviderContextMap;
    141   typedef std::map<int, WebServiceWorkerImpl*> WorkerObjectMap;
    142   typedef std::map<int, ServiceWorkerProviderContext*> WorkerToProviderMap;
    143   typedef std::map<int, WebServiceWorkerRegistrationImpl*>
    144       RegistrationObjectMap;
    145 
    146   friend class WebServiceWorkerImpl;
    147   friend class WebServiceWorkerRegistrationImpl;
    148 
    149   // WorkerTaskRunner::Observer implementation.
    150   virtual void OnWorkerRunLoopStopped() OVERRIDE;
    151 
    152   void OnAssociateRegistration(int thread_id,
    153                                int provider_id,
    154                                const ServiceWorkerRegistrationObjectInfo& info,
    155                                const ServiceWorkerVersionAttributes& attrs);
    156   void OnDisassociateRegistration(int thread_id,
    157                                   int provider_id);
    158   void OnRegistered(int thread_id,
    159                     int request_id,
    160                     const ServiceWorkerRegistrationObjectInfo& info,
    161                     const ServiceWorkerVersionAttributes& attrs);
    162   void OnUnregistered(int thread_id,
    163                       int request_id,
    164                       bool is_success);
    165   void OnDidGetRegistration(int thread_id,
    166                             int request_id,
    167                             const ServiceWorkerRegistrationObjectInfo& info,
    168                             const ServiceWorkerVersionAttributes& attrs);
    169   void OnRegistrationError(int thread_id,
    170                            int request_id,
    171                            blink::WebServiceWorkerError::ErrorType error_type,
    172                            const base::string16& message);
    173   void OnUnregistrationError(int thread_id,
    174                              int request_id,
    175                              blink::WebServiceWorkerError::ErrorType error_type,
    176                              const base::string16& message);
    177   void OnGetRegistrationError(
    178       int thread_id,
    179       int request_id,
    180       blink::WebServiceWorkerError::ErrorType error_type,
    181       const base::string16& message);
    182   void OnServiceWorkerStateChanged(int thread_id,
    183                                    int handle_id,
    184                                    blink::WebServiceWorkerState state);
    185   void OnSetVersionAttributes(int thread_id,
    186                               int provider_id,
    187                               int registration_handle_id,
    188                               int changed_mask,
    189                               const ServiceWorkerVersionAttributes& attributes);
    190   void OnUpdateFound(int thread_id,
    191                      const ServiceWorkerRegistrationObjectInfo& info);
    192   void OnSetControllerServiceWorker(int thread_id,
    193                                     int provider_id,
    194                                     const ServiceWorkerObjectInfo& info);
    195   void OnPostMessage(int thread_id,
    196                      int provider_id,
    197                      const base::string16& message,
    198                      const std::vector<int>& sent_message_port_ids,
    199                      const std::vector<int>& new_routing_ids);
    200 
    201   void SetInstallingServiceWorker(
    202       int provider_id,
    203       int registration_handle_id,
    204       const ServiceWorkerObjectInfo& info);
    205   void SetWaitingServiceWorker(
    206       int provider_id,
    207       int registration_handle_id,
    208       const ServiceWorkerObjectInfo& info);
    209   void SetActiveServiceWorker(
    210       int provider_id,
    211       int registration_handle_id,
    212       const ServiceWorkerObjectInfo& info);
    213   void SetReadyRegistration(
    214       int provider_id,
    215       int registration_handle_id);
    216 
    217   // Keeps map from handle_id to ServiceWorker object.
    218   void AddServiceWorker(int handle_id, WebServiceWorkerImpl* worker);
    219   void RemoveServiceWorker(int handle_id);
    220 
    221   // Keeps map from registration_handle_id to ServiceWorkerRegistration object.
    222   void AddServiceWorkerRegistration(
    223       int registration_handle_id,
    224       WebServiceWorkerRegistrationImpl* registration);
    225   void RemoveServiceWorkerRegistration(
    226       int registration_handle_id);
    227 
    228   WebServiceWorkerRegistrationImpl* FindOrCreateRegistration(
    229       const ServiceWorkerRegistrationObjectInfo& info,
    230       const ServiceWorkerVersionAttributes& attrs);
    231 
    232   RegistrationCallbackMap pending_registration_callbacks_;
    233   UnregistrationCallbackMap pending_unregistration_callbacks_;
    234   GetRegistrationCallbackMap pending_get_registration_callbacks_;
    235   ScriptClientMap script_clients_;
    236   ProviderContextMap provider_contexts_;
    237   WorkerObjectMap service_workers_;
    238   RegistrationObjectMap registrations_;
    239 
    240   // A map for ServiceWorkers that are associated to a particular document
    241   // (e.g. as .current).
    242   WorkerToProviderMap worker_to_provider_;
    243 
    244   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
    245 
    246   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerDispatcher);
    247 };
    248 
    249 }  // namespace content
    250 
    251 #endif  // CONTENT_CHILD_SERVICE_WORKER_SERVICE_WORKER_DISPATCHER_H_
    252