Home | History | Annotate | Download | only in api 
      1 // Copyright (c) 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 "chrome/browser/extensions/api/execute_code_function.h"
      6 
      7 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
      8 #include "chrome/browser/extensions/image_loader.h"
      9 #include "chrome/browser/extensions/script_executor.h"
     10 #include "chrome/common/extensions/api/i18n/default_locale_handler.h"
     11 #include "chrome/common/extensions/extension_file_util.h"
     12 #include "chrome/common/extensions/extension_messages.h"
     13 #include "chrome/common/extensions/message_bundle.h"
     14 #include "extensions/browser/file_reader.h"
     15 #include "extensions/common/error_utils.h"
     16 #include "net/base/net_util.h"
     17 #include "ui/base/resource/resource_bundle.h"
     18 
     19 namespace extensions {
     20 
     21 namespace keys = tabs_constants;
     22 using api::tabs::InjectDetails;
     23 
     24 ExecuteCodeFunction::ExecuteCodeFunction() {
     25 }
     26 
     27 ExecuteCodeFunction::~ExecuteCodeFunction() {
     28 }
     29 
     30 void ExecuteCodeFunction::DidLoadFile(bool success,
     31                                       const std::string& data) {
     32 
     33   if (!success || !details_->file) {
     34     DidLoadAndLocalizeFile(success, data);
     35     return;
     36   }
     37 
     38   ScriptExecutor::ScriptType script_type =
     39       ShouldInsertCSS() ? ScriptExecutor::CSS : ScriptExecutor::JAVASCRIPT;
     40 
     41   std::string extension_id;
     42   base::FilePath extension_path;
     43   std::string extension_default_locale;
     44   const Extension* extension = GetExtension();
     45   if (extension) {
     46     extension_id = extension->id();
     47     extension_path = extension->path();
     48     extension_default_locale = LocaleInfo::GetDefaultLocale(extension);
     49   }
     50 
     51   content::BrowserThread::PostTask(
     52       content::BrowserThread::FILE, FROM_HERE,
     53       base::Bind(&ExecuteCodeFunction::GetFileURLAndLocalizeCSS, this,
     54                   script_type,
     55                   data,
     56                   extension_id,
     57                   extension_path,
     58                   extension_default_locale));
     59 }
     60 
     61 void ExecuteCodeFunction::GetFileURLAndLocalizeCSS(
     62     ScriptExecutor::ScriptType script_type,
     63     const std::string& data,
     64     const std::string& extension_id,
     65     const base::FilePath& extension_path,
     66     const std::string& extension_default_locale) {
     67 
     68   std::string localized_data = data;
     69   // Check if the file is CSS and needs localization.
     70   if ((script_type == ScriptExecutor::CSS) &&
     71       !extension_id.empty() &&
     72       (data.find(MessageBundle::kMessageBegin) != std::string::npos)) {
     73     scoped_ptr<SubstitutionMap> localization_messages(
     74         extension_file_util::LoadMessageBundleSubstitutionMap(
     75             extension_path, extension_id, extension_default_locale));
     76 
     77     // We need to do message replacement on the data, so it has to be mutable.
     78     std::string error;
     79     MessageBundle::ReplaceMessagesWithExternalDictionary(*localization_messages,
     80                                                          &localized_data,
     81                                                          &error);
     82   }
     83 
     84   file_url_ = net::FilePathToFileURL(resource_.GetFilePath());
     85 
     86   // Call back DidLoadAndLocalizeFile on the UI thread. The success parameter
     87   // is always true, because if loading had failed, we wouldn't have had
     88   // anything to localize.
     89   content::BrowserThread::PostTask(
     90       content::BrowserThread::UI, FROM_HERE,
     91       base::Bind(&ExecuteCodeFunction::DidLoadAndLocalizeFile, this,
     92                  true, localized_data));
     93 }
     94 
     95 void ExecuteCodeFunction::DidLoadAndLocalizeFile(bool success,
     96                                                  const std::string& data) {
     97   if (success) {
     98     if (!Execute(data))
     99       SendResponse(false);
    100   } else {
    101     // TODO(viettrungluu): bug: there's no particular reason the path should be
    102     // UTF-8, in which case this may fail.
    103     error_ = ErrorUtils::FormatErrorMessage(keys::kLoadFileError,
    104         resource_.relative_path().AsUTF8Unsafe());
    105     SendResponse(false);
    106   }
    107 }
    108 
    109 bool ExecuteCodeFunction::Execute(const std::string& code_string) {
    110   ScriptExecutor* executor = GetScriptExecutor();
    111   if (!executor)
    112     return false;
    113 
    114   const Extension* extension = GetExtension();
    115   if (!extension)
    116     return false;
    117 
    118   ScriptExecutor::ScriptType script_type = ScriptExecutor::JAVASCRIPT;
    119   if (ShouldInsertCSS())
    120     script_type = ScriptExecutor::CSS;
    121 
    122   ScriptExecutor::FrameScope frame_scope =
    123       details_->all_frames.get() && *details_->all_frames ?
    124           ScriptExecutor::ALL_FRAMES :
    125           ScriptExecutor::TOP_FRAME;
    126 
    127   UserScript::RunLocation run_at =
    128       UserScript::UNDEFINED;
    129   switch (details_->run_at) {
    130     case InjectDetails::RUN_AT_NONE:
    131     case InjectDetails::RUN_AT_DOCUMENT_IDLE:
    132       run_at = UserScript::DOCUMENT_IDLE;
    133       break;
    134     case InjectDetails::RUN_AT_DOCUMENT_START:
    135       run_at = UserScript::DOCUMENT_START;
    136       break;
    137     case InjectDetails::RUN_AT_DOCUMENT_END:
    138       run_at = UserScript::DOCUMENT_END;
    139       break;
    140   }
    141   CHECK_NE(UserScript::UNDEFINED, run_at);
    142 
    143   executor->ExecuteScript(
    144       extension->id(),
    145       script_type,
    146       code_string,
    147       frame_scope,
    148       run_at,
    149       ScriptExecutor::ISOLATED_WORLD,
    150       IsWebView() ? ScriptExecutor::WEB_VIEW_PROCESS
    151                   : ScriptExecutor::DEFAULT_PROCESS,
    152       file_url_,
    153       has_callback() ? ScriptExecutor::JSON_SERIALIZED_RESULT
    154                      : ScriptExecutor::NO_RESULT,
    155       base::Bind(&ExecuteCodeFunction::OnExecuteCodeFinished, this));
    156   return true;
    157 }
    158 
    159 bool ExecuteCodeFunction::HasPermission() {
    160   return true;
    161 }
    162 
    163 bool ExecuteCodeFunction::RunImpl() {
    164   EXTENSION_FUNCTION_VALIDATE(Init());
    165 
    166   if (!details_->code.get() && !details_->file.get()) {
    167     error_ = keys::kNoCodeOrFileToExecuteError;
    168     return false;
    169   }
    170   if (details_->code.get() && details_->file.get()) {
    171     error_ = keys::kMoreThanOneValuesError;
    172     return false;
    173   }
    174 
    175   if (!CanExecuteScriptOnPage())
    176     return false;
    177 
    178   if (details_->code.get())
    179     return Execute(*details_->code);
    180 
    181   if (!details_->file.get())
    182     return false;
    183   resource_ = GetExtension()->GetResource(*details_->file);
    184 
    185   if (resource_.extension_root().empty() || resource_.relative_path().empty()) {
    186     error_ = keys::kNoCodeOrFileToExecuteError;
    187     return false;
    188   }
    189 
    190   int resource_id;
    191   if (ImageLoader::IsComponentExtensionResource(
    192           resource_.extension_root(), resource_.relative_path(),
    193           &resource_id)) {
    194     const ResourceBundle& rb = ResourceBundle::GetSharedInstance();
    195     DidLoadFile(true, rb.GetRawDataResource(resource_id).as_string());
    196   } else {
    197     scoped_refptr<FileReader> file_reader(new FileReader(
    198         resource_, base::Bind(&ExecuteCodeFunction::DidLoadFile, this)));
    199     file_reader->Start();
    200   }
    201 
    202   return true;
    203 }
    204 
    205 void ExecuteCodeFunction::OnExecuteCodeFinished(
    206     const std::string& error,
    207     int32 on_page_id,
    208     const GURL& on_url,
    209     const base::ListValue& result) {
    210   if (!error.empty())
    211     SetError(error);
    212 
    213   SendResponse(error.empty());
    214 }
    215 
    216 }  // namespace extensions
    217