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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
|
// Copyright (c) 2012 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_PUBLIC_BROWSER_RENDER_PROCESS_HOST_H_
#define CONTENT_PUBLIC_BROWSER_RENDER_PROCESS_HOST_H_
#include "base/basictypes.h"
#include "base/id_map.h"
#include "base/process/kill.h"
#include "base/process/process_handle.h"
#include "base/supports_user_data.h"
#include "content/common/content_export.h"
#include "ipc/ipc_channel_proxy.h"
#include "ipc/ipc_sender.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/surface/transport_dib.h"
class GURL;
struct ViewMsg_SwapOut_Params;
namespace base {
class TimeDelta;
}
namespace content {
class BrowserContext;
class BrowserMessageFilter;
class RenderProcessHostObserver;
class RenderWidgetHost;
class StoragePartition;
typedef base::Thread* (*RendererMainThreadFactoryFunction)(
const std::string& id);
// Interface that represents the browser side of the browser <-> renderer
// communication channel. There will generally be one RenderProcessHost per
// renderer process.
class CONTENT_EXPORT RenderProcessHost : public IPC::Sender,
public IPC::Listener,
public base::SupportsUserData {
public:
typedef IDMap<RenderProcessHost>::iterator iterator;
// Details for RENDERER_PROCESS_CLOSED notifications.
struct RendererClosedDetails {
RendererClosedDetails(base::ProcessHandle handle,
base::TerminationStatus status,
int exit_code) {
this->handle = handle;
this->status = status;
this->exit_code = exit_code;
}
base::ProcessHandle handle;
base::TerminationStatus status;
int exit_code;
};
// General functions ---------------------------------------------------------
virtual ~RenderProcessHost() {}
// Initialize the new renderer process, returning true on success. This must
// be called once before the object can be used, but can be called after
// that with no effect. Therefore, if the caller isn't sure about whether
// the process has been created, it should just call Init().
virtual bool Init() = 0;
// Gets the next available routing id.
virtual int GetNextRoutingID() = 0;
// These methods add or remove listener for a specific message routing ID.
// Used for refcounting, each holder of this object must AddRoute and
// RemoveRoute. This object should be allocated on the heap; when no
// listeners own it any more, it will delete itself.
virtual void AddRoute(int32 routing_id, IPC::Listener* listener) = 0;
virtual void RemoveRoute(int32 routing_id) = 0;
// Add and remove observers for lifecycle events. The order in which
// notifications are sent to observers is undefined. Observers must be sure to
// remove the observer before they go away.
virtual void AddObserver(RenderProcessHostObserver* observer) = 0;
virtual void RemoveObserver(RenderProcessHostObserver* observer) = 0;
// Called to wait for the next UpdateRect message for the specified render
// widget. Returns true if successful, and the msg out-param will contain a
// copy of the received UpdateRect message.
virtual bool WaitForBackingStoreMsg(int render_widget_id,
const base::TimeDelta& max_delay,
IPC::Message* msg) = 0;
// Called when a received message cannot be decoded.
virtual void ReceivedBadMessage() = 0;
// Track the count of visible widgets. Called by listeners to register and
// unregister visibility.
virtual void WidgetRestored() = 0;
virtual void WidgetHidden() = 0;
virtual int VisibleWidgetCount() const = 0;
// Indicates whether the current RenderProcessHost associated with a guest
// renderer process.
virtual bool IsGuest() const = 0;
// Returns the storage partition associated with this process.
//
// TODO(nasko): Remove this function from the public API once
// URLRequestContextGetter's creation is moved into StoragePartition.
// http://crbug.com/158595
virtual StoragePartition* GetStoragePartition() const = 0;
// Try to shutdown the associated renderer process as fast as possible.
// If this renderer has any RenderViews with unload handlers, then this
// function does nothing. The current implementation uses TerminateProcess.
// Returns True if it was able to do fast shutdown.
virtual bool FastShutdownIfPossible() = 0;
// Returns true if fast shutdown was started for the renderer.
virtual bool FastShutdownStarted() const = 0;
// Dump the child process' handle table before shutting down.
virtual void DumpHandles() = 0;
// Returns the process object associated with the child process. In certain
// tests or single-process mode, this will actually represent the current
// process.
//
// NOTE: this is not necessarily valid immediately after calling Init, as
// Init starts the process asynchronously. It's guaranteed to be valid after
// the first IPC arrives.
virtual base::ProcessHandle GetHandle() const = 0;
// Transport DIB functions ---------------------------------------------------
// Return the TransportDIB for the given id. On Linux, this can involve
// mapping shared memory. On Mac, the shared memory is created in the browser
// process and the cached metadata is returned. On Windows, this involves
// duplicating the handle from the remote process. The RenderProcessHost
// still owns the returned DIB.
virtual TransportDIB* GetTransportDIB(TransportDIB::Id dib_id) = 0;
// Return the TransportDIB for the given id. In contrast to GetTransportDIB,
// the caller owns the resulting TransportDIB.
virtual TransportDIB* MapTransportDIB(TransportDIB::Id dib_id) = 0;
// Returns the user browser context associated with this renderer process.
virtual content::BrowserContext* GetBrowserContext() const = 0;
// Returns whether this process is using the same StoragePartition as
// |partition|.
virtual bool InSameStoragePartition(StoragePartition* partition) const = 0;
// Returns the unique ID for this child process. This can be used later in
// a call to FromID() to get back to this object (this is used to avoid
// sending non-threadsafe pointers to other threads).
//
// This ID will be unique for all child processes, including workers, plugins,
// etc.
virtual int GetID() const = 0;
// Returns true iff channel_ has been set to non-NULL. Use this for checking
// if there is connection or not. Virtual for mocking out for tests.
virtual bool HasConnection() const = 0;
// Call this to allow queueing of IPC messages that are sent before the
// process is launched.
virtual void EnableSendQueue() = 0;
// Returns the renderer channel.
virtual IPC::ChannelProxy* GetChannel() = 0;
// Adds a message filter to the IPC channel.
virtual void AddFilter(BrowserMessageFilter* filter) = 0;
// Try to shutdown the associated render process as fast as possible
virtual bool FastShutdownForPageCount(size_t count) = 0;
// TODO(ananta)
// Revisit whether the virtual functions declared from here on need to be
// part of the interface.
virtual void SetIgnoreInputEvents(bool ignore_input_events) = 0;
virtual bool IgnoreInputEvents() const = 0;
// Schedules the host for deletion and removes it from the all_hosts list.
virtual void Cleanup() = 0;
// Track the count of pending views that are being swapped back in. Called
// by listeners to register and unregister pending views to prevent the
// process from exiting.
virtual void AddPendingView() = 0;
virtual void RemovePendingView() = 0;
// Sets a flag indicating that the process can be abnormally terminated.
virtual void SetSuddenTerminationAllowed(bool allowed) = 0;
// Returns true if the process can be abnormally terminated.
virtual bool SuddenTerminationAllowed() const = 0;
// Returns how long the child has been idle. The definition of idle
// depends on when a derived class calls mark_child_process_activity_time().
// This is a rough indicator and its resolution should not be better than
// 10 milliseconds.
virtual base::TimeDelta GetChildProcessIdleTime() const = 0;
// Called to resume the requests for a view created through window.open that
// were initially blocked.
virtual void ResumeRequestsForView(int route_id) = 0;
#if defined(ENABLE_WEBRTC)
virtual void EnableAecDump(const base::FilePath& file) = 0;
virtual void DisableAecDump() = 0;
#endif
// Static management functions -----------------------------------------------
// Flag to run the renderer in process. This is primarily
// for debugging purposes. When running "in process", the
// browser maintains a single RenderProcessHost which communicates
// to a RenderProcess which is instantiated in the same process
// with the Browser. All IPC between the Browser and the
// Renderer is the same, it's just not crossing a process boundary.
static bool run_renderer_in_process();
// This also calls out to ContentBrowserClient::GetApplicationLocale and
// modifies the current process' command line.
static void SetRunRendererInProcess(bool value);
// Allows iteration over all the RenderProcessHosts in the browser. Note
// that each host may not be active, and therefore may have NULL channels.
static iterator AllHostsIterator();
// Returns the RenderProcessHost given its ID. Returns NULL if the ID does
// not correspond to a live RenderProcessHost.
static RenderProcessHost* FromID(int render_process_id);
// Returns whether the process-per-site model is in use (globally or just for
// the current site), in which case we should ensure there is only one
// RenderProcessHost per site for the entire browser context.
static bool ShouldUseProcessPerSite(content::BrowserContext* browser_context,
const GURL& url);
// Returns true if the caller should attempt to use an existing
// RenderProcessHost rather than creating a new one.
static bool ShouldTryToUseExistingProcessHost(
content::BrowserContext* browser_context, const GURL& site_url);
// Get an existing RenderProcessHost associated with the given browser
// context, if possible. The renderer process is chosen randomly from
// suitable renderers that share the same context and type (determined by the
// site url).
// Returns NULL if no suitable renderer process is available, in which case
// the caller is free to create a new renderer.
static RenderProcessHost* GetExistingProcessHost(
content::BrowserContext* browser_context, const GURL& site_url);
// Overrides the default heuristic for limiting the max renderer process
// count. This is useful for unit testing process limit behaviors. It is
// also used to allow a command line parameter to configure the max number of
// renderer processes and should only be called once during startup.
// A value of zero means to use the default heuristic.
static void SetMaxRendererProcessCount(size_t count);
// Returns the current max number of renderer processes used by the content
// module.
static size_t GetMaxRendererProcessCount();
static void RegisterRendererMainThreadFactory(
RendererMainThreadFactoryFunction create);
};
} // namespace content.
#endif // CONTENT_PUBLIC_BROWSER_RENDER_PROCESS_HOST_H_
|