[email protected] | 64c82073 | 2012-01-05 20:50:34 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
[email protected] | bfdffe2b | 2009-04-24 22:05:35 | [diff] [blame] | 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/browser/extensions/extension_function_dispatcher.h" |
| 6 | |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 7 | #include "base/bind.h" |
[email protected] | ffbec69 | 2012-02-26 20:26:42 | [diff] [blame] | 8 | #include "base/json/json_string_value_serializer.h" |
[email protected] | 5bc248a | 2012-04-04 23:38:11 | [diff] [blame] | 9 | #include "base/lazy_instance.h" |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 10 | #include "base/logging.h" |
[email protected] | 3b63f8f4 | 2011-03-28 01:54:15 | [diff] [blame] | 11 | #include "base/memory/ref_counted.h" |
[email protected] | d09a4ce1c | 2013-07-24 17:37:02 | [diff] [blame] | 12 | #include "base/process/process.h" |
[email protected] | bfdffe2b | 2009-04-24 22:05:35 | [diff] [blame] | 13 | #include "base/values.h" |
[email protected] | 17d40f0 | 2010-07-01 01:18:06 | [diff] [blame] | 14 | #include "build/build_config.h" |
[email protected] | 05602fa3 | 2013-08-01 06:30:43 | [diff] [blame] | 15 | #include "chrome/browser/extensions/activity_log/activity_action_constants.h" |
[email protected] | 17263b2 | 2013-05-16 03:29:22 | [diff] [blame] | 16 | #include "chrome/browser/extensions/activity_log/activity_log.h" |
[email protected] | 05602fa3 | 2013-08-01 06:30:43 | [diff] [blame] | 17 | #include "chrome/browser/extensions/api/activity_log_private/activity_log_private_api.h" |
[email protected] | ae33d32 | 2012-03-19 22:24:35 | [diff] [blame] | 18 | #include "chrome/browser/extensions/extension_function_registry.h" |
[email protected] | 2f69b38 | 2011-02-19 00:34:25 | [diff] [blame] | 19 | #include "chrome/browser/extensions/extension_service.h" |
[email protected] | efb4b08 | 2012-10-17 22:28:28 | [diff] [blame] | 20 | #include "chrome/browser/extensions/extension_system.h" |
[email protected] | 8f9d4eb | 2011-02-05 01:39:10 | [diff] [blame] | 21 | #include "chrome/browser/extensions/extension_web_ui.h" |
[email protected] | d13950e | 2009-12-04 01:43:02 | [diff] [blame] | 22 | #include "chrome/browser/extensions/extensions_quota_service.h" |
[email protected] | 83820d4 | 2011-11-12 22:03:11 | [diff] [blame] | 23 | #include "chrome/browser/extensions/process_map.h" |
[email protected] | ed2b100 | 2011-05-25 14:12:10 | [diff] [blame] | 24 | #include "chrome/browser/external_protocol/external_protocol_handler.h" |
[email protected] | 8ecad5e | 2010-12-02 21:18:33 | [diff] [blame] | 25 | #include "chrome/browser/profiles/profile.h" |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 26 | #include "chrome/browser/renderer_host/chrome_render_message_filter.h" |
[email protected] | 83820d4 | 2011-11-12 22:03:11 | [diff] [blame] | 27 | #include "chrome/common/extensions/api/extension_api.h" |
[email protected] | 44c49c9 | 2011-03-28 16:17:23 | [diff] [blame] | 28 | #include "chrome/common/extensions/extension_messages.h" |
[email protected] | 615d88f | 2011-12-13 01:47:44 | [diff] [blame] | 29 | #include "chrome/common/extensions/extension_set.h" |
[email protected] | 9c45b718 | 2009-08-04 16:44:43 | [diff] [blame] | 30 | #include "chrome/common/url_constants.h" |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 31 | #include "content/public/browser/browser_thread.h" |
[email protected] | c333e79 | 2012-01-06 16:57:39 | [diff] [blame] | 32 | #include "content/public/browser/render_process_host.h" |
[email protected] | 9c1662b | 2012-03-06 15:44:33 | [diff] [blame] | 33 | #include "content/public/browser/render_view_host.h" |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 34 | #include "content/public/browser/render_view_host_observer.h" |
| 35 | #include "content/public/browser/user_metrics.h" |
| 36 | #include "content/public/common/result_codes.h" |
[email protected] | f82d57b5 | 2011-04-27 19:13:17 | [diff] [blame] | 37 | #include "ipc/ipc_message.h" |
| 38 | #include "ipc/ipc_message_macros.h" |
[email protected] | d0fcff7 | 2013-07-23 02:45:43 | [diff] [blame] | 39 | #include "webkit/common/resource_type.h" |
[email protected] | 61b55b6 | 2011-03-24 09:03:10 | [diff] [blame] | 40 | |
[email protected] | 05602fa3 | 2013-08-01 06:30:43 | [diff] [blame] | 41 | using extensions::api::activity_log_private::BlockedChromeActivityDetail; |
[email protected] | 1c321ee | 2012-05-21 03:02:34 | [diff] [blame] | 42 | using extensions::Extension; |
[email protected] | 83820d4 | 2011-11-12 22:03:11 | [diff] [blame] | 43 | using extensions::ExtensionAPI; |
[email protected] | b5b26b7 | 2013-08-02 00:25:11 | [diff] [blame^] | 44 | using extensions::Feature; |
[email protected] | eaabba2 | 2012-03-07 15:02:11 | [diff] [blame] | 45 | using content::RenderViewHost; |
[email protected] | 83820d4 | 2011-11-12 22:03:11 | [diff] [blame] | 46 | |
[email protected] | 5bc248a | 2012-04-04 23:38:11 | [diff] [blame] | 47 | namespace { |
| 48 | |
[email protected] | e5a440c | 2013-06-04 21:55:12 | [diff] [blame] | 49 | void LogSuccess(const std::string& extension_id, |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 50 | const std::string& api_name, |
[email protected] | aeca23f | 2013-06-21 22:34:41 | [diff] [blame] | 51 | scoped_ptr<base::ListValue> args, |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 52 | Profile* profile) { |
| 53 | // The ActivityLog can only be accessed from the main (UI) thread. If we're |
| 54 | // 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(&LogSuccess, |
[email protected] | e5a440c | 2013-06-04 21:55:12 | [diff] [blame] | 59 | extension_id, |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 60 | api_name, |
[email protected] | c02087b51 | 2013-02-04 03:09:20 | [diff] [blame] | 61 | base::Passed(&args), |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 62 | profile)); |
| 63 | } else { |
| 64 | extensions::ActivityLog* activity_log = |
| 65 | extensions::ActivityLog::GetInstance(profile); |
[email protected] | 05602fa3 | 2013-08-01 06:30:43 | [diff] [blame] | 66 | scoped_refptr<extensions::Action> action = |
| 67 | new extensions::Action(extension_id, |
| 68 | base::Time::Now(), |
| 69 | extensions::Action::ACTION_API_CALL, |
| 70 | api_name); |
| 71 | action->set_args(args.Pass()); |
| 72 | activity_log->LogAction(action); |
[email protected] | efd7599 | 2011-12-15 22:42:42 | [diff] [blame] | 73 | } |
| 74 | } |
| 75 | |
[email protected] | e5a440c | 2013-06-04 21:55:12 | [diff] [blame] | 76 | void LogFailure(const std::string& extension_id, |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 77 | const std::string& api_name, |
[email protected] | aeca23f | 2013-06-21 22:34:41 | [diff] [blame] | 78 | scoped_ptr<base::ListValue> args, |
[email protected] | 05602fa3 | 2013-08-01 06:30:43 | [diff] [blame] | 79 | BlockedChromeActivityDetail::Reason reason, |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 80 | Profile* profile) { |
| 81 | // The ActivityLog can only be accessed from the main (UI) thread. If we're |
| 82 | // running on the wrong thread, re-dispatch from the main thread. |
| 83 | if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { |
| 84 | BrowserThread::PostTask(BrowserThread::UI, |
| 85 | FROM_HERE, |
| 86 | base::Bind(&LogFailure, |
[email protected] | e5a440c | 2013-06-04 21:55:12 | [diff] [blame] | 87 | extension_id, |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 88 | api_name, |
[email protected] | c02087b51 | 2013-02-04 03:09:20 | [diff] [blame] | 89 | base::Passed(&args), |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 90 | reason, |
| 91 | profile)); |
| 92 | } else { |
| 93 | extensions::ActivityLog* activity_log = |
| 94 | extensions::ActivityLog::GetInstance(profile); |
[email protected] | 05602fa3 | 2013-08-01 06:30:43 | [diff] [blame] | 95 | scoped_refptr<extensions::Action> action = |
| 96 | new extensions::Action(extension_id, |
| 97 | base::Time::Now(), |
| 98 | extensions::Action::ACTION_API_BLOCKED, |
| 99 | api_name); |
| 100 | action->set_args(args.Pass()); |
| 101 | action->mutable_other() |
| 102 | ->SetString(activity_log_constants::kActionBlockedReason, |
| 103 | BlockedChromeActivityDetail::ToString(reason)); |
| 104 | activity_log->LogAction(action); |
[email protected] | efd7599 | 2011-12-15 22:42:42 | [diff] [blame] | 105 | } |
| 106 | } |
| 107 | |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 108 | |
[email protected] | 5bc248a | 2012-04-04 23:38:11 | [diff] [blame] | 109 | // Separate copy of ExtensionAPI used for IO thread extension functions. We need |
| 110 | // this because ExtensionAPI has mutable data. It should be possible to remove |
| 111 | // this once all the extension APIs are updated to the feature system. |
| 112 | struct Static { |
| 113 | Static() |
| 114 | : api(extensions::ExtensionAPI::CreateWithDefaultConfiguration()) { |
| 115 | } |
| 116 | scoped_ptr<extensions::ExtensionAPI> api; |
| 117 | }; |
| 118 | base::LazyInstance<Static> g_global_io_data = LAZY_INSTANCE_INITIALIZER; |
| 119 | |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 120 | // Kills the specified process because it sends us a malformed message. |
| 121 | void KillBadMessageSender(base::ProcessHandle process) { |
| 122 | NOTREACHED(); |
| 123 | content::RecordAction(content::UserMetricsAction("BadMessageTerminate_EFD")); |
| 124 | if (process) |
| 125 | base::KillProcess(process, content::RESULT_CODE_KILLED_BAD_MESSAGE, false); |
| 126 | } |
| 127 | |
| 128 | void CommonResponseCallback(IPC::Sender* ipc_sender, |
| 129 | int routing_id, |
| 130 | base::ProcessHandle peer_process, |
| 131 | int request_id, |
| 132 | ExtensionFunction::ResponseType type, |
| 133 | const base::ListValue& results, |
| 134 | const std::string& error) { |
| 135 | DCHECK(ipc_sender); |
| 136 | |
| 137 | if (type == ExtensionFunction::BAD_MESSAGE) { |
| 138 | // The renderer has done validation before sending extension api requests. |
| 139 | // Therefore, we should never receive a request that is invalid in a way |
| 140 | // that JSON validation in the renderer should have caught. It could be an |
| 141 | // attacker trying to exploit the browser, so we crash the renderer instead. |
| 142 | LOG(ERROR) << |
| 143 | "Terminating renderer because of malformed extension message."; |
| 144 | if (content::RenderProcessHost::run_renderer_in_process()) { |
| 145 | // In single process mode it is better if we don't suicide but just crash. |
| 146 | CHECK(false); |
| 147 | } else { |
| 148 | KillBadMessageSender(peer_process); |
| 149 | } |
| 150 | |
| 151 | return; |
| 152 | } |
| 153 | |
| 154 | ipc_sender->Send(new ExtensionMsg_Response( |
| 155 | routing_id, request_id, type == ExtensionFunction::SUCCEEDED, results, |
| 156 | error)); |
| 157 | } |
| 158 | |
| 159 | void IOThreadResponseCallback( |
| 160 | const base::WeakPtr<ChromeRenderMessageFilter>& ipc_sender, |
| 161 | int routing_id, |
| 162 | int request_id, |
| 163 | ExtensionFunction::ResponseType type, |
| 164 | const base::ListValue& results, |
| 165 | const std::string& error) { |
[email protected] | e8dad9b | 2013-06-04 04:43:45 | [diff] [blame] | 166 | if (!ipc_sender.get()) |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 167 | return; |
| 168 | |
[email protected] | e8dad9b | 2013-06-04 04:43:45 | [diff] [blame] | 169 | CommonResponseCallback(ipc_sender.get(), |
| 170 | routing_id, |
[email protected] | 950be55 | 2013-07-10 19:13:02 | [diff] [blame] | 171 | ipc_sender->PeerHandle(), |
[email protected] | e8dad9b | 2013-06-04 04:43:45 | [diff] [blame] | 172 | request_id, |
| 173 | type, |
| 174 | results, |
| 175 | error); |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 176 | } |
| 177 | |
[email protected] | 5bc248a | 2012-04-04 23:38:11 | [diff] [blame] | 178 | } // namespace |
| 179 | |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 180 | class ExtensionFunctionDispatcher::UIThreadResponseCallbackWrapper |
| 181 | : public content::RenderViewHostObserver { |
| 182 | public: |
| 183 | UIThreadResponseCallbackWrapper( |
| 184 | const base::WeakPtr<ExtensionFunctionDispatcher>& dispatcher, |
| 185 | RenderViewHost* render_view_host) |
| 186 | : content::RenderViewHostObserver(render_view_host), |
| 187 | dispatcher_(dispatcher), |
| 188 | weak_ptr_factory_(this) { |
| 189 | } |
| 190 | |
| 191 | virtual ~UIThreadResponseCallbackWrapper() { |
| 192 | } |
| 193 | |
| 194 | // content::RenderViewHostObserver overrides. |
| 195 | virtual void RenderViewHostDestroyed( |
| 196 | RenderViewHost* render_view_host) OVERRIDE { |
| 197 | DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
[email protected] | e8dad9b | 2013-06-04 04:43:45 | [diff] [blame] | 198 | if (dispatcher_.get()) { |
| 199 | dispatcher_->ui_thread_response_callback_wrappers_ |
| 200 | .erase(render_view_host); |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 201 | } |
| 202 | |
| 203 | // This call will delete |this|. |
| 204 | content::RenderViewHostObserver::RenderViewHostDestroyed(render_view_host); |
| 205 | } |
| 206 | |
| 207 | ExtensionFunction::ResponseCallback CreateCallback(int request_id) { |
| 208 | return base::Bind( |
| 209 | &UIThreadResponseCallbackWrapper::OnExtensionFunctionCompleted, |
| 210 | weak_ptr_factory_.GetWeakPtr(), |
| 211 | request_id); |
| 212 | } |
| 213 | |
| 214 | private: |
| 215 | void OnExtensionFunctionCompleted(int request_id, |
| 216 | ExtensionFunction::ResponseType type, |
| 217 | const base::ListValue& results, |
| 218 | const std::string& error) { |
| 219 | CommonResponseCallback( |
| 220 | render_view_host(), render_view_host()->GetRoutingID(), |
| 221 | render_view_host()->GetProcess()->GetHandle(), request_id, type, |
| 222 | results, error); |
| 223 | } |
| 224 | |
| 225 | base::WeakPtr<ExtensionFunctionDispatcher> dispatcher_; |
| 226 | base::WeakPtrFactory<UIThreadResponseCallbackWrapper> weak_ptr_factory_; |
| 227 | |
| 228 | DISALLOW_COPY_AND_ASSIGN(UIThreadResponseCallbackWrapper); |
| 229 | }; |
| 230 | |
[email protected] | 44f4b13 | 2012-07-17 20:36:57 | [diff] [blame] | 231 | extensions::WindowController* |
| 232 | ExtensionFunctionDispatcher::Delegate::GetExtensionWindowController() |
[email protected] | d72d3a6 | 2012-05-10 03:45:08 | [diff] [blame] | 233 | const { |
| 234 | return NULL; |
| 235 | } |
| 236 | |
| 237 | content::WebContents* |
[email protected] | 44f4b13 | 2012-07-17 20:36:57 | [diff] [blame] | 238 | ExtensionFunctionDispatcher::Delegate::GetAssociatedWebContents() const { |
[email protected] | d72d3a6 | 2012-05-10 03:45:08 | [diff] [blame] | 239 | return NULL; |
| 240 | } |
[email protected] | 5bc248a | 2012-04-04 23:38:11 | [diff] [blame] | 241 | |
[email protected] | 1ce88e8 | 2013-06-28 05:17:10 | [diff] [blame] | 242 | content::WebContents* |
| 243 | ExtensionFunctionDispatcher::Delegate::GetVisibleWebContents() const { |
| 244 | return GetAssociatedWebContents(); |
| 245 | } |
| 246 | |
[email protected] | bfdffe2b | 2009-04-24 22:05:35 | [diff] [blame] | 247 | void ExtensionFunctionDispatcher::GetAllFunctionNames( |
| 248 | std::vector<std::string>* names) { |
[email protected] | ae33d32 | 2012-03-19 22:24:35 | [diff] [blame] | 249 | ExtensionFunctionRegistry::GetInstance()->GetAllNames(names); |
[email protected] | bfdffe2b | 2009-04-24 22:05:35 | [diff] [blame] | 250 | } |
| 251 | |
[email protected] | b83e460 | 2009-05-15 22:58:33 | [diff] [blame] | 252 | bool ExtensionFunctionDispatcher::OverrideFunction( |
| 253 | const std::string& name, ExtensionFunctionFactory factory) { |
[email protected] | ae33d32 | 2012-03-19 22:24:35 | [diff] [blame] | 254 | return ExtensionFunctionRegistry::GetInstance()->OverrideFunction(name, |
| 255 | factory); |
[email protected] | b83e460 | 2009-05-15 22:58:33 | [diff] [blame] | 256 | } |
| 257 | |
| 258 | void ExtensionFunctionDispatcher::ResetFunctions() { |
[email protected] | ae33d32 | 2012-03-19 22:24:35 | [diff] [blame] | 259 | ExtensionFunctionRegistry::GetInstance()->ResetFunctions(); |
[email protected] | b83e460 | 2009-05-15 22:58:33 | [diff] [blame] | 260 | } |
| 261 | |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 262 | // static |
| 263 | void ExtensionFunctionDispatcher::DispatchOnIOThread( |
[email protected] | fd50e7b | 2011-11-03 09:20:25 | [diff] [blame] | 264 | ExtensionInfoMap* extension_info_map, |
[email protected] | 67351452 | 2011-07-13 18:17:18 | [diff] [blame] | 265 | void* profile, |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 266 | int render_process_id, |
| 267 | base::WeakPtr<ChromeRenderMessageFilter> ipc_sender, |
[email protected] | 74e21e7 | 2012-07-09 21:20:53 | [diff] [blame] | 268 | int routing_id, |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 269 | const ExtensionHostMsg_Request_Params& params) { |
| 270 | const Extension* extension = |
[email protected] | 83820d4 | 2011-11-12 22:03:11 | [diff] [blame] | 271 | extension_info_map->extensions().GetByID(params.extension_id); |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 272 | Profile* profile_cast = static_cast<Profile*>(profile); |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 273 | |
| 274 | ExtensionFunction::ResponseCallback callback( |
| 275 | base::Bind(&IOThreadResponseCallback, ipc_sender, routing_id, |
| 276 | params.request_id)); |
| 277 | |
[email protected] | 6f37144 | 2011-11-09 06:45:46 | [diff] [blame] | 278 | scoped_refptr<ExtensionFunction> function( |
| 279 | CreateExtensionFunction(params, extension, render_process_id, |
[email protected] | 5bc248a | 2012-04-04 23:38:11 | [diff] [blame] | 280 | extension_info_map->process_map(), |
| 281 | g_global_io_data.Get().api.get(), |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 282 | profile, callback)); |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 283 | scoped_ptr<ListValue> args(params.arguments.DeepCopy()); |
| 284 | |
[email protected] | dc24976f | 2013-06-02 21:15:09 | [diff] [blame] | 285 | if (!function.get()) { |
[email protected] | e5a440c | 2013-06-04 21:55:12 | [diff] [blame] | 286 | LogFailure(extension->id(), |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 287 | params.name, |
| 288 | args.Pass(), |
[email protected] | 05602fa3 | 2013-08-01 06:30:43 | [diff] [blame] | 289 | BlockedChromeActivityDetail::REASON_ACCESS_DENIED, |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 290 | profile_cast); |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 291 | return; |
[email protected] | efd7599 | 2011-12-15 22:42:42 | [diff] [blame] | 292 | } |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 293 | |
| 294 | IOThreadExtensionFunction* function_io = |
| 295 | function->AsIOThreadExtensionFunction(); |
| 296 | if (!function_io) { |
| 297 | NOTREACHED(); |
| 298 | return; |
| 299 | } |
[email protected] | 44295a1 | 2013-06-05 08:45:46 | [diff] [blame] | 300 | function_io->set_ipc_sender(ipc_sender, routing_id); |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 301 | function_io->set_extension_info_map(extension_info_map); |
| 302 | function->set_include_incognito( |
| 303 | extension_info_map->IsIncognitoEnabled(extension->id())); |
[email protected] | fd50e7b | 2011-11-03 09:20:25 | [diff] [blame] | 304 | |
[email protected] | dc24976f | 2013-06-02 21:15:09 | [diff] [blame] | 305 | if (!CheckPermissions(function.get(), extension, params, callback)) { |
[email protected] | e5a440c | 2013-06-04 21:55:12 | [diff] [blame] | 306 | LogFailure(extension->id(), |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 307 | params.name, |
| 308 | args.Pass(), |
[email protected] | 05602fa3 | 2013-08-01 06:30:43 | [diff] [blame] | 309 | BlockedChromeActivityDetail::REASON_ACCESS_DENIED, |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 310 | profile_cast); |
[email protected] | d2fe22ff | 2012-10-03 00:40:07 | [diff] [blame] | 311 | return; |
| 312 | } |
| 313 | |
[email protected] | 3629691 | 2012-03-20 11:08:49 | [diff] [blame] | 314 | ExtensionsQuotaService* quota = extension_info_map->GetQuotaService(); |
[email protected] | 85231d7 | 2012-08-31 09:45:29 | [diff] [blame] | 315 | std::string violation_error = quota->Assess(extension->id(), |
[email protected] | dc24976f | 2013-06-02 21:15:09 | [diff] [blame] | 316 | function.get(), |
[email protected] | 85231d7 | 2012-08-31 09:45:29 | [diff] [blame] | 317 | ¶ms.arguments, |
| 318 | base::TimeTicks::Now()); |
| 319 | if (violation_error.empty()) { |
[email protected] | e5a440c | 2013-06-04 21:55:12 | [diff] [blame] | 320 | LogSuccess(extension->id(), |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 321 | params.name, |
| 322 | args.Pass(), |
| 323 | profile_cast); |
[email protected] | fd50e7b | 2011-11-03 09:20:25 | [diff] [blame] | 324 | function->Run(); |
| 325 | } else { |
[email protected] | e5a440c | 2013-06-04 21:55:12 | [diff] [blame] | 326 | LogFailure(extension->id(), |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 327 | params.name, |
| 328 | args.Pass(), |
[email protected] | 05602fa3 | 2013-08-01 06:30:43 | [diff] [blame] | 329 | BlockedChromeActivityDetail::REASON_QUOTA_EXCEEDED, |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 330 | profile_cast); |
[email protected] | 85231d7 | 2012-08-31 09:45:29 | [diff] [blame] | 331 | function->OnQuotaExceeded(violation_error); |
[email protected] | fd50e7b | 2011-11-03 09:20:25 | [diff] [blame] | 332 | } |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 333 | } |
| 334 | |
[email protected] | c5dbef0 | 2011-05-13 05:06:09 | [diff] [blame] | 335 | ExtensionFunctionDispatcher::ExtensionFunctionDispatcher(Profile* profile, |
| 336 | Delegate* delegate) |
| 337 | : profile_(profile), |
[email protected] | 55ce33071 | 2011-05-24 19:04:27 | [diff] [blame] | 338 | delegate_(delegate) { |
[email protected] | bfdffe2b | 2009-04-24 22:05:35 | [diff] [blame] | 339 | } |
| 340 | |
[email protected] | 32dda36 | 2009-06-05 19:07:01 | [diff] [blame] | 341 | ExtensionFunctionDispatcher::~ExtensionFunctionDispatcher() { |
[email protected] | 32dda36 | 2009-06-05 19:07:01 | [diff] [blame] | 342 | } |
| 343 | |
[email protected] | c5dbef0 | 2011-05-13 05:06:09 | [diff] [blame] | 344 | void ExtensionFunctionDispatcher::Dispatch( |
| 345 | const ExtensionHostMsg_Request_Params& params, |
| 346 | RenderViewHost* render_view_host) { |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 347 | UIThreadResponseCallbackWrapperMap::const_iterator |
| 348 | iter = ui_thread_response_callback_wrappers_.find(render_view_host); |
| 349 | UIThreadResponseCallbackWrapper* callback_wrapper = NULL; |
| 350 | if (iter == ui_thread_response_callback_wrappers_.end()) { |
| 351 | callback_wrapper = new UIThreadResponseCallbackWrapper(AsWeakPtr(), |
| 352 | render_view_host); |
| 353 | ui_thread_response_callback_wrappers_[render_view_host] = callback_wrapper; |
| 354 | } else { |
| 355 | callback_wrapper = iter->second; |
| 356 | } |
| 357 | |
| 358 | DispatchWithCallback(params, render_view_host, |
| 359 | callback_wrapper->CreateCallback(params.request_id)); |
| 360 | } |
| 361 | |
| 362 | void ExtensionFunctionDispatcher::DispatchWithCallback( |
| 363 | const ExtensionHostMsg_Request_Params& params, |
| 364 | RenderViewHost* render_view_host, |
| 365 | const ExtensionFunction::ResponseCallback& callback) { |
| 366 | // TODO(yzshen): There is some shared logic between this method and |
| 367 | // DispatchOnIOThread(). It is nice to deduplicate. |
[email protected] | c5dbef0 | 2011-05-13 05:06:09 | [diff] [blame] | 368 | ExtensionService* service = profile()->GetExtensionService(); |
[email protected] | efb4b08 | 2012-10-17 22:28:28 | [diff] [blame] | 369 | ExtensionProcessManager* process_manager = |
| 370 | extensions::ExtensionSystem::Get(profile())->process_manager(); |
[email protected] | 6f37144 | 2011-11-09 06:45:46 | [diff] [blame] | 371 | extensions::ProcessMap* process_map = service->process_map(); |
| 372 | if (!service || !process_map) |
[email protected] | c5dbef0 | 2011-05-13 05:06:09 | [diff] [blame] | 373 | return; |
| 374 | |
[email protected] | 615d88f | 2011-12-13 01:47:44 | [diff] [blame] | 375 | const Extension* extension = service->extensions()->GetByID( |
| 376 | params.extension_id); |
[email protected] | c5dbef0 | 2011-05-13 05:06:09 | [diff] [blame] | 377 | if (!extension) |
[email protected] | be9915fb | 2013-07-18 09:28:55 | [diff] [blame] | 378 | extension = service->extensions()->GetHostedAppByURL(params.source_url); |
[email protected] | c5dbef0 | 2011-05-13 05:06:09 | [diff] [blame] | 379 | |
[email protected] | 8add541 | 2011-10-01 21:02:14 | [diff] [blame] | 380 | scoped_refptr<ExtensionFunction> function( |
[email protected] | 74e21e7 | 2012-07-09 21:20:53 | [diff] [blame] | 381 | CreateExtensionFunction(params, extension, |
[email protected] | 9f76c1e | 2012-03-05 15:15:58 | [diff] [blame] | 382 | render_view_host->GetProcess()->GetID(), |
[email protected] | 6f37144 | 2011-11-09 06:45:46 | [diff] [blame] | 383 | *(service->process_map()), |
[email protected] | 5bc248a | 2012-04-04 23:38:11 | [diff] [blame] | 384 | extensions::ExtensionAPI::GetSharedInstance(), |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 385 | profile(), callback)); |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 386 | scoped_ptr<ListValue> args(params.arguments.DeepCopy()); |
| 387 | |
[email protected] | dc24976f | 2013-06-02 21:15:09 | [diff] [blame] | 388 | if (!function.get()) { |
[email protected] | e5a440c | 2013-06-04 21:55:12 | [diff] [blame] | 389 | LogFailure(extension->id(), |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 390 | params.name, |
| 391 | args.Pass(), |
[email protected] | 05602fa3 | 2013-08-01 06:30:43 | [diff] [blame] | 392 | BlockedChromeActivityDetail::REASON_ACCESS_DENIED, |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 393 | profile()); |
[email protected] | f82d57b5 | 2011-04-27 19:13:17 | [diff] [blame] | 394 | return; |
[email protected] | efd7599 | 2011-12-15 22:42:42 | [diff] [blame] | 395 | } |
[email protected] | f82d57b5 | 2011-04-27 19:13:17 | [diff] [blame] | 396 | |
[email protected] | a2aef2e | 2011-05-26 22:48:12 | [diff] [blame] | 397 | UIThreadExtensionFunction* function_ui = |
| 398 | function->AsUIThreadExtensionFunction(); |
| 399 | if (!function_ui) { |
| 400 | NOTREACHED(); |
| 401 | return; |
| 402 | } |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 403 | function_ui->SetRenderViewHost(render_view_host); |
[email protected] | a2aef2e | 2011-05-26 22:48:12 | [diff] [blame] | 404 | function_ui->set_dispatcher(AsWeakPtr()); |
| 405 | function_ui->set_profile(profile_); |
[email protected] | 2a8f24e | 2010-11-03 21:37:05 | [diff] [blame] | 406 | function->set_include_incognito(service->CanCrossIncognito(extension)); |
[email protected] | cb0ce1e02 | 2010-03-10 19:54:41 | [diff] [blame] | 407 | |
[email protected] | dc24976f | 2013-06-02 21:15:09 | [diff] [blame] | 408 | if (!CheckPermissions(function.get(), extension, params, callback)) { |
[email protected] | e5a440c | 2013-06-04 21:55:12 | [diff] [blame] | 409 | LogFailure(extension->id(), |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 410 | params.name, |
| 411 | args.Pass(), |
[email protected] | 05602fa3 | 2013-08-01 06:30:43 | [diff] [blame] | 412 | BlockedChromeActivityDetail::REASON_ACCESS_DENIED, |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 413 | profile()); |
[email protected] | d2fe22ff | 2012-10-03 00:40:07 | [diff] [blame] | 414 | return; |
| 415 | } |
| 416 | |
[email protected] | d13950e | 2009-12-04 01:43:02 | [diff] [blame] | 417 | ExtensionsQuotaService* quota = service->quota_service(); |
[email protected] | 85231d7 | 2012-08-31 09:45:29 | [diff] [blame] | 418 | std::string violation_error = quota->Assess(extension->id(), |
[email protected] | dc24976f | 2013-06-02 21:15:09 | [diff] [blame] | 419 | function.get(), |
[email protected] | 85231d7 | 2012-08-31 09:45:29 | [diff] [blame] | 420 | ¶ms.arguments, |
| 421 | base::TimeTicks::Now()); |
| 422 | if (violation_error.empty()) { |
[email protected] | d070ec6 | 2010-07-27 21:28:26 | [diff] [blame] | 423 | // See crbug.com/39178. |
| 424 | ExternalProtocolHandler::PermitLaunchUrl(); |
[email protected] | e5a440c | 2013-06-04 21:55:12 | [diff] [blame] | 425 | LogSuccess(extension->id(), params.name, args.Pass(), profile()); |
[email protected] | d13950e | 2009-12-04 01:43:02 | [diff] [blame] | 426 | function->Run(); |
| 427 | } else { |
[email protected] | e5a440c | 2013-06-04 21:55:12 | [diff] [blame] | 428 | LogFailure(extension->id(), |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 429 | params.name, |
| 430 | args.Pass(), |
[email protected] | 05602fa3 | 2013-08-01 06:30:43 | [diff] [blame] | 431 | BlockedChromeActivityDetail::REASON_QUOTA_EXCEEDED, |
[email protected] | 4b64d71 | 2013-01-17 17:53:17 | [diff] [blame] | 432 | profile()); |
[email protected] | 85231d7 | 2012-08-31 09:45:29 | [diff] [blame] | 433 | function->OnQuotaExceeded(violation_error); |
[email protected] | d13950e | 2009-12-04 01:43:02 | [diff] [blame] | 434 | } |
[email protected] | 720ad131 | 2012-02-27 23:07:36 | [diff] [blame] | 435 | |
[email protected] | efb4b08 | 2012-10-17 22:28:28 | [diff] [blame] | 436 | // Note: do not access |this| after this point. We may have been deleted |
| 437 | // if function->Run() ended up closing the tab that owns us. |
| 438 | |
[email protected] | 5734e88 | 2012-05-04 22:17:56 | [diff] [blame] | 439 | // Check if extension was uninstalled by management.uninstall. |
| 440 | if (!service->extensions()->GetByID(params.extension_id)) |
| 441 | return; |
| 442 | |
[email protected] | 720ad131 | 2012-02-27 23:07:36 | [diff] [blame] | 443 | // We only adjust the keepalive count for UIThreadExtensionFunction for |
| 444 | // now, largely for simplicity's sake. This is OK because currently, only |
| 445 | // the webRequest API uses IOThreadExtensionFunction, and that API is not |
| 446 | // compatible with lazy background pages. |
[email protected] | efb4b08 | 2012-10-17 22:28:28 | [diff] [blame] | 447 | process_manager->IncrementLazyKeepaliveCount(extension); |
[email protected] | 720ad131 | 2012-02-27 23:07:36 | [diff] [blame] | 448 | } |
| 449 | |
| 450 | void ExtensionFunctionDispatcher::OnExtensionFunctionCompleted( |
| 451 | const Extension* extension) { |
[email protected] | be93bba0 | 2012-10-24 16:44:03 | [diff] [blame] | 452 | extensions::ExtensionSystem::Get(profile())->process_manager()-> |
| 453 | DecrementLazyKeepaliveCount(extension); |
[email protected] | bfdffe2b | 2009-04-24 22:05:35 | [diff] [blame] | 454 | } |
| 455 | |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 456 | // static |
[email protected] | d2fe22ff | 2012-10-03 00:40:07 | [diff] [blame] | 457 | bool ExtensionFunctionDispatcher::CheckPermissions( |
| 458 | ExtensionFunction* function, |
| 459 | const Extension* extension, |
| 460 | const ExtensionHostMsg_Request_Params& params, |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 461 | const ExtensionFunction::ResponseCallback& callback) { |
[email protected] | d2fe22ff | 2012-10-03 00:40:07 | [diff] [blame] | 462 | if (!function->HasPermission()) { |
| 463 | LOG(ERROR) << "Extension " << extension->id() << " does not have " |
| 464 | << "permission to function: " << params.name; |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 465 | SendAccessDenied(callback); |
[email protected] | d2fe22ff | 2012-10-03 00:40:07 | [diff] [blame] | 466 | return false; |
| 467 | } |
| 468 | return true; |
| 469 | } |
| 470 | |
[email protected] | f3354211 | 2013-02-04 16:52:38 | [diff] [blame] | 471 | namespace { |
| 472 | |
| 473 | // Only COMPONENT hosted apps may call extension APIs, and they are limited |
| 474 | // to just the permissions they explicitly request. They should not have access |
| 475 | // to extension APIs like eg chrome.runtime, chrome.windows, etc. that normally |
| 476 | // are available without permission. |
[email protected] | b5b26b7 | 2013-08-02 00:25:11 | [diff] [blame^] | 477 | // TODO(mpcomplete): move this to ExtensionFunction::HasPermission (or remove |
| 478 | // it altogether). |
[email protected] | f3354211 | 2013-02-04 16:52:38 | [diff] [blame] | 479 | bool AllowHostedAppAPICall(const Extension& extension, |
| 480 | const GURL& source_url, |
| 481 | const std::string& function_name) { |
| 482 | if (extension.location() != extensions::Manifest::COMPONENT) |
| 483 | return false; |
| 484 | |
| 485 | if (!extension.web_extent().MatchesURL(source_url)) |
| 486 | return false; |
| 487 | |
[email protected] | b5b26b7 | 2013-08-02 00:25:11 | [diff] [blame^] | 488 | Feature::Availability availability = |
| 489 | ExtensionAPI::GetSharedInstance()->IsAvailable( |
| 490 | function_name, &extension, Feature::BLESSED_EXTENSION_CONTEXT, |
| 491 | source_url); |
| 492 | return availability.is_available(); |
[email protected] | f3354211 | 2013-02-04 16:52:38 | [diff] [blame] | 493 | } |
| 494 | |
| 495 | } // namespace |
| 496 | |
| 497 | |
[email protected] | d2fe22ff | 2012-10-03 00:40:07 | [diff] [blame] | 498 | // static |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 499 | ExtensionFunction* ExtensionFunctionDispatcher::CreateExtensionFunction( |
| 500 | const ExtensionHostMsg_Request_Params& params, |
| 501 | const Extension* extension, |
[email protected] | 6f37144 | 2011-11-09 06:45:46 | [diff] [blame] | 502 | int requesting_process_id, |
| 503 | const extensions::ProcessMap& process_map, |
[email protected] | 5bc248a | 2012-04-04 23:38:11 | [diff] [blame] | 504 | extensions::ExtensionAPI* api, |
[email protected] | 67351452 | 2011-07-13 18:17:18 | [diff] [blame] | 505 | void* profile, |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 506 | const ExtensionFunction::ResponseCallback& callback) { |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 507 | if (!extension) { |
[email protected] | 6f37144 | 2011-11-09 06:45:46 | [diff] [blame] | 508 | LOG(ERROR) << "Specified extension does not exist."; |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 509 | SendAccessDenied(callback); |
[email protected] | 6f37144 | 2011-11-09 06:45:46 | [diff] [blame] | 510 | return NULL; |
| 511 | } |
| 512 | |
[email protected] | f3354211 | 2013-02-04 16:52:38 | [diff] [blame] | 513 | // Most hosted apps can't call APIs. |
| 514 | bool allowed = true; |
| 515 | if (extension->is_hosted_app()) |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 516 | allowed = AllowHostedAppAPICall(*extension, params.source_url, params.name); |
[email protected] | f3354211 | 2013-02-04 16:52:38 | [diff] [blame] | 517 | |
| 518 | // Privileged APIs can only be called from the process the extension |
| 519 | // is running in. |
| 520 | if (allowed && api->IsPrivileged(params.name)) |
| 521 | allowed = process_map.Contains(extension->id(), requesting_process_id); |
| 522 | |
| 523 | if (!allowed) { |
| 524 | LOG(ERROR) << "Extension API call disallowed - name:" << params.name |
| 525 | << " pid:" << requesting_process_id |
[email protected] | 6f37144 | 2011-11-09 06:45:46 | [diff] [blame] | 526 | << " from URL " << params.source_url.spec(); |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 527 | SendAccessDenied(callback); |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 528 | return NULL; |
| 529 | } |
| 530 | |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 531 | ExtensionFunction* function = |
[email protected] | ae33d32 | 2012-03-19 22:24:35 | [diff] [blame] | 532 | ExtensionFunctionRegistry::GetInstance()->NewFunction(params.name); |
[email protected] | 42681ec8 | 2013-04-09 12:40:14 | [diff] [blame] | 533 | if (!function) { |
| 534 | LOG(ERROR) << "Unknown Extension API - " << params.name; |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 535 | SendAccessDenied(callback); |
[email protected] | 42681ec8 | 2013-04-09 12:40:14 | [diff] [blame] | 536 | return NULL; |
| 537 | } |
| 538 | |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 539 | function->SetArgs(¶ms.arguments); |
| 540 | function->set_source_url(params.source_url); |
| 541 | function->set_request_id(params.request_id); |
| 542 | function->set_has_callback(params.has_callback); |
| 543 | function->set_user_gesture(params.user_gesture); |
| 544 | function->set_extension(extension); |
[email protected] | 637bf32 | 2011-10-01 20:46:32 | [diff] [blame] | 545 | function->set_profile_id(profile); |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 546 | function->set_response_callback(callback); |
[email protected] | 3d0e226 | 2012-08-02 15:32:16 | [diff] [blame] | 547 | |
[email protected] | c357acb4 | 2011-06-09 20:52:42 | [diff] [blame] | 548 | return function; |
| 549 | } |
| 550 | |
| 551 | // static |
[email protected] | c5dbef0 | 2011-05-13 05:06:09 | [diff] [blame] | 552 | void ExtensionFunctionDispatcher::SendAccessDenied( |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 553 | const ExtensionFunction::ResponseCallback& callback) { |
[email protected] | 602542d | 2012-04-20 02:48:01 | [diff] [blame] | 554 | ListValue empty_list; |
[email protected] | 35548ab | 2013-05-15 08:59:47 | [diff] [blame] | 555 | callback.Run(ExtensionFunction::FAILED, empty_list, |
| 556 | "Access to extension API denied."); |
[email protected] | bfdffe2b | 2009-04-24 22:05:35 | [diff] [blame] | 557 | } |