Extension package creation cleanup

chrome/browser/extensions/extensions_service_unittest.cc

 // Copyright (c) 2010 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/browser/extensions/extensions_service_unittest.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_creator.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/extensions/external_extension_provider.h"
 #include "chrome/browser/extensions/external_pref_extension_provider.h"
+#include "chrome/browser/extensions/pack_extension_job.cc"
 #include "chrome/browser/pref_value_store.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/json_value_serializer.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_service.h"
@@ skipping 553 matching lines @@
 
  protected:
   ExtensionList loaded_;
   std::string unloaded_id_;
   Extension* installed_;
 
  private:
   NotificationRegistrar registrar_;
 };
 
-FilePath::StringType NormalizeSeperators(FilePath::StringType path) {
+FilePath NormalizeSeparators(const FilePath& path) {
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
-  FilePath::StringType ret_val;
-  for (size_t i = 0; i < path.length(); i++) {
-    if (FilePath::IsSeparator(path[i]))
-      path[i] = FilePath::kSeparators[0];
-  }
+  return path.NormalizeWindowsPathSeparators();
+#else
+  return path;
 #endif  // FILE_PATH_USES_WIN_SEPARATORS
-  return path;
 }
+
+// Receives notifications from a PackExtensionJob, indicating either that
+// packing succeeded or that there was some error.
+class PackExtensionTestClient : public PackExtensionJob::Client {
+ public:
+  PackExtensionTestClient(const FilePath& expected_crx_path,
+                          const FilePath& expected_private_key_path);
+  virtual void OnPackSuccess(const FilePath& crx_path,
+                             const FilePath& private_key_path);
+  virtual void OnPackFailure(const std::string& error_message);
+
+ private:
+  const FilePath expected_crx_path_;
+  const FilePath expected_private_key_path_;
+  DISALLOW_COPY_AND_ASSIGN(PackExtensionTestClient);
+};
+
+PackExtensionTestClient::PackExtensionTestClient(
+    const FilePath& expected_crx_path,
+    const FilePath& expected_private_key_path)
+    : expected_crx_path_(expected_crx_path),
+      expected_private_key_path_(expected_private_key_path) {}
+
+// If packing succeeded, we make sure that the package names match our
+// expectations.
+void PackExtensionTestClient::OnPackSuccess(const FilePath& crx_path,
+                                            const FilePath& private_key_path) {
+  // We got the notification and processed it; we don't expect any further tasks
+  // to be posted to the current thread, so we should stop blocking and continue
+  // on with the rest of the test.
+  // This call to |Quit()| matches the call to |Run()| in the
+  // |PackPunctuatedExtension| test.
+  MessageLoop::current()->Quit();
+  EXPECT_EQ(expected_crx_path_.value(), crx_path.value());
+  EXPECT_EQ(expected_private_key_path_.value(), private_key_path.value());
+  ASSERT_TRUE(file_util::PathExists(private_key_path));
+}
+
+// The tests are designed so that we never expect to see a packing error.
+void PackExtensionTestClient::OnPackFailure(const std::string& error_message) {
+  FAIL() << "Packing should not fail.";
+}
+
 // Test loading good extensions from the profile directory.
 TEST_F(ExtensionsServiceTest, LoadAllExtensionsFromDirectorySuccess) {
   // Initialize the test dir with a good Preferences/extensions.
   FilePath source_install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_install_dir));
   source_install_dir = source_install_dir
       .AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions");
   FilePath pref_path = source_install_dir
@@ skipping 306 matching lines @@
   // Try packing with an invalid manifest.
   std::string invalid_manifest_content = "I am not a manifest.";
   ASSERT_TRUE(file_util::WriteFile(
       temp_dir2.path().Append(Extension::kManifestFilename),
       invalid_manifest_content.c_str(), invalid_manifest_content.size()));
   creator.reset(new ExtensionCreator());
   ASSERT_FALSE(creator->Run(temp_dir2.path(), crx_path, privkey_path,
                             FilePath()));
 }
 
