Introduce HostID and de-couple Extensions from "script injection System" [browser side]

chrome/browser/extensions/api/declarative_content/content_action.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/api/declarative_content/content_action.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
@@ skipping 44 matching lines @@
 // The following are concrete actions.
 //
 
 // Action that instructs to show an extension's page action.
 class ShowPageAction : public ContentAction {
  public:
   ShowPageAction() {}
 
   static scoped_refptr<ContentAction> Create(
       content::BrowserContext* browser_context,
+      const HostID& host_id,
       const Extension* extension,
       const base::DictionaryValue* dict,
       std::string* error,
       bool* bad_message) {
     // We can't show a page action if the extension doesn't have one.
     if (ActionInfo::GetPageActionInfo(extension) == NULL) {
       *error = kNoPageAction;
       return scoped_refptr<ContentAction>();
     }
     return scoped_refptr<ContentAction>(new ShowPageAction);
@@ skipping 43 matching lines @@
 };
 
 // Action that sets an extension's action icon.
 class SetIcon : public ContentAction {
  public:
   SetIcon(const gfx::Image& icon, ActionInfo::Type action_type)
       : icon_(icon), action_type_(action_type) {}
 
   static scoped_refptr<ContentAction> Create(
       content::BrowserContext* browser_context,
+      const HostID& host_id,
       const Extension* extension,
       const base::DictionaryValue* dict,
       std::string* error,
       bool* bad_message);
 
   // Implementation of ContentAction:
   Type GetType() const override { return ACTION_SET_ICON; }
   void Apply(const std::string& extension_id,
              const base::Time& extension_install_time,
              ApplyInfo* apply_info) const override {
@@ skipping 73 matching lines @@
 
 struct ContentActionFactory {
   // Factory methods for ContentAction instances. |extension| is the extension
   // for which the action is being created. |dict| contains the json dictionary
   // that describes the action. |error| is used to return error messages in case
   // the extension passed an action that was syntactically correct but
   // semantically incorrect. |bad_message| is set to true in case |dict| does
   // not confirm to the validated JSON specification.
   typedef scoped_refptr<ContentAction>(*FactoryMethod)(
       content::BrowserContext* /* browser_context */,
+      const HostID& host_id /* host id */,
       const Extension* /* extension */,
       const base::DictionaryValue* /* dict */,
       std::string* /* error */,
       bool* /* bad_message */);
   // Maps the name of a declarativeContent action type to the factory
   // function creating it.
   std::map<std::string, FactoryMethod> factory_methods;
 
   ContentActionFactory() {
     factory_methods[keys::kShowPageAction] =
@@ skipping 25 matching lines @@
 };
 
 RequestContentScript::ScriptData::ScriptData()
     : all_frames(false),
       match_about_blank(false) {}
 RequestContentScript::ScriptData::~ScriptData() {}
 
 // static
 scoped_refptr<ContentAction> RequestContentScript::Create(
     content::BrowserContext* browser_context,
+    const HostID& host_id,
     const Extension* extension,
     const base::DictionaryValue* dict,
     std::string* error,
     bool* bad_message) {
   ScriptData script_data;
   if (!InitScriptData(dict, error, bad_message, &script_data))
     return scoped_refptr<ContentAction>();
 
   return scoped_refptr<ContentAction>(new RequestContentScript(
       browser_context,
+      host_id,
       extension,
       script_data));
 }
 
 // static
 scoped_refptr<ContentAction> RequestContentScript::CreateForTest(
     DeclarativeUserScriptMaster* master,
+    const HostID& host_id,
     const Extension* extension,
     const base::Value& json_action,
     std::string* error,
     bool* bad_message) {
   // Simulate ContentAction-level initialization. Check that instance type is
   // RequestContentScript.
   ContentAction::ResetErrorData(error, bad_message);
   const base::DictionaryValue* action_dict = NULL;
   std::string instance_type;
   if (!ContentAction::Validate(
           json_action,
           error,
           bad_message,
           &action_dict,
           &instance_type) ||
       instance_type != std::string(keys::kRequestContentScript))
     return scoped_refptr<ContentAction>();
 
   // Normal RequestContentScript data initialization.
   ScriptData script_data;
   if (!InitScriptData(action_dict, error, bad_message, &script_data))
     return scoped_refptr<ContentAction>();
 
   // Inject provided DeclarativeUserScriptMaster, rather than looking it up
   // using a BrowserContext.
   return scoped_refptr<ContentAction>(new RequestContentScript(
       master,
+      host_id,
       extension,
       script_data));
 }
 
 // static
 bool RequestContentScript::InitScriptData(const base::DictionaryValue* dict,
                                           std::string* error,
                                           bool* bad_message,
                                           ScriptData* script_data) {
   const base::ListValue* list_value = NULL;
@@ skipping 21 matching lines @@
         dict->GetBoolean(
             keys::kMatchAboutBlank,
             &script_data->match_about_blank));
   }
 
   return true;
 }
 
 RequestContentScript::RequestContentScript(
     content::BrowserContext* browser_context,
+    const HostID& host_id,
     const Extension* extension,
     const ScriptData& script_data) {
-  InitScript(extension, script_data);
+  InitScript(host_id, extension, script_data);
 
   master_ = ExtensionSystem::Get(browser_context)
                 ->declarative_user_script_manager()
-                ->GetDeclarativeUserScriptMasterByID(extension->id());
+                ->GetDeclarativeUserScriptMasterByID(host_id);
   AddScript();
 }
 
 RequestContentScript::RequestContentScript(
     DeclarativeUserScriptMaster* master,
+    const HostID& host_id,
     const Extension* extension,
     const ScriptData& script_data) {
-  InitScript(extension, script_data);
+  InitScript(host_id, extension, script_data);
 
   master_ = master;
   AddScript();
 }
 
 RequestContentScript::~RequestContentScript() {
   DCHECK(master_);
   master_->RemoveScript(script_);
 }
 
-void RequestContentScript::InitScript(const Extension* extension,
+void RequestContentScript::InitScript(const HostID& host_id,
+                                      const Extension* extension,
                                       const ScriptData& script_data) {
   script_.set_id(UserScript::GenerateUserScriptID());
-  script_.set_extension_id(extension->id());
+  script_.set_host_id(host_id);
   script_.set_run_location(UserScript::BROWSER_DRIVEN);
   script_.set_match_all_frames(script_data.all_frames);
   script_.set_match_about_blank(script_data.match_about_blank);
   for (std::vector<std::string>::const_iterator it =
            script_data.css_file_names.begin();
        it != script_data.css_file_names.end(); ++it) {
     GURL url = extension->GetResourceURL(*it);
     ExtensionResource resource = extension->GetResource(*it);
     script_.css_scripts().push_back(UserScript::File(
         resource.extension_root(), resource.relative_path(), url));
@@ skipping 36 matching lines @@
       render_view_host->GetRoutingID(),
       SessionTabHelper::IdForTab(contents),
       extension_id,
       script_.id(),
       contents->GetLastCommittedURL()));
 }
 
 // static
 scoped_refptr<ContentAction> SetIcon::Create(
     content::BrowserContext* browser_context,
+    const HostID& host_id,
     const Extension* extension,
     const base::DictionaryValue* dict,
     std::string* error,
     bool* bad_message) {
   // We can't set a page or action's icon if the extension doesn't have one.
   ActionInfo::Type type;
   if (ActionInfo::GetPageActionInfo(extension) != NULL) {
     type = ActionInfo::TYPE_PAGE;
   } else if (ActionInfo::GetBrowserActionInfo(extension) != NULL) {
     type = ActionInfo::TYPE_BROWSER;
@@ skipping 17 matching lines @@
 // ContentAction
 //
 
 ContentAction::ContentAction() {}
 
 ContentAction::~ContentAction() {}
 
 // static
 scoped_refptr<ContentAction> ContentAction::Create(
     content::BrowserContext* browser_context,
+    const HostID& host_id,
     const Extension* extension,
     const base::Value& json_action,
     std::string* error,
     bool* bad_message) {
   ResetErrorData(error, bad_message);
   const base::DictionaryValue* action_dict = NULL;
   std::string instance_type;
   if (!Validate(json_action, error, bad_message, &action_dict, &instance_type))
     return scoped_refptr<ContentAction>();
 
   ContentActionFactory& factory = g_content_action_factory.Get();
   std::map<std::string, ContentActionFactory::FactoryMethod>::iterator
       factory_method_iter = factory.factory_methods.find(instance_type);
   if (factory_method_iter != factory.factory_methods.end())
     return (*factory_method_iter->second)(
-        browser_context, extension, action_dict, error, bad_message);
+        browser_context, host_id, extension, action_dict, error, bad_message);
 
   *error = base::StringPrintf(kInvalidInstanceTypeError, instance_type.c_str());
   return scoped_refptr<ContentAction>();
 }
 
 bool ContentAction::Validate(const base::Value& json_action,
                              std::string* error,
                              bool* bad_message,
                              const base::DictionaryValue** action_dict,
                              std::string* instance_type) {
   INPUT_FORMAT_VALIDATE(json_action.GetAsDictionary(action_dict));
   INPUT_FORMAT_VALIDATE(
       (*action_dict)->GetString(keys::kInstanceType, instance_type));
   return true;
 }
 
 }  // namespace extensions