Roll src/third_party/WebKit d9c6159:8139f33 (svn 201974:201975)
[chromium-blink-merge.git] / extensions / browser / extension_function_dispatcher.cc
blob60a3ce8a535033dcc949bddf4bb08f3d84470a30
1 // Copyright 2014 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.
5 #include "extensions/browser/extension_function_dispatcher.h"
7 #include "base/bind.h"
8 #include "base/json/json_string_value_serializer.h"
9 #include "base/lazy_instance.h"
10 #include "base/logging.h"
11 #include "base/memory/ref_counted.h"
12 #include "base/metrics/histogram_macros.h"
13 #include "base/metrics/sparse_histogram.h"
14 #include "base/process/process.h"
15 #include "base/profiler/scoped_profile.h"
16 #include "base/values.h"
17 #include "build/build_config.h"
18 #include "content/public/browser/browser_thread.h"
19 #include "content/public/browser/render_frame_host.h"
20 #include "content/public/browser/render_process_host.h"
21 #include "content/public/browser/render_view_host.h"
22 #include "content/public/browser/user_metrics.h"
23 #include "content/public/browser/web_contents.h"
24 #include "content/public/browser/web_contents_observer.h"
25 #include "content/public/common/result_codes.h"
26 #include "extensions/browser/api_activity_monitor.h"
27 #include "extensions/browser/extension_function_registry.h"
28 #include "extensions/browser/extension_registry.h"
29 #include "extensions/browser/extension_system.h"
30 #include "extensions/browser/extensions_browser_client.h"
31 #include "extensions/browser/io_thread_extension_message_filter.h"
32 #include "extensions/browser/process_manager.h"
33 #include "extensions/browser/process_map.h"
34 #include "extensions/browser/quota_service.h"
35 #include "extensions/common/extension_api.h"
36 #include "extensions/common/extension_messages.h"
37 #include "extensions/common/extension_set.h"
38 #include "ipc/ipc_message.h"
39 #include "ipc/ipc_message_macros.h"
41 using content::BrowserThread;
42 using content::RenderViewHost;
44 namespace extensions {
45 namespace {
47 // Notifies the ApiActivityMonitor that an extension API function has been
48 // called. May be called from any thread.
49 void NotifyApiFunctionCalled(const std::string& extension_id,
50 const std::string& api_name,
51 scoped_ptr<base::ListValue> args,
52 content::BrowserContext* browser_context) {
53 // The ApiActivityMonitor can only be accessed from the main (UI) thread. If
54 // we're running on the wrong thread, re-dispatch from the main thread.
55 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
56 BrowserThread::PostTask(BrowserThread::UI,
57 FROM_HERE,
58 base::Bind(&NotifyApiFunctionCalled,
59 extension_id,
60 api_name,
61 base::Passed(&args),
62 browser_context));
63 return;
65 // The BrowserContext may become invalid after the task above is posted.
66 if (!ExtensionsBrowserClient::Get()->IsValidContext(browser_context))
67 return;
69 ApiActivityMonitor* monitor =
70 ExtensionsBrowserClient::Get()->GetApiActivityMonitor(browser_context);
71 if (monitor)
72 monitor->OnApiFunctionCalled(extension_id, api_name, args.Pass());
75 // Separate copy of ExtensionAPI used for IO thread extension functions. We need
76 // this because ExtensionAPI has mutable data. It should be possible to remove
77 // this once all the extension APIs are updated to the feature system.
78 struct Static {
79 Static() : api(ExtensionAPI::CreateWithDefaultConfiguration()) {}
80 scoped_ptr<ExtensionAPI> api;
82 base::LazyInstance<Static> g_global_io_data = LAZY_INSTANCE_INITIALIZER;
84 // Kills the specified process because it sends us a malformed message.
85 // Track the specific function's |histogram_value|, as this may indicate a bug
86 // in that API's implementation on the renderer.
87 void KillBadMessageSender(const base::Process& process,
88 functions::HistogramValue histogram_value) {
89 NOTREACHED();
90 content::RecordAction(base::UserMetricsAction("BadMessageTerminate_EFD"));
91 UMA_HISTOGRAM_ENUMERATION("Extensions.BadMessageFunctionName",
92 histogram_value, functions::ENUM_BOUNDARY);
93 if (process.IsValid())
94 process.Terminate(content::RESULT_CODE_KILLED_BAD_MESSAGE, false);
97 void CommonResponseCallback(IPC::Sender* ipc_sender,
98 int routing_id,
99 const base::Process& peer_process,
100 int request_id,
101 ExtensionFunction::ResponseType type,
102 const base::ListValue& results,
103 const std::string& error,
104 functions::HistogramValue histogram_value) {
105 DCHECK(ipc_sender);
107 if (type == ExtensionFunction::BAD_MESSAGE) {
108 // The renderer has done validation before sending extension api requests.
109 // Therefore, we should never receive a request that is invalid in a way
110 // that JSON validation in the renderer should have caught. It could be an
111 // attacker trying to exploit the browser, so we crash the renderer instead.
112 LOG(ERROR) <<
113 "Terminating renderer because of malformed extension message.";
114 if (content::RenderProcessHost::run_renderer_in_process()) {
115 // In single process mode it is better if we don't suicide but just crash.
116 CHECK(false);
117 } else {
118 KillBadMessageSender(peer_process, histogram_value);
120 return;
123 ipc_sender->Send(new ExtensionMsg_Response(
124 routing_id, request_id, type == ExtensionFunction::SUCCEEDED, results,
125 error));
128 void IOThreadResponseCallback(
129 const base::WeakPtr<IOThreadExtensionMessageFilter>& ipc_sender,
130 int routing_id,
131 int request_id,
132 ExtensionFunction::ResponseType type,
133 const base::ListValue& results,
134 const std::string& error,
135 functions::HistogramValue histogram_value) {
136 if (!ipc_sender.get())
137 return;
139 base::Process peer_process =
140 base::Process::DeprecatedGetProcessFromHandle(ipc_sender->PeerHandle());
141 CommonResponseCallback(ipc_sender.get(), routing_id, peer_process, request_id,
142 type, results, error, histogram_value);
145 } // namespace
147 class ExtensionFunctionDispatcher::UIThreadResponseCallbackWrapper
148 : public content::WebContentsObserver {
149 public:
150 UIThreadResponseCallbackWrapper(
151 const base::WeakPtr<ExtensionFunctionDispatcher>& dispatcher,
152 content::RenderFrameHost* render_frame_host)
153 : content::WebContentsObserver(
154 content::WebContents::FromRenderFrameHost(render_frame_host)),
155 dispatcher_(dispatcher),
156 render_frame_host_(render_frame_host),
157 weak_ptr_factory_(this) {
160 ~UIThreadResponseCallbackWrapper() override {}
162 // content::WebContentsObserver overrides.
163 void RenderFrameDeleted(
164 content::RenderFrameHost* render_frame_host) override {
165 DCHECK_CURRENTLY_ON(BrowserThread::UI);
166 if (render_frame_host != render_frame_host_)
167 return;
169 if (dispatcher_.get()) {
170 dispatcher_->ui_thread_response_callback_wrappers_
171 .erase(render_frame_host);
174 delete this;
177 ExtensionFunction::ResponseCallback CreateCallback(int request_id) {
178 return base::Bind(
179 &UIThreadResponseCallbackWrapper::OnExtensionFunctionCompleted,
180 weak_ptr_factory_.GetWeakPtr(),
181 request_id);
184 private:
185 void OnExtensionFunctionCompleted(int request_id,
186 ExtensionFunction::ResponseType type,
187 const base::ListValue& results,
188 const std::string& error,
189 functions::HistogramValue histogram_value) {
190 base::Process process =
191 content::RenderProcessHost::run_renderer_in_process()
192 ? base::Process::Current()
193 : base::Process::DeprecatedGetProcessFromHandle(
194 render_frame_host_->GetProcess()->GetHandle());
195 CommonResponseCallback(render_frame_host_,
196 render_frame_host_->GetRoutingID(),
197 process, request_id, type, results, error,
198 histogram_value);
201 base::WeakPtr<ExtensionFunctionDispatcher> dispatcher_;
202 content::RenderFrameHost* render_frame_host_;
203 base::WeakPtrFactory<UIThreadResponseCallbackWrapper> weak_ptr_factory_;
205 DISALLOW_COPY_AND_ASSIGN(UIThreadResponseCallbackWrapper);
208 WindowController*
209 ExtensionFunctionDispatcher::Delegate::GetExtensionWindowController() const {
210 return nullptr;
213 content::WebContents*
214 ExtensionFunctionDispatcher::Delegate::GetAssociatedWebContents() const {
215 return nullptr;
218 content::WebContents*
219 ExtensionFunctionDispatcher::Delegate::GetVisibleWebContents() const {
220 return GetAssociatedWebContents();
223 bool ExtensionFunctionDispatcher::OverrideFunction(
224 const std::string& name, ExtensionFunctionFactory factory) {
225 return ExtensionFunctionRegistry::GetInstance()->OverrideFunction(name,
226 factory);
229 // static
230 void ExtensionFunctionDispatcher::DispatchOnIOThread(
231 InfoMap* extension_info_map,
232 void* profile_id,
233 int render_process_id,
234 base::WeakPtr<IOThreadExtensionMessageFilter> ipc_sender,
235 int routing_id,
236 const ExtensionHostMsg_Request_Params& params) {
237 const Extension* extension =
238 extension_info_map->extensions().GetByID(params.extension_id);
240 ExtensionFunction::ResponseCallback callback(
241 base::Bind(&IOThreadResponseCallback, ipc_sender, routing_id,
242 params.request_id));
244 scoped_refptr<ExtensionFunction> function(
245 CreateExtensionFunction(params,
246 extension,
247 render_process_id,
248 extension_info_map->process_map(),
249 g_global_io_data.Get().api.get(),
250 profile_id,
251 callback));
252 if (!function.get())
253 return;
255 IOThreadExtensionFunction* function_io =
256 function->AsIOThreadExtensionFunction();
257 if (!function_io) {
258 NOTREACHED();
259 return;
261 function_io->set_ipc_sender(ipc_sender, routing_id);
262 function_io->set_extension_info_map(extension_info_map);
263 if (extension) {
264 function->set_include_incognito(
265 extension_info_map->IsIncognitoEnabled(extension->id()));
268 if (!CheckPermissions(function.get(), params, callback))
269 return;
271 if (!extension) {
272 // Skip all of the UMA, quota, event page, activity logging stuff if there
273 // isn't an extension, e.g. if the function call was from WebUI.
274 function->Run()->Execute();
275 return;
278 QuotaService* quota = extension_info_map->GetQuotaService();
279 std::string violation_error = quota->Assess(extension->id(),
280 function.get(),
281 &params.arguments,
282 base::TimeTicks::Now());
283 if (violation_error.empty()) {
284 scoped_ptr<base::ListValue> args(params.arguments.DeepCopy());
285 NotifyApiFunctionCalled(extension->id(),
286 params.name,
287 args.Pass(),
288 static_cast<content::BrowserContext*>(profile_id));
289 UMA_HISTOGRAM_SPARSE_SLOWLY("Extensions.FunctionCalls",
290 function->histogram_value());
291 tracked_objects::ScopedProfile scoped_profile(
292 FROM_HERE_WITH_EXPLICIT_FUNCTION(function->name()),
293 tracked_objects::ScopedProfile::ENABLED);
294 function->Run()->Execute();
295 } else {
296 function->OnQuotaExceeded(violation_error);
300 ExtensionFunctionDispatcher::ExtensionFunctionDispatcher(
301 content::BrowserContext* browser_context)
302 : browser_context_(browser_context) {
305 ExtensionFunctionDispatcher::~ExtensionFunctionDispatcher() {
308 void ExtensionFunctionDispatcher::Dispatch(
309 const ExtensionHostMsg_Request_Params& params,
310 content::RenderFrameHost* render_frame_host) {
311 UIThreadResponseCallbackWrapperMap::const_iterator
312 iter = ui_thread_response_callback_wrappers_.find(render_frame_host);
313 UIThreadResponseCallbackWrapper* callback_wrapper = nullptr;
314 if (iter == ui_thread_response_callback_wrappers_.end()) {
315 callback_wrapper = new UIThreadResponseCallbackWrapper(AsWeakPtr(),
316 render_frame_host);
317 ui_thread_response_callback_wrappers_[render_frame_host] = callback_wrapper;
318 } else {
319 callback_wrapper = iter->second;
322 DispatchWithCallbackInternal(
323 params, render_frame_host,
324 callback_wrapper->CreateCallback(params.request_id));
327 void ExtensionFunctionDispatcher::DispatchWithCallbackInternal(
328 const ExtensionHostMsg_Request_Params& params,
329 content::RenderFrameHost* render_frame_host,
330 const ExtensionFunction::ResponseCallback& callback) {
331 DCHECK(render_frame_host);
332 // TODO(yzshen): There is some shared logic between this method and
333 // DispatchOnIOThread(). It is nice to deduplicate.
334 ProcessMap* process_map = ProcessMap::Get(browser_context_);
335 if (!process_map)
336 return;
338 ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context_);
339 const Extension* extension =
340 registry->enabled_extensions().GetByID(params.extension_id);
341 if (!extension) {
342 extension =
343 registry->enabled_extensions().GetHostedAppByURL(params.source_url);
346 int process_id = render_frame_host->GetProcess()->GetID();
347 scoped_refptr<ExtensionFunction> function(
348 CreateExtensionFunction(params,
349 extension,
350 process_id,
351 *process_map,
352 ExtensionAPI::GetSharedInstance(),
353 browser_context_,
354 callback));
355 if (!function.get())
356 return;
358 UIThreadExtensionFunction* function_ui =
359 function->AsUIThreadExtensionFunction();
360 if (!function_ui) {
361 NOTREACHED();
362 return;
364 function_ui->SetRenderFrameHost(render_frame_host);
365 function_ui->set_dispatcher(AsWeakPtr());
366 function_ui->set_browser_context(browser_context_);
367 if (extension &&
368 ExtensionsBrowserClient::Get()->CanExtensionCrossIncognito(
369 extension, browser_context_)) {
370 function->set_include_incognito(true);
373 if (!CheckPermissions(function.get(), params, callback))
374 return;
376 if (!extension) {
377 // Skip all of the UMA, quota, event page, activity logging stuff if there
378 // isn't an extension, e.g. if the function call was from WebUI.
379 function->Run()->Execute();
380 return;
383 // Fetch the ProcessManager before |this| is possibly invalidated.
384 ProcessManager* process_manager = ProcessManager::Get(browser_context_);
386 ExtensionSystem* extension_system = ExtensionSystem::Get(browser_context_);
387 QuotaService* quota = extension_system->quota_service();
388 std::string violation_error = quota->Assess(extension->id(),
389 function.get(),
390 &params.arguments,
391 base::TimeTicks::Now());
393 if (violation_error.empty()) {
394 scoped_ptr<base::ListValue> args(params.arguments.DeepCopy());
396 // See crbug.com/39178.
397 ExtensionsBrowserClient::Get()->PermitExternalProtocolHandler();
398 NotifyApiFunctionCalled(
399 extension->id(), params.name, args.Pass(), browser_context_);
400 UMA_HISTOGRAM_SPARSE_SLOWLY("Extensions.FunctionCalls",
401 function->histogram_value());
402 tracked_objects::ScopedProfile scoped_profile(
403 FROM_HERE_WITH_EXPLICIT_FUNCTION(function->name()),
404 tracked_objects::ScopedProfile::ENABLED);
405 function->Run()->Execute();
406 } else {
407 function->OnQuotaExceeded(violation_error);
410 // Note: do not access |this| after this point. We may have been deleted
411 // if function->Run() ended up closing the tab that owns us.
413 // Check if extension was uninstalled by management.uninstall.
414 if (!registry->enabled_extensions().GetByID(params.extension_id))
415 return;
417 // We only adjust the keepalive count for UIThreadExtensionFunction for
418 // now, largely for simplicity's sake. This is OK because currently, only
419 // the webRequest API uses IOThreadExtensionFunction, and that API is not
420 // compatible with lazy background pages.
421 process_manager->IncrementLazyKeepaliveCount(extension);
424 void ExtensionFunctionDispatcher::OnExtensionFunctionCompleted(
425 const Extension* extension) {
426 if (extension) {
427 ProcessManager::Get(browser_context_)
428 ->DecrementLazyKeepaliveCount(extension);
432 WindowController*
433 ExtensionFunctionDispatcher::GetExtensionWindowController() const {
434 return delegate_ ? delegate_->GetExtensionWindowController() : nullptr;
437 content::WebContents*
438 ExtensionFunctionDispatcher::GetAssociatedWebContents() const {
439 return delegate_ ? delegate_->GetAssociatedWebContents() : nullptr;
442 content::WebContents*
443 ExtensionFunctionDispatcher::GetVisibleWebContents() const {
444 return delegate_ ? delegate_->GetVisibleWebContents() :
445 GetAssociatedWebContents();
448 // static
449 bool ExtensionFunctionDispatcher::CheckPermissions(
450 ExtensionFunction* function,
451 const ExtensionHostMsg_Request_Params& params,
452 const ExtensionFunction::ResponseCallback& callback) {
453 if (!function->HasPermission()) {
454 LOG(ERROR) << "Permission denied for " << params.name;
455 SendAccessDenied(callback, function->histogram_value());
456 return false;
458 return true;
461 // static
462 ExtensionFunction* ExtensionFunctionDispatcher::CreateExtensionFunction(
463 const ExtensionHostMsg_Request_Params& params,
464 const Extension* extension,
465 int requesting_process_id,
466 const ProcessMap& process_map,
467 ExtensionAPI* api,
468 void* profile_id,
469 const ExtensionFunction::ResponseCallback& callback) {
470 ExtensionFunction* function =
471 ExtensionFunctionRegistry::GetInstance()->NewFunction(params.name);
472 if (!function) {
473 LOG(ERROR) << "Unknown Extension API - " << params.name;
474 SendAccessDenied(callback, function->histogram_value());
475 return NULL;
478 function->SetArgs(&params.arguments);
479 function->set_source_url(params.source_url);
480 function->set_request_id(params.request_id);
481 function->set_has_callback(params.has_callback);
482 function->set_user_gesture(params.user_gesture);
483 function->set_extension(extension);
484 function->set_profile_id(profile_id);
485 function->set_response_callback(callback);
486 function->set_source_tab_id(params.source_tab_id);
487 function->set_source_context_type(
488 process_map.GetMostLikelyContextType(extension, requesting_process_id));
489 function->set_source_process_id(requesting_process_id);
491 return function;
494 // static
495 void ExtensionFunctionDispatcher::SendAccessDenied(
496 const ExtensionFunction::ResponseCallback& callback,
497 functions::HistogramValue histogram_value) {
498 base::ListValue empty_list;
499 callback.Run(ExtensionFunction::FAILED, empty_list,
500 "Access to extension API denied.", histogram_value);
503 } // namespace extensions