Generate IDs for --load-extension by hashing the path instead

chrome/common/extensions/extension.cc

 // Copyright (c) 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 "chrome/common/extensions/extension.h"
 
 #include "app/resource_bundle.h"
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 46 matching lines @@
   for (size_t i = 0; i < Extension::kNumPermissions; ++i) {
     if (str == Extension::kPermissionNames[i])
       return true;
   }
 
   return false;
 }
 
 }  // namespace
 
-// static
-int Extension::id_counter_ = 0;
-
 const char Extension::kManifestFilename[] = "manifest.json";
 const char Extension::kLocaleFolder[] = "_locales";
 const char Extension::kMessagesFilename[] = "messages.json";
 
 // A list of all the keys allowed by themes.
 static const wchar_t* kValidThemeKeys[] = {
   keys::kDescription,
   keys::kName,
   keys::kPublicKey,
   keys::kSignature,
@@ skipping 89 matching lines @@
   HKEY reg_root = HKEY_LOCAL_MACHINE;
   RegKey key;
   registry_path.append("\\");
   registry_path.append(id_);
   if (key.Open(reg_root, ASCIIToWide(registry_path).c_str()))
     return Extension::EXTERNAL_REGISTRY;
 #endif
   return Extension::EXTERNAL_PREF;
 }
 
-bool Extension::GenerateIdFromPublicKey(const std::string& input,
-                                        std::string* output) {
+bool Extension::GenerateId(const std::string& input, std::string* output) {
   CHECK(output);
   if (input.length() == 0)
     return false;
 
   const uint8* ubuf = reinterpret_cast<const unsigned char*>(input.data());
   SHA256Context ctx;
   SHA256_Begin(&ctx);
   SHA256_Update(&ctx, ubuf, input.length());
   uint8 hash[Extension::kIdSize];
   SHA256_End(&ctx, hash, NULL, sizeof(hash));
@@ skipping 409 matching lines @@
   // Nothing much has changed.
   return false;
 }
 
 bool Extension::InitFromValue(const DictionaryValue& source, bool require_id,
                               std::string* error) {
   if (source.HasKey(keys::kPublicKey)) {
     std::string public_key_bytes;
     if (!source.GetString(keys::kPublicKey, &public_key_) ||
       !ParsePEMKeyBytes(public_key_, &public_key_bytes) ||
-      !GenerateIdFromPublicKey(public_key_bytes, &id_)) {
+      !GenerateId(public_key_bytes, &id_)) {
         *error = errors::kInvalidKey;
         return false;
     }
   } else if (require_id) {
     *error = errors::kInvalidKey;
     return false;
   } else {
-    // Generate a random ID
-    id_ = StringPrintf("%x", NextGeneratedId());
-
-    // pad the string out to kIdSize*2 chars with zeroes.
-    id_.insert(0, Extension::kIdSize*2 - id_.length(), '0');
-
-    // Convert to our mp-decimal.
-    ConvertHexadecimalToIDAlphabet(&id_);
+    // If there is a path, we generate the ID from it. This is useful for
+    // development mode, because it keeps the ID stable across restarts and
+    // reloading the extension.
+    if (!GenerateId(WideToUTF8(path_.ToWStringHack()), &id_)) {
+      NOTREACHED() << "Could not create ID from path.";
+      return false;
+    }
   }
 
   // Make a copy of the manifest so we can store it in prefs.
   manifest_value_.reset(static_cast<DictionaryValue*>(source.DeepCopy()));
 
   // Initialize the URL.
   extension_url_ = GURL(std::string(chrome::kExtensionScheme) +
                         chrome::kStandardSchemeSeparator + id_ + "/");
 
   // Initialize version.
@@ skipping 536 matching lines @@
     UserScript::PatternList::const_iterator pattern =
         content_script->url_patterns().begin();
     for (; pattern != content_script->url_patterns().end(); ++pattern) {
       if (pattern->match_subdomains() && pattern->host().empty())
         return true;
     }
   }
 
   return false;
 }