OLD | NEW |
| (Empty) |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "chrome/renderer/blocked_plugin.h" | |
6 | |
7 #include "base/string_piece.h" | |
8 #include "base/string_util.h" | |
9 #include "base/values.h" | |
10 #include "chrome/common/jstemplate_builder.h" | |
11 #include "chrome/common/render_messages.h" | |
12 #include "chrome/renderer/plugin_uma.h" | |
13 #include "content/public/renderer/render_thread.h" | |
14 #include "content/public/renderer/render_view.h" | |
15 #include "grit/generated_resources.h" | |
16 #include "third_party/WebKit/Source/WebKit/chromium/public/WebContextMenuData.h" | |
17 #include "third_party/WebKit/Source/WebKit/chromium/public/WebData.h" | |
18 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h" | |
19 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h" | |
20 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h" | |
21 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h" | |
22 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMenuItemInfo.h" | |
23 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h" | |
24 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPoint.h" | |
25 #include "third_party/WebKit/Source/WebKit/chromium/public/WebRegularExpression.
h" | |
26 #include "third_party/WebKit/Source/WebKit/chromium/public/WebTextCaseSensitivit
y.h" | |
27 #include "third_party/WebKit/Source/WebKit/chromium/public/WebVector.h" | |
28 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h" | |
29 #include "ui/base/l10n/l10n_util.h" | |
30 #include "ui/base/resource/resource_bundle.h" | |
31 #include "webkit/glue/webpreferences.h" | |
32 #include "webkit/plugins/npapi/plugin_group.h" | |
33 #include "webkit/plugins/npapi/webview_plugin.h" | |
34 | |
35 using WebKit::WebContextMenuData; | |
36 using WebKit::WebElement; | |
37 using WebKit::WebFrame; | |
38 using WebKit::WebMenuItemInfo; | |
39 using WebKit::WebNode; | |
40 using WebKit::WebPlugin; | |
41 using WebKit::WebPluginContainer; | |
42 using WebKit::WebPluginParams; | |
43 using WebKit::WebPoint; | |
44 using WebKit::WebRegularExpression; | |
45 using WebKit::WebString; | |
46 using WebKit::WebURLRequest; | |
47 using WebKit::WebVector; | |
48 using content::RenderThread; | |
49 | |
50 static const char* const kBlockedPluginDataURL = "chrome://blockedplugindata/"; | |
51 // TODO(cevans) - move these to a shared header file so that there are no | |
52 // collisions in the longer term. Currently, blocked_plugin.cc is the only | |
53 // user of custom menu commands (extension menu items have their own range). | |
54 static const unsigned kMenuActionLoad = 1; | |
55 static const unsigned kMenuActionRemove = 2; | |
56 | |
57 static const BlockedPlugin* g_last_active_menu; | |
58 | |
59 BlockedPlugin::BlockedPlugin(content::RenderView* render_view, | |
60 WebFrame* frame, | |
61 const webkit::WebPluginInfo& info, | |
62 const WebPluginParams& params, | |
63 const WebPreferences& preferences, | |
64 int template_id, | |
65 const string16& name, | |
66 const string16& message, | |
67 bool is_blocked_for_prerendering, | |
68 bool allow_loading) | |
69 : content::RenderViewObserver(render_view), | |
70 frame_(frame), | |
71 plugin_info_(info), | |
72 plugin_params_(params), | |
73 name_(name), | |
74 is_blocked_for_prerendering_(is_blocked_for_prerendering), | |
75 hidden_(false), | |
76 allow_loading_(allow_loading) { | |
77 const base::StringPiece template_html( | |
78 ResourceBundle::GetSharedInstance().GetRawDataResource(template_id)); | |
79 | |
80 DCHECK(!template_html.empty()) << "unable to load template. ID: " | |
81 << template_id; | |
82 | |
83 DictionaryValue values; | |
84 values.SetString("message", message); | |
85 values.SetString("name", name_); | |
86 values.SetString("hide", l10n_util::GetStringUTF8(IDS_PLUGIN_HIDE)); | |
87 | |
88 // "t" is the id of the templates root node. | |
89 std::string html_data = jstemplate_builder::GetI18nTemplateHtml( | |
90 template_html, &values); | |
91 | |
92 plugin_ = webkit::npapi::WebViewPlugin::Create(this, | |
93 preferences, | |
94 html_data, | |
95 GURL(kBlockedPluginDataURL)); | |
96 } | |
97 | |
98 BlockedPlugin::~BlockedPlugin() { | |
99 } | |
100 | |
101 void BlockedPlugin::BindWebFrame(WebFrame* frame) { | |
102 BindToJavascript(frame, "plugin"); | |
103 BindMethod("load", &BlockedPlugin::LoadCallback); | |
104 BindMethod("hide", &BlockedPlugin::HideCallback); | |
105 BindMethod("openURL", &BlockedPlugin::OpenUrlCallback); | |
106 } | |
107 | |
108 void BlockedPlugin::WillDestroyPlugin() { | |
109 delete this; | |
110 } | |
111 | |
112 void BlockedPlugin::ShowContextMenu(const WebKit::WebMouseEvent& event) { | |
113 WebContextMenuData menu_data; | |
114 | |
115 size_t num_items = name_.empty() ? 2u : 4u; | |
116 WebVector<WebMenuItemInfo> custom_items(num_items); | |
117 | |
118 size_t i = 0; | |
119 if (!name_.empty()) { | |
120 WebMenuItemInfo name_item; | |
121 name_item.label = name_; | |
122 name_item.hasTextDirectionOverride = false; | |
123 name_item.textDirection = WebKit::WebTextDirectionDefault; | |
124 custom_items[i++] = name_item; | |
125 | |
126 WebMenuItemInfo separator_item; | |
127 separator_item.type = WebMenuItemInfo::Separator; | |
128 custom_items[i++] = separator_item; | |
129 } | |
130 | |
131 WebMenuItemInfo run_item; | |
132 run_item.action = kMenuActionLoad; | |
133 // Disable this menu item if the plugin is blocked by policy. | |
134 run_item.enabled = allow_loading_; | |
135 run_item.label = WebString::fromUTF8( | |
136 l10n_util::GetStringUTF8(IDS_CONTENT_CONTEXT_PLUGIN_RUN).c_str()); | |
137 run_item.hasTextDirectionOverride = false; | |
138 run_item.textDirection = WebKit::WebTextDirectionDefault; | |
139 custom_items[i++] = run_item; | |
140 | |
141 WebMenuItemInfo hide_item; | |
142 hide_item.action = kMenuActionRemove; | |
143 hide_item.enabled = true; | |
144 hide_item.label = WebString::fromUTF8( | |
145 l10n_util::GetStringUTF8(IDS_CONTENT_CONTEXT_PLUGIN_HIDE).c_str()); | |
146 hide_item.hasTextDirectionOverride = false; | |
147 hide_item.textDirection = WebKit::WebTextDirectionDefault; | |
148 custom_items[i++] = hide_item; | |
149 | |
150 menu_data.customItems.swap(custom_items); | |
151 menu_data.mousePosition = WebPoint(event.windowX, event.windowY); | |
152 render_view()->ShowContextMenu(NULL, menu_data); | |
153 g_last_active_menu = this; | |
154 } | |
155 | |
156 bool BlockedPlugin::OnMessageReceived(const IPC::Message& message) { | |
157 // We don't swallow ViewMsg_CustomContextMenuAction because we listen for all | |
158 // custom menu IDs, and not just our own. We don't swallow | |
159 // ViewMsg_LoadBlockedPlugins because multiple blocked plugins have an | |
160 // interest in it. | |
161 IPC_BEGIN_MESSAGE_MAP(BlockedPlugin, message) | |
162 IPC_MESSAGE_HANDLER(ChromeViewMsg_LoadBlockedPlugins, OnLoadBlockedPlugins) | |
163 IPC_MESSAGE_HANDLER(ChromeViewMsg_SetIsPrerendering, OnSetIsPrerendering) | |
164 IPC_END_MESSAGE_MAP() | |
165 | |
166 return false; | |
167 } | |
168 | |
169 void BlockedPlugin::ContextMenuAction(unsigned id) { | |
170 if (g_last_active_menu != this) | |
171 return; | |
172 if (id == kMenuActionLoad) { | |
173 RenderThread::Get()->RecordUserMetrics("Plugin_Load_Menu"); | |
174 LoadPlugin(); | |
175 } else if (id == kMenuActionRemove) { | |
176 RenderThread::Get()->RecordUserMetrics("Plugin_Hide_Menu"); | |
177 HidePlugin(); | |
178 } | |
179 } | |
180 | |
181 void BlockedPlugin::OnLoadBlockedPlugins() { | |
182 RenderThread::Get()->RecordUserMetrics("Plugin_Load_UI"); | |
183 LoadPlugin(); | |
184 } | |
185 | |
186 void BlockedPlugin::OnSetIsPrerendering(bool is_prerendering) { | |
187 // Prerendering can only be enabled prior to a RenderView's first navigation, | |
188 // so no BlockedPlugin should see the notification that enables prerendering. | |
189 DCHECK(!is_prerendering); | |
190 if (is_blocked_for_prerendering_ && !is_prerendering) | |
191 LoadPlugin(); | |
192 } | |
193 | |
194 void BlockedPlugin::LoadPlugin() { | |
195 CHECK(plugin_); | |
196 // This is not strictly necessary but is an important defense in case the | |
197 // event propagation changes between "close" vs. "click-to-play". | |
198 if (hidden_) | |
199 return; | |
200 if (!allow_loading_) | |
201 return; | |
202 WebPluginContainer* container = plugin_->container(); | |
203 WebPlugin* new_plugin = | |
204 render_view()->CreatePlugin(frame_, plugin_info_, plugin_params_); | |
205 if (new_plugin && new_plugin->initialize(container)) { | |
206 plugin_->RestoreTitleText(); | |
207 container->setPlugin(new_plugin); | |
208 container->invalidate(); | |
209 container->reportGeometry(); | |
210 plugin_->ReplayReceivedData(new_plugin); | |
211 plugin_->destroy(); | |
212 } else { | |
213 MissingPluginReporter::GetInstance()->ReportPluginMissing( | |
214 plugin_params_.mimeType.utf8(), | |
215 plugin_params_.url); | |
216 } | |
217 } | |
218 | |
219 void BlockedPlugin::LoadCallback(const CppArgumentList& args, | |
220 CppVariant* result) { | |
221 RenderThread::Get()->RecordUserMetrics("Plugin_Load_Click"); | |
222 LoadPlugin(); | |
223 } | |
224 | |
225 void BlockedPlugin::HideCallback(const CppArgumentList& args, | |
226 CppVariant* result) { | |
227 RenderThread::Get()->RecordUserMetrics("Plugin_Hide_Click"); | |
228 HidePlugin(); | |
229 } | |
230 | |
231 void BlockedPlugin::OpenUrlCallback(const CppArgumentList& args, | |
232 CppVariant* result) { | |
233 if (args.size() < 1) { | |
234 NOTREACHED(); | |
235 return; | |
236 } | |
237 if (!args[0].isString()) { | |
238 NOTREACHED(); | |
239 return; | |
240 } | |
241 | |
242 GURL url(args[0].ToString()); | |
243 WebURLRequest request; | |
244 request.initialize(); | |
245 request.setURL(url); | |
246 render_view()->LoadURLExternally( | |
247 frame_, request, WebKit::WebNavigationPolicyNewForegroundTab); | |
248 } | |
249 | |
250 void BlockedPlugin::HidePlugin() { | |
251 CHECK(plugin_); | |
252 hidden_ = true; | |
253 WebPluginContainer* container = plugin_->container(); | |
254 WebElement element = container->element(); | |
255 element.setAttribute("style", "display: none;"); | |
256 // If we have a width and height, search for a parent (often <div>) with the | |
257 // same dimensions. If we find such a parent, hide that as well. | |
258 // This makes much more uncovered page content usable (including clickable) | |
259 // as opposed to merely visible. | |
260 // TODO(cevans) -- it's a foul heurisitc but we're going to tolerate it for | |
261 // now for these reasons: | |
262 // 1) Makes the user experience better. | |
263 // 2) Foulness is encapsulated within this single function. | |
264 // 3) Confidence in no fasle positives. | |
265 // 4) Seems to have a good / low false negative rate at this time. | |
266 if (element.hasAttribute("width") && element.hasAttribute("height")) { | |
267 std::string width_str("width:[\\s]*"); | |
268 width_str += element.getAttribute("width").utf8().data(); | |
269 if (EndsWith(width_str, "px", false)) { | |
270 width_str = width_str.substr(0, width_str.length() - 2); | |
271 } | |
272 TrimWhitespace(width_str, TRIM_TRAILING, &width_str); | |
273 width_str += "[\\s]*px"; | |
274 WebRegularExpression width_regex(WebString::fromUTF8(width_str.c_str()), | |
275 WebKit::WebTextCaseSensitive); | |
276 std::string height_str("height:[\\s]*"); | |
277 height_str += element.getAttribute("height").utf8().data(); | |
278 if (EndsWith(height_str, "px", false)) { | |
279 height_str = height_str.substr(0, height_str.length() - 2); | |
280 } | |
281 TrimWhitespace(height_str, TRIM_TRAILING, &height_str); | |
282 height_str += "[\\s]*px"; | |
283 WebRegularExpression height_regex(WebString::fromUTF8(height_str.c_str()), | |
284 WebKit::WebTextCaseSensitive); | |
285 WebNode parent = element; | |
286 while (!parent.parentNode().isNull()) { | |
287 parent = parent.parentNode(); | |
288 if (!parent.isElementNode()) | |
289 continue; | |
290 element = parent.toConst<WebElement>(); | |
291 if (element.hasAttribute("style")) { | |
292 WebString style_str = element.getAttribute("style"); | |
293 if (width_regex.match(style_str) >= 0 && | |
294 height_regex.match(style_str) >= 0) | |
295 element.setAttribute("style", "display: none;"); | |
296 } | |
297 } | |
298 } | |
299 } | |
OLD | NEW |