Parse manifest file with app.service_worker.script.

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_util.h"
 #include "base/files/file_path.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/path_service.h"
 #include "base/values.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_l10n_util.h"
+#include "extensions/common/test_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using extensions::Extension;
 
 namespace {
 
 // If filename is a relative path, LoadManifestFile will treat it relative to
 // the appropriate test directory.
 base::DictionaryValue* LoadManifestFile(const base::FilePath& filename_path,
                                         std::string* error) {
@@ skipping 36 matching lines @@
 ExtensionManifestTest::Manifest::Manifest(const char* name)
     : name_(name), manifest_(NULL) {
 }
 
 ExtensionManifestTest::Manifest::Manifest(base::DictionaryValue* manifest,
                                           const char* name)
     : name_(name), manifest_(manifest) {
   CHECK(manifest_) << "Manifest NULL";
 }
 
+ExtensionManifestTest::Manifest::Manifest(
+    scoped_ptr<base::DictionaryValue> manifest)
+    : manifest_(manifest.get()), manifest_holder_(manifest.Pass()) {
+  CHECK(manifest_) << "Manifest NULL";
+}
+
 ExtensionManifestTest::Manifest::Manifest(const Manifest& m) {
   NOTREACHED();
 }
 
 ExtensionManifestTest::Manifest::~Manifest() {
 }
 
 base::DictionaryValue* ExtensionManifestTest::Manifest::GetManifest(
     char const* test_data_dir, std::string* error) const {
   if (manifest_)
@@ skipping 47 matching lines @@
   return extension;
 }
 
 scoped_refptr<Extension> ExtensionManifestTest::LoadAndExpectSuccess(
     char const* manifest_name,
     extensions::Manifest::Location location,
     int flags) {
   return LoadAndExpectSuccess(Manifest(manifest_name), location, flags);
 }
 
+scoped_refptr<Extension> ExtensionManifestTest::LoadFromStringAndExpectSuccess(
+    char const* manifest_json) {
+  return LoadAndExpectSuccess(
+      Manifest(extensions::test_util::ParseJsonDictionaryWithSingleQuotes(
+          manifest_json)));
+}
+
 scoped_refptr<Extension> ExtensionManifestTest::LoadAndExpectWarning(
     const Manifest& manifest,
     const std::string& expected_warning,
     extensions::Manifest::Location location,
     int flags) {
   std::string error;
   scoped_refptr<Extension> extension =
       LoadExtension(manifest, &error, location, flags);
   EXPECT_TRUE(extension.get()) << manifest.name();
   EXPECT_EQ("", error) << manifest.name();
@@ skipping 37 matching lines @@
 
 void ExtensionManifestTest::LoadAndExpectError(
     char const* manifest_name,
     const std::string& expected_error,
     extensions::Manifest::Location location,
     int flags) {
   return LoadAndExpectError(
       Manifest(manifest_name), expected_error, location, flags);
 }
 
+void ExtensionManifestTest::LoadFromStringAndExpectError(
+    char const* manifest_json,
+    const std::string& expected_error) {
+  return LoadAndExpectError(
+      Manifest(extensions::test_util::ParseJsonDictionaryWithSingleQuotes(
+          manifest_json)),
+      expected_error);
+}
+
 void ExtensionManifestTest::AddPattern(extensions::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,
     extensions::Manifest::Location location,
@@ skipping 46 matching lines @@
                            testcase.location_,
                            testcase.flags_);
       break;
     case EXPECT_TYPE_SUCCESS:
       LoadAndExpectSuccess(testcase.manifest_filename_.c_str(),
                            testcase.location_,
                            testcase.flags_);
       break;
    }
 }