1 // Copyright 2013 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 "extensions/browser/extension_function.h" 6 7 #include "base/logging.h" 8 #include "content/public/browser/notification_source.h" 9 #include "content/public/browser/notification_types.h" 10 #include "content/public/browser/render_frame_host.h" 11 #include "content/public/browser/render_view_host.h" 12 #include "content/public/browser/web_contents.h" 13 #include "content/public/browser/web_contents_observer.h" 14 #include "extensions/browser/extension_function_dispatcher.h" 15 #include "extensions/browser/extension_message_filter.h" 16 #include "extensions/common/error_utils.h" 17 #include "extensions/common/extension_api.h" 18 #include "extensions/common/extension_messages.h" 19 20 using content::BrowserThread; 21 using content::RenderViewHost; 22 using content::WebContents; 23 using extensions::ErrorUtils; 24 using extensions::ExtensionAPI; 25 using extensions::Feature; 26 27 namespace { 28 29 class ArgumentListResponseValue 30 : public ExtensionFunction::ResponseValueObject { 31 public: 32 ArgumentListResponseValue(const std::string& function_name, 33 const char* title, 34 ExtensionFunction* function, 35 scoped_ptr<base::ListValue> result) 36 : function_name_(function_name), title_(title) { 37 if (function->GetResultList()) { 38 DCHECK_EQ(function->GetResultList(), result.get()) 39 << "The result set on this function (" << function_name_ << ") " 40 << "either by calling SetResult() or directly modifying |result_| is " 41 << "different to the one passed to " << title_ << "(). " 42 << "The best way to fix this problem is to exclusively use " << title_ 43 << "(). SetResult() and |result_| are deprecated."; 44 } else { 45 function->SetResultList(result.Pass()); 46 } 47 // It would be nice to DCHECK(error.empty()) but some legacy extension 48 // function implementations... I'm looking at chrome.input.ime... do this 49 // for some reason. 50 } 51 52 virtual ~ArgumentListResponseValue() {} 53 54 virtual bool Apply() OVERRIDE { return true; } 55 56 private: 57 std::string function_name_; 58 const char* title_; 59 }; 60 61 class ErrorResponseValue : public ExtensionFunction::ResponseValueObject { 62 public: 63 ErrorResponseValue(ExtensionFunction* function, const std::string& error) { 64 // It would be nice to DCHECK(!error.empty()) but too many legacy extension 65 // function implementations don't set error but signal failure. 66 function->SetError(error); 67 } 68 69 virtual ~ErrorResponseValue() {} 70 71 virtual bool Apply() OVERRIDE { return false; } 72 }; 73 74 class BadMessageResponseValue : public ExtensionFunction::ResponseValueObject { 75 public: 76 explicit BadMessageResponseValue(ExtensionFunction* function) { 77 function->set_bad_message(true); 78 NOTREACHED() << function->name() << ": bad message"; 79 } 80 81 virtual ~BadMessageResponseValue() {} 82 83 virtual bool Apply() OVERRIDE { return false; } 84 }; 85 86 class RespondNowAction : public ExtensionFunction::ResponseActionObject { 87 public: 88 typedef base::Callback<void(bool)> SendResponseCallback; 89 RespondNowAction(ExtensionFunction::ResponseValue result, 90 const SendResponseCallback& send_response) 91 : result_(result.Pass()), send_response_(send_response) {} 92 virtual ~RespondNowAction() {} 93 94 virtual void Execute() OVERRIDE { send_response_.Run(result_->Apply()); } 95 96 private: 97 ExtensionFunction::ResponseValue result_; 98 SendResponseCallback send_response_; 99 }; 100 101 class RespondLaterAction : public ExtensionFunction::ResponseActionObject { 102 public: 103 virtual ~RespondLaterAction() {} 104 105 virtual void Execute() OVERRIDE {} 106 }; 107 108 } // namespace 109 110 // static 111 void ExtensionFunctionDeleteTraits::Destruct(const ExtensionFunction* x) { 112 x->Destruct(); 113 } 114 115 // Helper class to track the lifetime of ExtensionFunction's RenderViewHost or 116 // RenderFrameHost pointer and NULL it out when it dies. It also allows us to 117 // filter IPC messages coming from the RenderViewHost/RenderFrameHost. 118 class UIThreadExtensionFunction::RenderHostTracker 119 : public content::WebContentsObserver { 120 public: 121 explicit RenderHostTracker(UIThreadExtensionFunction* function) 122 : content::WebContentsObserver( 123 function->render_view_host() ? 124 WebContents::FromRenderViewHost(function->render_view_host()) : 125 WebContents::FromRenderFrameHost( 126 function->render_frame_host())), 127 function_(function) { 128 } 129 130 private: 131 // content::WebContentsObserver: 132 virtual void RenderViewDeleted( 133 content::RenderViewHost* render_view_host) OVERRIDE { 134 if (render_view_host != function_->render_view_host()) 135 return; 136 137 function_->SetRenderViewHost(NULL); 138 } 139 virtual void RenderFrameDeleted( 140 content::RenderFrameHost* render_frame_host) OVERRIDE { 141 if (render_frame_host != function_->render_frame_host()) 142 return; 143 144 function_->SetRenderFrameHost(NULL); 145 } 146 147 virtual bool OnMessageReceived( 148 const IPC::Message& message, 149 content::RenderFrameHost* render_frame_host) OVERRIDE { 150 DCHECK(render_frame_host); 151 if (render_frame_host == function_->render_frame_host()) 152 return function_->OnMessageReceived(message); 153 else 154 return false; 155 } 156 157 virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE { 158 return function_->OnMessageReceived(message); 159 } 160 161 UIThreadExtensionFunction* function_; 162 163 DISALLOW_COPY_AND_ASSIGN(RenderHostTracker); 164 }; 165 166 ExtensionFunction::ExtensionFunction() 167 : request_id_(-1), 168 profile_id_(NULL), 169 has_callback_(false), 170 include_incognito_(false), 171 user_gesture_(false), 172 bad_message_(false), 173 histogram_value_(extensions::functions::UNKNOWN), 174 source_tab_id_(-1) { 175 } 176 177 ExtensionFunction::~ExtensionFunction() { 178 } 179 180 UIThreadExtensionFunction* ExtensionFunction::AsUIThreadExtensionFunction() { 181 return NULL; 182 } 183 184 IOThreadExtensionFunction* ExtensionFunction::AsIOThreadExtensionFunction() { 185 return NULL; 186 } 187 188 bool ExtensionFunction::HasPermission() { 189 Feature::Availability availability = 190 ExtensionAPI::GetSharedInstance()->IsAvailable( 191 name_, extension_, Feature::BLESSED_EXTENSION_CONTEXT, source_url()); 192 return availability.is_available(); 193 } 194 195 void ExtensionFunction::OnQuotaExceeded(const std::string& violation_error) { 196 error_ = violation_error; 197 SendResponse(false); 198 } 199 200 void ExtensionFunction::SetArgs(const base::ListValue* args) { 201 DCHECK(!args_.get()); // Should only be called once. 202 args_.reset(args->DeepCopy()); 203 } 204 205 void ExtensionFunction::SetResult(base::Value* result) { 206 results_.reset(new base::ListValue()); 207 results_->Append(result); 208 } 209 210 void ExtensionFunction::SetResultList(scoped_ptr<base::ListValue> results) { 211 results_ = results.Pass(); 212 } 213 214 const base::ListValue* ExtensionFunction::GetResultList() const { 215 return results_.get(); 216 } 217 218 std::string ExtensionFunction::GetError() const { 219 return error_; 220 } 221 222 void ExtensionFunction::SetError(const std::string& error) { 223 error_ = error; 224 } 225 226 ExtensionFunction::ResponseValue ExtensionFunction::NoArguments() { 227 return ResponseValue(new ArgumentListResponseValue( 228 name(), "NoArguments", this, make_scoped_ptr(new base::ListValue()))); 229 } 230 231 ExtensionFunction::ResponseValue ExtensionFunction::OneArgument( 232 base::Value* arg) { 233 scoped_ptr<base::ListValue> args(new base::ListValue()); 234 args->Append(arg); 235 return ResponseValue( 236 new ArgumentListResponseValue(name(), "OneArgument", this, args.Pass())); 237 } 238 239 ExtensionFunction::ResponseValue ExtensionFunction::TwoArguments( 240 base::Value* arg1, 241 base::Value* arg2) { 242 scoped_ptr<base::ListValue> args(new base::ListValue()); 243 args->Append(arg1); 244 args->Append(arg2); 245 return ResponseValue( 246 new ArgumentListResponseValue(name(), "TwoArguments", this, args.Pass())); 247 } 248 249 ExtensionFunction::ResponseValue ExtensionFunction::ArgumentList( 250 scoped_ptr<base::ListValue> args) { 251 return ResponseValue( 252 new ArgumentListResponseValue(name(), "ArgumentList", this, args.Pass())); 253 } 254 255 ExtensionFunction::ResponseValue ExtensionFunction::Error( 256 const std::string& error) { 257 return ResponseValue(new ErrorResponseValue(this, error)); 258 } 259 260 ExtensionFunction::ResponseValue ExtensionFunction::Error( 261 const std::string& format, 262 const std::string& s1) { 263 return ResponseValue( 264 new ErrorResponseValue(this, ErrorUtils::FormatErrorMessage(format, s1))); 265 } 266 267 ExtensionFunction::ResponseValue ExtensionFunction::Error( 268 const std::string& format, 269 const std::string& s1, 270 const std::string& s2) { 271 return ResponseValue(new ErrorResponseValue( 272 this, ErrorUtils::FormatErrorMessage(format, s1, s2))); 273 } 274 275 ExtensionFunction::ResponseValue ExtensionFunction::Error( 276 const std::string& format, 277 const std::string& s1, 278 const std::string& s2, 279 const std::string& s3) { 280 return ResponseValue(new ErrorResponseValue( 281 this, ErrorUtils::FormatErrorMessage(format, s1, s2, s3))); 282 } 283 284 ExtensionFunction::ResponseValue ExtensionFunction::BadMessage() { 285 return ResponseValue(new BadMessageResponseValue(this)); 286 } 287 288 ExtensionFunction::ResponseAction ExtensionFunction::RespondNow( 289 ResponseValue result) { 290 return ResponseAction(new RespondNowAction( 291 result.Pass(), base::Bind(&ExtensionFunction::SendResponse, this))); 292 } 293 294 ExtensionFunction::ResponseAction ExtensionFunction::RespondLater() { 295 return ResponseAction(new RespondLaterAction()); 296 } 297 298 // static 299 ExtensionFunction::ResponseAction ExtensionFunction::ValidationFailure( 300 ExtensionFunction* function) { 301 return function->RespondNow(function->BadMessage()); 302 } 303 304 void ExtensionFunction::Respond(ResponseValue result) { 305 SendResponse(result->Apply()); 306 } 307 308 bool ExtensionFunction::ShouldSkipQuotaLimiting() const { 309 return false; 310 } 311 312 bool ExtensionFunction::HasOptionalArgument(size_t index) { 313 base::Value* value; 314 return args_->Get(index, &value) && !value->IsType(base::Value::TYPE_NULL); 315 } 316 317 void ExtensionFunction::SendResponseImpl(bool success) { 318 DCHECK(!response_callback_.is_null()); 319 320 ResponseType type = success ? SUCCEEDED : FAILED; 321 if (bad_message_) { 322 type = BAD_MESSAGE; 323 LOG(ERROR) << "Bad extension message " << name_; 324 } 325 326 // If results were never set, we send an empty argument list. 327 if (!results_) 328 results_.reset(new base::ListValue()); 329 330 response_callback_.Run(type, *results_, GetError()); 331 } 332 333 void ExtensionFunction::OnRespondingLater(ResponseValue value) { 334 SendResponse(value->Apply()); 335 } 336 337 UIThreadExtensionFunction::UIThreadExtensionFunction() 338 : render_view_host_(NULL), 339 render_frame_host_(NULL), 340 context_(NULL), 341 delegate_(NULL) { 342 } 343 344 UIThreadExtensionFunction::~UIThreadExtensionFunction() { 345 if (dispatcher() && render_view_host()) 346 dispatcher()->OnExtensionFunctionCompleted(GetExtension()); 347 } 348 349 UIThreadExtensionFunction* 350 UIThreadExtensionFunction::AsUIThreadExtensionFunction() { 351 return this; 352 } 353 354 bool UIThreadExtensionFunction::OnMessageReceived(const IPC::Message& message) { 355 return false; 356 } 357 358 void UIThreadExtensionFunction::Destruct() const { 359 BrowserThread::DeleteOnUIThread::Destruct(this); 360 } 361 362 void UIThreadExtensionFunction::SetRenderViewHost( 363 RenderViewHost* render_view_host) { 364 DCHECK(!render_frame_host_); 365 render_view_host_ = render_view_host; 366 tracker_.reset(render_view_host ? new RenderHostTracker(this) : NULL); 367 } 368 369 void UIThreadExtensionFunction::SetRenderFrameHost( 370 content::RenderFrameHost* render_frame_host) { 371 DCHECK(!render_view_host_); 372 render_frame_host_ = render_frame_host; 373 tracker_.reset(render_frame_host ? new RenderHostTracker(this) : NULL); 374 } 375 376 content::WebContents* UIThreadExtensionFunction::GetAssociatedWebContents() { 377 content::WebContents* web_contents = NULL; 378 if (dispatcher()) 379 web_contents = dispatcher()->delegate()->GetAssociatedWebContents(); 380 381 return web_contents; 382 } 383 384 void UIThreadExtensionFunction::SendResponse(bool success) { 385 if (delegate_) 386 delegate_->OnSendResponse(this, success, bad_message_); 387 else 388 SendResponseImpl(success); 389 390 if (!transferred_blob_uuids_.empty()) { 391 DCHECK(!delegate_) << "Blob transfer not supported with test delegate."; 392 GetIPCSender()->Send( 393 new ExtensionMsg_TransferBlobs(transferred_blob_uuids_)); 394 } 395 } 396 397 void UIThreadExtensionFunction::SetTransferredBlobUUIDs( 398 const std::vector<std::string>& blob_uuids) { 399 DCHECK(transferred_blob_uuids_.empty()); // Should only be called once. 400 transferred_blob_uuids_ = blob_uuids; 401 } 402 403 void UIThreadExtensionFunction::WriteToConsole( 404 content::ConsoleMessageLevel level, 405 const std::string& message) { 406 GetIPCSender()->Send( 407 new ExtensionMsg_AddMessageToConsole(GetRoutingID(), level, message)); 408 } 409 410 IPC::Sender* UIThreadExtensionFunction::GetIPCSender() { 411 if (render_view_host_) 412 return render_view_host_; 413 else 414 return render_frame_host_; 415 } 416 417 int UIThreadExtensionFunction::GetRoutingID() { 418 if (render_view_host_) 419 return render_view_host_->GetRoutingID(); 420 else 421 return render_frame_host_->GetRoutingID(); 422 } 423 424 IOThreadExtensionFunction::IOThreadExtensionFunction() 425 : routing_id_(MSG_ROUTING_NONE) { 426 } 427 428 IOThreadExtensionFunction::~IOThreadExtensionFunction() { 429 } 430 431 IOThreadExtensionFunction* 432 IOThreadExtensionFunction::AsIOThreadExtensionFunction() { 433 return this; 434 } 435 436 void IOThreadExtensionFunction::Destruct() const { 437 BrowserThread::DeleteOnIOThread::Destruct(this); 438 } 439 440 void IOThreadExtensionFunction::SendResponse(bool success) { 441 SendResponseImpl(success); 442 } 443 444 AsyncExtensionFunction::AsyncExtensionFunction() { 445 } 446 447 AsyncExtensionFunction::~AsyncExtensionFunction() { 448 } 449 450 ExtensionFunction::ResponseAction AsyncExtensionFunction::Run() { 451 return RunAsync() ? RespondLater() : RespondNow(Error(error_)); 452 } 453 454 // static 455 bool AsyncExtensionFunction::ValidationFailure( 456 AsyncExtensionFunction* function) { 457 return false; 458 } 459 460 SyncExtensionFunction::SyncExtensionFunction() { 461 } 462 463 SyncExtensionFunction::~SyncExtensionFunction() { 464 } 465 466 ExtensionFunction::ResponseAction SyncExtensionFunction::Run() { 467 return RespondNow(RunSync() ? ArgumentList(results_.Pass()) : Error(error_)); 468 } 469 470 // static 471 bool SyncExtensionFunction::ValidationFailure(SyncExtensionFunction* function) { 472 return false; 473 } 474 475 SyncIOThreadExtensionFunction::SyncIOThreadExtensionFunction() { 476 } 477 478 SyncIOThreadExtensionFunction::~SyncIOThreadExtensionFunction() { 479 } 480 481 ExtensionFunction::ResponseAction SyncIOThreadExtensionFunction::Run() { 482 return RespondNow(RunSync() ? ArgumentList(results_.Pass()) : Error(error_)); 483 } 484 485 // static 486 bool SyncIOThreadExtensionFunction::ValidationFailure( 487 SyncIOThreadExtensionFunction* function) { 488 return false; 489 } 490