Browser changes for wiring up RequestContentScript API to shared memory

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"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/declarative_content/content_constants.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
+#include "chrome/browser/extensions/declarative_user_script_master.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/sessions/session_tab_helper.h"
+#include "chrome/common/extensions/manifest_handlers/content_scripts_handler.h"
 #include "content/public/browser/invalidate_type.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
+#include "extensions/common/extension_messages.h"
 
 namespace extensions {
 
 namespace keys = declarative_content_constants;
 
 namespace {
 // Error messages.
 const char kInvalidInstanceTypeError[] =
     "An action has an invalid instanceType: %s";
 const char kNoPageAction[] =
     "Can't use declarativeContent.ShowPageAction without a page action";
 const char kMissingParameter[] = "Missing parameter is required: %s";
 
 #define INPUT_FORMAT_VALIDATE(test) do { \
     if (!(test)) { \
       *bad_message = true; \
       return scoped_refptr<ContentAction>(NULL); \
     } \
   } while (0)
 
 //
 // 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(const Extension* extension,
+  static scoped_refptr<ContentAction> Create(Profile* profile,
+                                             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 11 matching lines @@
   virtual void Revert(const std::string& extension_id,
                       const base::Time& extension_install_time,
                       ApplyInfo* apply_info) const OVERRIDE {
     if (ExtensionAction* action =
             GetPageAction(apply_info->profile, extension_id)) {
       action->UndoDeclarativeShow(ExtensionTabUtil::GetTabId(apply_info->tab));
       ExtensionActionAPI::Get(apply_info->profile)->NotifyChange(
           action, apply_info->tab);
     }
   }
+  virtual void Reapply(const std::string& extension_id,
+                       const base::Time& extension_install_time,
+                       ApplyInfo* apply_info) const OVERRIDE {
+  }
 
  private:
   static ExtensionAction* GetPageAction(Profile* profile,
                                         const std::string& extension_id) {
     const Extension* extension =
         ExtensionRegistry::Get(profile)
             ->GetExtensionById(extension_id, ExtensionRegistry::EVERYTHING);
     if (!extension)
       return NULL;
     return ExtensionActionManager::Get(profile)->GetPageAction(*extension);
   }
   virtual ~ShowPageAction() {}
 
   DISALLOW_COPY_AND_ASSIGN(ShowPageAction);
 };
 
 // Action that injects a content script.
 class RequestContentScript : public ContentAction {
  public:
-  RequestContentScript(const std::vector<std::string>& css_file_names,
-                       const std::vector<std::string>& js_file_names,
-                       bool all_frames,
-                       bool match_about_blank)
-      : css_file_names_(css_file_names),
-        js_file_names_(js_file_names),
-        all_frames_(all_frames),
-        match_about_blank_(match_about_blank) {}
-
-  static scoped_refptr<ContentAction> Create(const Extension* extension,
+  static scoped_refptr<ContentAction> Create(Profile* profile,
+                                             const Extension* extension,
                                              const base::DictionaryValue* dict,
                                              std::string* error,
                                              bool* bad_message);
 
+  RequestContentScript(Profile* profile,
+                       const Extension* extension,
+                       const std::vector<std::string>& css_file_names,
+                       const std::vector<std::string>& js_file_names,
+                       bool all_frames,
+                       bool match_about_blank);
+
   // Implementation of ContentAction:
   virtual Type GetType() const OVERRIDE {
     return ACTION_REQUEST_CONTENT_SCRIPT;
   }
 
   virtual void Apply(const std::string& extension_id,
                      const base::Time& extension_install_time,
                      ApplyInfo* apply_info) const OVERRIDE {
-    // TODO(markdittmer): Invoke UserScriptMaster declarative script loader:
-    // load new user script.
+    InstructRenderProcessToInject(apply_info->tab, extension_id);
   }
 
   virtual void Revert(const std::string& extension_id,
                       const base::Time& extension_install_time,
                       ApplyInfo* apply_info) const OVERRIDE {
-    // TODO(markdittmer): Invoke UserScriptMaster declarative script loader:
-    // do not load user script if Apply() runs again on the same page.
+  }
+  virtual void Reapply(const std::string& extension_id,
+                       const base::Time& extension_install_time,
+                       ApplyInfo* apply_info) const OVERRIDE {
+    InstructRenderProcessToInject(apply_info->tab, extension_id);
   }
 
  private:
-  virtual ~RequestContentScript() {}
+  virtual ~RequestContentScript() {
+    DCHECK(master_);
+    master_->RemoveScript(script_);
+  }
 
-  std::vector<std::string> css_file_names_;
-  std::vector<std::string> js_file_names_;
-  bool all_frames_;
-  bool match_about_blank_;
+  void InstructRenderProcessToInject(content::WebContents* contents,
+                                     const std::string& extension_id) const;
+
+  UserScript script_;
+  DeclarativeUserScriptMaster* master_;
 
   DISALLOW_COPY_AND_ASSIGN(RequestContentScript);
 };
 
 // Helper for getting JS collections into C++.
 static bool AppendJSStringsToCPPStrings(const base::ListValue& append_strings,
                                         std::vector<std::string>* append_to) {
   for (base::ListValue::const_iterator it = append_strings.begin();
        it != append_strings.end();
        ++it) {
     std::string value;
     if ((*it)->GetAsString(&value)) {
       append_to->push_back(value);
     } else {
       return false;
     }
   }
 
   return true;
 }
 
 // static
 scoped_refptr<ContentAction> RequestContentScript::Create(
+    Profile* profile,
     const Extension* extension,
     const base::DictionaryValue* dict,
     std::string* error,
     bool* bad_message) {
   std::vector<std::string> css_file_names;
   std::vector<std::string> js_file_names;
   bool all_frames = false;
   bool match_about_blank = false;
   const base::ListValue* list_value;
 
@@ skipping 13 matching lines @@
   }
   if (dict->HasKey(keys::kAllFrames)) {
     INPUT_FORMAT_VALIDATE(dict->GetBoolean(keys::kAllFrames, &all_frames));
   }
   if (dict->HasKey(keys::kMatchAboutBlank)) {
     INPUT_FORMAT_VALIDATE(
         dict->GetBoolean(keys::kMatchAboutBlank, &match_about_blank));
   }
 
   return scoped_refptr<ContentAction>(new RequestContentScript(
-      css_file_names, js_file_names, all_frames, match_about_blank));
+      profile,
+      extension,
+      css_file_names,
+      js_file_names,
+      all_frames,
+      match_about_blank));
+}
+
+RequestContentScript::RequestContentScript(
+    Profile* profile,
+    const Extension* extension,
+    const std::vector<std::string>& css_file_names,
+    const std::vector<std::string>& js_file_names,
+    bool all_frames,
+    bool match_about_blank) {
+  script_.set_id(ContentScriptsHandler::GetNextUserScriptID());
+  script_.set_extension_id(extension->id());
+  script_.set_run_location(UserScript::BROWSER_DRIVEN);
+  script_.set_match_all_frames(all_frames);
+  script_.set_match_about_blank(match_about_blank);
+  for (std::vector<std::string>::const_iterator it = css_file_names.begin();
+       it != 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));
+  }
+  for (std::vector<std::string>::const_iterator it = js_file_names.begin();
+       it != js_file_names.end(); ++it) {
+    GURL url = extension->GetResourceURL(*it);
+    ExtensionResource resource = extension->GetResource(*it);
+    script_.js_scripts().push_back(UserScript::File(
+        resource.extension_root(), resource.relative_path(), url));
+  }
+
+  master_ =
+      ExtensionSystem::Get(profile)->GetDeclarativeUserScriptMasterByExtension(
+          extension->id());
+  DCHECK(master_);
+  master_->AddScript(script_);
+}
+
+void RequestContentScript::InstructRenderProcessToInject(
+    content::WebContents* contents,
+    const std::string& extension_id) const {
+  // TODO(markdittmer): Send ExtensionMsg to renderer.
 }
 
 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)(
+      Profile* /* profile */,
       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 11 matching lines @@
 //
 // ContentAction
 //
 
 ContentAction::ContentAction() {}
 
 ContentAction::~ContentAction() {}
 
 // static
 scoped_refptr<ContentAction> ContentAction::Create(
+    Profile* profile,
     const Extension* extension,
     const base::Value& json_action,
     std::string* error,
     bool* bad_message) {
   *error = "";
   *bad_message = false;
 
   const base::DictionaryValue* action_dict = NULL;
   INPUT_FORMAT_VALIDATE(json_action.GetAsDictionary(&action_dict));
 
   std::string instance_type;
   INPUT_FORMAT_VALIDATE(
       action_dict->GetString(keys::kInstanceType, &instance_type));
 
   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)(
-        extension, action_dict, error, bad_message);
+        profile, extension, action_dict, error, bad_message);
 
   *error = base::StringPrintf(kInvalidInstanceTypeError, instance_type.c_str());
   return scoped_refptr<ContentAction>();
 }
 
 }  // namespace extensions