content/browser/shared_worker/shared_worker_service_impl.h

   1 // Copyright 2014 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_SHARED_WORKER_SHARED_WORKER_SERVICE_IMPL_H_
   6 #define CONTENT_BROWSER_SHARED_WORKER_SHARED_WORKER_SERVICE_IMPL_H_
   7
   8 #include <set>
   9
  10 #include "base/compiler_specific.h"
  11 #include "base/containers/scoped_ptr_hash_map.h"
  12 #include "base/memory/singleton.h"
  13 #include "base/observer_list.h"
  14 #include "content/public/browser/notification_observer.h"
  15 #include "content/public/browser/notification_registrar.h"
  16 #include "content/public/browser/worker_service.h"
  17
  18 struct ViewHostMsg_CreateWorker_Params;
  19
  20 namespace IPC {
  21 class Message;
  22 }
  23
  24 namespace content {
  25
  26 class SharedWorkerInstance;
  27 class SharedWorkerHost;
  28 class SharedWorkerMessageFilter;
  29 class ResourceContext;
  30 class WorkerServiceObserver;
  31 class WorkerStoragePartitionId;
  32
  33 // If "enable-embedded-shared-worker" is set this class will be used instead of
  34 // WorkerServiceImpl.
  35 // TODO(horo): implement this class.
  36 class CONTENT_EXPORT SharedWorkerServiceImpl
  37     : public NON_EXPORTED_BASE(WorkerService) {
  38  public:
  39   // Returns the SharedWorkerServiceImpl singleton.
  40   static SharedWorkerServiceImpl* GetInstance();
  41
  42   // WorkerService implementation:
  43   bool TerminateWorker(int process_id, int route_id) override;
  44   std::vector<WorkerInfo> GetWorkers() override;
  45   void AddObserver(WorkerServiceObserver* observer) override;
  46   void RemoveObserver(WorkerServiceObserver* observer) override;
  47
  48   // These methods correspond to worker related IPCs.
  49   void CreateWorker(const ViewHostMsg_CreateWorker_Params& params,
  50                     int route_id,
  51                     SharedWorkerMessageFilter* filter,
  52                     ResourceContext* resource_context,
  53                     const WorkerStoragePartitionId& partition_id,
  54                     bool* url_mismatch);
  55   void ForwardToWorker(const IPC::Message& message,
  56                        SharedWorkerMessageFilter* filter);
  57   void DocumentDetached(unsigned long long document_id,
  58                         SharedWorkerMessageFilter* filter);
  59   void WorkerContextClosed(int worker_route_id,
  60                            SharedWorkerMessageFilter* filter);
  61   void WorkerContextDestroyed(int worker_route_id,
  62                               SharedWorkerMessageFilter* filter);
  63   void WorkerReadyForInspection(int worker_route_id,
  64                                 SharedWorkerMessageFilter* filter);
  65   void WorkerScriptLoaded(int worker_route_id,
  66                           SharedWorkerMessageFilter* filter);
  67   void WorkerScriptLoadFailed(int worker_route_id,
  68                               SharedWorkerMessageFilter* filter);
  69   void WorkerConnected(int message_port_id,
  70                        int worker_route_id,
  71                        SharedWorkerMessageFilter* filter);
  72   void AllowDatabase(int worker_route_id,
  73                      const GURL& url,
  74                      const base::string16& name,
  75                      const base::string16& display_name,
  76                      unsigned long estimated_size,
  77                      bool* result,
  78                      SharedWorkerMessageFilter* filter);
  79   void AllowFileSystem(int worker_route_id,
  80                        const GURL& url,
  81                        IPC::Message* reply_msg,
  82                        SharedWorkerMessageFilter* filter);
  83   void AllowIndexedDB(int worker_route_id,
  84                       const GURL& url,
  85                       const base::string16& name,
  86                       bool* result,
  87                       SharedWorkerMessageFilter* filter);
  88
  89   void OnSharedWorkerMessageFilterClosing(
  90       SharedWorkerMessageFilter* filter);
  91
  92   // Checks the worker dependency of renderer processes and calls
  93   // IncrementWorkerRefCount and DecrementWorkerRefCount of
  94   // RenderProcessHostImpl on UI thread if necessary.
  95   void CheckWorkerDependency();
  96
  97   void NotifyWorkerDestroyed(int worker_process_id, int worker_route_id);
  98
  99  private:
 100   class SharedWorkerPendingInstance;
 101   class SharedWorkerReserver;
 102
 103   friend struct base::DefaultSingletonTraits<SharedWorkerServiceImpl>;
 104   friend class SharedWorkerServiceImplTest;
 105
 106   typedef void (*UpdateWorkerDependencyFunc)(const std::vector<int>&,
 107                                              const std::vector<int>&);
 108   typedef bool (*TryIncrementWorkerRefCountFunc)(bool);
 109   // Pair of render_process_id and worker_route_id.
 110   typedef std::pair<int, int> ProcessRouteIdPair;
 111   typedef base::ScopedPtrHashMap<ProcessRouteIdPair,
 112                                  scoped_ptr<SharedWorkerHost>> WorkerHostMap;
 113   typedef base::ScopedPtrHashMap<int, scoped_ptr<SharedWorkerPendingInstance>>
 114       PendingInstaneMap;
 115
 116   SharedWorkerServiceImpl();
 117   ~SharedWorkerServiceImpl() override;
 118
 119   void ResetForTesting();
 120
 121   // Reserves the render process to create Shared Worker. This reservation
 122   // procedure will be executed on UI thread and
 123   // RenderProcessReservedCallback() or RenderProcessReserveFailedCallback()
 124   // will be called on IO thread.
 125   void ReserveRenderProcessToCreateWorker(
 126       scoped_ptr<SharedWorkerPendingInstance> pending_instance,
 127       bool* url_mismatch);
 128
 129   // Called after the render process is reserved to create Shared Worker in it.
 130   void RenderProcessReservedCallback(int pending_instance_id,
 131                                      int worker_process_id,
 132                                      int worker_route_id,
 133                                      bool is_new_worker,
 134                                      bool pause_on_start);
 135
 136   // Called after the fast shutdown is detected while reserving the render
 137   // process to create Shared Worker in it.
 138   void RenderProcessReserveFailedCallback(int pending_instance_id,
 139                                           int worker_process_id,
 140                                           int worker_route_id,
 141                                           bool is_new_worker);
 142
 143   SharedWorkerHost* FindSharedWorkerHost(
 144       SharedWorkerMessageFilter* filter,
 145       int worker_route_id);
 146
 147   SharedWorkerHost* FindSharedWorkerHost(const SharedWorkerInstance& instance);
 148   SharedWorkerPendingInstance* FindPendingInstance(
 149       const SharedWorkerInstance& instance);
 150
 151   // Returns the IDs of the renderer processes which are executing
 152   // SharedWorkers connected to other renderer processes.
 153   const std::set<int> GetRenderersWithWorkerDependency();
 154
 155   void ChangeUpdateWorkerDependencyFuncForTesting(
 156       UpdateWorkerDependencyFunc new_func);
 157   void ChangeTryIncrementWorkerRefCountFuncForTesting(bool (*new_func)(int));
 158
 159   std::set<int> last_worker_depended_renderers_;
 160   // Function ptr to update worker dependency, tests may override this.
 161   UpdateWorkerDependencyFunc update_worker_dependency_;
 162
 163   // Function ptr to increment worker ref count, tests may override this.
 164   static bool (*s_try_increment_worker_ref_count_)(int);
 165
 166   WorkerHostMap worker_hosts_;
 167   PendingInstaneMap pending_instances_;
 168   int next_pending_instance_id_;
 169
 170   base::ObserverList<WorkerServiceObserver> observers_;
 171
 172   DISALLOW_COPY_AND_ASSIGN(SharedWorkerServiceImpl);
 173 };
 174
 175 }  // namespace content
 176
 177 #endif  // CONTENT_BROWSER_SHARED_WORKER_SHARED_WORKER_SERVICE_IMPL_H_