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