Add platform_app flag to manifest.

chrome/common/extensions/extension_manifests_unittest.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"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #endif
 
-#include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/i18n/rtl.h"
 #include "base/json/json_value_serializer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
-#include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_sidebar_defaults.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/extensions/url_pattern.h"
+#include "chrome/test/base/scoped_command_line_override.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 
 namespace {
 
 static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
   int schemes = URLPattern::SCHEME_ALL;
   extent->AddPattern(URLPattern(schemes, pattern));
 }
@@ skipping 174 matching lines @@
   // distinguish between API and host permissions.
   extension = LoadAndExpectSuccess("init_valid_permissions.json");
 
   // Test with an options page.
   extension = LoadAndExpectSuccess("init_valid_options.json");
   EXPECT_EQ("chrome-extension", extension->options_url().scheme());
   EXPECT_EQ("/options.html", extension->options_url().path());
 
   // Test that an empty list of page actions does not stop a browser action
   // from being loaded.
-  extension = LoadAndExpectSuccess("init_valid_empty_page_actions.json");
+  LoadAndExpectSuccess("init_valid_empty_page_actions.json");
 
   // Test with a minimum_chrome_version.
-  extension = LoadAndExpectSuccess("init_valid_minimum_chrome.json");
+  LoadAndExpectSuccess("init_valid_minimum_chrome.json");
 
   // Test a hosted app with a minimum_chrome_version.
-  extension = LoadAndExpectSuccess("init_valid_app_minimum_chrome.json");
+  LoadAndExpectSuccess("init_valid_app_minimum_chrome.json");
 
   // Test a hosted app with a requirements section.
-  extension = LoadAndExpectSuccess("init_valid_app_requirements.json");
+  LoadAndExpectSuccess("init_valid_app_requirements.json");
 
   // Verify empty permission settings are considered valid.
   LoadAndExpectSuccess("init_valid_permissions_empty.json");
 
   // We allow unknown API permissions, so this will be valid until we better
   // distinguish between API and host permissions.
   LoadAndExpectSuccess("init_valid_permissions_unknown.json");
 }
 
