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

chrome/common/extensions/manifest_tests/extension_manifest_test.h

 // 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.
 
 #ifndef CHROME_COMMON_EXTENSIONS_MANIFEST_TESTS_EXTENSION_MANIFEST_TEST_H_
 #define CHROME_COMMON_EXTENSIONS_MANIFEST_TESTS_EXTENSION_MANIFEST_TEST_H_
 
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
-#include "base/memory/scoped_ptr.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace errors = extension_manifest_errors;
 namespace keys = extension_manifest_keys;
 
 class ExtensionManifestTest : public testing::Test {
  public:
   ExtensionManifestTest();
 
  protected:
-  // If filename is a relative path, LoadManifestFile will treat it relative to
-  // the appropriate test directory.
-  static DictionaryValue* LoadManifestFile(const std::string& filename,
-                                           std::string* error);
-
   // Helper class that simplifies creating methods that take either a filename
   // to a manifest or the manifest itself.
   class Manifest {
    public:
     explicit Manifest(const char* name);
     Manifest(DictionaryValue* manifest, const char* name);
     // C++98 requires the copy constructor for a type to be visible if you
     // take a const-ref of a temporary for that type.  Since Manifest
     // contains a scoped_ptr, its implicit copy constructor is declared
     // Manifest(Manifest&) according to spec 12.8.5.  This breaks the first
     // requirement and thus you cannot use it with LoadAndExpectError() or
     // LoadAndExpectSuccess() easily.
     //
     // To get around this spec pedantry, we declare the copy constructor
     // explicitly.  It will never get invoked.
     Manifest(const Manifest& m);
 
     ~Manifest();
 
     const std::string& name() const { return name_; };
 
-    DictionaryValue* GetManifest(std::string* error) const;
+    DictionaryValue* GetManifest(char const* test_data_dir,
+                                 std::string* error) const;
 
    private:
     const std::string name_;
     mutable DictionaryValue* manifest_;
     mutable scoped_ptr<DictionaryValue> manifest_holder_;
   };
 
+  // The subdirectory in which to find test data files.
+  virtual char const* test_data_dir() {
+    return "manifest_tests";
+  }
+
+  scoped_ptr<DictionaryValue> LoadManifest(
+      char const* manifest_name,
+      std::string* error);
+
   scoped_refptr<extensions::Extension> LoadExtension(
       const Manifest& manifest,
       std::string* error,
       extensions::Extension::Location location =
           extensions::Extension::INTERNAL,
       int flags = extensions::Extension::NO_FLAGS);
 
   scoped_refptr<extensions::Extension> LoadAndExpectSuccess(
       const Manifest& manifest,
       extensions::Extension::Location location =
@@ skipping 74 matching lines @@
   // Force the manifest tests to run as though they are on trunk, since several
   // tests rely on manifest features being available that aren't on
   // stable/beta.
   //
   // These objects nest, so if a test wants to explicitly test the behaviour
   // on stable or beta, declare it inside that test.
   extensions::Feature::ScopedCurrentChannel current_channel_;
 };
 
 #endif  // CHROME_COMMON_EXTENSIONS_MANIFEST_TESTS_EXTENSION_MANIFEST_TEST_H_