Manifest handler for all keys background-related.

chrome/common/extensions/extension.cc

 // Copyright (c) 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.
 
 #include "chrome/common/extensions/extension.h"
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 12 matching lines @@
 #include "base/version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 // TODO(rdevlin.cronin): Remove this once PageAction, BrowserAction, and
 // SystemIndicator have been moved out of Extension.
 #include "chrome/common/extensions/api/extension_action/action_info.h"
 #include "chrome/common/extensions/api/extension_action/page_action_handler.h"
 #include "chrome/common/extensions/api/icons/icons_handler.h"
 #include "chrome/common/extensions/api/themes/theme_handler.h"
+#include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/csp_handler.h"
 #include "chrome/common/extensions/csp_validator.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/extensions/features/base_feature_provider.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/manifest_handler_helpers.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
@@ skipping 98 matching lines @@
   // Note: Component extensions have this right implicitly and do not need to be
   // added to this list.
   Extension::ScriptingWhitelist scripting_whitelist_;
 };
 
 bool ReadLaunchDimension(const extensions::Manifest* manifest,
                          const char* key,
                          int* target,
                          bool is_valid_container,
                          string16* error) {
-  Value* temp = NULL;
+  const Value* temp = NULL;
   if (manifest->Get(key, &temp)) {
     if (!is_valid_container) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidLaunchValueContainer,
           key);
       return false;
     }
     if (!temp->GetAsInteger(target) || *target < 0) {
       *target = 0;
       *error = ErrorUtils::FormatErrorMessageUTF16(
@@ skipping 340 matching lines @@
 // static
 const Extension::ScriptingWhitelist* Extension::GetScriptingWhitelist() {
   return ExtensionConfig::GetInstance()->whitelist();
 }
 
 bool Extension::ParsePermissions(const char* key,
                                  string16* error,
                                  APIPermissionSet* api_permissions,
                                  URLPatternSet* host_permissions) {
   if (manifest_->HasKey(key)) {
-    ListValue* permissions = NULL;
+    const ListValue* permissions = NULL;
     if (!manifest_->GetList(key, &permissions)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidPermissions, "");
       return false;
     }
 
     // NOTE: We need to get the APIPermission before we check if features
     // associated with them are available because the feature system does not
     // know about aliases.
 
@@ skipping 573 matching lines @@
   return !content_pack_site_list_.empty();
 }
 
 ExtensionResource Extension::GetContentPackSiteList() const {
   if (!is_content_pack())
     return ExtensionResource();
 
   return GetResource(content_pack_site_list_);
 }
 
-GURL Extension::GetBackgroundURL() const {
-  if (background_scripts_.empty())
-    return background_url_;
-  return GetResourceURL(extension_filenames::kGeneratedBackgroundPageFilename);
-}
-
 Extension::RuntimeData::RuntimeData() {}
 Extension::RuntimeData::RuntimeData(const PermissionSet* active)
     : active_permissions_(active) {}
 Extension::RuntimeData::~RuntimeData() {}
 
 void Extension::RuntimeData::SetActivePermissions(
     const PermissionSet* active) {
   active_permissions_ = active;
 }
 
@@ skipping 82 matching lines @@
 
   return base::FilePath(path_str);
 #else
   return path;
 #endif
 }
 
 bool Extension::LoadManagedModeFeatures(string16* error) {
   if (!manifest_->HasKey(keys::kContentPack))
     return true;
-  DictionaryValue* content_pack_value = NULL;
+  const DictionaryValue* content_pack_value = NULL;
   if (!manifest_->GetDictionary(keys::kContentPack, &content_pack_value)) {
     *error = ASCIIToUTF16(errors::kInvalidContentPack);
     return false;
   }
 
   if (!LoadManagedModeSites(content_pack_value, error))
     return false;
   if (!LoadManagedModeConfigurations(content_pack_value, error))
     return false;
 
@@ skipping 29 matching lines @@
   // See http://b/4946060 for more details.
   return id == std::string("nckgahadagoaajjgafhacjanaoiihapd");
 }
 
 Extension::Extension(const base::FilePath& path,
                      scoped_ptr<extensions::Manifest> manifest)
     : manifest_version_(0),
       incognito_split_mode_(false),
       offline_enabled_(false),
       converted_from_user_script_(false),
-      background_page_is_persistent_(true),
-      allow_background_js_access_(true),
       manifest_(manifest.release()),
       finished_parsing_manifest_(false),
       is_storage_isolated_(false),
       launch_container_(extension_misc::LAUNCH_TAB),
       launch_width_(0),
       launch_height_(0),
       display_in_launcher_(true),
       display_in_new_tab_page_(true),
       wants_file_access_(false),
       creation_flags_(0) {
@@ skipping 118 matching lines @@
     is_storage_isolated_ = true;
     return true;
   }
 
   // Other apps only get it if it is requested _and_ experimental APIs are
   // enabled.
   if (!initial_api_permissions()->count(APIPermission::kExperimental)
       || !is_app())
     return true;
 
-  Value* tmp_isolation = NULL;
+  const Value* tmp_isolation = NULL;
   if (!manifest_->Get(keys::kIsolation, &tmp_isolation))
     return true;
 
-  if (tmp_isolation->GetType() != Value::TYPE_LIST) {
+  const ListValue* isolation_list = NULL;
+  if (!tmp_isolation->GetAsList(&isolation_list)) {
     *error = ASCIIToUTF16(errors::kInvalidIsolation);
     return false;
   }
 
-  ListValue* isolation_list = static_cast<ListValue*>(tmp_isolation);
   for (size_t i = 0; i < isolation_list->GetSize(); ++i) {
     std::string isolation_string;
     if (!isolation_list->GetString(i, &isolation_string)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidIsolationValue,
           base::UintToString(i));
       return false;
     }
 
     // Check for isolated storage.
@@ skipping 62 matching lines @@
     display_in_new_tab_page_ = display_in_launcher_;
   }
   return true;
 }
 
 bool Extension::LoadExtent(const char* key,
                            URLPatternSet* extent,
                            const char* list_error,
                            const char* value_error,
                            string16* error) {
-  Value* temp_pattern_value = NULL;
+  const Value* temp_pattern_value = NULL;
   if (!manifest_->Get(key, &temp_pattern_value))
     return true;
 
-  if (temp_pattern_value->GetType() != Value::TYPE_LIST) {
+  const ListValue* pattern_list = NULL;
+  if (!temp_pattern_value->GetAsList(&pattern_list)) {
     *error = ASCIIToUTF16(list_error);
     return false;
   }
 
-  ListValue* pattern_list = static_cast<ListValue*>(temp_pattern_value);
   for (size_t i = 0; i < pattern_list->GetSize(); ++i) {
     std::string pattern_string;
     if (!pattern_list->GetString(i, &pattern_string)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(value_error,
                                                        base::UintToString(i),
                                                        errors::kExpectString);
       return false;
     }
 
     URLPattern pattern(kValidWebExtentSchemes);
@@ skipping 40 matching lines @@
     }
     pattern.SetPath(pattern.path() + '*');
 
     extent->AddPattern(pattern);
   }
 
   return true;
 }
 
 bool Extension::LoadLaunchContainer(string16* error) {
-  Value* tmp_launcher_container = NULL;
+  const Value* tmp_launcher_container = NULL;
   if (!manifest_->Get(keys::kLaunchContainer, &tmp_launcher_container))
     return true;
 
   std::string launch_container_string;
   if (!tmp_launcher_container->GetAsString(&launch_container_string)) {
     *error = ASCIIToUTF16(errors::kInvalidLaunchContainer);
     return false;
   }
 
   if (launch_container_string == values::kLaunchContainerPanel) {
@@ skipping 24 matching lines @@
                            &launch_height_,
                            can_specify_initial_size,
                            error)) {
       return false;
   }
 
   return true;
 }
 
 bool Extension::LoadLaunchURL(string16* error) {
-  Value* temp = NULL;
+  const Value* temp = NULL;
 
   // launch URL can be either local (to chrome-extension:// root) or an absolute
   // web URL.
   if (manifest_->Get(keys::kLaunchLocalPath, &temp)) {
     if (manifest_->Get(keys::kLaunchWebURL, NULL)) {
       *error = ASCIIToUTF16(errors::kLaunchPathAndURLAreExclusive);
       return false;
     }
 
     if (manifest_->Get(keys::kWebURLs, NULL)) {
@@ skipping 97 matching lines @@
   return true;
 }
 
 bool Extension::LoadSharedFeatures(string16* error) {
   if (!LoadDescription(error) ||
       !ManifestHandler::ParseExtension(this, error) ||
       !LoadPlugins(error) ||
       !LoadNaClModules(error) ||
       !LoadSandboxedPages(error) ||
       !LoadRequirements(error) ||
-      !LoadOfflineEnabled(error) ||
-      // LoadBackgroundScripts() must be called before LoadBackgroundPage().
-      !LoadBackgroundScripts(error) ||
-      !LoadBackgroundPage(error) ||
-      !LoadBackgroundPersistent(error) ||
-      !LoadBackgroundAllowJSAccess(error))
+      !LoadOfflineEnabled(error))
     return false;
 
   return true;
 }
 
 bool Extension::LoadDescription(string16* error) {
   if (manifest_->HasKey(keys::kDescription) &&
       !manifest_->GetString(keys::kDescription, &description_)) {
     *error = ASCIIToUTF16(errors::kInvalidDescription);
     return false;
@@ skipping 24 matching lines @@
     return false;
   }
 
   return true;
 }
 
 bool Extension::LoadPlugins(string16* error) {
   if (!manifest_->HasKey(keys::kPlugins))
     return true;
 
-  ListValue* list_value = NULL;
+  const ListValue* list_value = NULL;
   if (!manifest_->GetList(keys::kPlugins, &list_value)) {
     *error = ASCIIToUTF16(errors::kInvalidPlugins);
     return false;
   }
 
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
-    DictionaryValue* plugin_value = NULL;
+    const DictionaryValue* plugin_value = NULL;
     if (!list_value->GetDictionary(i, &plugin_value)) {
       *error = ASCIIToUTF16(errors::kInvalidPlugins);
       return false;
     }
     // Get plugins[i].path.
     std::string path_str;
     if (!plugin_value->GetString(keys::kPluginsPath, &path_str)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidPluginsPath, base::IntToString(i));
       return false;
@@ skipping 24 matching lines @@
     plugins_.back().path = path().Append(
         base::FilePath::FromUTF8Unsafe(path_str));
     plugins_.back().is_public = is_public;
   }
   return true;
 }
 
 bool Extension::LoadNaClModules(string16* error) {
   if (!manifest_->HasKey(keys::kNaClModules))
     return true;
-  ListValue* list_value = NULL;
+  const ListValue* list_value = NULL;
   if (!manifest_->GetList(keys::kNaClModules, &list_value)) {
     *error = ASCIIToUTF16(errors::kInvalidNaClModules);
     return false;
   }
 
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
-    DictionaryValue* module_value = NULL;
+    const DictionaryValue* module_value = NULL;
     if (!list_value->GetDictionary(i, &module_value)) {
       *error = ASCIIToUTF16(errors::kInvalidNaClModules);
       return false;
     }
 
     // Get nacl_modules[i].path.
     std::string path_str;
     if (!module_value->GetString(keys::kNaClModulesPath, &path_str)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidNaClModulesPath, base::IntToString(i));
@@ skipping 13 matching lines @@
     nacl_modules_.back().mime_type = mime_type;
   }
 
   return true;
 }
 
 bool Extension::LoadSandboxedPages(string16* error) {
   if (!manifest_->HasPath(keys::kSandboxedPages))
     return true;
 
-  ListValue* list_value = NULL;
+  const ListValue* list_value = NULL;
   if (!manifest_->GetList(keys::kSandboxedPages, &list_value)) {
     *error = ASCIIToUTF16(errors::kInvalidSandboxedPagesList);
     return false;
   }
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     std::string relative_path;
     if (!list_value->GetString(i, &relative_path)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidSandboxedPage, base::IntToString(i));
       return false;
@@ skipping 30 matching lines @@
     CHECK(ContentSecurityPolicyIsSandboxed(
         sandboxed_pages_content_security_policy_, GetType()));
   }
 
   return true;
 }
 
 bool Extension::LoadRequirements(string16* error) {
   // Before parsing requirements from the manifest, automatically default the
   // NPAPI plugin requirement based on whether it includes NPAPI plugins.
-  ListValue* list_value = NULL;
+  const ListValue* list_value = NULL;
   requirements_.npapi =
     manifest_->GetList(keys::kPlugins, &list_value) && !list_value->empty();
 
   if (!manifest_->HasKey(keys::kRequirements))
     return true;
 
-  DictionaryValue* requirements_value = NULL;
+  const DictionaryValue* requirements_value = NULL;
   if (!manifest_->GetDictionary(keys::kRequirements, &requirements_value)) {
     *error = ASCIIToUTF16(errors::kInvalidRequirements);
     return false;
   }
 
   for (DictionaryValue::Iterator it(*requirements_value); !it.IsAtEnd();
        it.Advance()) {
     const DictionaryValue* requirement_value;
     if (!it.value().GetAsDictionary(&requirement_value)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
@@ skipping 58 matching lines @@
     offline_enabled_ = is_platform_app();
     return true;
   }
   if (!manifest_->GetBoolean(keys::kOfflineEnabled, &offline_enabled_)) {
     *error = ASCIIToUTF16(errors::kInvalidOfflineEnabled);
     return false;
   }
   return true;
 }
 
-bool Extension::LoadBackgroundScripts(string16* error) {
-  const std::string& key = is_platform_app() ?
-      keys::kPlatformAppBackgroundScripts : keys::kBackgroundScripts;
-  return LoadBackgroundScripts(key, error);
-}
-
-bool Extension::LoadBackgroundScripts(const std::string& key, string16* error) {
-  Value* background_scripts_value = NULL;
-  if (!manifest_->Get(key, &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 = ErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidBackgroundScript, base::IntToString(i));
-      return false;
-    }
-    background_scripts_.push_back(script);
-  }
-
-  return true;
-}
-
-bool Extension::LoadBackgroundPage(string16* error) {
-  if (is_platform_app()) {
-    return LoadBackgroundPage(keys::kPlatformAppBackgroundPage, error);
-  }
-
-  if (!LoadBackgroundPage(keys::kBackgroundPage, error))
-    return false;
-  if (background_url_.is_empty()) {
-    return LoadBackgroundPage(
-        keys::kBackgroundPageLegacy, error);
-  }
-  return true;
-}
-
-bool Extension::LoadBackgroundPage(const std::string& key, string16* error) {
-  base::Value* background_page_value = NULL;
-  if (!manifest_->Get(key, &background_page_value))
-    return true;
-
-  if (!background_scripts_.empty()) {
-    *error = ASCIIToUTF16(errors::kInvalidBackgroundCombination);
-    return false;
-  }
-
-
-  std::string background_str;
-  if (!background_page_value->GetAsString(&background_str)) {
-    *error = ASCIIToUTF16(errors::kInvalidBackground);
-    return false;
-  }
-
-  if (is_hosted_app()) {
-    background_url_ = GURL(background_str);
-
-    // Make sure "background" permission is set.
-    if (!initial_api_permissions()->count(APIPermission::kBackground)) {
-      *error = ASCIIToUTF16(errors::kBackgroundPermissionNeeded);
-      return false;
-    }
-    // Hosted apps require an absolute URL.
-    if (!background_url_.is_valid()) {
-      *error = ASCIIToUTF16(errors::kInvalidBackgroundInHostedApp);
-      return false;
-    }
-
-    if (!(background_url_.SchemeIs("https") ||
-          (CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kAllowHTTPBackgroundPage) &&
-           background_url_.SchemeIs("http")))) {
-      *error = ASCIIToUTF16(errors::kInvalidBackgroundInHostedApp);
-      return false;
-    }
-  } else {
-    background_url_ = GetResourceURL(background_str);
-  }
-
-  return true;
-}
-
-bool Extension::LoadBackgroundPersistent(string16* error) {
-  if (is_platform_app()) {
-    background_page_is_persistent_ = false;
-    return true;
-  }
-
-  Value* background_persistent = NULL;
-  if (!manifest_->Get(keys::kBackgroundPersistent, &background_persistent))
-    return true;
-
-  if (!background_persistent->GetAsBoolean(&background_page_is_persistent_)) {
-    *error = ASCIIToUTF16(errors::kInvalidBackgroundPersistent);
-    return false;
-  }
-
-  if (!has_background_page()) {
-    *error = ASCIIToUTF16(errors::kInvalidBackgroundPersistentNoPage);
-    return false;
-  }
-
-  return true;
-}
-
-bool Extension::LoadBackgroundAllowJSAccess(string16* error) {
-  Value* allow_js_access = NULL;
-  if (!manifest_->Get(keys::kBackgroundAllowJsAccess, &allow_js_access))
-    return true;
-
-  if (!allow_js_access->IsType(Value::TYPE_BOOLEAN) ||
-      !allow_js_access->GetAsBoolean(&allow_background_js_access_)) {
-    *error = ASCIIToUTF16(errors::kInvalidBackgroundAllowJsAccess);
-    return false;
-  }
-
-  return true;
-}
-
 bool Extension::LoadExtensionFeatures(string16* error) {
   if (manifest_->HasKey(keys::kConvertedFromUserScript))
     manifest_->GetBoolean(keys::kConvertedFromUserScript,
                           &converted_from_user_script_);
 
   if (!LoadContentScripts(error) ||
       !LoadSystemIndicator(error) ||
       !LoadIncognitoMode(error))
     return false;
 
   return true;
 }
 
 bool Extension::LoadContentScripts(string16* error) {
   if (!manifest_->HasKey(keys::kContentScripts))
     return true;
-  ListValue* list_value;
+  const ListValue* list_value;
   if (!manifest_->GetList(keys::kContentScripts, &list_value)) {
     *error = ASCIIToUTF16(errors::kInvalidContentScriptsList);
     return false;
   }
 
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
-    DictionaryValue* content_script = NULL;
+    const DictionaryValue* content_script = NULL;
     if (!list_value->GetDictionary(i, &content_script)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidContentScript, base::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);
       script.set_match_all_frames(true);  // Greasemonkey matches all frames.
     }
     content_scripts_.push_back(script);
   }
   return true;
 }
 
 bool Extension::LoadSystemIndicator(string16* error) {
   if (!manifest_->HasKey(keys::kSystemIndicator)) {
     // There was no manifest entry for the system indicator.
     return true;
   }
 
-  DictionaryValue* system_indicator_value = NULL;
+  const DictionaryValue* system_indicator_value = NULL;
   if (!manifest_->GetDictionary(keys::kSystemIndicator,
                                 &system_indicator_value)) {
     *error = ASCIIToUTF16(errors::kInvalidSystemIndicator);
     return false;
   }
 
   system_indicator_info_ = LoadExtensionActionInfoHelper(
       this, system_indicator_value, error);
 
   if (!system_indicator_info_.get()) {
@@ skipping 390 matching lines @@
         minimum_version_string);
     return false;
   }
   return true;
 }
 
 bool Extension::CheckPlatformAppFeatures(std::string* utf8_error) const {
   if (!is_platform_app())
     return true;
 
-  if (!has_background_page()) {
+  if (!BackgroundInfo::HasBackgroundPage(this)) {
     *utf8_error = errors::kBackgroundRequiredForPlatformApps;
     return false;
   }
 
   if (!incognito_split_mode_) {
     *utf8_error = errors::kInvalidIncognitoModeForPlatformApp;
     return false;
   }
 
   return true;
 }
 
 bool Extension::CheckConflictingFeatures(std::string* utf8_error) const {
-  if (has_lazy_background_page() &&
+  if (BackgroundInfo::HasLazyBackgroundPage(this) &&
       HasAPIPermission(APIPermission::kWebRequest)) {
     *utf8_error = errors::kWebRequestConflictsWithLazyBackground;
     return false;
   }
 
   return true;
 }
 
 ExtensionInfo::ExtensionInfo(const DictionaryValue* manifest,
                              const std::string& id,
@@ skipping 17 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions