Home | History | Annotate | Download | only in declarative_content 
      1 // Copyright (c) 2012 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/declarative_content/content_action.h"
      6 
      7 #include <map>
      8 
      9 #include "base/lazy_instance.h"
     10 #include "base/strings/stringprintf.h"
     11 #include "base/values.h"
     12 #include "chrome/browser/extensions/api/declarative_content/content_constants.h"
     13 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
     14 #include "chrome/browser/extensions/extension_action.h"
     15 #include "chrome/browser/extensions/extension_action_manager.h"
     16 #include "chrome/browser/extensions/extension_tab_util.h"
     17 #include "chrome/browser/profiles/profile.h"
     18 #include "chrome/browser/sessions/session_tab_helper.h"
     19 #include "content/public/browser/invalidate_type.h"
     20 #include "content/public/browser/render_view_host.h"
     21 #include "content/public/browser/web_contents.h"
     22 #include "extensions/browser/extension_registry.h"
     23 #include "extensions/browser/extension_system.h"
     24 #include "extensions/common/extension.h"
     25 #include "extensions/common/extension_messages.h"
     26 #include "ui/gfx/image/image.h"
     27 #include "ui/gfx/image/image_skia.h"
     28 
     29 namespace extensions {
     30 
     31 namespace keys = declarative_content_constants;
     32 
     33 namespace {
     34 // Error messages.
     35 const char kInvalidIconDictionary[] =
     36     "Icon dictionary must be of the form {\"19\": ImageData1, \"38\": "
     37     "ImageData2}";
     38 const char kInvalidInstanceTypeError[] =
     39     "An action has an invalid instanceType: %s";
     40 const char kMissingParameter[] = "Missing parameter is required: %s";
     41 const char kNoPageAction[] =
     42     "Can't use declarativeContent.ShowPageAction without a page action";
     43 const char kNoPageOrBrowserAction[] =
     44     "Can't use declarativeContent.SetIcon without a page or browser action";
     45 
     46 #define INPUT_FORMAT_VALIDATE(test) do { \
     47     if (!(test)) { \
     48       *bad_message = true; \
     49       return false; \
     50     } \
     51   } while (0)
     52 
     53 //
     54 // The following are concrete actions.
     55 //
     56 
     57 // Action that instructs to show an extension's page action.
     58 class ShowPageAction : public ContentAction {
     59  public:
     60   ShowPageAction() {}
     61 
     62   static scoped_refptr<ContentAction> Create(
     63       content::BrowserContext* browser_context,
     64       const Extension* extension,
     65       const base::DictionaryValue* dict,
     66       std::string* error,
     67       bool* bad_message) {
     68     // We can't show a page action if the extension doesn't have one.
     69     if (ActionInfo::GetPageActionInfo(extension) == NULL) {
     70       *error = kNoPageAction;
     71       return scoped_refptr<ContentAction>();
     72     }
     73     return scoped_refptr<ContentAction>(new ShowPageAction);
     74   }
     75 
     76   // Implementation of ContentAction:
     77   virtual Type GetType() const OVERRIDE { return ACTION_SHOW_PAGE_ACTION; }
     78   virtual void Apply(const std::string& extension_id,
     79                      const base::Time& extension_install_time,
     80                      ApplyInfo* apply_info) const OVERRIDE {
     81     ExtensionAction* action =
     82         GetPageAction(apply_info->browser_context, extension_id);
     83     action->DeclarativeShow(ExtensionTabUtil::GetTabId(apply_info->tab));
     84     ExtensionActionAPI::Get(apply_info->browser_context)->NotifyChange(
     85         action, apply_info->tab, apply_info->browser_context);
     86   }
     87   // The page action is already showing, so nothing needs to be done here.
     88   virtual void Reapply(const std::string& extension_id,
     89                        const base::Time& extension_install_time,
     90                        ApplyInfo* apply_info) const OVERRIDE {}
     91   virtual void Revert(const std::string& extension_id,
     92                       const base::Time& extension_install_time,
     93                       ApplyInfo* apply_info) const OVERRIDE {
     94     if (ExtensionAction* action =
     95             GetPageAction(apply_info->browser_context, extension_id)) {
     96       action->UndoDeclarativeShow(ExtensionTabUtil::GetTabId(apply_info->tab));
     97       ExtensionActionAPI::Get(apply_info->browser_context)->NotifyChange(
     98           action, apply_info->tab, apply_info->browser_context);
     99     }
    100   }
    101 
    102  private:
    103   static ExtensionAction* GetPageAction(
    104       content::BrowserContext* browser_context,
    105       const std::string& extension_id) {
    106     const Extension* extension =
    107         ExtensionRegistry::Get(browser_context)
    108             ->GetExtensionById(extension_id, ExtensionRegistry::EVERYTHING);
    109     if (!extension)
    110       return NULL;
    111     return ExtensionActionManager::Get(browser_context)
    112         ->GetPageAction(*extension);
    113   }
    114   virtual ~ShowPageAction() {}
    115 
    116   DISALLOW_COPY_AND_ASSIGN(ShowPageAction);
    117 };
    118 
    119 // Action that sets an extension's action icon.
    120 class SetIcon : public ContentAction {
    121  public:
    122   SetIcon(const gfx::Image& icon, ActionInfo::Type action_type)
    123       : icon_(icon), action_type_(action_type) {}
    124 
    125   static scoped_refptr<ContentAction> Create(
    126       content::BrowserContext* browser_context,
    127       const Extension* extension,
    128       const base::DictionaryValue* dict,
    129       std::string* error,
    130       bool* bad_message);
    131 
    132   // Implementation of ContentAction:
    133   virtual Type GetType() const OVERRIDE { return ACTION_SET_ICON; }
    134   virtual void Apply(const std::string& extension_id,
    135                      const base::Time& extension_install_time,
    136                      ApplyInfo* apply_info) const OVERRIDE {
    137     Profile* profile = Profile::FromBrowserContext(apply_info->browser_context);
    138     ExtensionAction* action = GetExtensionAction(profile, extension_id);
    139     if (action) {
    140       action->DeclarativeSetIcon(ExtensionTabUtil::GetTabId(apply_info->tab),
    141                                  apply_info->priority,
    142                                  icon_);
    143       ExtensionActionAPI::Get(profile)
    144           ->NotifyChange(action, apply_info->tab, profile);
    145     }
    146   }
    147 
    148   virtual void Reapply(const std::string& extension_id,
    149                        const base::Time& extension_install_time,
    150                        ApplyInfo* apply_info) const OVERRIDE {}
    151 
    152   virtual void Revert(const std::string& extension_id,
    153                       const base::Time& extension_install_time,
    154                       ApplyInfo* apply_info) const OVERRIDE {
    155     Profile* profile = Profile::FromBrowserContext(apply_info->browser_context);
    156     ExtensionAction* action = GetExtensionAction(profile, extension_id);
    157     if (action) {
    158       action->UndoDeclarativeSetIcon(
    159           ExtensionTabUtil::GetTabId(apply_info->tab),
    160           apply_info->priority,
    161           icon_);
    162       ExtensionActionAPI::Get(apply_info->browser_context)
    163           ->NotifyChange(action, apply_info->tab, profile);
    164     }
    165   }
    166 
    167  private:
    168   ExtensionAction* GetExtensionAction(Profile* profile,
    169                                       const std::string& extension_id) const {
    170     const Extension* extension =
    171         ExtensionRegistry::Get(profile)
    172             ->GetExtensionById(extension_id, ExtensionRegistry::EVERYTHING);
    173     if (!extension)
    174       return NULL;
    175     switch (action_type_) {
    176       case ActionInfo::TYPE_BROWSER:
    177         return ExtensionActionManager::Get(profile)
    178             ->GetBrowserAction(*extension);
    179       case ActionInfo::TYPE_PAGE:
    180         return ExtensionActionManager::Get(profile)->GetPageAction(*extension);
    181       default:
    182         NOTREACHED();
    183     }
    184     return NULL;
    185   }
    186   virtual ~SetIcon() {}
    187 
    188   gfx::Image icon_;
    189   ActionInfo::Type action_type_;
    190 
    191   DISALLOW_COPY_AND_ASSIGN(SetIcon);
    192 };
    193 
    194 // Helper for getting JS collections into C++.
    195 static bool AppendJSStringsToCPPStrings(const base::ListValue& append_strings,
    196                                         std::vector<std::string>* append_to) {
    197   for (base::ListValue::const_iterator it = append_strings.begin();
    198        it != append_strings.end();
    199        ++it) {
    200     std::string value;
    201     if ((*it)->GetAsString(&value)) {
    202       append_to->push_back(value);
    203     } else {
    204       return false;
    205     }
    206   }
    207 
    208   return true;
    209 }
    210 
    211 struct ContentActionFactory {
    212   // Factory methods for ContentAction instances. |extension| is the extension
    213   // for which the action is being created. |dict| contains the json dictionary
    214   // that describes the action. |error| is used to return error messages in case
    215   // the extension passed an action that was syntactically correct but
    216   // semantically incorrect. |bad_message| is set to true in case |dict| does
    217   // not confirm to the validated JSON specification.
    218   typedef scoped_refptr<ContentAction>(*FactoryMethod)(
    219       content::BrowserContext* /* browser_context */,
    220       const Extension* /* extension */,
    221       const base::DictionaryValue* /* dict */,
    222       std::string* /* error */,
    223       bool* /* bad_message */);
    224   // Maps the name of a declarativeContent action type to the factory
    225   // function creating it.
    226   std::map<std::string, FactoryMethod> factory_methods;
    227 
    228   ContentActionFactory() {
    229     factory_methods[keys::kShowPageAction] =
    230         &ShowPageAction::Create;
    231     factory_methods[keys::kRequestContentScript] =
    232         &RequestContentScript::Create;
    233     factory_methods[keys::kSetIcon] =
    234         &SetIcon::Create;
    235   }
    236 };
    237 
    238 base::LazyInstance<ContentActionFactory>::Leaky
    239     g_content_action_factory = LAZY_INSTANCE_INITIALIZER;
    240 
    241 }  // namespace
    242 
    243 //
    244 // RequestContentScript
    245 //
    246 
    247 struct RequestContentScript::ScriptData {
    248   ScriptData();
    249   ~ScriptData();
    250 
    251   std::vector<std::string> css_file_names;
    252   std::vector<std::string> js_file_names;
    253   bool all_frames;
    254   bool match_about_blank;
    255 };
    256 
    257 RequestContentScript::ScriptData::ScriptData()
    258     : all_frames(false),
    259       match_about_blank(false) {}
    260 RequestContentScript::ScriptData::~ScriptData() {}
    261 
    262 // static
    263 scoped_refptr<ContentAction> RequestContentScript::Create(
    264     content::BrowserContext* browser_context,
    265     const Extension* extension,
    266     const base::DictionaryValue* dict,
    267     std::string* error,
    268     bool* bad_message) {
    269   ScriptData script_data;
    270   if (!InitScriptData(dict, error, bad_message, &script_data))
    271     return scoped_refptr<ContentAction>();
    272 
    273   return scoped_refptr<ContentAction>(new RequestContentScript(
    274       browser_context,
    275       extension,
    276       script_data));
    277 }
    278 
    279 // static
    280 scoped_refptr<ContentAction> RequestContentScript::CreateForTest(
    281     DeclarativeUserScriptMaster* master,
    282     const Extension* extension,
    283     const base::Value& json_action,
    284     std::string* error,
    285     bool* bad_message) {
    286   // Simulate ContentAction-level initialization. Check that instance type is
    287   // RequestContentScript.
    288   ContentAction::ResetErrorData(error, bad_message);
    289   const base::DictionaryValue* action_dict = NULL;
    290   std::string instance_type;
    291   if (!ContentAction::Validate(
    292           json_action,
    293           error,
    294           bad_message,
    295           &action_dict,
    296           &instance_type) ||
    297       instance_type != std::string(keys::kRequestContentScript))
    298     return scoped_refptr<ContentAction>();
    299 
    300   // Normal RequestContentScript data initialization.
    301   ScriptData script_data;
    302   if (!InitScriptData(action_dict, error, bad_message, &script_data))
    303     return scoped_refptr<ContentAction>();
    304 
    305   // Inject provided DeclarativeUserScriptMaster, rather than looking it up
    306   // using a BrowserContext.
    307   return scoped_refptr<ContentAction>(new RequestContentScript(
    308       master,
    309       extension,
    310       script_data));
    311 }
    312 
    313 // static
    314 bool RequestContentScript::InitScriptData(const base::DictionaryValue* dict,
    315                                           std::string* error,
    316                                           bool* bad_message,
    317                                           ScriptData* script_data) {
    318   const base::ListValue* list_value = NULL;
    319 
    320   if (!dict->HasKey(keys::kCss) && !dict->HasKey(keys::kJs)) {
    321     *error = base::StringPrintf(kMissingParameter, "css or js");
    322     return false;
    323   }
    324   if (dict->HasKey(keys::kCss)) {
    325     INPUT_FORMAT_VALIDATE(dict->GetList(keys::kCss, &list_value));
    326     INPUT_FORMAT_VALIDATE(
    327         AppendJSStringsToCPPStrings(*list_value, &script_data->css_file_names));
    328   }
    329   if (dict->HasKey(keys::kJs)) {
    330     INPUT_FORMAT_VALIDATE(dict->GetList(keys::kJs, &list_value));
    331     INPUT_FORMAT_VALIDATE(
    332         AppendJSStringsToCPPStrings(*list_value, &script_data->js_file_names));
    333   }
    334   if (dict->HasKey(keys::kAllFrames)) {
    335     INPUT_FORMAT_VALIDATE(
    336         dict->GetBoolean(keys::kAllFrames, &script_data->all_frames));
    337   }
    338   if (dict->HasKey(keys::kMatchAboutBlank)) {
    339     INPUT_FORMAT_VALIDATE(
    340         dict->GetBoolean(
    341             keys::kMatchAboutBlank,
    342             &script_data->match_about_blank));
    343   }
    344 
    345   return true;
    346 }
    347 
    348 RequestContentScript::RequestContentScript(
    349     content::BrowserContext* browser_context,
    350     const Extension* extension,
    351     const ScriptData& script_data) {
    352   InitScript(extension, script_data);
    353 
    354   master_ =
    355       ExtensionSystem::Get(browser_context)->
    356       GetDeclarativeUserScriptMasterByExtension(extension->id());
    357   AddScript();
    358 }
    359 
    360 RequestContentScript::RequestContentScript(
    361     DeclarativeUserScriptMaster* master,
    362     const Extension* extension,
    363     const ScriptData& script_data) {
    364   InitScript(extension, script_data);
    365 
    366   master_ = master;
    367   AddScript();
    368 }
    369 
    370 RequestContentScript::~RequestContentScript() {
    371   DCHECK(master_);
    372   master_->RemoveScript(script_);
    373 }
    374 
    375 void RequestContentScript::InitScript(const Extension* extension,
    376                                       const ScriptData& script_data) {
    377   script_.set_id(UserScript::GenerateUserScriptID());
    378   script_.set_extension_id(extension->id());
    379   script_.set_run_location(UserScript::BROWSER_DRIVEN);
    380   script_.set_match_all_frames(script_data.all_frames);
    381   script_.set_match_about_blank(script_data.match_about_blank);
    382   for (std::vector<std::string>::const_iterator it =
    383            script_data.css_file_names.begin();
    384        it != script_data.css_file_names.end(); ++it) {
    385     GURL url = extension->GetResourceURL(*it);
    386     ExtensionResource resource = extension->GetResource(*it);
    387     script_.css_scripts().push_back(UserScript::File(
    388         resource.extension_root(), resource.relative_path(), url));
    389   }
    390   for (std::vector<std::string>::const_iterator it =
    391            script_data.js_file_names.begin();
    392        it != script_data.js_file_names.end(); ++it) {
    393     GURL url = extension->GetResourceURL(*it);
    394     ExtensionResource resource = extension->GetResource(*it);
    395     script_.js_scripts().push_back(UserScript::File(
    396         resource.extension_root(), resource.relative_path(), url));
    397   }
    398 }
    399 
    400 ContentAction::Type RequestContentScript::GetType() const {
    401   return ACTION_REQUEST_CONTENT_SCRIPT;
    402 }
    403 
    404 void RequestContentScript::Apply(const std::string& extension_id,
    405                                  const base::Time& extension_install_time,
    406                                  ApplyInfo* apply_info) const {
    407   InstructRenderProcessToInject(apply_info->tab, extension_id);
    408 }
    409 
    410 void RequestContentScript::Reapply(const std::string& extension_id,
    411                                    const base::Time& extension_install_time,
    412                                    ApplyInfo* apply_info) const {
    413   InstructRenderProcessToInject(apply_info->tab, extension_id);
    414 }
    415 
    416 void RequestContentScript::Revert(const std::string& extension_id,
    417                       const base::Time& extension_install_time,
    418                       ApplyInfo* apply_info) const {}
    419 
    420 void RequestContentScript::InstructRenderProcessToInject(
    421     content::WebContents* contents,
    422     const std::string& extension_id) const {
    423   content::RenderViewHost* render_view_host = contents->GetRenderViewHost();
    424   render_view_host->Send(new ExtensionMsg_ExecuteDeclarativeScript(
    425       render_view_host->GetRoutingID(),
    426       SessionTabHelper::IdForTab(contents),
    427       extension_id,
    428       script_.id(),
    429       contents->GetLastCommittedURL()));
    430 }
    431 
    432 // static
    433 scoped_refptr<ContentAction> SetIcon::Create(
    434     content::BrowserContext* browser_context,
    435     const Extension* extension,
    436     const base::DictionaryValue* dict,
    437     std::string* error,
    438     bool* bad_message) {
    439   // We can't set a page or action's icon if the extension doesn't have one.
    440   ActionInfo::Type type;
    441   if (ActionInfo::GetPageActionInfo(extension) != NULL) {
    442     type = ActionInfo::TYPE_PAGE;
    443   } else if (ActionInfo::GetBrowserActionInfo(extension) != NULL) {
    444     type = ActionInfo::TYPE_BROWSER;
    445   } else {
    446     *error = kNoPageOrBrowserAction;
    447     return scoped_refptr<ContentAction>();
    448   }
    449 
    450   gfx::ImageSkia icon;
    451   const base::DictionaryValue* canvas_set = NULL;
    452   if (dict->GetDictionary("imageData", &canvas_set) &&
    453       !ExtensionAction::ParseIconFromCanvasDictionary(*canvas_set, &icon)) {
    454     *error = kInvalidIconDictionary;
    455     *bad_message = true;
    456     return scoped_refptr<ContentAction>();
    457   }
    458   return scoped_refptr<ContentAction>(new SetIcon(gfx::Image(icon), type));
    459 }
    460 
    461 //
    462 // ContentAction
    463 //
    464 
    465 ContentAction::ContentAction() {}
    466 
    467 ContentAction::~ContentAction() {}
    468 
    469 // static
    470 scoped_refptr<ContentAction> ContentAction::Create(
    471     content::BrowserContext* browser_context,
    472     const Extension* extension,
    473     const base::Value& json_action,
    474     std::string* error,
    475     bool* bad_message) {
    476   ResetErrorData(error, bad_message);
    477   const base::DictionaryValue* action_dict = NULL;
    478   std::string instance_type;
    479   if (!Validate(json_action, error, bad_message, &action_dict, &instance_type))
    480     return scoped_refptr<ContentAction>();
    481 
    482   ContentActionFactory& factory = g_content_action_factory.Get();
    483   std::map<std::string, ContentActionFactory::FactoryMethod>::iterator
    484       factory_method_iter = factory.factory_methods.find(instance_type);
    485   if (factory_method_iter != factory.factory_methods.end())
    486     return (*factory_method_iter->second)(
    487         browser_context, extension, action_dict, error, bad_message);
    488 
    489   *error = base::StringPrintf(kInvalidInstanceTypeError, instance_type.c_str());
    490   return scoped_refptr<ContentAction>();
    491 }
    492 
    493 bool ContentAction::Validate(const base::Value& json_action,
    494                              std::string* error,
    495                              bool* bad_message,
    496                              const base::DictionaryValue** action_dict,
    497                              std::string* instance_type) {
    498   INPUT_FORMAT_VALIDATE(json_action.GetAsDictionary(action_dict));
    499   INPUT_FORMAT_VALIDATE(
    500       (*action_dict)->GetString(keys::kInstanceType, instance_type));
    501   return true;
    502 }
    503 
    504 }  // namespace extensions
    505