Add early-injection capability to user scripts. I haven't yet

chrome/browser/extensions/extension.cc

 // Copyright (c) 2006-2008 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/extension.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "net/base/net_util.h"
 #include "chrome/common/extensions/user_script.h"
 
 const char kExtensionURLScheme[] = "chrome-extension";
 const char kUserScriptURLScheme[] = "chrome-user-script";
 
 const char Extension::kManifestFilename[] = "manifest.json";
 
 const wchar_t* Extension::kDescriptionKey = L"description";
 const wchar_t* Extension::kFilesKey = L"files";
 const wchar_t* Extension::kFormatVersionKey = L"format_version";
 const wchar_t* Extension::kIdKey = L"id";
 const wchar_t* Extension::kMatchesKey = L"matches";
 const wchar_t* Extension::kNameKey = L"name";
 const wchar_t* Extension::kUserScriptsKey = L"user_scripts";
+const wchar_t* Extension::kRunAtKey = L"run_at";
 const wchar_t* Extension::kVersionKey = L"version";
 const wchar_t* Extension::kZipHashKey = L"zip_hash";
 
+const char* Extension::kRunAtDocumentStartValue = "document_start";
+const char* Extension::kRunAtDocumentEndValue = "document_end";
+
 // Extension-related error messages. Some of these are simple patterns, where a
 // '*' is replaced at runtime with a specific value. This is used instead of
 // printf because we want to unit test them and scanf is hard to make
 // cross-platform.
 const char* Extension::kInvalidDescriptionError =
     "Invalid value for 'description'.";
 const char* Extension::kInvalidFileCountError =
     "Invalid value for 'user_scripts[*].files. Only one file is currently "
     "supported per-user script.";
 const char* Extension::kInvalidFileError =
     "Invalid value for 'user_scripts[*].files[*]'.";
 const char* Extension::kInvalidFilesError =
     "Required value 'user_scripts[*].files is missing or invalid.";
 const char* Extension::kInvalidFormatVersionError =
     "Required value 'format_version' is missing or invalid.";
 const char* Extension::kInvalidIdError =
     "Required value 'id' is missing or invalid.";
 const char* Extension::kInvalidManifestError =
     "Manifest is missing or invalid.";
 const char* Extension::kInvalidMatchCountError =
     "Invalid value for 'user_scripts[*].matches. There must be at least one "
     "match specified.";
 const char* Extension::kInvalidMatchError =
     "Invalid value for 'user_scripts[*].matches[*]'.";
 const char* Extension::kInvalidMatchesError =
     "Required value 'user_scripts[*].matches' is missing or invalid.";
 const char* Extension::kInvalidNameError =
     "Required value 'name' is missing or invalid.";
+const char* Extension::kInvalidRunAtError =
+    "Invalid value for 'user_scripts[*].run_at'.";
 const char* Extension::kInvalidUserScriptError =
     "Invalid value for 'user_scripts[*]'.";
 const char* Extension::kInvalidUserScriptsListError =
     "Invalid value for 'user_scripts'.";
 const char* Extension::kInvalidVersionError =
     "Required value 'version' is missing or invalid.";
 const char* Extension::kInvalidZipHashError =
     "Required key 'zip_hash' is missing or invalid.";
 
 const std::string Extension::VersionString() const {
@@ skipping 191 matching lines @@
         return false;
       }
 
       // NOTE: Only one file is supported right now.
       if (files->GetSize() != 1) {
         *error = FormatErrorMessage(kInvalidFileCountError, IntToString(i));
         return false;
       }
 
       UserScript script;
+      if (user_script->HasKey(kRunAtKey)) {
+        std::string run_location;
+        if (!user_script->GetString(kRunAtKey, &run_location)) {
+          *error = FormatErrorMessage(kInvalidRunAtError, IntToString(i));
+          return false;
+        }
+
+        if (run_location == kRunAtDocumentStartValue) {
+          script.set_run_location(UserScript::DOCUMENT_START);
+        } else if (run_location == kRunAtDocumentEndValue) {
+          script.set_run_location(UserScript::DOCUMENT_END);
+        } else {
+          *error = FormatErrorMessage(kInvalidRunAtError, IntToString(i));
+          return false;
+        }
+      }
+
       for (size_t j = 0; j < matches->GetSize(); ++j) {
         std::string match_str;
         if (!matches->GetString(j, &match_str)) {
           *error = FormatErrorMessage(kInvalidMatchError, IntToString(i),
                                       IntToString(j));
           return false;
         }
 
         URLPattern pattern;
         if (!pattern.Parse(match_str)) {
@@ skipping 15 matching lines @@
       script.set_path(Extension::GetResourcePath(path(), file));
       script.set_url(Extension::GetResourceURL(url(), file));
 
       user_scripts_.push_back(script);
     }
   }
 
   return true;
 }