+TEST_F(ExtensionManifestTest, PlatformApps) {
+  // A minimal platform app.
+  LoadAndExpectSuccess("init_valid_platform_app.json");
+}
+
 TEST_F(ExtensionManifestTest, InitFromValueValidNameInRTL) {
 #if defined(TOOLKIT_GTK)
   GtkTextDirection gtk_dir = gtk_widget_get_default_direction();
   gtk_widget_set_default_direction(GTK_TEXT_DIR_RTL);
 #else
   std::string locale = l10n_util::GetApplicationLocale("");
   base::i18n::SetICUDefaultLocale("he");
 #endif
 
   // No strong RTL characters in name.
@@ skipping 132 matching lines @@
   extension = LoadAndExpectSuccess("launch_width.json");
   EXPECT_EQ(640, extension->launch_width());
 
   extension = LoadAndExpectSuccess("launch_height.json");
   EXPECT_EQ(480, extension->launch_height());
 
   LoadAndExpectError("launch_window.json",
                      errors::kInvalidLaunchContainer);
   LoadAndExpectError("launch_container_invalid_type.json",
                      errors::kInvalidLaunchContainer);
+  {
+    ScopedCommandLineOverride override(switches::kEnablePlatformApps);
+    LoadAndExpectError("launch_container_invalid_type_for_platform.json",
+                       errors::kInvalidLaunchContainerForPlatform);
+  }
   LoadAndExpectError("launch_container_invalid_value.json",
                      errors::kInvalidLaunchContainer);
   LoadAndExpectError("launch_container_without_launch_url.json",
                      errors::kLaunchURLRequired);
   LoadAndExpectError("launch_width_invalid.json",
                      errors::kInvalidLaunchWidthContainer);
   LoadAndExpectError("launch_width_negative.json",
                      errors::kInvalidLaunchWidth);
   LoadAndExpectError("launch_height_invalid.json",
                      errors::kInvalidLaunchHeightContainer);
@@ skipping 114 matching lines @@
                      "Invalid value for "
                      "'content_scripts[0].exclude_matches[0]': "
                      "Invalid host wildcard.");
 }
 
 TEST_F(ExtensionManifestTest, ExperimentalPermission) {
   LoadAndExpectError("experimental.json", errors::kExperimentalFlagRequired);
   LoadAndExpectSuccess("experimental.json", Extension::COMPONENT);
   LoadAndExpectSuccess("experimental.json", Extension::INTERNAL,
                        Extension::FROM_WEBSTORE);
-  CommandLine old_command_line = *CommandLine::ForCurrentProcess();
-  CommandLine::ForCurrentProcess()->AppendSwitch(
+  ScopedCommandLineOverride override(
       switches::kEnableExperimentalExtensionApis);
   LoadAndExpectSuccess("experimental.json");
-  *CommandLine::ForCurrentProcess() = old_command_line;
 }
 
 TEST_F(ExtensionManifestTest, DevToolsExtensions) {
   LoadAndExpectError("devtools_extension_no_permissions.json",
       errors::kDevToolsExperimental);
   LoadAndExpectError("devtools_extension_url_invalid_type.json",
       errors::kInvalidDevToolsPage);
 
-  CommandLine old_command_line = *CommandLine::ForCurrentProcess();
-  CommandLine::ForCurrentProcess()->AppendSwitch(
+  ScopedCommandLineOverride override(
       switches::kEnableExperimentalExtensionApis);
-
   scoped_refptr<Extension> extension;
   extension = LoadAndExpectSuccess("devtools_extension.json");
   EXPECT_EQ(extension->url().spec() + "devtools.html",
             extension->devtools_url().spec());
   EXPECT_TRUE(extension->HasEffectiveAccessToAllHosts());
-
-  *CommandLine::ForCurrentProcess() = old_command_line;
 }
 
 TEST_F(ExtensionManifestTest, Sidebar) {
   LoadAndExpectError("sidebar.json",
       errors::kExperimentalFlagRequired);
 
-  CommandLine old_command_line = *CommandLine::ForCurrentProcess();
-  CommandLine::ForCurrentProcess()->AppendSwitch(
+  ScopedCommandLineOverride override(
       switches::kEnableExperimentalExtensionApis);
 
   LoadAndExpectError("sidebar_no_permissions.json",
       errors::kSidebarExperimental);
 
   LoadAndExpectError("sidebar_icon_empty.json",
       errors::kInvalidSidebarDefaultIconPath);
   LoadAndExpectError("sidebar_icon_invalid_type.json",
       errors::kInvalidSidebarDefaultIconPath);
   LoadAndExpectError("sidebar_page_empty.json",
       errors::kInvalidSidebarDefaultPage);
   LoadAndExpectError("sidebar_page_invalid_type.json",
       errors::kInvalidSidebarDefaultPage);
   LoadAndExpectError("sidebar_title_invalid_type.json",
       errors::kInvalidSidebarDefaultTitle);
 
   scoped_refptr<Extension> extension(LoadAndExpectSuccess("sidebar.json"));
   ASSERT_TRUE(extension->sidebar_defaults() != NULL);
   EXPECT_EQ(extension->sidebar_defaults()->default_title(),
             ASCIIToUTF16("Default title"));
   EXPECT_EQ(extension->sidebar_defaults()->default_icon_path(),
             "icon.png");
   EXPECT_EQ(extension->url().spec() + "sidebar.html",
             extension->sidebar_defaults()->default_page().spec());
-
-  *CommandLine::ForCurrentProcess() = old_command_line;
 }
 
 TEST_F(ExtensionManifestTest, DisallowHybridApps) {
   LoadAndExpectError("disallow_hybrid_1.json",
       ExtensionErrorUtils::FormatErrorMessage(
           errors::kHostedAppsCannotIncludeExtensionFeatures,
           keys::kBrowserAction));
   LoadAndExpectError("disallow_hybrid_2.json",
                      errors::kBackgroundPermissionNeeded);
 }
@@ skipping 212 matching lines @@
       LoadAndExpectSuccess("tts_engine_valid.json"));
 
   ASSERT_EQ(1u, extension->tts_voices().size());
   EXPECT_EQ("name", extension->tts_voices()[0].voice_name);
   EXPECT_EQ("en-US", extension->tts_voices()[0].lang);
   EXPECT_EQ("female", extension->tts_voices()[0].gender);
   EXPECT_EQ(3U, extension->tts_voices()[0].event_types.size());
 }
 
 TEST_F(ExtensionManifestTest, WebIntents) {
-  CommandLine::ForCurrentProcess()->AppendSwitch("--enable-web-intents");
+  ScopedCommandLineOverride override("--enable-web-intents");
 
   LoadAndExpectError("intent_invalid_1.json",
                      extension_manifest_errors::kInvalidIntents);
   LoadAndExpectError("intent_invalid_2.json",
                      extension_manifest_errors::kInvalidIntent);
   LoadAndExpectError("intent_invalid_3.json",
                      extension_manifest_errors::kInvalidIntentPath);
   LoadAndExpectError("intent_invalid_4.json",
                      extension_manifest_errors::kInvalidIntentDisposition);
   LoadAndExpectError("intent_invalid_5.json",
@@ skipping 42 matching lines @@
   // to flag this case.
   LoadAndExpectSuccess("forbid_ports_in_permissions.json",
                        Extension::INTERNAL, Extension::STRICT_ERROR_CHECKS);
 }
 
 TEST_F(ExtensionManifestTest, IsolatedApps) {
   // Requires --enable-experimental-extension-apis
   LoadAndExpectError("isolated_app_valid.json",
                      errors::kExperimentalFlagRequired);
 
-  CommandLine old_command_line = *CommandLine::ForCurrentProcess();
-  CommandLine::ForCurrentProcess()->AppendSwitch(
+  ScopedCommandLineOverride override(
       switches::kEnableExperimentalExtensionApis);
   scoped_refptr<Extension> extension2(
       LoadAndExpectSuccess("isolated_app_valid.json"));
   EXPECT_TRUE(extension2->is_storage_isolated());
-  *CommandLine::ForCurrentProcess() = old_command_line;
 }
 
 
 TEST_F(ExtensionManifestTest, FileBrowserHandlers) {
   LoadAndExpectError("filebrowser_invalid_actions_1.json",
       errors::kInvalidFileBrowserHandler);
   LoadAndExpectError("filebrowser_invalid_actions_2.json",
       errors::kInvalidFileBrowserHandler);
   LoadAndExpectError("filebrowser_invalid_action_id.json",
       errors::kInvalidPageActionId);
@@ skipping 56 matching lines @@
   scoped_refptr<Extension> extension_2(
       LoadAndExpectSuccess("offline_disabled_packaged_app.json"));
   EXPECT_FALSE(extension_2->offline_enabled());
   scoped_refptr<Extension> extension_3(
       LoadAndExpectSuccess("offline_default_packaged_app.json"));
   EXPECT_FALSE(extension_3->offline_enabled());
   scoped_refptr<Extension> extension_4(
       LoadAndExpectSuccess("offline_enabled_hosted_app.json"));
   EXPECT_TRUE(extension_4->offline_enabled());
 }