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 20using content::BrowserThread; 21using content::RenderViewHost; 22using content::WebContents; 23using extensions::ErrorUtils; 24using extensions::ExtensionAPI; 25using extensions::Feature; 26 27namespace { 28 29class 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 61class 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 74class 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 86class 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 101class RespondLaterAction : public ExtensionFunction::ResponseActionObject { 102 public: 103 virtual ~RespondLaterAction() {} 104 105 virtual void Execute() OVERRIDE {} 106}; 107 108} // namespace 109 110// static 111void 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. 118class 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 166ExtensionFunction::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 source_context_type_(Feature::UNSPECIFIED_CONTEXT) { 176} 177 178ExtensionFunction::~ExtensionFunction() { 179} 180 181UIThreadExtensionFunction* ExtensionFunction::AsUIThreadExtensionFunction() { 182 return NULL; 183} 184 185IOThreadExtensionFunction* ExtensionFunction::AsIOThreadExtensionFunction() { 186 return NULL; 187} 188 189bool ExtensionFunction::HasPermission() { 190 Feature::Availability availability = 191 ExtensionAPI::GetSharedInstance()->IsAvailable( 192 name_, extension_.get(), source_context_type_, source_url()); 193 return availability.is_available(); 194} 195 196void ExtensionFunction::OnQuotaExceeded(const std::string& violation_error) { 197 error_ = violation_error; 198 SendResponse(false); 199} 200 201void ExtensionFunction::SetArgs(const base::ListValue* args) { 202 DCHECK(!args_.get()); // Should only be called once. 203 args_.reset(args->DeepCopy()); 204} 205 206void ExtensionFunction::SetResult(base::Value* result) { 207 results_.reset(new base::ListValue()); 208 results_->Append(result); 209} 210 211void ExtensionFunction::SetResultList(scoped_ptr<base::ListValue> results) { 212 results_ = results.Pass(); 213} 214 215const base::ListValue* ExtensionFunction::GetResultList() const { 216 return results_.get(); 217} 218 219std::string ExtensionFunction::GetError() const { 220 return error_; 221} 222 223void ExtensionFunction::SetError(const std::string& error) { 224 error_ = error; 225} 226 227ExtensionFunction::ResponseValue ExtensionFunction::NoArguments() { 228 return ResponseValue(new ArgumentListResponseValue( 229 name(), "NoArguments", this, make_scoped_ptr(new base::ListValue()))); 230} 231 232ExtensionFunction::ResponseValue ExtensionFunction::OneArgument( 233 base::Value* arg) { 234 scoped_ptr<base::ListValue> args(new base::ListValue()); 235 args->Append(arg); 236 return ResponseValue( 237 new ArgumentListResponseValue(name(), "OneArgument", this, args.Pass())); 238} 239 240ExtensionFunction::ResponseValue ExtensionFunction::TwoArguments( 241 base::Value* arg1, 242 base::Value* arg2) { 243 scoped_ptr<base::ListValue> args(new base::ListValue()); 244 args->Append(arg1); 245 args->Append(arg2); 246 return ResponseValue( 247 new ArgumentListResponseValue(name(), "TwoArguments", this, args.Pass())); 248} 249 250ExtensionFunction::ResponseValue ExtensionFunction::ArgumentList( 251 scoped_ptr<base::ListValue> args) { 252 return ResponseValue( 253 new ArgumentListResponseValue(name(), "ArgumentList", this, args.Pass())); 254} 255 256ExtensionFunction::ResponseValue ExtensionFunction::Error( 257 const std::string& error) { 258 return ResponseValue(new ErrorResponseValue(this, error)); 259} 260 261ExtensionFunction::ResponseValue ExtensionFunction::Error( 262 const std::string& format, 263 const std::string& s1) { 264 return ResponseValue( 265 new ErrorResponseValue(this, ErrorUtils::FormatErrorMessage(format, s1))); 266} 267 268ExtensionFunction::ResponseValue ExtensionFunction::Error( 269 const std::string& format, 270 const std::string& s1, 271 const std::string& s2) { 272 return ResponseValue(new ErrorResponseValue( 273 this, ErrorUtils::FormatErrorMessage(format, s1, s2))); 274} 275 276ExtensionFunction::ResponseValue ExtensionFunction::Error( 277 const std::string& format, 278 const std::string& s1, 279 const std::string& s2, 280 const std::string& s3) { 281 return ResponseValue(new ErrorResponseValue( 282 this, ErrorUtils::FormatErrorMessage(format, s1, s2, s3))); 283} 284 285ExtensionFunction::ResponseValue ExtensionFunction::BadMessage() { 286 return ResponseValue(new BadMessageResponseValue(this)); 287} 288 289ExtensionFunction::ResponseAction ExtensionFunction::RespondNow( 290 ResponseValue result) { 291 return ResponseAction(new RespondNowAction( 292 result.Pass(), base::Bind(&ExtensionFunction::SendResponse, this))); 293} 294 295ExtensionFunction::ResponseAction ExtensionFunction::RespondLater() { 296 return ResponseAction(new RespondLaterAction()); 297} 298 299// static 300ExtensionFunction::ResponseAction ExtensionFunction::ValidationFailure( 301 ExtensionFunction* function) { 302 return function->RespondNow(function->BadMessage()); 303} 304 305void ExtensionFunction::Respond(ResponseValue result) { 306 SendResponse(result->Apply()); 307} 308 309bool ExtensionFunction::ShouldSkipQuotaLimiting() const { 310 return false; 311} 312 313bool ExtensionFunction::HasOptionalArgument(size_t index) { 314 base::Value* value; 315 return args_->Get(index, &value) && !value->IsType(base::Value::TYPE_NULL); 316} 317 318void ExtensionFunction::SendResponseImpl(bool success) { 319 DCHECK(!response_callback_.is_null()); 320 321 ResponseType type = success ? SUCCEEDED : FAILED; 322 if (bad_message_) { 323 type = BAD_MESSAGE; 324 LOG(ERROR) << "Bad extension message " << name_; 325 } 326 327 // If results were never set, we send an empty argument list. 328 if (!results_) 329 results_.reset(new base::ListValue()); 330 331 response_callback_.Run(type, *results_, GetError()); 332} 333 334void ExtensionFunction::OnRespondingLater(ResponseValue value) { 335 SendResponse(value->Apply()); 336} 337 338UIThreadExtensionFunction::UIThreadExtensionFunction() 339 : render_view_host_(NULL), 340 render_frame_host_(NULL), 341 context_(NULL), 342 delegate_(NULL) { 343} 344 345UIThreadExtensionFunction::~UIThreadExtensionFunction() { 346 if (dispatcher() && render_view_host()) 347 dispatcher()->OnExtensionFunctionCompleted(extension()); 348} 349 350UIThreadExtensionFunction* 351UIThreadExtensionFunction::AsUIThreadExtensionFunction() { 352 return this; 353} 354 355bool UIThreadExtensionFunction::OnMessageReceived(const IPC::Message& message) { 356 return false; 357} 358 359void UIThreadExtensionFunction::Destruct() const { 360 BrowserThread::DeleteOnUIThread::Destruct(this); 361} 362 363void UIThreadExtensionFunction::SetRenderViewHost( 364 RenderViewHost* render_view_host) { 365 DCHECK(!render_frame_host_); 366 render_view_host_ = render_view_host; 367 tracker_.reset(render_view_host ? new RenderHostTracker(this) : NULL); 368} 369 370void UIThreadExtensionFunction::SetRenderFrameHost( 371 content::RenderFrameHost* render_frame_host) { 372 DCHECK(!render_view_host_); 373 render_frame_host_ = render_frame_host; 374 tracker_.reset(render_frame_host ? new RenderHostTracker(this) : NULL); 375} 376 377content::WebContents* UIThreadExtensionFunction::GetAssociatedWebContents() { 378 content::WebContents* web_contents = NULL; 379 if (dispatcher()) 380 web_contents = dispatcher()->delegate()->GetAssociatedWebContents(); 381 382 return web_contents; 383} 384 385void UIThreadExtensionFunction::SendResponse(bool success) { 386 if (delegate_) 387 delegate_->OnSendResponse(this, success, bad_message_); 388 else 389 SendResponseImpl(success); 390 391 if (!transferred_blob_uuids_.empty()) { 392 DCHECK(!delegate_) << "Blob transfer not supported with test delegate."; 393 GetIPCSender()->Send( 394 new ExtensionMsg_TransferBlobs(transferred_blob_uuids_)); 395 } 396} 397 398void UIThreadExtensionFunction::SetTransferredBlobUUIDs( 399 const std::vector<std::string>& blob_uuids) { 400 DCHECK(transferred_blob_uuids_.empty()); // Should only be called once. 401 transferred_blob_uuids_ = blob_uuids; 402} 403 404void UIThreadExtensionFunction::WriteToConsole( 405 content::ConsoleMessageLevel level, 406 const std::string& message) { 407 GetIPCSender()->Send( 408 new ExtensionMsg_AddMessageToConsole(GetRoutingID(), level, message)); 409} 410 411IPC::Sender* UIThreadExtensionFunction::GetIPCSender() { 412 if (render_view_host_) 413 return render_view_host_; 414 else 415 return render_frame_host_; 416} 417 418int UIThreadExtensionFunction::GetRoutingID() { 419 if (render_view_host_) 420 return render_view_host_->GetRoutingID(); 421 else 422 return render_frame_host_->GetRoutingID(); 423} 424 425IOThreadExtensionFunction::IOThreadExtensionFunction() 426 : routing_id_(MSG_ROUTING_NONE) { 427} 428 429IOThreadExtensionFunction::~IOThreadExtensionFunction() { 430} 431 432IOThreadExtensionFunction* 433IOThreadExtensionFunction::AsIOThreadExtensionFunction() { 434 return this; 435} 436 437void IOThreadExtensionFunction::Destruct() const { 438 BrowserThread::DeleteOnIOThread::Destruct(this); 439} 440 441void IOThreadExtensionFunction::SendResponse(bool success) { 442 SendResponseImpl(success); 443} 444 445AsyncExtensionFunction::AsyncExtensionFunction() { 446} 447 448AsyncExtensionFunction::~AsyncExtensionFunction() { 449} 450 451ExtensionFunction::ResponseAction AsyncExtensionFunction::Run() { 452 return RunAsync() ? RespondLater() : RespondNow(Error(error_)); 453} 454 455// static 456bool AsyncExtensionFunction::ValidationFailure( 457 AsyncExtensionFunction* function) { 458 return false; 459} 460 461SyncExtensionFunction::SyncExtensionFunction() { 462} 463 464SyncExtensionFunction::~SyncExtensionFunction() { 465} 466 467ExtensionFunction::ResponseAction SyncExtensionFunction::Run() { 468 return RespondNow(RunSync() ? ArgumentList(results_.Pass()) : Error(error_)); 469} 470 471// static 472bool SyncExtensionFunction::ValidationFailure(SyncExtensionFunction* function) { 473 return false; 474} 475 476SyncIOThreadExtensionFunction::SyncIOThreadExtensionFunction() { 477} 478 479SyncIOThreadExtensionFunction::~SyncIOThreadExtensionFunction() { 480} 481 482ExtensionFunction::ResponseAction SyncIOThreadExtensionFunction::Run() { 483 return RespondNow(RunSync() ? ArgumentList(results_.Pass()) : Error(error_)); 484} 485 486// static 487bool SyncIOThreadExtensionFunction::ValidationFailure( 488 SyncIOThreadExtensionFunction* function) { 489 return false; 490} 491