Add first-class support for user scripts

chrome/common/extensions/extension.cc

 // Copyright (c) 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.
 
 #include "chrome/common/extensions/extension.h"
 
 #include "app/resource_bundle.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ skipping 228 matching lines @@
     URLPattern pattern;
     if (!pattern.Parse(match_str)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidMatch,
           IntToString(definition_index), IntToString(j));
       return false;
     }
 
     result->add_url_pattern(pattern);
   }
 
+  // include/exclude globs (mostly for Greasemonkey compat)
+  if (!LoadGlobsHelper(content_script, definition_index, keys::kIncludeGlobs,
+                       error, &UserScript::add_glob, result)) {
+      return false;
+  }
+
+  if (!LoadGlobsHelper(content_script, definition_index, keys::kExcludeGlobs,
+                       error, &UserScript::add_exclude_glob, result)) {
+      return false;
+  }
+
   // js and css keys
   ListValue* js = NULL;
   if (content_script->HasKey(keys::kJs) &&
       !content_script->GetList(keys::kJs, &js)) {
     *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidJsList,
         IntToString(definition_index));
     return false;
   }
 
   ListValue* css = NULL;
@@ skipping 43 matching lines @@
       GURL url = GetResourceURL(WideToUTF8(relative));
       ExtensionResource resource = GetResource(WideToUTF8(relative));
       result->css_scripts().push_back(UserScript::File(
           resource.extension_root(), resource.relative_path(), url));
     }
   }
 
   return true;
 }
 
+bool Extension::LoadGlobsHelper(
+    const DictionaryValue* content_script,
+    int content_script_index,
+    const wchar_t* globs_property_name,
+    std::string* error,
+    void (UserScript::*add_method) (const std::string& glob),
+    UserScript *instance) {
+  if (!content_script->HasKey(globs_property_name))
+    return true;  // they are optional
+
+  ListValue* list = NULL;
+  if (!content_script->GetList(globs_property_name, &list)) {
+    *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidGlobList,
+        IntToString(content_script_index), WideToASCII(globs_property_name));
+    return false;
+  }
+
+  for (size_t i = 0; i < list->GetSize(); ++i) {
+    std::string glob;
+    if (!list->GetString(i, &glob)) {
+      *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidGlob,
+          IntToString(content_script_index), WideToASCII(globs_property_name),
+          IntToString(i));
+      return false;
+    }
+
+    (instance->*add_method)(glob);
+  }
+
+  return true;
+}
+
 ExtensionAction* Extension::LoadExtensionActionHelper(
     const DictionaryValue* extension_action, std::string* error) {
   scoped_ptr<ExtensionAction> result(new ExtensionAction());
   result->set_extension_id(id());
 
   // Page actions are hidden by default, and browser actions ignore
   // visibility.
   result->SetIsVisible(ExtensionAction::kDefaultTabId, false);
 
   // TODO(EXTENSIONS_DEPRECATED): icons list is obsolete.
@@ skipping 119 matching lines @@
   if (start_pos == std::string::npos)
     return ExtensionResource();
   std::string trimmed_path = relative_path.substr(start_pos);
 
   FilePath relative_resource_path;
   return ExtensionResource(extension_path,
                            relative_resource_path.AppendASCII(trimmed_path));
 }
 
 Extension::Extension(const FilePath& path)
-    : is_theme_(false), background_page_ready_(false) {
+    : is_theme_(false), background_page_ready_(false),
+      converted_from_user_script_(false) {
   DCHECK(path.IsAbsolute());
   location_ = INVALID;
 
 #if defined(OS_WIN)
   // Normalize any drive letter to upper-case. We do this for consistency with
   // net_utils::FilePathToFileURL(), which does the same thing, to make string
   // comparisons simpler.
   std::wstring path_str = path.value();
   if (path_str.size() >= 2 && path_str[0] >= L'a' && path_str[0] <= L'z' &&
       path_str[1] == ':')
@@ skipping 197 matching lines @@
       return false;
     }
     update_url_ = GURL(tmp);
     if (!update_url_.is_valid() || update_url_.has_ref()) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidUpdateURL, tmp);
       return false;
     }
   }
 
+  // Initialize converted_from_user_script (if present)
+  source.GetBoolean(keys::kConvertedFromUserScript,
+                    &converted_from_user_script_);
+
   // Initialize icons (if present).
   if (source.HasKey(keys::kIcons)) {
     DictionaryValue* icons_value = NULL;
     if (!source.GetDictionary(keys::kIcons, &icons_value)) {
       *error = errors::kInvalidIcons;
       return false;
     }
 
     for (size_t i = 0; i < arraysize(kIconSizes); ++i) {
       std::wstring key = ASCIIToWide(IntToString(kIconSizes[i]));
@@ skipping 255 matching lines @@
       if (!list_value->GetDictionary(i, &content_script)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
             errors::kInvalidContentScript, IntToString(i));
         return false;
       }
 
       UserScript script;
       if (!LoadUserScriptHelper(content_script, i, error, &script))
         return false;  // Failed to parse script context definition
       script.set_extension_id(id());
+      if (converted_from_user_script_)
+        script.set_emulate_greasemonkey(true);
       content_scripts_.push_back(script);
     }
   }
 
   // Initialize page action (optional).
   if (source.HasKey(keys::kPageActions)) {
     ListValue* list_value;
     if (!source.GetList(keys::kPageActions, &list_value)) {
       *error = errors::kInvalidPageActionsList;
       return false;
@@ skipping 236 matching lines @@
     UserScript::PatternList::const_iterator pattern =
         content_script->url_patterns().begin();
     for (; pattern != content_script->url_patterns().end(); ++pattern) {
       if (pattern->match_subdomains() && pattern->host().empty())
         return true;
     }
   }
 
   return false;
 }