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
|
// 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_BROWSER_PLUGIN_PROCESS_HOST_H_
#define CONTENT_BROWSER_PLUGIN_PROCESS_HOST_H_
#include "build/build_config.h"
#include <list>
#include <set>
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "content/common/content_export.h"
#include "content/public/browser/browser_child_process_host_delegate.h"
#include "content/public/browser/browser_child_process_host_iterator.h"
#include "ipc/ipc_channel_proxy.h"
#include "webkit/plugins/webplugininfo.h"
#include "ui/gfx/native_widget_types.h"
class BrowserChildProcessHostImpl;
namespace content {
class ResourceContext;
}
namespace gfx {
class Rect;
}
namespace IPC {
struct ChannelHandle;
}
// Represents the browser side of the browser <--> plugin communication
// channel. Different plugins run in their own process, but multiple instances
// of the same plugin run in the same process. There will be one
// PluginProcessHost per plugin process, matched with a corresponding
// PluginProcess running in the plugin process. The browser is responsible for
// starting the plugin process when a plugin is created that doesn't already
// have a process. After that, most of the communication is directly between
// the renderer and plugin processes.
class CONTENT_EXPORT PluginProcessHost
: public content::BrowserChildProcessHostDelegate,
public IPC::Sender {
public:
class Client {
public:
// Returns an opaque unique identifier for the process requesting
// the channel.
virtual int ID() = 0;
// Returns the resource context for the renderer requesting the channel.
virtual content::ResourceContext* GetResourceContext() = 0;
virtual bool OffTheRecord() = 0;
virtual void SetPluginInfo(const webkit::WebPluginInfo& info) = 0;
virtual void OnFoundPluginProcessHost(PluginProcessHost* host) = 0;
virtual void OnSentPluginChannelRequest() = 0;
// The client should delete itself when one of these methods is called.
virtual void OnChannelOpened(const IPC::ChannelHandle& handle) = 0;
virtual void OnError() = 0;
protected:
virtual ~Client() {}
};
PluginProcessHost();
virtual ~PluginProcessHost();
// IPC::Sender implementation:
virtual bool Send(IPC::Message* message) OVERRIDE;
// Initialize the new plugin process, returning true on success. This must
// be called before the object can be used.
bool Init(const webkit::WebPluginInfo& info);
// Force the plugin process to shutdown (cleanly).
void ForceShutdown();
virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
virtual void OnChannelError() OVERRIDE;
// Tells the plugin process to create a new channel for communication with a
// renderer. When the plugin process responds with the channel name,
// OnChannelOpened in the client is called.
void OpenChannelToPlugin(Client* client);
// Cancels all pending channel requests for the given resource context.
static void CancelPendingRequestsForResourceContext(
content::ResourceContext* context);
// This function is called to cancel pending requests to open new channels.
void CancelPendingRequest(Client* client);
// This function is called to cancel sent requests to open new channels.
void CancelSentRequest(Client* client);
// This function is called on the IO thread once we receive a reply from the
// modal HTML dialog (in the form of a JSON string). This function forwards
// that reply back to the plugin that requested the dialog.
void OnModalDialogResponse(const std::string& json_retval,
IPC::Message* sync_result);
#if defined(OS_MACOSX)
// This function is called on the IO thread when the browser becomes the
// active application.
void OnAppActivation();
#endif
const webkit::WebPluginInfo& info() const { return info_; }
#if defined(OS_WIN)
// Tracks plugin parent windows created on the browser UI thread.
void AddWindow(HWND window);
#endif
// Adds an IPC message filter. A reference will be kept to the filter.
void AddFilter(IPC::ChannelProxy::MessageFilter* filter);
private:
// Sends a message to the plugin process to request creation of a new channel
// for the given mime type.
void RequestPluginChannel(Client* client);
// Message handlers.
void OnChannelCreated(const IPC::ChannelHandle& channel_handle);
#if defined(OS_WIN)
void OnPluginWindowDestroyed(HWND window, HWND parent);
void OnReparentPluginWindow(HWND window, HWND parent);
void OnReportExecutableMemory(size_t size);
#endif
#if defined(USE_X11)
void OnMapNativeViewId(gfx::NativeViewId id, gfx::PluginWindowHandle* output);
#endif
#if defined(OS_MACOSX)
void OnPluginSelectWindow(uint32 window_id, gfx::Rect window_rect,
bool modal);
void OnPluginShowWindow(uint32 window_id, gfx::Rect window_rect,
bool modal);
void OnPluginHideWindow(uint32 window_id, gfx::Rect window_rect);
void OnPluginSetCursorVisibility(bool visible);
#endif
virtual bool CanShutdown() OVERRIDE;
virtual void OnProcessCrashed(int exit_code) OVERRIDE;
void CancelRequests();
// These are channel requests that we are waiting to send to the
// plugin process once the channel is opened.
std::vector<Client*> pending_requests_;
// These are the channel requests that we have already sent to
// the plugin process, but haven't heard back about yet.
std::list<Client*> sent_requests_;
// Information about the plugin.
webkit::WebPluginInfo info_;
#if defined(OS_WIN)
// Tracks plugin parent windows created on the UI thread.
std::set<HWND> plugin_parent_windows_set_;
#endif
#if defined(OS_MACOSX)
// Tracks plugin windows currently visible.
std::set<uint32> plugin_visible_windows_set_;
// Tracks full screen windows currently visible.
std::set<uint32> plugin_fullscreen_windows_set_;
// Tracks modal windows currently visible.
std::set<uint32> plugin_modal_windows_set_;
// Tracks the current visibility of the cursor.
bool plugin_cursor_visible_;
#endif
scoped_ptr<BrowserChildProcessHostImpl> process_;
DISALLOW_COPY_AND_ASSIGN(PluginProcessHost);
};
class PluginProcessHostIterator
: public content::BrowserChildProcessHostTypeIterator<PluginProcessHost> {
public:
PluginProcessHostIterator()
: content::BrowserChildProcessHostTypeIterator<PluginProcessHost>(
content::PROCESS_TYPE_PLUGIN) {}
};
#endif // CONTENT_BROWSER_PLUGIN_PROCESS_HOST_H_
|
