Adding the --load-component-extension flag.

chrome/browser/extensions/component_loader.cc

 // Copyright (c) 2011 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/component_loader.h"
 
 #include "base/command_line.h"
+#include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/json/json_value_serializer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
 #include "chrome/browser/prefs/pref_notifier.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "grit/browser_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #if defined(OFFICIAL_BUILD)
 #include "chrome/browser/defaults.h"
 #endif
 
@@ skipping 63 matching lines @@
   // required in case LoadAll() is called again.
   DictionaryValue* manifest = ParseManifest(manifest_contents);
   if (manifest)
     return Add(manifest, root_directory);
   return NULL;
 }
 
 const Extension* ComponentLoader::Add(
     const DictionaryValue* parsed_manifest,
     const FilePath& root_directory) {
-  // Get the absolute path to the extension.
-  FilePath absolute_path(root_directory);
-  if (!absolute_path.IsAbsolute()) {
-    if (PathService::Get(chrome::DIR_RESOURCES, &absolute_path)) {
-      absolute_path = absolute_path.Append(root_directory);
-    } else {
-      NOTREACHED();
-    }
-  }
-
-  ComponentExtensionInfo info(parsed_manifest, absolute_path);
+  CHECK(!Exists(GenerateId(parsed_manifest)));
+  ComponentExtensionInfo info(parsed_manifest, root_directory);
   component_extensions_.push_back(info);
   if (extension_service_->is_ready())
     return Load(info);
   return NULL;
 }
 
+const Extension* ComponentLoader::AddOrReplace(const FilePath& path) {
+  FilePath absolute_path = path;
+  file_util::AbsolutePath(&absolute_path);
+  std::string error;
+  scoped_ptr<DictionaryValue> manifest(
+      extension_file_util::LoadManifest(absolute_path, &error));
+  if (!manifest.get()) {
+    LOG(ERROR) << "Could not load extension from '" <<
+                  absolute_path.value() << "'. " << error;
+    return NULL;
+  }
+  Remove(GenerateId(manifest.get()));
+
+  return Add(manifest.release(), absolute_path);
+}
+
 const Extension* ComponentLoader::Load(const ComponentExtensionInfo& info) {
   int flags = Extension::REQUIRE_KEY;
   // TODO(abarth): We should REQUIRE_MODERN_MANIFEST_VERSION once we've updated
   //               our component extensions to the new manifest version.
   if (Extension::ShouldDoStrictErrorChecking(Extension::COMPONENT))
     flags |= Extension::STRICT_ERROR_CHECKS;
   std::string error;
+
+  // Get the absolute path to the extension.
+  FilePath absolute_path(info.root_directory);
+  if (!absolute_path.IsAbsolute()) {
+    if (PathService::Get(chrome::DIR_RESOURCES, &absolute_path)) {
+      absolute_path = absolute_path.Append(info.root_directory);
+    } else {
+      NOTREACHED();
+    }
+  }
+
   scoped_refptr<const Extension> extension(Extension::Create(
-      info.root_directory,
+      absolute_path,
       Extension::COMPONENT,
       *info.manifest,
       flags,
       &error));
   if (!extension.get()) {
     LOG(ERROR) << error;
     return NULL;
   }
   extension_service_->AddExtension(extension);
   return extension;
 }
 
 void ComponentLoader::Remove(const FilePath& root_directory) {
   // Find the ComponentExtensionInfo for the extension.
   RegisteredComponentExtensions::iterator it = component_extensions_.begin();
   for (; it != component_extensions_.end(); ++it) {
-    if (it->root_directory == root_directory)
+    if (it->root_directory == root_directory) {
+      Remove(GenerateId(it->manifest));
       break;
+    }
   }
-  // If the extension is not in the list, there's nothing to do.
-  if (it == component_extensions_.end())
-    return;
+}
 
-  // The list owns the dictionary, so it must be deleted after removal.
-  scoped_ptr<const DictionaryValue> manifest(it->manifest);
+void ComponentLoader::Remove(const std::string& id) {
+  RegisteredComponentExtensions::iterator it = component_extensions_.begin();
+  for (; it != component_extensions_.end(); ++it) {

[Aaron Boodman, 2011/12/06 19:43:35]

It seems like this class spends a lot of time finding things by ID. Can you
please change it to use a map internally instead of a list. That would probably
cut down a lot of this code.

[SeRya, 2011/12/06 22:19:37]

It only does it when reloads Enterprise Web Store or component extensions with
command line switch (on startup). I'd prefer refactor this code in a separate
CL.

[Aaron Boodman, 2011/12/07 00:09:02]

I didn't mean compute time, I meant lines of code. We now repeat the same
pattern to find an extension by ID in several places.

I am OK with you fixing this in a subsequent change, but please do so soon.

+    if (GenerateId(it->manifest) == id) {
+      delete it->manifest;
+      it = component_extensions_.erase(it);
+      if (extension_service_->is_ready())
+        extension_service_->
+            UnloadExtension(id, extension_misc::UNLOAD_REASON_DISABLE);
+      break;
+    }
+  }
+}
 
-  // Remove the extension from the list of registered extensions.
-  *it = component_extensions_.back();
-  component_extensions_.pop_back();
+bool ComponentLoader::Exists(const std::string& id) const {
+  RegisteredComponentExtensions::const_iterator it =
+      component_extensions_.begin();
+  for (; it != component_extensions_.end(); ++it)
+    if (GenerateId(it->manifest) == id)
+      return true;
+  return false;
+}
 
-  // Determine the extension id and unload the extension.
+std::string ComponentLoader::GenerateId(const DictionaryValue* manifest) {
   std::string public_key;
   std::string public_key_bytes;
   std::string id;
   if (!manifest->GetString(
           extension_manifest_keys::kPublicKey, &public_key) ||
       !Extension::ParsePEMKeyBytes(public_key, &public_key_bytes) ||
       !Extension::GenerateId(public_key_bytes, &id)) {
-    LOG(ERROR) << "Failed to get extension id";
-    return;
+    return std::string();
   }
-  extension_service_->
-      UnloadExtension(id, extension_misc::UNLOAD_REASON_DISABLE);
+  return id;
 }
 
 void ComponentLoader::AddFileManagerExtension() {
 #if defined(FILE_MANAGER_EXTENSION)
 #ifndef NDEBUG
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kFileManagerExtensionPath)) {
     FilePath filemgr_extension_path(
         command_line->GetSwitchValuePath(switches::kFileManagerExtensionPath));
     Add(IDR_FILEMANAGER_MANIFEST, filemgr_extension_path);
@@ skipping 106 matching lines @@
 void ComponentLoader::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kEnterpriseWebStoreURL,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(prefs::kEnterpriseWebStoreName,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
 }
 
 }  // namespace extensions