Add first-class support for user scripts

chrome/common/extensions/user_script.h

 // Copyright 2009 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 CHROME_COMMON_EXTENSIONS_USER_SCRIPT_H_
 #define CHROME_COMMON_EXTENSIONS_USER_SCRIPT_H_
 
 #include <vector>
 #include <string>
 
 #include "base/file_path.h"
 #include "base/string_piece.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "googleurl/src/gurl.h"
 
 class Pickle;
 
 // Represents a user script, either a standalone one, or one that is part of an
 // extension.
 class UserScript {
  public:
   typedef std::vector<URLPattern> PatternList;
 
+  // The file extension for standalone user scripts.
+  static const char kFileExtension[];
+
+  // Check if a file or URL has the user script file extension.
+  static bool HasUserScriptFileExtension(const GURL& url);
+  static bool HasUserScriptFileExtension(const FilePath& path);
+
   // Locations that user scripts can be run inside the document.
   enum RunLocation {
     DOCUMENT_START,  // After the documentElemnet is created, but before
                      // anything else happens.
     DOCUMENT_END,  // After the entire document is parsed. Same as
                    // DOMContentLoaded.
 
     RUN_LOCATION_LAST  // Leave this as the last item.
   };
 
@@ skipping 48 matching lines @@
     base::StringPiece external_content_;
 
     // Set when the content is loaded by LoadContent
     std::string content_;
   };
 
   typedef std::vector<File> FileList;
 
   // Constructor. Default the run location to document end, which is like
   // Greasemonkey and probably more useful for typical scripts.
-  UserScript() : run_location_(DOCUMENT_END) {}
+  UserScript()
+    : run_location_(DOCUMENT_END), emulate_greasemonkey_(false) {
+  }
+
+  const std::string& name_space() const { return name_space_; }
+  void set_name_space(const std::string& name_space) {
+    name_space_ = name_space;
+  }
+
+  const std::string& name() const { return name_; }
+  void set_name(const std::string& name) { name_ = name; }
+
+  const std::string& description() const { return description_; }
+  void set_description(const std::string& description) {
+    description_ = description;
+  }
 
   // The place in the document to run the script.
   RunLocation run_location() const { return run_location_; }
   void set_run_location(RunLocation location) { run_location_ = location; }
 
+  // Whether to emulate greasemonkey when running this script.
+  bool emulate_greasemonkey() const { return emulate_greasemonkey_; }
+  void set_emulate_greasemonkey(bool val) { emulate_greasemonkey_ = val; }
+
   // The globs, if any, that determine which pages this script runs against.
   // These are only used with "standalone" Greasemonkey-like user scripts.
   const std::vector<std::string>& globs() const { return globs_; }
   void add_glob(const std::string& glob) { globs_.push_back(glob); }
   void clear_globs() { globs_.clear(); }
+  const std::vector<std::string>& exclude_globs() const {
+    return exclude_globs_;
+  }
+  void add_exclude_glob(const std::string& glob) {
+    exclude_globs_.push_back(glob);
+  }
+  void clear_exclude_globs() { exclude_globs_.clear(); }
 
   // The URLPatterns, if any, that determine which pages this script runs
   // against.
   const PatternList& url_patterns() const { return url_patterns_; }
   void add_url_pattern(const URLPattern& pattern) {
     url_patterns_.push_back(pattern);
   }
   void clear_url_patterns() { url_patterns_.clear(); }
 
   // List of js scripts for this user script
@@ skipping 19 matching lines @@
 
   // 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, void** iter);
 
  private:
   // 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.
+  std::string name_space_;
+
+  // The script's name. Only used when parsing Greasemonkey-style scripts.
+  std::string name_;
+
+  // A longer description. Only used when parsing Greasemonkey-style scripts.
+  std::string description_;
+
   // Greasemonkey-style globs that determine pages to inject the script into.
   // These are only used with standalone scripts.
   std::vector<std::string> globs_;
+  std::vector<std::string> exclude_globs_;
 
   // URLPatterns that determine pages to inject the script into. These are
   // only used with scripts that are part of extensions.
   PatternList url_patterns_;
 
   // 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 extension this script is a part of, if any. Can be empty if
   // the script is a "standlone" user script.
   std::string extension_id_;
+
+  // Whether we should try to emulate Greasemonkey's APIs when running this
+  // script.
+  bool emulate_greasemonkey_;
 };
 
 typedef std::vector<UserScript> UserScriptList;
 
 #endif  // CHROME_COMMON_EXTENSIONS_USER_SCRIPT_H_