Move page action manifest parsing out of Extension; the first multi-key manifest handler.

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"
 #include "base/path_service.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_l10n_util.h"
 #include "chrome/common/extensions/manifest_handler.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using extensions::Extension;
 
-ExtensionManifestTest::ExtensionManifestTest()
-    : enable_apps_(true),
-      // UNKNOWN == trunk.
-      current_channel_(chrome::VersionInfo::CHANNEL_UNKNOWN) {}
+namespace {
 
-void ExtensionManifestTest::TearDown() {
-  extensions::ManifestHandler::ClearRegistryForTesting();
-}
-
-// static
-DictionaryValue* ExtensionManifestTest::LoadManifestFile(
-    const std::string& filename,
-    std::string* error) {
-  base::FilePath filename_path(base::FilePath::FromUTF8Unsafe(filename));
+// If filename is a relative path, LoadManifestFile will treat it relative to
+// the appropriate test directory.
+DictionaryValue* LoadManifestFile(
+    const base::FilePath& filename_path, std::string* error) {
   base::FilePath extension_path;
   base::FilePath manifest_path;
 
-  if (filename_path.IsAbsolute()) {
-    extension_path = filename_path.DirName();
-    manifest_path = filename_path;
-  } else {
-    PathService::Get(chrome::DIR_TEST_DATA, &extension_path);
-    extension_path = extension_path.AppendASCII("extensions")
-        .AppendASCII("manifest_tests");
-    manifest_path = extension_path.AppendASCII(filename.c_str());
-  }
+  PathService::Get(chrome::DIR_TEST_DATA, &manifest_path);
+  manifest_path = manifest_path.Append(filename_path);
+  extension_path = manifest_path.DirName();
 
   EXPECT_TRUE(file_util::PathExists(manifest_path)) <<
       "Couldn't find " << manifest_path.value();
 
   JSONFileValueSerializer serializer(manifest_path);
   DictionaryValue* manifest =
       static_cast<DictionaryValue*>(serializer.Deserialize(NULL, error));
 
   // Most unit tests don't need localization, and they'll fail if we try to
   // localize them, since their manifests don't have a default_locale key.
   // Only localize manifests that indicate they want to be localized.
   // Calling LocalizeExtension at this point mirrors
   // extension_file_util::LoadExtension.
-  if (manifest && filename.find("localized") != std::string::npos)
+  if (manifest &&
+      filename_path.value().find(FILE_PATH_LITERAL("localized")) !=
+      std::string::npos)
     extension_l10n_util::LocalizeExtension(extension_path, manifest, error);
 
   return manifest;
 }
 
+}  // namespace
+
+ExtensionManifestTest::ExtensionManifestTest()
+    : enable_apps_(true),
+      // UNKNOWN == trunk.
+      current_channel_(chrome::VersionInfo::CHANNEL_UNKNOWN) {}
+
+void ExtensionManifestTest::TearDown() {
+  extensions::ManifestHandler::ClearRegistryForTesting();
+}
+
 // Helper class that simplifies creating methods that take either a filename
 // to a manifest or the manifest itself.
 ExtensionManifestTest::Manifest::Manifest(const char* name)
     : name_(name), manifest_(NULL) {
 }
 
 ExtensionManifestTest::Manifest::Manifest(DictionaryValue* manifest,
                                           const char* name)
     : name_(name), manifest_(manifest) {
   CHECK(manifest_) << "Manifest NULL";
 }
 
 ExtensionManifestTest::Manifest::Manifest(const Manifest& m) {
   NOTREACHED();
 }
 
 ExtensionManifestTest::Manifest::~Manifest() {
 }
 
 DictionaryValue* ExtensionManifestTest::Manifest::GetManifest(
-    std::string* error) const {
+    char const* test_data_dir, std::string* error) const {
   if (manifest_)
     return manifest_;
 
-  manifest_ = LoadManifestFile(name_, error);
+  base::FilePath filename_path;
+  filename_path = filename_path.AppendASCII("extensions")
+      .AppendASCII(test_data_dir)
+      .AppendASCII(name_);
+  manifest_ = LoadManifestFile(filename_path, error);
   manifest_holder_.reset(manifest_);
   return manifest_;
 }
 
+char const* ExtensionManifestTest::test_data_dir() {
+  return "manifest_tests";
+}
+
+scoped_ptr<DictionaryValue> ExtensionManifestTest::LoadManifest(
+    char const* manifest_name, std::string* error) {
+  base::FilePath filename_path;
+  filename_path = filename_path.AppendASCII("extensions")
+      .AppendASCII(test_data_dir())
+      .AppendASCII(manifest_name);
+  return make_scoped_ptr(LoadManifestFile(filename_path, error));
+}
+
 scoped_refptr<Extension> ExtensionManifestTest::LoadExtension(
     const Manifest& manifest,
     std::string* error,
     extensions::Manifest::Location location,
     int flags) {
-  DictionaryValue* value = manifest.GetManifest(error);
+  DictionaryValue* value = manifest.GetManifest(test_data_dir(), error);
   if (!value)
     return NULL;
   base::FilePath path;
   PathService::Get(chrome::DIR_TEST_DATA, &path);
-  path = path.AppendASCII("extensions").AppendASCII("manifest_tests");
+  path = path.AppendASCII("extensions").AppendASCII(test_data_dir());
   return Extension::Create(path.DirName(), location, *value, flags, error);
 }
 
 scoped_refptr<Extension> ExtensionManifestTest::LoadAndExpectSuccess(
     const Manifest& manifest,
     extensions::Manifest::Location location,
     int flags) {
   std::string error;
   scoped_refptr<Extension> extension =
       LoadExtension(manifest, &error, location, flags);
@@ skipping 129 matching lines @@
       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;
    }
 }