Add platform_app flag to manifest.

chrome/common/extensions/extension.cc

 // Copyright (c) 2011 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 885 matching lines @@
       return true;
   }
   return false;
 }
 
 bool Extension::LoadIsApp(const DictionaryValue* manifest,
                           std::string* error) {
   if (manifest->HasKey(keys::kApp))
     is_app_ = true;
 
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnablePlatformApps)) {
+    if (manifest->HasKey(keys::kPlatformApp))
+      is_platform_app_ = true;
+  }
+
   return true;
 }
 
 bool Extension::LoadExtent(const DictionaryValue* manifest,
                            const char* key,
                            URLPatternSet* extent,
                            const char* list_error,
                            const char* value_error,
                            URLPattern::ParseOption parse_strictness,
                            std::string* error) {
@@ skipping 349 matching lines @@
   return id == std::string("nckgahadagoaajjgafhacjanaoiihapd");
 }
 
 Extension::Extension(const FilePath& path, Location location)
     : incognito_split_mode_(false),
       offline_enabled_(false),
       location_(location),
       converted_from_user_script_(false),
       is_theme_(false),
       is_app_(false),
+      is_platform_app_(false),
       is_storage_isolated_(false),
       launch_container_(extension_misc::LAUNCH_TAB),
       launch_width_(0),
       launch_height_(0),
       wants_file_access_(false),
       creation_flags_(0) {
   DCHECK(path.empty() || path.IsAbsolute());
   path_ = MaybeNormalizePath(path);
 }
 
@@ skipping 220 matching lines @@
       !LoadExtent(manifest_value_.get(), keys::kWebURLs,
                   &extent_,
                   errors::kInvalidWebURLs, errors::kInvalidWebURL,
                   parse_strictness, error) ||
       !EnsureNotHybridApp(manifest_value_.get(), error) ||
       !LoadLaunchURL(manifest_value_.get(), error) ||
       !LoadLaunchContainer(manifest_value_.get(), error)) {
     return false;
   }
 
+  if (is_platform_app_) {
+    if (launch_container() != extension_misc::LAUNCH_PANEL) {

[Aaron Boodman, 2011/11/05 16:10:21]

Nit: why not put this in the LoadLaunchContainer() method?

[miket_OOO, 2011/11/07 17:07:46]

Doing so would contribute to a problem I see with this class in general: that
certain methods have implicit dependencies on other methods being called before
them. I wanted to keep the new ordering dependency (that LoadLaunchContainer be
called after LoadIsApp) contained within the InitFromValue method.

+      *error = errors::kInvalidLaunchContainerForPlatform;
+      return false;
+    }
+  }
+
   // Initialize the permissions (optional).
   ExtensionAPIPermissionSet api_permissions;
   URLPatternSet host_permissions;
   if (!ParsePermissions(&source,
                         keys::kPermissions,
                         flags,
                         error,
                         &api_permissions,
                         &host_permissions)) {
     return false;
@@ skipping 1478 matching lines @@
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}