Change extension id format back to mp-decimal, and change the

chrome/browser/extensions/extensions_service_unittest.cc

 // Copyright (c) 2006-2009 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 <algorithm>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json_reader.h"
@@ skipping 13 matching lines @@
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/test/testing_profile.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace {
 
 // Extension ids used during testing.
-const char* const all_zero = "0000000000000000000000000000000000000000";
-const char* const zero_n_one = "0000000000000000000000000000000000000001";
-const char* const good0 = "fc6f6ba6693faf6773c13701019f2e7a12f0febe";
-const char* const good1 = "e5ead92b2c6795c1d2b92df9c5cb37de5582471a";
-const char* const good2 = "a37fed892f622823f4daaec4426a32fc7f6147dc";
-const char* const good_crx = "b3dd733cd71a98fa83f387455e12f5c5501c519e";
-const char* const page_action = "a4ca7d01469a010acb200568a0b8f4d9b3ac1f91";
-const char* const theme_crx = "80c45f5ae9e0f839d105c6a6d2461a036bc40a04";
-const char* const theme2_crx = "f9f6c52c01efdd5edd7c396b5f995a15fc7ad6d1";
+const char* const all_zero = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+const char* const zero_n_one = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab";
+const char* const good0 = "behllobkkfkfnphdnhnkndlbkcpglgmj";
+const char* const good1 = "hpiknbiabeeppbpihjehijgoemciehgk";
+const char* const good2 = "bjafgdebaacbbbecmhlhpofkepfkgcpa";
+const char* const good_crx = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
+const char* const page_action = "kemkhnabegjkabakmlcaafgikalipenj";
+const char* const theme_crx = "iamefpfkojoapidjnbafmgkgncegbkad";
+const char* const theme2_crx = "pjpgmfcmabopnnfonnhmdjglfpjjfkbf";
 
 struct ExtensionsOrder {
   bool operator()(const Extension* a, const Extension* b) {
     return a->name() < b->name();
   }
 };
 
 static std::vector<std::string> GetErrors() {
   const std::vector<std::string>* errors =
       ExtensionErrorReporter::GetInstance()->GetErrors();
@@ skipping 334 matching lines @@
 
   // Make sure the dictionary is empty.
   ValidatePrefKeyCount(0);
 
   EXPECT_TRUE(MatchPattern(GetErrors()[0],
       std::string("Could not load extension from '*'. * ") +
       JSONReader::kBadRootElementType)) << GetErrors()[0];
 
   EXPECT_TRUE(MatchPattern(GetErrors()[1],
       std::string("Could not load extension from '*'. ") +
-      Extension::kMissingFileError)) << GetErrors()[1];
+      Extension::kInvalidManifestError)) << GetErrors()[1];
 
   EXPECT_TRUE(MatchPattern(GetErrors()[2],
       std::string("Could not load extension from '*'. ") +
-      Extension::kInvalidManifestError)) << GetErrors()[2];
+      Extension::kMissingFileError)) << GetErrors()[2];
 };
 
 // Test that partially deleted extensions are cleaned up during startup
 // Test loading bad extensions from the profile directory.
 TEST_F(ExtensionsServiceTest, CleanupOnStartup) {
   FilePath source_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_path));
   source_path = source_path.AppendASCII("extensions");
   source_path = source_path.AppendASCII("good");
 
   FilePath dest_path = profile_->GetPath().AppendASCII("Extensions");
   file_util::CopyDirectory(source_path, dest_path, true);  // Recursive.
 
   // Simulate that one of them got partially deleted by deling the
   // Current Version file.
-  dest_path = dest_path.AppendASCII("extension1")
+  dest_path = dest_path.AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
                        .AppendASCII(ExtensionsService::kCurrentVersionFileName);
   ASSERT_TRUE(file_util::Delete(dest_path, false));  // not recursive
 
   service_->Init();
   loop_.RunAllPending();
 
   // We should have only gotten two extensions now.
   EXPECT_EQ(2u, loaded_.size());
 
   // And extension1 dir should now be toast.
@@ skipping 51 matching lines @@
   path = extensions_path.AppendASCII("bad_magic.crx");
   InstallExtension(path, false);
   ValidatePrefKeyCount(pref_count);
 
   // TODO(erikkay): add more tests for many of the failure cases.
   // TODO(erikkay): add tests for upgrade cases.
 }
 
 #if defined(OS_WIN)  // TODO(port)
 // Test Packaging and installing an extension.
-// TODO(aa): add a test that uses an openssl-generate private key.
 // TODO(rafaelw): add more tests for failure cases.
 TEST_F(ExtensionsServiceTest, PackExtension) {
   SetExtensionsEnabled(true);
 
   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("extension1").AppendASCII("1");
+      .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj").AppendASCII("1.0.0.0");
 
   FilePath output_directory;
   file_util::CreateNewTempDirectory(FILE_PATH_LITERAL("chrome_"),
       &output_directory);
   FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
   FilePath privkey_path(output_directory.AppendASCII("privkey.pem"));
 
   scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
   ASSERT_TRUE(creator->Run(input_directory, crx_path, FilePath(),
       privkey_path));
 
   ASSERT_TRUE(file_util::PathExists(privkey_path));
-
-  // TODO(aa): Re-enable this when ExtensionUnpacker expects the same format we
-  // are generating in ExtensionCreator.
-  // InstallExtension(crx_path, true);
+  InstallExtension(crx_path, true);
 
   file_util::Delete(crx_path, false);
   file_util::Delete(privkey_path, false);
 }
 
 // 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) {
   SetExtensionsEnabled(true);
 
   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("extension1").AppendASCII("1");
+      .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj").AppendASCII("1.0.0.0");
   FilePath privkey_path(extensions_path.AppendASCII(
       "openssl_privkey_asn1.pem"));
   ASSERT_TRUE(file_util::PathExists(privkey_path));
 
   FilePath output_directory;
   file_util::CreateNewTempDirectory(FILE_PATH_LITERAL("chrome_"),
       &output_directory);
   FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
 
   scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
   ASSERT_TRUE(creator->Run(input_directory, crx_path, privkey_path,
       FilePath()));
 
-  // TODO(aa): Re-enable this when ExtensionUnpacker expects the same format we
-  // are generating in ExtensionCreator.
-  // InstallExtension(crx_path, true);
+  InstallExtension(crx_path, true);
 
   file_util::Delete(crx_path, false);
 }
 #endif  // defined(OS_WIN)
 
 TEST_F(ExtensionsServiceTest, InstallTheme) {
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
@@ skipping 165 matching lines @@
   ValidatePref(good_crx, L"state", Extension::DISABLED);
   ValidatePref(good_crx, L"location", Extension::INTERNAL);
 }
 
 // Tests loading single extensions (like --load-extension)
 TEST_F(ExtensionsServiceTest, LoadExtension) {
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
-  FilePath ext1 = extensions_path.AppendASCII("good").AppendASCII("extension1")
-      .AppendASCII("1");
+  FilePath ext1 = extensions_path.AppendASCII("good")
+      .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
+      .AppendASCII("1.0.0.0");
   service_->LoadExtension(ext1);
   loop_.RunAllPending();
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ(Extension::LOAD, loaded_[0]->location());
 
   ValidatePrefKeyCount(1);
   ValidatePref(good0, L"state", Extension::ENABLED);
   ValidatePref(good0, L"location", Extension::INTERNAL);
 
@@ skipping 27 matching lines @@
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath no_id_ext = extensions_path.AppendASCII("no_id");
   service_->LoadExtension(no_id_ext);
   loop_.RunAllPending();
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   std::string id1 = loaded_[0]->id();
   ASSERT_EQ(all_zero, id1);
-  ASSERT_EQ("chrome-extension://0000000000000000000000000000000000000000/",
+  ASSERT_EQ("chrome-extension://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/",
             loaded_[0]->url().spec());
 
   ValidatePrefKeyCount(1);
   ValidatePref(all_zero, L"state", Extension::ENABLED);
   ValidatePref(all_zero, L"location", Extension::INTERNAL);
 
   service_->LoadExtension(no_id_ext);
   loop_.RunAllPending();
   std::string id2 = loaded_[1]->id();
   ASSERT_EQ(zero_n_one, id2);
-  ASSERT_EQ("chrome-extension://0000000000000000000000000000000000000001/",
+  ASSERT_EQ("chrome-extension://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab/",
             loaded_[1]->url().spec());
 
   ValidatePrefKeyCount(2);
   ValidatePref(zero_n_one, L"state", Extension::ENABLED);
   ValidatePref(zero_n_one, L"location", Extension::INTERNAL);
 }
 
 // Tests the external installation feature
 #if defined(OS_WIN)
 
@@ skipping 201 matching lines @@
   ValidatePrefKeyCount(1);
   ValidatePref(good_crx, L"state", Extension::KILLBIT);
   ValidatePref(good_crx, L"location", Extension::EXTERNAL_PREF);
 
   // The extension should also be gone from disk.
   FilePath extension_path = install_path.DirName();
   extension_path = extension_path.AppendASCII(good_crx);
   EXPECT_FALSE(file_util::PathExists(extension_path)) <<
       extension_path.ToWStringHack();
 }