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
|
// 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.
#include "chrome/common/chrome_content_client.h"
#include "base/command_line.h"
#include "base/file_util.h"
#include "base/path_service.h"
#include "base/string_split.h"
#include "base/string_util.h"
#include "chrome/common/child_process_logging.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/render_messages.h"
#include "content/common/pepper_plugin_registry.h"
#include "remoting/client/plugin/pepper_entrypoints.h"
namespace {
const char* kPDFPluginName = "Chrome PDF Viewer";
const char* kPDFPluginMimeType = "application/pdf";
const char* kPDFPluginExtension = "pdf";
const char* kPDFPluginDescription = "Portable Document Format";
const char* kNaClPluginName = "Chrome NaCl";
const char* kNaClPluginMimeType = "application/x-nacl";
const char* kNaClPluginExtension = "nexe";
const char* kNaClPluginDescription = "Native Client Executable";
#if defined(ENABLE_REMOTING)
const char* kRemotingViewerPluginName = "Remoting Viewer";
const FilePath::CharType kRemotingViewerPluginPath[] =
FILE_PATH_LITERAL("internal-remoting-viewer");
#if defined(GOOGLE_CHROME_BUILD)
const char* kRemotingViewerPluginMimeType =
"application/vnd.google-chrome.remoting-viewer";
#else // CHROMIUM_BUILD
const char* kRemotingViewerPluginMimeType =
"application/vnd.chromium.remoting-viewer";
#endif
// TODO(wez): Remove the old MIME-type once client code no longer needs it.
const char* kRemotingViewerPluginOldMimeType =
"pepper-application/x-chromoting";
#endif
const char* kFlashPluginName = "Shockwave Flash";
const char* kFlashPluginSwfMimeType = "application/x-shockwave-flash";
const char* kFlashPluginSwfExtension = "swf";
const char* kFlashPluginSwfDescription = "Shockwave Flash";
const char* kFlashPluginSplMimeType = "application/futuresplash";
const char* kFlashPluginSplExtension = "spl";
const char* kFlashPluginSplDescription = "FutureSplash Player";
#if !defined(NACL_WIN64) // The code this needs isn't linked on Win64 builds.
// Appends the known built-in plugins to the given vector. Some built-in
// plugins are "internal" which means they are compiled into the Chrome binary,
// and some are extra shared libraries distributed with the browser (these are
// not marked internal, aside from being automatically registered, they're just
// regular plugins).
void ComputeBuiltInPlugins(std::vector<PepperPluginInfo>* plugins) {
// PDF.
//
// Once we're sandboxed, we can't know if the PDF plugin is available or not;
// but (on Linux) this function is always called once before we're sandboxed.
// So the first time through test if the file is available and then skip the
// check on subsequent calls if yes.
static bool skip_pdf_file_check = false;
FilePath path;
if (PathService::Get(chrome::FILE_PDF_PLUGIN, &path)) {
if (skip_pdf_file_check || file_util::PathExists(path)) {
PepperPluginInfo pdf;
pdf.path = path;
pdf.name = kPDFPluginName;
webkit::npapi::WebPluginMimeType pdf_mime_type(kPDFPluginMimeType,
kPDFPluginExtension,
kPDFPluginDescription);
pdf.mime_types.push_back(pdf_mime_type);
plugins->push_back(pdf);
skip_pdf_file_check = true;
}
}
// Handle the Native Client plugin just like the PDF plugin.
static bool skip_nacl_file_check = false;
if (PathService::Get(chrome::FILE_NACL_PLUGIN, &path)) {
if (skip_nacl_file_check || file_util::PathExists(path)) {
PepperPluginInfo nacl;
nacl.path = path;
nacl.name = kNaClPluginName;
// Enable the Native Client Plugin based on the command line.
nacl.enabled = CommandLine::ForCurrentProcess()->HasSwitch(
switches::kEnableNaCl);
webkit::npapi::WebPluginMimeType nacl_mime_type(kNaClPluginMimeType,
kNaClPluginExtension,
kNaClPluginDescription);
nacl.mime_types.push_back(nacl_mime_type);
plugins->push_back(nacl);
skip_nacl_file_check = true;
}
}
// The Remoting Viewer plugin is built-in, but behind a flag for now.
#if defined(ENABLE_REMOTING)
if (CommandLine::ForCurrentProcess()->HasSwitch(
switches::kEnableRemoting)) {
PepperPluginInfo info;
info.is_internal = true;
info.name = kRemotingViewerPluginName;
info.path = FilePath(kRemotingViewerPluginPath);
webkit::npapi::WebPluginMimeType remoting_mime_type(
kRemotingViewerPluginMimeType,
std::string(),
std::string());
info.mime_types.push_back(remoting_mime_type);
webkit::npapi::WebPluginMimeType old_remoting_mime_type(
kRemotingViewerPluginOldMimeType,
std::string(),
std::string());
info.mime_types.push_back(old_remoting_mime_type);
info.internal_entry_points.get_interface = remoting::PPP_GetInterface;
info.internal_entry_points.initialize_module =
remoting::PPP_InitializeModule;
info.internal_entry_points.shutdown_module = remoting::PPP_ShutdownModule;
plugins->push_back(info);
}
#endif
}
void AddOutOfProcessFlash(std::vector<PepperPluginInfo>* plugins) {
// Flash being out of process is handled separately than general plugins
// for testing purposes.
bool flash_out_of_process = !CommandLine::ForCurrentProcess()->HasSwitch(
switches::kPpapiFlashInProcess);
// Handle any Pepper Flash first.
const CommandLine::StringType flash_path =
CommandLine::ForCurrentProcess()->GetSwitchValueNative(
switches::kPpapiFlashPath);
if (flash_path.empty())
return;
PepperPluginInfo plugin;
plugin.is_out_of_process = flash_out_of_process;
plugin.path = FilePath(flash_path);
plugin.name = kFlashPluginName;
const std::string flash_version =
CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
switches::kPpapiFlashVersion);
std::vector<std::string> flash_version_numbers;
base::SplitString(flash_version, '.', &flash_version_numbers);
if (flash_version_numbers.size() < 1)
flash_version_numbers.push_back("10");
// |SplitString()| puts in an empty string given an empty string. :(
else if (flash_version_numbers[0].empty())
flash_version_numbers[0] = "10";
if (flash_version_numbers.size() < 2)
flash_version_numbers.push_back("2");
if (flash_version_numbers.size() < 3)
flash_version_numbers.push_back("999");
if (flash_version_numbers.size() < 4)
flash_version_numbers.push_back("999");
// E.g., "Shockwave Flash 10.2 r154":
plugin.description = plugin.name + " " + flash_version_numbers[0] + "." +
flash_version_numbers[1] + " r" + flash_version_numbers[2];
plugin.version = JoinString(flash_version_numbers, '.');
webkit::npapi::WebPluginMimeType swf_mime_type(kFlashPluginSwfMimeType,
kFlashPluginSwfExtension,
kFlashPluginSwfDescription);
plugin.mime_types.push_back(swf_mime_type);
webkit::npapi::WebPluginMimeType spl_mime_type(kFlashPluginSplMimeType,
kFlashPluginSplExtension,
kFlashPluginSplDescription);
plugin.mime_types.push_back(spl_mime_type);
plugins->push_back(plugin);
}
#endif // !defined(NACL_WIN64)
} // namespace
namespace chrome {
const char* ChromeContentClient::kPDFPluginName = ::kPDFPluginName;
void ChromeContentClient::SetActiveURL(const GURL& url) {
child_process_logging::SetActiveURL(url);
}
void ChromeContentClient::SetGpuInfo(const GPUInfo& gpu_info) {
child_process_logging::SetGpuInfo(gpu_info);
}
void ChromeContentClient::AddPepperPlugins(
std::vector<PepperPluginInfo>* plugins) {
#if !defined(NACL_WIN64) // The code this needs isn't linked on Win64 builds.
ComputeBuiltInPlugins(plugins);
AddOutOfProcessFlash(plugins);
#endif
}
bool ChromeContentClient::CanSendWhileSwappedOut(const IPC::Message* msg) {
// Any Chrome-specific messages that must be allowed to be sent from swapped
// out renderers.
switch (msg->type()) {
case ViewHostMsg_DomOperationResponse::ID:
return true;
default:
break;
}
return false;
}
bool ChromeContentClient::CanHandleWhileSwappedOut(
const IPC::Message& msg) {
// Any Chrome-specific messages (apart from those listed in
// CanSendWhileSwappedOut) that must be handled by the browser when sent from
// swapped out renderers.
switch (msg.type()) {
case ViewHostMsg_Snapshot::ID:
return true;
default:
break;
}
return false;
}
} // namespace chrome
|
