Switch platform apps from a declarative launch container to handling an onLaunched event.

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 460 matching lines @@
     *utf8_error = UTF16ToUTF8(error);
     return NULL;
   }
 
   scoped_refptr<Extension> extension = new Extension(path, manifest.Pass());
   if (!extension->InitFromValue(flags, &error)) {
     *utf8_error = UTF16ToUTF8(error);
     return NULL;
   }
 
-  if (extension->is_platform_app() &&
-      !CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnablePlatformApps)) {
-    *utf8_error = errors::kPlatformAppFlagRequired;
-    return NULL;
+  if (extension->is_platform_app()) {
+    if (!CommandLine::ForCurrentProcess()->HasSwitch(
+        switches::kEnablePlatformApps)) {
+      *utf8_error = errors::kPlatformAppFlagRequired;
+      return NULL;
+    }
+
+    if (!extension->has_background_page()) {
+      *utf8_error = errors::kBackgroundRequiredForPlatformApps;
+      return NULL;
+    }
   }
 
   return extension;
 }
 
 // static
 Extension::Location Extension::GetHigherPriorityLocation(
     Extension::Location loc1, Extension::Location loc2) {
   if (loc1 == loc2)
     return loc1;
@@ skipping 762 matching lines @@
 
     extent->AddPattern(pattern);
   }
 
   return true;
 }
 
 bool Extension::LoadLaunchURL(string16* error) {
   Value* temp = NULL;
 
+  // TODO(mihaip): Implement this check via _manifest_features.json (requires
+  // subkey support, see http://crbug.com/122459).
+  if (is_platform_app() && manifest_->Get(keys::kLaunch, &temp)) {
+      *error = ASCIIToUTF16(errors::kLaunchNotAllowedForPlatformApps);
+      return false;
+  }
+
   // 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)) {
       *error = ASCIIToUTF16(errors::kLaunchPathAndExtentAreExclusive);
@@ skipping 31 matching lines @@
     GURL url(launch_url);
     URLPattern pattern(kValidWebExtentSchemes);
     if (!url.is_valid() || !pattern.SetScheme(url.scheme())) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidLaunchValue,
           keys::kLaunchWebURL);
       return false;
     }
 
     launch_web_url_ = launch_url;
-  } else if (is_app()) {
+  } else if (is_packaged_app() || is_hosted_app()) {
     *error = ASCIIToUTF16(errors::kLaunchURLRequired);
     return false;
   }
 
   // If there is no extent, we default the extent based on the launch URL.
   if (web_extent().is_empty() && !launch_web_url().empty()) {
     GURL launch_url(launch_web_url());
     URLPattern pattern(kValidWebExtentSchemes);
     if (!pattern.SetScheme("*")) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
@@ skipping 44 matching lines @@
   Value* temp = NULL;
   if (!manifest_->Get(keys::kLaunchContainer, &temp))
     return true;
 
   std::string launch_container_string;
   if (!temp->GetAsString(&launch_container_string)) {
     *error = ASCIIToUTF16(errors::kInvalidLaunchContainer);
     return false;
   }
 
-  if (launch_container_string == values::kLaunchContainerShell) {
-    launch_container_ = extension_misc::LAUNCH_SHELL;
-  } else if (launch_container_string == values::kLaunchContainerPanel) {
+  if (launch_container_string == values::kLaunchContainerPanel) {
     launch_container_ = extension_misc::LAUNCH_PANEL;
   } else if (launch_container_string == values::kLaunchContainerTab) {
     launch_container_ = extension_misc::LAUNCH_TAB;
   } else {
     *error = ASCIIToUTF16(errors::kInvalidLaunchContainer);
     return false;
   }
 
   bool can_specify_initial_size =
       launch_container_ == extension_misc::LAUNCH_PANEL ||
-      launch_container_ == extension_misc::LAUNCH_WINDOW ||
-      launch_container_ == extension_misc::LAUNCH_SHELL;
+      launch_container_ == extension_misc::LAUNCH_WINDOW;
 
   // Validate the container width if present.
   if (!ReadLaunchDimension(manifest_,
                            keys::kLaunchWidth,
                            &launch_width_,
                            can_specify_initial_size,
                            error))
       return false;
 
   // Validate container height if present.
   if (!ReadLaunchDimension(manifest_,
                            keys::kLaunchHeight,
                            &launch_height_,
                            can_specify_initial_size,
                            error))
       return false;
 
-  bool can_specify_size_range =
-      launch_container_ == extension_misc::LAUNCH_SHELL;
-
-  // Validate min size if present.
-  if (!ReadLaunchDimension(manifest_,
-                           keys::kLaunchMinWidth,
-                           &launch_min_width_,
-                           can_specify_size_range,
-                           error))
-      return false;
-  if (!ReadLaunchDimension(manifest_,
-                           keys::kLaunchMinHeight,
-                           &launch_min_height_,
-                           can_specify_size_range,
-                           error))
-      return false;
-  if (!ReadLaunchDimension(manifest_,
-                           keys::kLaunchMaxWidth,
-                           &launch_max_width_,
-                           can_specify_size_range,
-                           error))
-      return false;
-  if (!ReadLaunchDimension(manifest_,
-                           keys::kLaunchMaxHeight,
-                           &launch_max_height_,
-                           can_specify_size_range,
-                           error))
-      return false;
-
-  if (launch_container_ == extension_misc::LAUNCH_SHELL) {
-    if (!manifest_->Get(keys::kLaunchWidth, &temp)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidLaunchValue,
-          keys::kLaunchWidth);
-      return false;
-    }
-    if (!manifest_->Get(keys::kLaunchHeight, &temp)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidLaunchValue,
-          keys::kLaunchHeight);
-      return false;
-    }
-    if (launch_max_width_ > 0 && launch_max_width_ < launch_min_width_) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidLaunchValue,
-          keys::kLaunchMaxWidth);
-      return false;
-    }
-    if (launch_max_height_ > 0 && launch_max_height_ < launch_min_height_) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidLaunchValue,
-          keys::kLaunchMaxHeight);
-      return false;
-    }
-  }
-
-  if (is_platform_app()) {
-    if (launch_container_ != extension_misc::LAUNCH_SHELL) {
-      *error = ASCIIToUTF16(errors::kInvalidLaunchContainerForPlatform);
-      return false;
-    }
-  } else if (launch_container_ == extension_misc::LAUNCH_SHELL) {
-    *error = ASCIIToUTF16(errors::kInvalidLaunchContainerForNonPlatform);
-    return false;
-  }
-
   return true;
 }
 
 bool Extension::LoadSharedFeatures(
     const ExtensionAPIPermissionSet& api_permissions,
     string16* error) {
   if (!LoadDescription(error) ||
       !LoadHomepageURL(error) ||
       !LoadUpdateURL(error) ||
       !LoadIcons(error) ||
@@ skipping 1369 matching lines @@
       incognito_split_mode_(false),
       offline_enabled_(false),
       converted_from_user_script_(false),
       background_page_is_transient_(false),
       allow_background_js_access_(true),
       manifest_(manifest.release()),
       is_storage_isolated_(false),
       launch_container_(extension_misc::LAUNCH_TAB),
       launch_width_(0),
       launch_height_(0),
-      launch_min_width_(0),
-      launch_min_height_(0),
-      launch_max_width_(0),
-      launch_max_height_(0),
       wants_file_access_(false),
       creation_flags_(0) {
   DCHECK(path.empty() || path.IsAbsolute());
   path_ = MaybeNormalizePath(path);
 }
 
 Extension::~Extension() {
   if (manifest_)
     delete manifest_;
 }
@@ skipping 822 matching lines @@
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}