Refactoring: de-couple Extensions from "script injection System" [render side]:2

extensions/common/user_script.h

 // Copyright 2013 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.
 
 #ifndef EXTENSIONS_COMMON_USER_SCRIPT_H_
 #define EXTENSIONS_COMMON_USER_SCRIPT_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/strings/string_piece.h"
+#include "extensions/common/consumer_instance_info.h"
 #include "extensions/common/host_id.h"
 #include "extensions/common/url_pattern.h"
 #include "extensions/common/url_pattern_set.h"
 #include "url/gurl.h"
 
 class Pickle;
 class PickleIterator;
 
 namespace extensions {
 
@@ skipping 95 matching lines @@
     // The script content. It can be set to either loaded_content_ or
     // externally allocated string.
     base::StringPiece external_content_;
 
     // Set when the content is loaded by LoadContent
     std::string content_;
   };
 
   typedef std::vector<File> FileList;
 
+  // Render's routing info of a <webview> that the user script will be injected
+  // on. Only user scripts from <webview>s have a custom routing info.
+  struct RoutingInfo {
+    RoutingInfo() : render_process_id(-1), render_view_id(-1) {};
+    ~RoutingInfo() {};
+
+    int render_process_id;
+    int render_view_id;
+  };
+
   // Constructor. Default the run location to document end, which is like
   // Greasemonkey and probably more useful for typical scripts.
   UserScript();
   ~UserScript();
 
   const std::string& name_space() const { return name_space_; }
   void set_name_space(const std::string& name_space) {
     name_space_ = name_space;
   }
 
@@ skipping 54 matching lines @@
 
   // List of css scripts for this user script
   FileList& css_scripts() { return css_scripts_; }
   const FileList& css_scripts() const { return css_scripts_; }
 
   const std::string& extension_id() const { return host_id_.id(); }
 
   const HostID& host_id() const { return host_id_; }
   void set_host_id(const HostID& host_id) { host_id_ = host_id; }
 
+  const ConsumerInstanceInfo& consumer_instance_info() const {
+    return consumer_instance_info_;
+  }
+  void set_consumer_instance_info(const ConsumerInstanceInfo& instance_info) {

[Devlin, 2015/02/11 20:29:01]

I don't see these being set anywhere yet - are they supposed to be?

[Xi Han, 2015/02/11 21:57:24]

Yes, once we have add/remove content scripts APIs for <webviews>, the webview
will set the consumer_instance_info when initializing the user scripts.

+    consumer_instance_info_ = instance_info;
+  }
+
+  const RoutingInfo& routing_info() const { return routing_info_; }
+  void set_routing_info(const RoutingInfo& routing_info) {
+    routing_info_ = routing_info;
+  }
+
   int id() const { return user_script_id_; }
   void set_id(int id) { user_script_id_ = id; }
 
   bool is_incognito_enabled() const { return incognito_enabled_; }
   void set_incognito_enabled(bool enabled) { incognito_enabled_ = enabled; }
 
   bool is_standalone() const { return extension_id().empty(); }
 
   // Returns true if the script should be applied to the specified URL, false
   // otherwise.
   bool MatchesURL(const GURL& url) const;
 
   // Serialize the UserScript into a pickle. The content of the scripts and
   // paths to UserScript::Files will not be serialized!
   void Pickle(::Pickle* pickle) const;
 
   // Deserialize the script from a pickle. Note that this always succeeds
   // because presumably we were the one that pickled it, and we did it
   // correctly.
   void Unpickle(const ::Pickle& pickle, PickleIterator* iter);
 
  private:
   // Pickle helper functions used to pickle the individual types of components.
   void PickleGlobs(::Pickle* pickle,
                    const std::vector<std::string>& globs) const;
   void PickleHostID(::Pickle* pickle, const HostID& host_id) const;
+  void PickleConsumerInstanceInfo(
+      ::Pickle* pickle,
+      const ConsumerInstanceInfo& consumer_instance_info) const;
+  void PickleRoutingInfo(::Pickle* pickle,
+                         const RoutingInfo& routing_info) const;
   void PickleURLPatternSet(::Pickle* pickle,
                            const URLPatternSet& pattern_list) const;
   void PickleScripts(::Pickle* pickle, const FileList& scripts) const;
 
   // Unpickle helper functions used to unpickle individual types of components.
   void UnpickleGlobs(const ::Pickle& pickle, PickleIterator* iter,
                      std::vector<std::string>* globs);
   void UnpickleHostID(const ::Pickle& pickle,
                       PickleIterator* iter,
                       HostID* host_id);
+  void UnpickleConsumerInstanceInfo(
+      const ::Pickle& pickle,
+      PickleIterator* iter,
+      ConsumerInstanceInfo* consumer_instance_info);
+  void UnpickleRoutingInfo(const ::Pickle& pickle,
+                           PickleIterator* iter,
+                           RoutingInfo* routing_info);
   void UnpickleURLPatternSet(const ::Pickle& pickle, PickleIterator* iter,
                              URLPatternSet* pattern_list);
   void UnpickleScripts(const ::Pickle& pickle, PickleIterator* iter,
                        FileList* scripts);
 
   // The location to run the script inside the document.
   RunLocation run_location_;
 
   // The namespace of the script. This is used by Greasemonkey in the same way
   // as XML namespaces. Only used when parsing Greasemonkey-style scripts.
@@ skipping 22 matching lines @@
   // List of js scripts defined in content_scripts
   FileList js_scripts_;
 
   // List of css scripts defined in content_scripts
   FileList css_scripts_;
 
   // The ID of the host this script is a part of. The |ID| of the
   // |host_id| can be empty if the script is a "standlone" user script.
   HostID host_id_;
 
+  // The type and id of the consumer instance that the script will be injected.
+  ConsumerInstanceInfo consumer_instance_info_;
+
+  // The render side's rounting info for content_scripts of <webview>.
+  RoutingInfo routing_info_;
+
   // The globally-unique id associated with this user script. Defaults to
   // -1 for invalid.
   int user_script_id_;
 
   // Whether we should try to emulate Greasemonkey's APIs when running this
   // script.
   bool emulate_greasemonkey_;
 
   // Whether the user script should run in all frames, or only just the top one.
   // Defaults to false.
   bool match_all_frames_;
 
   // Whether the user script should run in about:blank and about:srcdoc as well.
   // Defaults to false.
   bool match_about_blank_;
 
   // True if the script should be injected into an incognito tab.
   bool incognito_enabled_;
 };
 
 // For storing UserScripts with unique IDs in sets.
 bool operator<(const UserScript& script1, const UserScript& script2);
 
 typedef std::vector<UserScript> UserScriptList;
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_USER_SCRIPT_H_