Introduce background.scripts feature for extension manifests.

chrome/common/extensions/extension.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/common/extensions/extension.h"
 
 #include <algorithm>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 355 matching lines @@
                                const std::string& relative_path) {
   DCHECK(extension_url.SchemeIs(chrome::kExtensionScheme));
   DCHECK_EQ("/", extension_url.path());
 
   GURL ret_val = GURL(extension_url.spec() + relative_path);
   DCHECK(StartsWithASCII(ret_val.spec(), extension_url.spec(), false));
 
   return ret_val;
 }
 
+GURL Extension::GetBackgroundURL() const {
+  if (!background_scripts_.empty()) {
+    return GetResourceURL(
+        extension_filenames::kGeneratedBackgroundPageFilename);
+  } else {
+    return background_url_;
+  }
+}
+
 bool Extension::IsResourceWebAccessible(const std::string& relative_path)
     const {
   // For old manifest versions which do not specify web_accessible_resources
   // we always allow resource loads.
   if (manifest_version() < 2 && !HasWebAccessibleResources())
     return true;
 
   if (web_accessible_resources_.find(relative_path) !=
       web_accessible_resources_.end())
     return true;
@@ skipping 796 matching lines @@
         service.disposition =
             webkit_glue::WebIntentServiceData::DISPOSITION_WINDOW;
       }
     }
 
     intents_services_.push_back(service);
   }
   return true;
 }
 
+bool Extension::LoadBackgroundScripts(const extensions::Manifest* manifest,
+                                      string16* error) {
+  Value* background_scripts_value = NULL;
+  if (!manifest->Get(keys::kBackgroundScripts, &background_scripts_value))
+    return true;
+
+  CHECK(background_scripts_value);
+  if (background_scripts_value->GetType() != Value::TYPE_LIST) {
+    *error = ASCIIToUTF16(errors::kInvalidBackgroundScripts);
+    return false;
+  }
+
+  ListValue* background_scripts =
+      static_cast<ListValue*>(background_scripts_value);
+  for (size_t i = 0; i < background_scripts->GetSize(); ++i) {
+    std::string script;
+    if (!background_scripts->GetString(i, &script)) {
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+          errors::kInvalidBackgroundScript, base::IntToString(i));
+      return false;
+    }
+    background_scripts_.push_back(script);

[Mihai Parparita -not on Chrome, 2012/01/10 01:51:37]

Drive by: Do you want to validate that these are relative paths only? It looks
like "background": {"scripts": ["http://www.mysite.com/script.js"]] will result
in a <script> tag pointed at that URL being generated. Though maybe that's OK,
because of CSP?

+  }
+
+  return true;
+}
+
 bool Extension::LoadBackgroundPage(
     const extensions::Manifest* manifest,
     const ExtensionAPIPermissionSet& api_permissions,
     string16* error) {
   base::Value* background_page_value = NULL;
   if (!manifest->Get(keys::kBackgroundPage, &background_page_value)) {
     if (manifest_version_ == 1)
       manifest->Get(keys::kBackgroundPageLegacy, &background_page_value);
   }
 
   if (!background_page_value)
     return true;
 
   std::string background_str;
   if (!background_page_value->GetAsString(&background_str)) {
     *error = ASCIIToUTF16(errors::kInvalidBackground);
     return false;
   }
 
+  if (!background_scripts_.empty()) {
+    *error = ASCIIToUTF16(errors::kInvalidBackgroundCombination);
+    return false;
+  }
+
   if (is_hosted_app()) {
     // Make sure "background" permission is set.
     if (!api_permissions.count(ExtensionAPIPermission::kBackground)) {
       *error = ASCIIToUTF16(errors::kBackgroundPermissionNeeded);
       return false;
     }
     // Hosted apps require an absolute URL.
     GURL bg_page(background_str);
     if (!bg_page.is_valid()) {
       *error = ASCIIToUTF16(errors::kInvalidBackgroundInHostedApp);
@@ skipping 742 matching lines @@
         return false;
       }
       options_url_ = GetResourceURL(options_str);
       if (!options_url_.is_valid()) {
         *error = ASCIIToUTF16(errors::kInvalidOptionsPage);
         return false;
       }
     }
   }
 
+  if (!LoadBackgroundScripts(manifest, error))
+    return false;
+
   if (!LoadBackgroundPage(manifest, api_permissions, error))
     return false;
 
   if (manifest->HasKey(keys::kDefaultLocale)) {
     if (!manifest->GetString(keys::kDefaultLocale, &default_locale_) ||
         !l10n_util::IsValidLocaleSyntax(default_locale_)) {
       *error = ASCIIToUTF16(errors::kInvalidDefaultLocale);
       return false;
     }
   }
@@ skipping 978 matching lines @@
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}