TBR: Revert "Implement chromium.self in content scripts..."

chrome/browser/extensions/extensions_service.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 "chrome/browser/extensions/extensions_service.h"
 
 #include "base/file_util.h"
 #include "base/scoped_handle.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_util.h"
@@ skipping 240 matching lines @@
   // Explicit UI loads are always noisy.
   alert_on_error_ = true;
 
   FilePath extension_path = path_in;
   if (!file_util::AbsolutePath(&extension_path))
     NOTREACHED();
 
   LOG(INFO) << "Loading single extension from " <<
       WideToASCII(extension_path.BaseName().ToWStringHack());
 
-  Extension* extension = LoadExtension(extension_path,
-                                       false);  // don't require ID
+  Extension* extension = LoadExtension(extension_path);
   if (extension) {
+    if (extension->id().empty()) {
+      // Generate an ID
+      static int counter = 0;
+      std::string id = StringPrintf("%x", counter);
+      ++counter;
+
+      // pad the string out to 40 chars with zeroes.
+      id.insert(0, 40 - id.length(), '0');
+      extension->set_id(id);
+    }
     ExtensionList* extensions = new ExtensionList;
     extensions->push_back(extension);
     ReportExtensionsLoaded(extensions);
   }
 }
 
 Extension* ExtensionsServiceBackend::LoadExtensionCurrentVersion(
     const FilePath& extension_path) {
   std::string version_str;
   if (!ReadCurrentVersion(extension_path, &version_str)) {
     ReportExtensionLoadError(extension_path,
         StringPrintf("Could not read '%s' file.",
             ExtensionsService::kCurrentVersionFileName));
     return NULL;
   }
 
   LOG(INFO) << "  " <<
       WideToASCII(extension_path.BaseName().ToWStringHack()) <<
       " version: " << version_str;
 
-  return LoadExtension(extension_path.AppendASCII(version_str),
-                       true);  // require id
+  return LoadExtension(extension_path.AppendASCII(version_str));
 }
 
 Extension* ExtensionsServiceBackend::LoadExtension(
-    const FilePath& extension_path, bool require_id) {
+    const FilePath& extension_path) {
   FilePath manifest_path =
       extension_path.AppendASCII(Extension::kManifestFilename);
   if (!file_util::PathExists(manifest_path)) {
     ReportExtensionLoadError(extension_path, Extension::kInvalidManifestError);
     return NULL;
   }
 
   JSONFileValueSerializer serializer(manifest_path);
   std::string error;
   scoped_ptr<Value> root(serializer.Deserialize(&error));
   if (!root.get()) {
     ReportExtensionLoadError(extension_path, error);
     return NULL;
   }
 
   if (!root->IsType(Value::TYPE_DICTIONARY)) {
     ReportExtensionLoadError(extension_path, Extension::kInvalidManifestError);
     return NULL;
   }
 
   scoped_ptr<Extension> extension(new Extension(extension_path));
   if (!extension->InitFromValue(*static_cast<DictionaryValue*>(root.get()),
-                                require_id, &error)) {
+                                &error)) {
     ReportExtensionLoadError(extension_path, error);
     return NULL;
   }
 
   // Validate that claimed resources actually exist.
   for (size_t i = 0; i < extension->content_scripts().size(); ++i) {
     const UserScript& script = extension->content_scripts()[i];
 
     for (size_t j = 0; j < script.js_scripts().size(); j++) {
       const FilePath& path = script.js_scripts()[j].path();
@@ skipping 300 matching lines @@
 
   // Read and verify the extension.
   scoped_ptr<DictionaryValue> manifest(ReadManifest(source_file));
   if (!manifest.get()) {
     // ReadManifest has already reported the extension error.
     return false;
   }
   DictionaryValue* dict = manifest.get();
   Extension extension;
   std::string error;
-  if (!extension.InitFromValue(*dict,
-                               true,  // require ID
-                               &error)) {
+  if (!extension.InitFromValue(*dict, &error)) {
     ReportExtensionInstallError(source_file,
                                 "Invalid extension manifest.");
     return false;
   }
 
   // ID is required for installed extensions.
   if (extension.id().empty()) {
     ReportExtensionInstallError(source_file, "Required value 'id' is missing.");
     return false;
   }
@@ skipping 191 matching lines @@
 
 bool ExtensionsServiceBackend::ShouldInstall(const std::string& id,
                                              const std::string& version) {
   FilePath dir(install_directory_.AppendASCII(id.c_str()));
   std::string current_version;
   if (ReadCurrentVersion(dir, &current_version)) {
     return !CheckCurrentVersion(version, current_version, dir);
   }
   return true;
 }