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(

[Mihai Parparita -not on Chrome, 2011/11/03 21:37:12]

Maybe I'm missing something, but it seems like the ! is not needed; you only
want to set the platform app bit if the switch is present.

[miket_OOO, 2011/11/04 22:39:45]

Overly subtle manual testing that didn't get cleaned up.

+          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) {

[Mihai Parparita -not on Chrome, 2011/11/03 21:37:12]

Rather than forcing panel to be specified, it might be cleaner for the default
to be panel, and to not allow the container to be specified in the manifest at
all.

[miket_OOO, 2011/11/04 22:39:45]

I thought about this, but the panel dimensions are still specified in the
manifest, so it'd be weird to have one without the other.

Eventually I envision many panel attributes to be controllable via JS, and then
it would make sense to remove the dimensions from the manifest. But not today.

+      *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) {}