Home | History | Annotate | Download | only in browser 
      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       source_context_type_(Feature::UNSPECIFIED_CONTEXT) {
    176 }
    177 
    178 ExtensionFunction::~ExtensionFunction() {
    179 }
    180 
    181 UIThreadExtensionFunction* ExtensionFunction::AsUIThreadExtensionFunction() {
    182   return NULL;
    183 }
    184 
    185 IOThreadExtensionFunction* ExtensionFunction::AsIOThreadExtensionFunction() {
    186   return NULL;
    187 }
    188 
    189 bool 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 
    196 void ExtensionFunction::OnQuotaExceeded(const std::string& violation_error) {
    197   error_ = violation_error;
    198   SendResponse(false);
    199 }
    200 
    201 void ExtensionFunction::SetArgs(const base::ListValue* args) {
    202   DCHECK(!args_.get());  // Should only be called once.
    203   args_.reset(args->DeepCopy());
    204 }
    205 
    206 void ExtensionFunction::SetResult(base::Value* result) {
    207   results_.reset(new base::ListValue());
    208   results_->Append(result);
    209 }
    210 
    211 void ExtensionFunction::SetResultList(scoped_ptr<base::ListValue> results) {
    212   results_ = results.Pass();
    213 }
    214 
    215 const base::ListValue* ExtensionFunction::GetResultList() const {
    216   return results_.get();
    217 }
    218 
    219 std::string ExtensionFunction::GetError() const {
    220   return error_;
    221 }
    222 
    223 void ExtensionFunction::SetError(const std::string& error) {
    224   error_ = error;
    225 }
    226 
    227 ExtensionFunction::ResponseValue ExtensionFunction::NoArguments() {
    228   return ResponseValue(new ArgumentListResponseValue(
    229       name(), "NoArguments", this, make_scoped_ptr(new base::ListValue())));
    230 }
    231 
    232 ExtensionFunction::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 
    240 ExtensionFunction::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 
    250 ExtensionFunction::ResponseValue ExtensionFunction::ArgumentList(
    251     scoped_ptr<base::ListValue> args) {
    252   return ResponseValue(
    253       new ArgumentListResponseValue(name(), "ArgumentList", this, args.Pass()));
    254 }
    255 
    256 ExtensionFunction::ResponseValue ExtensionFunction::Error(
    257     const std::string& error) {
    258   return ResponseValue(new ErrorResponseValue(this, error));
    259 }
    260 
    261 ExtensionFunction::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 
    268 ExtensionFunction::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 
    276 ExtensionFunction::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 
    285 ExtensionFunction::ResponseValue ExtensionFunction::BadMessage() {
    286   return ResponseValue(new BadMessageResponseValue(this));
    287 }
    288 
    289 ExtensionFunction::ResponseAction ExtensionFunction::RespondNow(
    290     ResponseValue result) {
    291   return ResponseAction(new RespondNowAction(
    292       result.Pass(), base::Bind(&ExtensionFunction::SendResponse, this)));
    293 }
    294 
    295 ExtensionFunction::ResponseAction ExtensionFunction::RespondLater() {
    296   return ResponseAction(new RespondLaterAction());
    297 }
    298 
    299 // static
    300 ExtensionFunction::ResponseAction ExtensionFunction::ValidationFailure(
    301     ExtensionFunction* function) {
    302   return function->RespondNow(function->BadMessage());
    303 }
    304 
    305 void ExtensionFunction::Respond(ResponseValue result) {
    306   SendResponse(result->Apply());
    307 }
    308 
    309 bool ExtensionFunction::ShouldSkipQuotaLimiting() const {
    310   return false;
    311 }
    312 
    313 bool ExtensionFunction::HasOptionalArgument(size_t index) {
    314   base::Value* value;
    315   return args_->Get(index, &value) && !value->IsType(base::Value::TYPE_NULL);
    316 }
    317 
    318 void 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 
    334 void ExtensionFunction::OnRespondingLater(ResponseValue value) {
    335   SendResponse(value->Apply());
    336 }
    337 
    338 UIThreadExtensionFunction::UIThreadExtensionFunction()
    339     : render_view_host_(NULL),
    340       render_frame_host_(NULL),
    341       context_(NULL),
    342       delegate_(NULL) {
    343 }
    344 
    345 UIThreadExtensionFunction::~UIThreadExtensionFunction() {
    346   if (dispatcher() && render_view_host())
    347     dispatcher()->OnExtensionFunctionCompleted(extension());
    348 }
    349 
    350 UIThreadExtensionFunction*
    351 UIThreadExtensionFunction::AsUIThreadExtensionFunction() {
    352   return this;
    353 }
    354 
    355 bool UIThreadExtensionFunction::OnMessageReceived(const IPC::Message& message) {
    356   return false;
    357 }
    358 
    359 void UIThreadExtensionFunction::Destruct() const {
    360   BrowserThread::DeleteOnUIThread::Destruct(this);
    361 }
    362 
    363 void 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 
    370 void 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 
    377 content::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 
    385 void 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 
    398 void 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 
    404 void UIThreadExtensionFunction::WriteToConsole(
    405     content::ConsoleMessageLevel level,
    406     const std::string& message) {
    407   GetIPCSender()->Send(
    408       new ExtensionMsg_AddMessageToConsole(GetRoutingID(), level, message));
    409 }
    410 
    411 IPC::Sender* UIThreadExtensionFunction::GetIPCSender() {
    412   if (render_view_host_)
    413     return render_view_host_;
    414   else
    415     return render_frame_host_;
    416 }
    417 
    418 int UIThreadExtensionFunction::GetRoutingID() {
    419   if (render_view_host_)
    420     return render_view_host_->GetRoutingID();
    421   else
    422     return render_frame_host_->GetRoutingID();
    423 }
    424 
    425 IOThreadExtensionFunction::IOThreadExtensionFunction()
    426     : routing_id_(MSG_ROUTING_NONE) {
    427 }
    428 
    429 IOThreadExtensionFunction::~IOThreadExtensionFunction() {
    430 }
    431 
    432 IOThreadExtensionFunction*
    433 IOThreadExtensionFunction::AsIOThreadExtensionFunction() {
    434   return this;
    435 }
    436 
    437 void IOThreadExtensionFunction::Destruct() const {
    438   BrowserThread::DeleteOnIOThread::Destruct(this);
    439 }
    440 
    441 void IOThreadExtensionFunction::SendResponse(bool success) {
    442   SendResponseImpl(success);
    443 }
    444 
    445 AsyncExtensionFunction::AsyncExtensionFunction() {
    446 }
    447 
    448 AsyncExtensionFunction::~AsyncExtensionFunction() {
    449 }
    450 
    451 ExtensionFunction::ResponseAction AsyncExtensionFunction::Run() {
    452   return RunAsync() ? RespondLater() : RespondNow(Error(error_));
    453 }
    454 
    455 // static
    456 bool AsyncExtensionFunction::ValidationFailure(
    457     AsyncExtensionFunction* function) {
    458   return false;
    459 }
    460 
    461 SyncExtensionFunction::SyncExtensionFunction() {
    462 }
    463 
    464 SyncExtensionFunction::~SyncExtensionFunction() {
    465 }
    466 
    467 ExtensionFunction::ResponseAction SyncExtensionFunction::Run() {
    468   return RespondNow(RunSync() ? ArgumentList(results_.Pass()) : Error(error_));
    469 }
    470 
    471 // static
    472 bool SyncExtensionFunction::ValidationFailure(SyncExtensionFunction* function) {
    473   return false;
    474 }
    475 
    476 SyncIOThreadExtensionFunction::SyncIOThreadExtensionFunction() {
    477 }
    478 
    479 SyncIOThreadExtensionFunction::~SyncIOThreadExtensionFunction() {
    480 }
    481 
    482 ExtensionFunction::ResponseAction SyncIOThreadExtensionFunction::Run() {
    483   return RespondNow(RunSync() ? ArgumentList(results_.Pass()) : Error(error_));
    484 }
    485 
    486 // static
    487 bool SyncIOThreadExtensionFunction::ValidationFailure(
    488     SyncIOThreadExtensionFunction* function) {
    489   return false;
    490 }
    491