Change the platform app manifest structure.

chrome/common/extensions/manifest.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/manifest.h"
 
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/simple_feature_provider.h"
 
 namespace errors = extension_manifest_errors;
 namespace keys = extension_manifest_keys;
 
 namespace extensions {
 
 Manifest::Manifest(Extension::Location location,
                    scoped_ptr<DictionaryValue> value)
     : location_(location),
       value_(value.Pass()),
       type_(Extension::TYPE_UNKNOWN) {
   if (value_->HasKey(keys::kTheme)) {
     type_ = Extension::TYPE_THEME;
+  } else if (value_->HasKey(keys::kApp)) {
+    if (value_->Get(keys::kWebURLs, NULL) ||
+        value_->Get(keys::kLaunchWebURL, NULL)) {
+      type_ = Extension::TYPE_HOSTED_APP;
+    } else if (value_->Get(keys::kPlatformAppBackground, NULL)) {
+      type_ = Extension::TYPE_PLATFORM_APP;
+    } else {
+      type_ = Extension::TYPE_PACKAGED_APP;
+    }
   } else {
-    bool is_platform_app = false;
-    if (value_->GetBoolean(keys::kPlatformApp, &is_platform_app) &&
-        is_platform_app) {
-      type_ = Extension::TYPE_PLATFORM_APP;
-    } else if (value_->HasKey(keys::kApp)) {
-      if (value_->Get(keys::kWebURLs, NULL) ||
-          value_->Get(keys::kLaunchWebURL, NULL)) {
-        type_ = Extension::TYPE_HOSTED_APP;
-      } else {
-        type_ = Extension::TYPE_PACKAGED_APP;
-      }
-    } else {
-      type_ = Extension::TYPE_EXTENSION;
-    }
+    type_ = Extension::TYPE_EXTENSION;
   }
   CHECK_NE(type_, Extension::TYPE_UNKNOWN);
 }
 
 Manifest::~Manifest() {
 }
 
 void Manifest::ValidateManifest(std::string* error,
                                 std::vector<std::string>* warnings) const {
   *error = "";
@@ skipping 32 matching lines @@
       warnings->push_back(base::StringPrintf("Unrecognized manifest key '%s'.",
           (*key).c_str()));
     }
   }
 }
 
 bool Manifest::HasKey(const std::string& key) const {
   return CanAccessKey(key) && value_->HasKey(key);
 }
 
+bool Manifest::HasPath(const std::string& path) const {
+  Value* ignored = NULL;
+  return CanAccessPath(path) && value_->Get(path, &ignored);
+}
+
 bool Manifest::Get(
     const std::string& path, Value** out_value) const {
   return CanAccessPath(path) && value_->Get(path, out_value);
 }
 
 bool Manifest::GetBoolean(
     const std::string& path, bool* out_value) const {
   return CanAccessPath(path) && value_->GetBoolean(path, out_value);
 }
 
@@ skipping 57 matching lines @@
       SimpleFeatureProvider::GetManifestFeatures()->GetFeature(key);
   if (!feature)
     return true;
 
   return Feature::IS_AVAILABLE == feature->IsAvailableToManifest(
       extension_id_, type_, Feature::ConvertLocation(location_),
       GetManifestVersion());
 }
 
 }  // namespace extensions