blob: 8e95b029fc672f02e6ac852e2747ee8fd2bc0622 (
plain)
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
|
// Copyright (c) 2011 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_RENDERER_HOST_BROWSER_RENDER_PROCESS_HOST_H_
#define CONTENT_BROWSER_RENDERER_HOST_BROWSER_RENDER_PROCESS_HOST_H_
#pragma once
#include <map>
#include <queue>
#include <string>
#include "base/memory/scoped_ptr.h"
#include "base/process.h"
#include "base/timer.h"
#include "content/browser/child_process_launcher.h"
#include "content/browser/renderer_host/render_process_host.h"
#include "ui/gfx/surface/transport_dib.h"
class CommandLine;
class RendererMainThread;
class RenderWidgetHelper;
namespace base {
class SharedMemory;
}
// Implements a concrete RenderProcessHost for the browser process for talking
// to actual renderer processes (as opposed to mocks).
//
// Represents the browser side of the browser <--> renderer communication
// channel. There will be one RenderProcessHost per renderer process.
//
// This object is refcounted so that it can release its resources when all
// hosts using it go away.
//
// This object communicates back and forth with the RenderProcess object
// running in the renderer process. Each RenderProcessHost and RenderProcess
// keeps a list of RenderView (renderer) and TabContents (browser) which
// are correlated with IDs. This way, the Views and the corresponding ViewHosts
// communicate through the two process objects.
class BrowserRenderProcessHost : public RenderProcessHost,
public ChildProcessLauncher::Client {
public:
explicit BrowserRenderProcessHost(content::BrowserContext* browser_context);
virtual ~BrowserRenderProcessHost();
// RenderProcessHost implementation (public portion).
virtual void EnableSendQueue();
virtual bool Init(bool is_accessibility_enabled);
virtual int GetNextRoutingID();
virtual void CancelResourceRequests(int render_widget_id);
virtual void CrossSiteSwapOutACK(const ViewMsg_SwapOut_Params& params);
virtual bool WaitForUpdateMsg(int render_widget_id,
const base::TimeDelta& max_delay,
IPC::Message* msg);
virtual void ReceivedBadMessage();
virtual void WidgetRestored();
virtual void WidgetHidden();
virtual int VisibleWidgetCount() const;
virtual bool FastShutdownIfPossible();
virtual base::ProcessHandle GetHandle();
virtual TransportDIB* GetTransportDIB(TransportDIB::Id dib_id);
virtual void SetCompositingSurface(
int render_widget_id,
gfx::PluginWindowHandle compositing_surface);
// IPC::Channel::Sender via RenderProcessHost.
virtual bool Send(IPC::Message* msg);
// IPC::Channel::Listener via RenderProcessHost.
virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
virtual void OnChannelError() OVERRIDE;
// ChildProcessLauncher::Client implementation.
virtual void OnProcessLaunched();
private:
friend class VisitRelayingRenderProcessHost;
// Creates and adds the IO thread message filters.
void CreateMessageFilters();
// Control message handlers.
void OnShutdownRequest();
void SuddenTerminationChanged(bool enabled);
void OnUserMetricsRecordAction(const std::string& action);
void OnRevealFolderInOS(const FilePath& path);
void OnSavedPageAsMHTML(int job_id, bool success);
// Generates a command line to be used to spawn a renderer and appends the
// results to |*command_line|.
void AppendRendererCommandLine(CommandLine* command_line) const;
// Copies applicable command line switches from the given |browser_cmd| line
// flags to the output |renderer_cmd| line flags. Not all switches will be
// copied over.
void PropagateBrowserCommandLineToRenderer(const CommandLine& browser_cmd,
CommandLine* renderer_cmd) const;
// Callers can reduce the RenderProcess' priority.
void SetBackgrounded(bool backgrounded);
// Handle termination of our process.
void ProcessDied();
// The count of currently visible widgets. Since the host can be a container
// for multiple widgets, it uses this count to determine when it should be
// backgrounded.
int32 visible_widgets_;
// Does this process have backgrounded priority.
bool backgrounded_;
// Used to allow a RenderWidgetHost to intercept various messages on the
// IO thread.
scoped_refptr<RenderWidgetHelper> widget_helper_;
// A map of transport DIB ids to cached TransportDIBs
std::map<TransportDIB::Id, TransportDIB*> cached_dibs_;
enum {
// This is the maximum size of |cached_dibs_|
MAX_MAPPED_TRANSPORT_DIBS = 3,
};
// Map a transport DIB from its Id and return it. Returns NULL on error.
TransportDIB* MapTransportDIB(TransportDIB::Id dib_id);
void ClearTransportDIBCache();
// This is used to clear our cache five seconds after the last use.
base::DelayTimer<BrowserRenderProcessHost> cached_dibs_cleaner_;
// Used in single-process mode.
scoped_ptr<RendererMainThread> in_process_renderer_;
// True if this prcoess should have accessibility enabled;
bool accessibility_enabled_;
// True after Init() has been called. We can't just check channel_ because we
// also reset that in the case of process termination.
bool is_initialized_;
// Used to launch and terminate the process without blocking the UI thread.
scoped_ptr<ChildProcessLauncher> child_process_launcher_;
// Messages we queue while waiting for the process handle. We queue them here
// instead of in the channel so that we ensure they're sent after init related
// messages that are sent once the process handle is available. This is
// because the queued messages may have dependencies on the init messages.
std::queue<IPC::Message*> queued_messages_;
DISALLOW_COPY_AND_ASSIGN(BrowserRenderProcessHost);
};
#endif // CONTENT_BROWSER_RENDERER_HOST_BROWSER_RENDER_PROCESS_HOST_H_
|
