Enforce new id format (hex str of sha-1)

chrome/browser/extensions/extensions_service_unittest.cc

 // Copyright (c) 2006-2008 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 92 matching lines @@
   }
 
   void TestInstallExtension(const FilePath& path,
                             ExtensionsServiceBackend* backend,
                             bool should_succeed) {
     ASSERT_TRUE(file_util::PathExists(path));
     backend->InstallExtension(path, install_dir_, false,
         scoped_refptr<ExtensionsServiceFrontendInterface>(this));
     message_loop_.RunAllPending();
     if (should_succeed) {
-      EXPECT_EQ(1u, installed_.size());
+      EXPECT_EQ(1u, installed_.size()) << path.value();
       EXPECT_EQ(0u, errors_.size()) << path.value();
+      for (std::vector<std::string>::iterator err = errors_.begin();
+        err != errors_.end(); ++err) {
+        LOG(ERROR) << *err;
+      }
     } else {
-      EXPECT_EQ(0u, installed_.size());
-      EXPECT_EQ(1u, errors_.size());
+      EXPECT_EQ(0u, installed_.size()) << path.value();
+      EXPECT_EQ(1u, errors_.size()) << path.value();
     }
     installed_.clear();
     errors_.clear();
   }
 
 
  private:
   MessageLoop message_loop_;
   ExtensionList extensions_;
   std::vector<std::string> errors_;
@@ skipping 13 matching lines @@
 
   scoped_refptr<ExtensionsServiceBackend> backend(new ExtensionsServiceBackend);
   scoped_refptr<ExtensionsServiceTestFrontend> frontend(
       new ExtensionsServiceTestFrontend);
 
   std::vector<Extension*> extensions;
   backend->LoadExtensionsFromDirectory(extensions_path,
       scoped_refptr<ExtensionsServiceFrontendInterface>(frontend.get()));
   frontend->GetMessageLoop()->RunAllPending();
 
+  std::vector<std::string>* errors = frontend->errors();
+  for (std::vector<std::string>::iterator err = errors->begin();
+    err != errors->end(); ++err) {
+    LOG(ERROR) << *err;
+  }
   ASSERT_EQ(3u, frontend->extensions()->size());
 
-  EXPECT_EQ(std::string("com.google.myextension1"),
+  EXPECT_EQ(std::string("00123456789ABCDEF0123456789ABCDEF0123456"),
             frontend->extensions()->at(0)->id());
   EXPECT_EQ(std::string("My extension 1"),
             frontend->extensions()->at(0)->name());
   EXPECT_EQ(std::string("The first extension that I made."),
             frontend->extensions()->at(0)->description());
 
   Extension* extension = frontend->extensions()->at(0);
   const UserScriptList& scripts = extension->content_scripts();
   ASSERT_EQ(2u, scripts.size());
   EXPECT_EQ(2u, scripts[0].url_patterns().size());
   EXPECT_EQ("http://*.google.com/*",
             scripts[0].url_patterns()[0].GetAsString());
   EXPECT_EQ("https://*.google.com/*",
             scripts[0].url_patterns()[1].GetAsString());
   EXPECT_EQ(extension->path().AppendASCII("script1.js").value(),
             scripts[0].path().value());
   EXPECT_EQ(1u, scripts[1].url_patterns().size());
   EXPECT_EQ("http://*.yahoo.com/*", scripts[1].url_patterns()[0].GetAsString());
   EXPECT_EQ(extension->path().AppendASCII("script2.js").value(),
             scripts[1].path().value());
 
-  EXPECT_EQ(std::string("com.google.myextension2"),
+  EXPECT_EQ(std::string("10123456789ABCDEF0123456789ABCDEF0123456"),
             frontend->extensions()->at(1)->id());
   EXPECT_EQ(std::string("My extension 2"),
             frontend->extensions()->at(1)->name());
   EXPECT_EQ(std::string(""),
             frontend->extensions()->at(1)->description());
   EXPECT_EQ(frontend->extensions()->at(1)->path().AppendASCII("npapi").value(),
             frontend->extensions()->at(1)->plugins_dir().value());
   ASSERT_EQ(0u, frontend->extensions()->at(1)->content_scripts().size());
 
-  EXPECT_EQ(std::string("com.google.myextension3"),
+  EXPECT_EQ(std::string("20123456789ABCDEF0123456789ABCDEF0123456"),
             frontend->extensions()->at(2)->id());
   EXPECT_EQ(std::string("My extension 3"),
             frontend->extensions()->at(2)->name());
   EXPECT_EQ(std::string(""),
             frontend->extensions()->at(2)->description());
   ASSERT_EQ(0u, frontend->extensions()->at(2)->content_scripts().size());
 };
 
 // Test loading bad extensions from the profile directory.
 TEST_F(ExtensionsServiceTest, LoadAllExtensionsFromDirectoryFail) {
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   extensions_path = extensions_path.AppendASCII("bad");
 
   scoped_refptr<ExtensionsServiceBackend> backend(new ExtensionsServiceBackend);
   scoped_refptr<ExtensionsServiceTestFrontend> frontend(
       new ExtensionsServiceTestFrontend);
 
   std::vector<Extension*> extensions;
   backend->LoadExtensionsFromDirectory(extensions_path,
       scoped_refptr<ExtensionsServiceFrontendInterface>(frontend.get()));
   frontend->GetMessageLoop()->RunAllPending();
 
   EXPECT_EQ(4u, frontend->errors()->size());
   EXPECT_EQ(0u, frontend->extensions()->size());
 
   EXPECT_TRUE(MatchPattern(frontend->errors()->at(0),
       std::string("Could not load extension from '*'. * ") +
-      JSONReader::kBadRootElementType));
+      JSONReader::kBadRootElementType)) << frontend->errors()->at(0);
 
   EXPECT_TRUE(MatchPattern(frontend->errors()->at(1),
       std::string("Could not load extension from '*'. ") +
-      Extension::kInvalidJsListError));
+      Extension::kInvalidJsListError)) << frontend->errors()->at(1);
 
   EXPECT_TRUE(MatchPattern(frontend->errors()->at(2),
       std::string("Could not load extension from '*'. ") +
-      Extension::kInvalidManifestError));
+      Extension::kInvalidManifestError)) << frontend->errors()->at(2);
 
   EXPECT_TRUE(MatchPattern(frontend->errors()->at(3),
-      "Could not load extension from '*'. Could not read '*' file."));
+      "Could not load extension from '*'. Could not read '*' file.")) <<
+      frontend->errors()->at(3);
 };
 
 // Test installing extensions.
 TEST_F(ExtensionsServiceTest, InstallExtension) {
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   scoped_refptr<ExtensionsServiceBackend> backend(new ExtensionsServiceBackend);
   scoped_refptr<ExtensionsServiceTestFrontend> frontend(
@@ skipping 47 matching lines @@
 
   FilePath no_manifest = extensions_path.AppendASCII("bad")
       .AppendASCII("no_manifest").AppendASCII("1");
   backend->LoadSingleExtension(no_manifest,
       scoped_refptr<ExtensionsServiceFrontendInterface>(frontend.get()));
   frontend->GetMessageLoop()->RunAllPending();
   EXPECT_EQ(1u, frontend->errors()->size());
   ASSERT_EQ(1u, frontend->extensions()->size());
 }