fullscreen window app launch container

chrome/common/extensions/extension_manifests_unittest.cc

 // Copyright (c) 2010 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 "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 43 matching lines @@
     return extension;
   }
 
   void LoadAndExpectError(const std::string& name,
                           const std::string& expected_error) {
     std::string error;
     scoped_ptr<Extension> extension(LoadExtension(name, &error));
     EXPECT_FALSE(extension.get()) <<
         "Expected failure loading extension '" << name <<
         "', but didn't get one.";
-    EXPECT_TRUE(MatchPatternASCII(error, expected_error));
+    EXPECT_TRUE(MatchPatternASCII(error, expected_error)) << name <<
+        " expected '" << expected_error << "' but got '" << error << "'";
   }
 
   bool enable_apps_;
 };
 
 TEST_F(ManifestTest, AppsDisabledByDefault) {
   enable_apps_ = false;
   LoadAndExpectError("web_content_disabled.json", errors::kAppsNotEnabled);
   LoadAndExpectError("launch_local_path.json", errors::kAppsNotEnabled);
 }
 
 TEST_F(ManifestTest, ValidApp) {
   scoped_ptr<Extension> extension(LoadAndExpectSuccess("valid_app.json"));
   EXPECT_TRUE(extension->web_content_enabled());
   EXPECT_EQ(GURL("http://www.google.com/"), extension->web_extent().origin());
   EXPECT_EQ(2u, extension->web_extent().paths().size());
   EXPECT_EQ("mail/", extension->web_extent().paths()[0]);
   EXPECT_EQ("foobar/", extension->web_extent().paths()[1]);
   EXPECT_EQ(Extension::LAUNCH_WINDOW, extension->launch_container());
+  EXPECT_EQ(false, extension->launch_fullscreen());
   EXPECT_EQ("mail/", extension->launch_web_url());
 }
 
 TEST_F(ManifestTest, AppWebContentEnabled) {
   LoadAndExpectError("web_content_enabled_invalid.json",
                      errors::kInvalidWebContentEnabled);
   LoadAndExpectError("web_content_disabled.json",
                      errors::kWebContentMustBeEnabled);
   LoadAndExpectError("web_content_not_enabled.json",
                      errors::kWebContentMustBeEnabled);
@@ skipping 29 matching lines @@
 
   extension.reset(LoadAndExpectSuccess("launch_window.json"));
   EXPECT_EQ(Extension::LAUNCH_WINDOW, extension->launch_container());
 
   extension.reset(LoadAndExpectSuccess("launch_panel.json"));
   EXPECT_EQ(Extension::LAUNCH_PANEL, extension->launch_container());
 
   extension.reset(LoadAndExpectSuccess("launch_default.json"));
   EXPECT_EQ(Extension::LAUNCH_TAB, extension->launch_container());
 
+  extension.reset(LoadAndExpectSuccess("launch_fullscreen.json"));
+  EXPECT_EQ(true, extension->launch_fullscreen());
+
   LoadAndExpectError("launch_container_invalid_type.json",
                      errors::kInvalidLaunchContainer);
   LoadAndExpectError("launch_container_invalid_value.json",
                      errors::kInvalidLaunchContainer);
   LoadAndExpectError("launch_container_without_launch_url.json",
                      errors::kLaunchContainerWithoutURL);
+  LoadAndExpectError("launch_fullscreen_invalid.json",
+                     errors::kInvalidLaunchFullscreen);
 }
 
 TEST_F(ManifestTest, AppLaunchURL) {
   LoadAndExpectError("launch_path_and_url.json",
                      errors::kLaunchPathAndURLAreExclusive);
   LoadAndExpectError("launch_path_invalid_type.json",
                      errors::kInvalidLaunchLocalPath);
   LoadAndExpectError("launch_path_invalid_value.json",
                      errors::kInvalidLaunchLocalPath);
   LoadAndExpectError("launch_url_invalid_type.json",
@@ skipping 32 matching lines @@
 
 TEST_F(ManifestTest, ChromeURLPermissionInvalid) {
   LoadAndExpectError("permission_chrome_url_invalid.json",
       errors::kInvalidPermissionScheme);
 }
 
 TEST_F(ManifestTest, ChromeURLContentScriptInvalid) {
   LoadAndExpectError("content_script_chrome_url_invalid.json",
       errors::kInvalidMatch);
 }