+// Test Packaging and installing an extension whose name contains punctuation.
+TEST_F(ExtensionsServiceTest, PackPunctuatedExtension) {
+  InitializeEmptyExtensionsService();
+  FilePath extensions_path;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
+  extensions_path = extensions_path.AppendASCII("extensions");
+  FilePath input_directory = extensions_path
+      .AppendASCII("good")
+      .AppendASCII("Extensions")
+      .AppendASCII(good0)
+      .AppendASCII("1.0.0.0");
+
+  ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+  // Extension names containing punctuation, and the expected names for the
+  // packed extensions.
+  const FilePath punctuated_names[] = {
+    FilePath(FilePath::StringType(
+        FILE_PATH_LITERAL("this.extensions.name.has.periods"))),
+    FilePath(FilePath::StringType(
+        FILE_PATH_LITERAL(".thisextensionsnamestartswithaperiod"))),
+    NormalizeSeparators(FilePath(FilePath::StringType(
+        FILE_PATH_LITERAL("thisextensionhasaslashinitsname/")))),
+  };
+  const FilePath expected_crx_names[] = {
+    FilePath(FilePath::StringType(
+        FILE_PATH_LITERAL("this.extensions.name.has.periods.crx"))),
+    FilePath(FilePath::StringType(
+        FILE_PATH_LITERAL(".thisextensionsnamestartswithaperiod.crx"))),
+    FilePath(FilePath::StringType(
+        FILE_PATH_LITERAL("thisextensionhasaslashinitsname.crx"))),
+  };
+  const FilePath expected_private_key_names[] = {
+    FilePath(FilePath::StringType(
+        FILE_PATH_LITERAL("this.extensions.name.has.periods.pem"))),
+    FilePath(FilePath::StringType(
+        FILE_PATH_LITERAL(".thisextensionsnamestartswithaperiod.pem"))),
+    FilePath(FilePath::StringType(
+        FILE_PATH_LITERAL("thisextensionhasaslashinitsname.pem"))),
+  };
+
+  for (size_t i = 0; i < arraysize(punctuated_names); ++i) {
+    SCOPED_TRACE(punctuated_names[i].value().c_str());
+    FilePath output_dir = temp_dir.path().Append(punctuated_names[i]);
+
+    // Copy the extension into the output directory, as PackExtensionJob doesn't
+    // let us choose where to output the packed extension.
+    ASSERT_TRUE(file_util::CopyDirectory(input_directory, output_dir, true));
+
+    FilePath expected_crx_path = temp_dir.path().Append(expected_crx_names[i]);
+    FilePath expected_private_key_path =
+        temp_dir.path().Append(expected_private_key_names[i]);
+    PackExtensionTestClient pack_client(expected_crx_path,
+                                        expected_private_key_path);
+    scoped_refptr<PackExtensionJob> packer(new PackExtensionJob(&pack_client,
+                                                                output_dir,
+                                                                FilePath()));
+    packer->Start();
+
+    // The packer will post a notification task to the current thread's message
+    // loop when it is finished.  We manually run the loop here so that we
+    // block and catch the notification; otherwise, the process would exit.
+    // This call to |Run()| is matched by a call to |Quit()| in the
+    // |PackExtensionTestClient|'s notification handling code.
+    MessageLoop::current()->Run();
+
+    if (HasFatalFailure())
+      return;
+
+    InstallExtension(expected_crx_path, true);
+  }
+}
+
 // Test Packaging and installing an extension using an openssl generated key.
 // The openssl is generated with the following:
 // > openssl genrsa -out privkey.pem 1024
 // > openssl pkcs8 -topk8 -nocrypt -in privkey.pem -out privkey_asn1.pem
 // The privkey.pem is a PrivateKey, and the pcks8 -topk8 creates a
 // PrivateKeyInfo ASN.1 structure, we our RSAPrivateKey expects.
 TEST_F(ExtensionsServiceTest, PackExtensionOpenSSLKey) {
   InitializeEmptyExtensionsService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
@@ skipping 1172 matching lines @@
   // Component extensions shouldn't get recourded in the prefs.
   ValidatePrefKeyCount(0);
 
   // Reload all extensions, and make sure it comes back.
   std::string extension_id = service_->extensions()->at(0)->id();
   loaded_.clear();
   service_->ReloadExtensions();
   ASSERT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(extension_id, service_->extensions()->at(0)->id());
 }