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 80 matching lines @@
     }
   }
 
   ComponentExtensionInfo info(parsed_manifest, absolute_path);
   component_extensions_.push_back(info);
   if (extension_service_->is_ready())
     return Load(info);
   return NULL;
 }
 
+const Extension* ComponentLoader::AddFromCommandLine(const FilePath& path) {
+  // Load extensions from the command line synchronously to avoid a race
+  // between extension loading and loading an URL from the command line.
+  base::ThreadRestrictions::ScopedAllowIO allow_io;

[Aaron Boodman, 2011/11/29 05:32:25]

Move this up to the call site in profile_impl.cc. People who call this method
should have to think harder about what they are doing and whether its a good
idea.

[SeRya, 2011/11/29 21:31:00]

Removed completely. It's not necessary for the place it's used.

+
+  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()));

[Aaron Boodman, 2011/11/29 05:32:25]

What happens if the extension is already loaded? You should CHECK that it isn't
since we don't need or want to support that for now.

[SeRya, 2011/11/29 21:31:00]

Previous will be removed and unloaded.

+
+  ComponentExtensionInfo info(manifest.release(), absolute_path);

[Aaron Boodman, 2011/11/29 05:32:25]

Can you delegate to the Add() method that takes a manifest and a path here,
rather than duplicating code?

[SeRya, 2011/11/29 21:31:00]

Done.

+  component_extensions_.push_back(info);
+  if (extension_service_->is_ready())
+    return Load(info);
+  return NULL;
+}
+
 const Extension* ComponentLoader::Load(const ComponentExtensionInfo& info) {
   int flags = Extension::REQUIRE_KEY;
   if (Extension::ShouldDoStrictErrorChecking(Extension::COMPONENT))
     flags |= Extension::STRICT_ERROR_CHECKS;
   std::string error;
   scoped_refptr<const Extension> extension(Extension::Create(
       info.root_directory,
       Extension::COMPONENT,
       *info.manifest,
       flags,
@@ skipping 17 matching lines @@
   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);
 
   // Remove the extension from the list of registered extensions.
   *it = component_extensions_.back();
   component_extensions_.pop_back();
 
-  // Determine the extension id and unload the extension.
+  std::string id = GenerateId(manifest.get());
+  if (id.empty()) {
+    LOG(ERROR) << "Failed to get extension id";
+    return;
+  }
+  extension_service_->
+      UnloadExtension(id, extension_misc::UNLOAD_REASON_DISABLE);
+}
+
+void ComponentLoader::Remove(const std::string& id) {

[Aaron Boodman, 2011/11/29 05:32:25]

Don't duplicate code. One of these methods should delegate to the other.

[SeRya, 2011/11/29 21:31:00]

Done.

+  RegisteredComponentExtensions::iterator it = component_extensions_.begin();
+  for (; it != component_extensions_.end(); ++it) {
+    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;
+    }
+  }
+}
+
+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