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