Move BrowserAction out of Extension

chrome/common/extensions/extension_file_util_unittest.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_file_util.h"
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/extensions/api/extension_action/browser_action_handler.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
+#include "chrome/common/extensions/manifest_handler.h"
 #include "grit/generated_resources.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using extensions::Extension;
 
 namespace keys = extension_manifest_keys;
 
+class ExtensionFileUtil : public testing::Test {

[Yoyo Zhou, 2012/12/21 23:50:59]

ExtensionFileUtilTest is a better name.

[Devlin, 2012/12/27 20:36:46]

I thought so too, but wasn't sure I should change the full test suite name (I
typically avoid that, so that searching trybot records, etc, is the same when
possible). But since you think the name's a poor choice, too, done.

+ protected:
+  virtual void SetUp() OVERRIDE {

[Yoyo Zhou, 2012/12/21 23:50:59]

call base class SetUp

[Devlin, 2012/12/27 20:36:46]

Done.

+    extensions::ManifestHandler::Register(
+        extension_manifest_keys::kBrowserAction,
+        new extensions::BrowserActionHandler);
+  }
+};
+
 #if defined(OS_WIN)
 // http://crbug.com/106381
 #define InstallUninstallGarbageCollect DISABLED_InstallUninstallGarbageCollect
 #endif
