Change the platform app manifest structure.

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 "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ skipping 1575 matching lines @@
     }
     if (relative_path[0] != '/')
       relative_path = '/' + relative_path;
     web_accessible_resources_.insert(relative_path);
   }
 
   return true;
 }
 
 bool Extension::LoadSandboxedPages(string16* error) {
-  // Can't use HasKey, since it doesn't do path expansion.
-  Value* ignored = NULL;
-  if (!manifest_->Get(keys::kSandboxedPages, &ignored))
+  if (!manifest_->HasPath(keys::kSandboxedPages))
     return true;
 
   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 = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidSandboxedPage, base::IntToString(i));
       return false;
     }
     if (relative_path[0] != '/')
       relative_path = '/' + relative_path;
     sandboxed_pages_.insert(relative_path);
   }
 
-  if (manifest_->Get(keys::kSandboxedPagesCSP, &ignored)) {
+  if (manifest_->HasPath(keys::kSandboxedPagesCSP)) {
     if (!manifest_->GetString(
         keys::kSandboxedPagesCSP, &sandboxed_pages_content_security_policy_)) {
       *error = ASCIIToUTF16(errors::kInvalidSandboxedPagesCSP);
       return false;
     }
 
     if (!ContentSecurityPolicyIsLegal(
             sandboxed_pages_content_security_policy_) ||
         !ContentSecurityPolicyIsSandboxed(
             sandboxed_pages_content_security_policy_, GetType())) {
@@ skipping 83 matching lines @@
     if (!options_url_.is_valid()) {
       *error = ASCIIToUTF16(errors::kInvalidOptionsPage);
       return false;
     }
   }
 
   return true;
 }
 
 bool Extension::LoadBackgroundScripts(string16* error) {
+  if (is_platform_app()) {
+    return LoadBackgroundScripts(keys::kPlatformAppBackgroundScripts, error);
+  }
+
+  return LoadBackgroundScripts(keys::kBackgroundScripts, error);
+}
+
+bool Extension::LoadBackgroundScripts(const std::string& key, string16* error) {
   Value* background_scripts_value = NULL;
-  if (!manifest_->Get(keys::kBackgroundScripts, &background_scripts_value))
+  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 = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidBackgroundScript, base::IntToString(i));
       return false;
     }
     background_scripts_.push_back(script);
   }
 
   return true;
 }
 
 bool Extension::LoadBackgroundPage(
     const ExtensionAPIPermissionSet& api_permissions,
     string16* error) {
+  if (is_platform_app()) {
+    return LoadBackgroundPage(
+        keys::kPlatformAppBackgroundPage, api_permissions, error);
+  }
+
+  if (!LoadBackgroundPage(keys::kBackgroundPage, api_permissions, error))
+    return false;
+  if (background_url_.is_empty())
+    return LoadBackgroundPage(
+        keys::kBackgroundPageLegacy, api_permissions, error);
+  return true;
+}
+
+bool Extension::LoadBackgroundPage(
+    const std::string& key,
+    const ExtensionAPIPermissionSet& api_permissions,
+    string16* error) {
   base::Value* background_page_value = NULL;
-  if (!manifest_->Get(keys::kBackgroundPage, &background_page_value))
-    manifest_->Get(keys::kBackgroundPageLegacy, &background_page_value);
+  if (!manifest_->Get(key, &background_page_value))
+    return true;
 
-  if (!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 (!background_scripts_.empty()) {
-    *error = ASCIIToUTF16(errors::kInvalidBackgroundCombination);
-    return false;
-  }
+  if (is_hosted_app()) {
+    background_url_ = GURL(background_str);
 
-  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()) {
+    if (!background_url_.is_valid()) {
       *error = ASCIIToUTF16(errors::kInvalidBackgroundInHostedApp);
       return false;
     }
 
-    if (!(bg_page.SchemeIs("https") ||
+    if (!(background_url_.SchemeIs("https") ||
           (CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kAllowHTTPBackgroundPage) &&
-           bg_page.SchemeIs("http")))) {
+           background_url_.SchemeIs("http")))) {
       *error = ASCIIToUTF16(errors::kInvalidBackgroundInHostedApp);
       return false;
     }
-    background_url_ = bg_page;
   } else {
     background_url_ = GetResourceURL(background_str);
   }
 
   return true;
 }
 
 bool Extension::LoadBackgroundPersistent(
     const ExtensionAPIPermissionSet& api_permissions,
     string16* error) {
@@ skipping 1903 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions