Change the platform app manifest structure.

chrome/common/extensions/manifest_tests/extension_manifest_test.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/manifest_tests/extension_manifest_test.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/values.h"
 #include "base/json/json_file_value_serializer.h"
@@ skipping 98 matching lines @@
   return extension;
 }
 
 scoped_refptr<Extension> ExtensionManifestTest::LoadAndExpectSuccess(
     char const* manifest_name,
     Extension::Location location,
     int flags) {
   return LoadAndExpectSuccess(Manifest(manifest_name), location, flags);
 }
 
+scoped_refptr<Extension> ExtensionManifestTest::LoadAndExpectWarning(
+    const Manifest& manifest,
+    const std::string& expected_warning,
+    Extension::Location location,
+    int flags) {
+  std::string error;
+  scoped_refptr<Extension> extension =
+      LoadExtension(manifest, &error, location, flags);
+  EXPECT_TRUE(extension) << manifest.name();
+  EXPECT_EQ("", error) << manifest.name();
+  EXPECT_EQ(1u, extension->install_warnings().size());
+  EXPECT_EQ(expected_warning, extension->install_warnings()[0]);
+  return extension;
+}
+
+scoped_refptr<Extension> ExtensionManifestTest::LoadAndExpectWarning(
+    char const* manifest_name,
+    const std::string& expected_warning,
+    Extension::Location location,
+    int flags) {
+  return LoadAndExpectWarning(
+      Manifest(manifest_name), expected_warning, location, flags);
+}
+
 void ExtensionManifestTest::VerifyExpectedError(
     Extension* extension,
     const std::string& name,
     const std::string& error,
     const std::string& expected_error) {
   EXPECT_FALSE(extension) <<
       "Expected failure loading extension '" << name <<
       "', but didn't get one.";
   EXPECT_TRUE(MatchPattern(error, expected_error)) << name <<
       " expected '" << expected_error << "' but got '" << error << "'";
@@ skipping 13 matching lines @@
 
 void ExtensionManifestTest::LoadAndExpectError(
     char const* manifest_name,
     const std::string& expected_error,
     Extension::Location location,
     int flags) {
   return LoadAndExpectError(
       Manifest(manifest_name), expected_error, location, flags);
 }
 
-
 void ExtensionManifestTest::AddPattern(URLPatternSet* extent,
                                        const std::string& pattern) {
   int schemes = URLPattern::SCHEME_ALL;
   extent->AddPattern(URLPattern(schemes, pattern));
 }
 
 ExtensionManifestTest::Testcase::Testcase(std::string manifest_filename,
                                           std::string expected_error,
                                           Extension::Location location,
                                           int flags)
@@ skipping 31 matching lines @@
                                          EXPECT_TYPE type) {
   switch (type) {
     case EXPECT_TYPE_ERROR:
       for (size_t i = 0; i < num_testcases; ++i) {
         LoadAndExpectError(testcases[i].manifest_filename_.c_str(),
                            testcases[i].expected_error_,
                            testcases[i].location_,
                            testcases[i].flags_);
       }
       break;
+    case EXPECT_TYPE_WARNING:
+      for (size_t i = 0; i < num_testcases; ++i) {
+        LoadAndExpectWarning(testcases[i].manifest_filename_.c_str(),
+                             testcases[i].expected_error_,
+                             testcases[i].location_,
+                             testcases[i].flags_);
+      }
+      break;
     case EXPECT_TYPE_SUCCESS:
       for (size_t i = 0; i < num_testcases; ++i) {
         LoadAndExpectSuccess(testcases[i].manifest_filename_.c_str(),
                              testcases[i].location_,
                              testcases[i].flags_);
       }
       break;
    }
 }