-TEST(ExtensionFileUtil, InstallUninstallGarbageCollect) {
+TEST_F(ExtensionFileUtil, InstallUninstallGarbageCollect) {
   base::ScopedTempDir temp;
   ASSERT_TRUE(temp.CreateUniqueTempDir());
 
   // Create a source extension.
   std::string extension_id("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
   std::string version("1.0");
   FilePath src = temp.path().AppendASCII(extension_id);
   ASSERT_TRUE(file_util::CreateDirectory(src));
 
   // Create a extensions tree.
@@ skipping 50 matching lines @@
   ASSERT_TRUE(file_util::DirectoryExists(version_2));
   ASSERT_TRUE(file_util::DirectoryExists(version_3));
 
   // Uninstall. Should remove entire extension subtree.
   extension_file_util::UninstallExtension(all_extensions, extension_id);
   ASSERT_FALSE(file_util::DirectoryExists(version_2.DirName()));
   ASSERT_FALSE(file_util::DirectoryExists(version_3.DirName()));
   ASSERT_TRUE(file_util::DirectoryExists(all_extensions));
 }
 
-TEST(ExtensionFileUtil, LoadExtensionWithValidLocales) {
+TEST_F(ExtensionFileUtil, LoadExtensionWithValidLocales) {
   FilePath install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
   install_dir = install_dir.AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0");
 
   std::string error;
   scoped_refptr<Extension> extension(extension_file_util::LoadExtension(
       install_dir, Extension::LOAD, Extension::NO_FLAGS, &error));
   ASSERT_TRUE(extension != NULL);
   EXPECT_EQ("The first extension that I made.", extension->description());
 }
 
-TEST(ExtensionFileUtil, LoadExtensionWithoutLocalesFolder) {
+TEST_F(ExtensionFileUtil, LoadExtensionWithoutLocalesFolder) {
   FilePath install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
   install_dir = install_dir.AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("bjafgdebaacbbbecmhlhpofkepfkgcpa")
       .AppendASCII("1.0");
 
   std::string error;
   scoped_refptr<Extension> extension(extension_file_util::LoadExtension(
       install_dir, Extension::LOAD, Extension::NO_FLAGS, &error));
   ASSERT_FALSE(extension == NULL);
   EXPECT_TRUE(error.empty());
 }
 
 #if defined(OS_WIN)
 // http://crbug.com/106381
 #define CheckIllegalFilenamesNoUnderscores \
     DISABLED_CheckIllegalFilenamesNoUnderscores
 #endif
-TEST(ExtensionFileUtil, CheckIllegalFilenamesNoUnderscores) {
+TEST_F(ExtensionFileUtil, CheckIllegalFilenamesNoUnderscores) {
   base::ScopedTempDir temp;
   ASSERT_TRUE(temp.CreateUniqueTempDir());
 
   FilePath src_path = temp.path().AppendASCII("some_dir");
   ASSERT_TRUE(file_util::CreateDirectory(src_path));
 
   std::string data = "{ \"name\": { \"message\": \"foobar\" } }";
   ASSERT_TRUE(file_util::WriteFile(src_path.AppendASCII("some_file.txt"),
                                    data.c_str(), data.length()));
   std::string error;
   EXPECT_TRUE(extension_file_util::CheckForIllegalFilenames(temp.path(),
                                                             &error));
 }
 
 #if defined(OS_WIN)
 // http://crbug.com/106381
 #define CheckIllegalFilenamesOnlyReserved \
     DISABLED_CheckIllegalFilenamesOnlyReserved
 #endif
-TEST(ExtensionFileUtil, CheckIllegalFilenamesOnlyReserved) {
+TEST_F(ExtensionFileUtil, CheckIllegalFilenamesOnlyReserved) {
   base::ScopedTempDir temp;
   ASSERT_TRUE(temp.CreateUniqueTempDir());
 
   FilePath src_path = temp.path().Append(Extension::kLocaleFolder);
   ASSERT_TRUE(file_util::CreateDirectory(src_path));
 
   std::string error;
   EXPECT_TRUE(extension_file_util::CheckForIllegalFilenames(temp.path(),
                                                             &error));
 }
 
 #if defined(OS_WIN)
 // http://crbug.com/106381
 #define CheckIllegalFilenamesReservedAndIllegal \
     DISABLED_CheckIllegalFilenamesReservedAndIllegal
 #endif
-TEST(ExtensionFileUtil, CheckIllegalFilenamesReservedAndIllegal) {
+TEST_F(ExtensionFileUtil, CheckIllegalFilenamesReservedAndIllegal) {
   base::ScopedTempDir temp;
   ASSERT_TRUE(temp.CreateUniqueTempDir());
 
   FilePath src_path = temp.path().Append(Extension::kLocaleFolder);
   ASSERT_TRUE(file_util::CreateDirectory(src_path));
 
   src_path = temp.path().AppendASCII("_some_dir");
   ASSERT_TRUE(file_util::CreateDirectory(src_path));
 
   std::string error;
   EXPECT_FALSE(extension_file_util::CheckForIllegalFilenames(temp.path(),
                                                              &error));
 }
 
-TEST(ExtensionFileUtil, LoadExtensionGivesHelpfullErrorOnMissingManifest) {
+TEST_F(ExtensionFileUtil, LoadExtensionGivesHelpfullErrorOnMissingManifest) {
   FilePath install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
   install_dir = install_dir.AppendASCII("extensions")
       .AppendASCII("bad")
       .AppendASCII("Extensions")
       .AppendASCII("dddddddddddddddddddddddddddddddd")
       .AppendASCII("1.0");
 
   std::string error;
   scoped_refptr<Extension> extension(extension_file_util::LoadExtension(
       install_dir, Extension::LOAD, Extension::NO_FLAGS, &error));
   ASSERT_TRUE(extension == NULL);
   ASSERT_FALSE(error.empty());
   ASSERT_STREQ("Manifest file is missing or unreadable.", error.c_str());
 }
 
-TEST(ExtensionFileUtil, LoadExtensionGivesHelpfullErrorOnBadManifest) {
+TEST_F(ExtensionFileUtil, LoadExtensionGivesHelpfullErrorOnBadManifest) {
   FilePath install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
   install_dir = install_dir.AppendASCII("extensions")
       .AppendASCII("bad")
       .AppendASCII("Extensions")
       .AppendASCII("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee")
       .AppendASCII("1.0");
 
   std::string error;
   scoped_refptr<Extension> extension(extension_file_util::LoadExtension(
       install_dir, Extension::LOAD, Extension::NO_FLAGS, &error));
   ASSERT_TRUE(extension == NULL);
   ASSERT_FALSE(error.empty());
   ASSERT_STREQ("Manifest is not valid JSON.  "
                "Line: 2, column: 16, Syntax error.", error.c_str());
 }
 
-TEST(ExtensionFileUtil, FailLoadingNonUTF8Scripts) {
+TEST_F(ExtensionFileUtil, FailLoadingNonUTF8Scripts) {
   FilePath install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
   install_dir = install_dir.AppendASCII("extensions")
       .AppendASCII("bad")
       .AppendASCII("bad_encoding");
 
   std::string error;
   scoped_refptr<Extension> extension(extension_file_util::LoadExtension(
       install_dir, Extension::LOAD, Extension::NO_FLAGS, &error));
   ASSERT_TRUE(extension == NULL);
   ASSERT_STREQ("Could not load file 'bad_encoding.js' for content script. "
                "It isn't UTF-8 encoded.", error.c_str());
 }
 
-TEST(ExtensionFileUtil, ExtensionURLToRelativeFilePath) {
+TEST_F(ExtensionFileUtil, ExtensionURLToRelativeFilePath) {
 #define URL_PREFIX "chrome-extension://extension-id/"
   struct TestCase {
     const char* url;
     const char* expected_relative_path;
   } test_cases[] = {
     { URL_PREFIX "simple.html",
       "simple.html" },
     { URL_PREFIX "directory/to/file.html",
       "directory/to/file.html" },
     { URL_PREFIX "escape%20spaces.html",
@@ skipping 25 matching lines @@
 
     FilePath actual_path =
         extension_file_util::ExtensionURLToRelativeFilePath(url);
     EXPECT_FALSE(actual_path.IsAbsolute()) <<
       " For the path " << actual_path.value();
     EXPECT_EQ(expected_path.value(), actual_path.value()) <<
       " For the path " << url;
   }
 }
 
-TEST(ExtensionFileUtil, ExtensionResourceURLToFilePath) {
+TEST_F(ExtensionFileUtil, ExtensionResourceURLToFilePath) {
   // Setup filesystem for testing.
   FilePath root_path;
   ASSERT_TRUE(file_util::CreateNewTempDirectory(
         FILE_PATH_LITERAL(""), &root_path));
   ASSERT_TRUE(file_util::AbsolutePath(&root_path));
 
   FilePath api_path = root_path.Append(FILE_PATH_LITERAL("apiname"));
   ASSERT_TRUE(file_util::CreateDirectory(api_path));
 
   const char data[] = "Test Data";
@@ skipping 78 matching lines @@
                                manifest_dir,
                                location,
                                extra_flags,
                                error);
 }
 
 #if defined(OS_WIN)
 // http://crbug.com/108279
 #define ValidateThemeUTF8 DISABLED_ValidateThemeUTF8
 #endif
-TEST(ExtensionFileUtil, ValidateThemeUTF8) {
+TEST_F(ExtensionFileUtil, ValidateThemeUTF8) {
   base::ScopedTempDir temp;
   ASSERT_TRUE(temp.CreateUniqueTempDir());
 
   // "aeo" with accents. Use http://0xcc.net/jsescape/ to decode them.
   std::string non_ascii_file = "\xC3\xA0\xC3\xA8\xC3\xB2.png";
   FilePath non_ascii_path = temp.path().Append(FilePath::FromUTF8Unsafe(
       non_ascii_file));
   file_util::WriteFile(non_ascii_path, "", 0);
 
   std::string kManifest =
@@ skipping 12 matching lines @@
       error;
   EXPECT_EQ(0U, warnings.size());
 }
 
 #if defined(OS_WIN)
 // This test hangs on Windows sometimes. http://crbug.com/110279
 #define MAYBE_BackgroundScriptsMustExist DISABLED_BackgroundScriptsMustExist
 #else
 #define MAYBE_BackgroundScriptsMustExist BackgroundScriptsMustExist
 #endif
-TEST(ExtensionFileUtil, MAYBE_BackgroundScriptsMustExist) {
+TEST_F(ExtensionFileUtil, MAYBE_BackgroundScriptsMustExist) {
   base::ScopedTempDir temp;
   ASSERT_TRUE(temp.CreateUniqueTempDir());
 
   scoped_ptr<DictionaryValue> value(new DictionaryValue());
   value->SetString("name", "test");
   value->SetString("version", "1");
   value->SetInteger("manifest_version", 1);
 
   ListValue* scripts = new ListValue();
   scripts->Append(Value::CreateStringValue("foo.js"));
@@ skipping 42 matching lines @@
     "4GAAeWonDdkQJBANNb8wrqNWFn7DqyQTfELzcRTRnqQ/r1pdeJo6obzbnwGnlqe3t\n"
     "KhLjtJNIGrQg5iC0OVLWFuvPJs0t3z62A1ckCQQDPq2JZuwTwu5Pl4DJ0r9O1FdqN\n"
     "JgqPZyMptokCDQ3khLLGakIu+TqB9YtrzI69rJMSG2Egb+6McaDX+dh3XmR/AkB9t\n"
     "xJf6qDnmA2td/tMtTc0NOk8Qdg/fD8xbZ/YfYMnVoYYs9pQoilBaWRePDRNURMLYZ\n"
     "vHAI0Llmw7tj7jv17pAkEAz44uXRpjRKtllUIvi5pUENAHwDz+HvdpGH68jpU3hmb\n"
     "uOwrmnQYxaMReFV68Z2w9DcLZn07f7/R9Wn72z89CxwJAFsDoNaDes4h48bX7plct\n"
     "s9ACjmTwcCigZjN2K7AGv7ntCLF3DnV5dK0dTHNaAdD3SbY3jl29Rk2CwiURSX6Ee\n"
     "g==\n"
     "-----END PRIVATE KEY-----\n";
 
-TEST(ExtensionFileUtil, FindPrivateKeyFiles) {
+TEST_F(ExtensionFileUtil, FindPrivateKeyFiles) {
   base::ScopedTempDir temp;
   ASSERT_TRUE(temp.CreateUniqueTempDir());
 
   FilePath src_path = temp.path().AppendASCII("some_dir");
   ASSERT_TRUE(file_util::CreateDirectory(src_path));
 
   ASSERT_TRUE(file_util::WriteFile(src_path.AppendASCII("a_key.pem"),
                                    private_key, arraysize(private_key)));
   ASSERT_TRUE(file_util::WriteFile(src_path.AppendASCII("second_key.pem"),
                                    private_key, arraysize(private_key)));
   // Shouldn't find a key with a different extension.
   ASSERT_TRUE(file_util::WriteFile(src_path.AppendASCII("key.diff_ext"),
                                    private_key, arraysize(private_key)));
   // Shouldn't find a key that isn't parsable.
   ASSERT_TRUE(file_util::WriteFile(src_path.AppendASCII("unparsable_key.pem"),
                                    private_key, arraysize(private_key) - 30));
   std::vector<FilePath> private_keys =
       extension_file_util::FindPrivateKeyFiles(temp.path());
   EXPECT_EQ(2U, private_keys.size());
   EXPECT_THAT(private_keys,
               testing::Contains(src_path.AppendASCII("a_key.pem")));
   EXPECT_THAT(private_keys,
               testing::Contains(src_path.AppendASCII("second_key.pem")));
 }
 
-TEST(ExtensionFileUtil, WarnOnPrivateKey) {
+TEST_F(ExtensionFileUtil, WarnOnPrivateKey) {
   base::ScopedTempDir temp;
   ASSERT_TRUE(temp.CreateUniqueTempDir());
 
   FilePath ext_path = temp.path().AppendASCII("ext_root");
   ASSERT_TRUE(file_util::CreateDirectory(ext_path));
 
   const char manifest[] =
       "{\n"
       "  \"name\": \"Test Extension\",\n"
       "  \"version\": \"1.0\",\n"
@@ skipping 22 matching lines @@
   // Turn the warning into an error with ERROR_ON_PRIVATE_KEY.
   extension = extension_file_util::LoadExtension(
       ext_path, "the_id", Extension::EXTERNAL_PREF,
       Extension::ERROR_ON_PRIVATE_KEY, &error);
   EXPECT_FALSE(extension.get());
   EXPECT_THAT(error,
               testing::ContainsRegex(
                   "extension includes the key file.*ext_root.a_key.pem"));
 }
 
-TEST(ExtensionFileUtil, CheckZeroLengthImageFile) {
+TEST_F(ExtensionFileUtil, CheckZeroLengthImageFile) {
   FilePath install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
 
   // Try to install an extension with a zero-length icon file.
   FilePath ext_dir = install_dir.AppendASCII("extensions")
       .AppendASCII("bad")
       .AppendASCII("Extensions")
       .AppendASCII("ffffffffffffffffffffffffffffffff");
 
   std::string error;
@@ skipping 24 matching lines @@
   scoped_refptr<Extension> extension3(extension_file_util::LoadExtension(
       ext_dir, Extension::LOAD, Extension::NO_FLAGS, &error));
   ASSERT_TRUE(extension3 == NULL);
   ASSERT_STREQ("Could not load icon 'icon.png' for page action.",
       error.c_str());
 }
 
 // TODO(aa): More tests as motivation allows. Maybe steal some from
 // ExtensionService? Many of them could probably be tested here without the
 // MessageLoop shenanigans.