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
|
// 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_PPAPI_PLUGIN_PPAPI_THREAD_H_
#define CONTENT_PPAPI_PLUGIN_PPAPI_THREAD_H_
#include <stdint.h>
#include <map>
#include <memory>
#include <string>
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "base/process/process.h"
#include "base/scoped_native_library.h"
#include "build/build_config.h"
#include "content/child/child_thread_impl.h"
#include "content/public/common/pepper_plugin_info.h"
#include "ppapi/c/pp_module.h"
#include "ppapi/c/trusted/ppp_broker.h"
#include "ppapi/proxy/connection.h"
#include "ppapi/proxy/plugin_dispatcher.h"
#include "ppapi/proxy/plugin_globals.h"
#include "ppapi/proxy/plugin_proxy_delegate.h"
#if defined(OS_WIN)
#include "base/win/scoped_handle.h"
#endif
namespace base {
class CommandLine;
class FilePath;
}
namespace discardable_memory {
class ClientDiscardableSharedMemoryManager;
}
namespace IPC {
struct ChannelHandle;
}
namespace content {
class PpapiBlinkPlatformImpl;
#if defined(COMPILER_MSVC)
// See explanation for other RenderViewHostImpl which is the same issue.
#pragma warning(push)
#pragma warning(disable: 4250)
#endif
class PpapiThread : public ChildThreadImpl,
public ppapi::proxy::PluginDispatcher::PluginDelegate,
public ppapi::proxy::PluginProxyDelegate {
public:
PpapiThread(base::RepeatingClosure quit_closure,
const base::CommandLine& command_line,
bool is_broker);
~PpapiThread() override;
void Shutdown() override;
private:
// Make sure the enum list in tools/histogram/histograms.xml is updated with
// any change in this list.
enum LoadResult {
LOAD_SUCCESS,
LOAD_FAILED,
ENTRY_POINT_MISSING,
INIT_FAILED,
FILE_MISSING,
// NOTE: Add new values only immediately above this line.
LOAD_RESULT_MAX // Boundary value for UMA_HISTOGRAM_ENUMERATION.
};
// ChildThread overrides.
bool Send(IPC::Message* msg) override;
bool OnControlMessageReceived(const IPC::Message& msg) override;
void OnChannelConnected(int32_t peer_pid) override;
// PluginDispatcher::PluginDelegate implementation.
std::set<PP_Instance>* GetGloballySeenInstanceIDSet() override;
base::SingleThreadTaskRunner* GetIPCTaskRunner() override;
base::WaitableEvent* GetShutdownEvent() override;
IPC::PlatformFileForTransit ShareHandleWithRemote(
base::PlatformFile handle,
base::ProcessId peer_pid,
bool should_close_source) override;
base::SharedMemoryHandle ShareSharedMemoryHandleWithRemote(
const base::SharedMemoryHandle& handle,
base::ProcessId remote_pid) override;
base::UnsafeSharedMemoryRegion ShareUnsafeSharedMemoryRegionWithRemote(
const base::UnsafeSharedMemoryRegion& region,
base::ProcessId remote_pid) override;
base::ReadOnlySharedMemoryRegion ShareReadOnlySharedMemoryRegionWithRemote(
const base::ReadOnlySharedMemoryRegion& region,
base::ProcessId remote_pid) override;
uint32_t Register(ppapi::proxy::PluginDispatcher* plugin_dispatcher) override;
void Unregister(uint32_t plugin_dispatcher_id) override;
// PluginProxyDelegate.
// SendToBrowser() is intended to be safe to use on another thread so
// long as the main PpapiThread outlives it.
IPC::Sender* GetBrowserSender() override;
std::string GetUILanguage() override;
void PreCacheFontForFlash(const void* logfontw) override;
void SetActiveURL(const std::string& url) override;
PP_Resource CreateBrowserFont(ppapi::proxy::Connection connection,
PP_Instance instance,
const PP_BrowserFont_Trusted_Description& desc,
const ppapi::Preferences& prefs) override;
// Message handlers.
void OnLoadPlugin(const base::FilePath& path,
const ppapi::PpapiPermissions& permissions);
void OnCreateChannel(base::ProcessId renderer_pid,
int renderer_child_id,
bool incognito);
void OnSetNetworkState(bool online);
void OnCrash();
void OnHang();
// Sets up the channel to the given renderer. If |renderer_pid| is
// base::kNullProcessId, the channel is set up to the browser. On success,
// returns true and fills the given ChannelHandle with the information from
// the new channel.
bool SetupChannel(base::ProcessId renderer_pid,
int renderer_child_id,
bool incognito,
IPC::ChannelHandle* handle);
// Sets up the name of the plugin for logging using the given path.
void SavePluginName(const base::FilePath& path);
void ReportLoadResult(const base::FilePath& path, LoadResult result);
// Reports |error| to UMA when plugin load fails.
void ReportLoadErrorCode(const base::FilePath& path,
const base::NativeLibraryLoadError& error);
// Reports time to load the plugin.
void ReportLoadTime(const base::FilePath& path,
const base::TimeDelta load_time);
// True if running in a broker process rather than a normal plugin process.
bool is_broker_;
base::ScopedNativeLibrary library_;
ppapi::PpapiPermissions permissions_;
// Global state tracking for the proxy.
ppapi::proxy::PluginGlobals plugin_globals_;
// Storage for plugin entry points.
PepperPluginInfo::EntryPoints plugin_entry_points_;
// Callback to call when a new instance connects to the broker.
// Used only when is_broker_.
PP_ConnectInstance_Func connect_instance_func_;
// Local concept of the module ID. Some functions take this. It's necessary
// for the in-process PPAPI to handle this properly, but for proxied it's
// unnecessary. The proxy talking to multiple renderers means that each
// renderer has a different idea of what the module ID is for this plugin.
// To force people to "do the right thing" we generate a random module ID
// and pass it around as necessary.
PP_Module local_pp_module_;
// See Dispatcher::Delegate::GetGloballySeenInstanceIDSet.
std::set<PP_Instance> globally_seen_instance_ids_;
// The PluginDispatcher instances contained in the map are not owned by it.
std::map<uint32_t, ppapi::proxy::PluginDispatcher*> plugin_dispatchers_;
uint32_t next_plugin_dispatcher_id_;
// The BlinkPlatformImpl implementation.
std::unique_ptr<PpapiBlinkPlatformImpl> blink_platform_impl_;
#if defined(OS_WIN)
// Caches the handle to the peer process if this is a broker.
base::win::ScopedHandle peer_handle_;
#endif
std::unique_ptr<discardable_memory::ClientDiscardableSharedMemoryManager>
discardable_shared_memory_manager_;
DISALLOW_IMPLICIT_CONSTRUCTORS(PpapiThread);
};
#if defined(COMPILER_MSVC)
#pragma warning(pop)
#endif
} // namespace content
#endif // CONTENT_PPAPI_PLUGIN_PPAPI_THREAD_H_
|
