Almost all actions in Declarative Web Request require all_urls host permissions

chrome/common/extensions/extension_test_util.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/extension_test_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.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
-#include "chrome/common/extensions/extension_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using extensions::Extension;
+using extensions::Manifest;
 
 namespace extension_test_util {
 
 scoped_refptr<Extension> CreateExtensionWithID(std::string id) {
   DictionaryValue values;
   values.SetString(extension_manifest_keys::kName, "test");
   values.SetString(extension_manifest_keys::kVersion, "0.1");
   std::string error;
   return Extension::Create(base::FilePath(), extensions::Manifest::INTERNAL,
                            values, Extension::NO_FLAGS, id, &error);
 }
 
+scoped_refptr<Extension> LoadManifestUnchecked(const std::string& dir,
+                                               const std::string& test_file,
+                                               Manifest::Location location,
+                                               int extra_flags,
+                                               const std::string& id,
+                                               std::string* error) {
+  base::FilePath path;
+  PathService::Get(chrome::DIR_TEST_DATA, &path);
+  path = path.AppendASCII("extensions")
+             .AppendASCII(dir)
+             .AppendASCII(test_file);
+
+  JSONFileValueSerializer serializer(path);
+  scoped_ptr<Value> result(serializer.Deserialize(NULL, error));
+  if (!result.get())
+    return NULL;
+
+  scoped_refptr<Extension> extension = Extension::Create(
+      path.DirName(), location, *static_cast<DictionaryValue*>(result.get()),
+      extra_flags, id, error);
+  return extension;
+}
+
+scoped_refptr<Extension> LoadManifestUnchecked(const std::string& dir,
+                                               const std::string& test_file,
+                                               Manifest::Location location,
+                                               int extra_flags,
+                                               std::string* error) {
+  return LoadManifestUnchecked(
+      dir, test_file, location, extra_flags, std::string(), error);
+}
+
+scoped_refptr<Extension> LoadManifest(const std::string& dir,
+                                      const std::string& test_file,
+                                      Manifest::Location location,
+                                      int extra_flags) {
+  std::string error;
+  scoped_refptr<Extension> extension = LoadManifestUnchecked(dir, test_file,
+    location, extra_flags, &error);
+
+  EXPECT_TRUE(extension) << test_file << ":" << error;
+  return extension;
+}
+
+scoped_refptr<Extension> LoadManifest(const std::string& dir,
+                                      const std::string& test_file,
+                                      int extra_flags) {
+  return LoadManifest(dir, test_file, Manifest::INVALID_LOCATION, extra_flags);
+}
+
+scoped_refptr<Extension> LoadManifestStrict(const std::string& dir,
+                                            const std::string& test_file) {
+  return LoadManifest(dir, test_file, Extension::NO_FLAGS);
+}
+
+scoped_refptr<Extension> LoadManifest(const std::string& dir,
+                                      const std::string& test_file) {
+  return LoadManifest(dir, test_file, Extension::NO_FLAGS);
+}
+
 }  // namespace extension_test_util