Adding the --load-component-extension flag.

chrome/common/extensions/extension_file_util.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/common/extensions/extension_file_util.h"
 
 #include <map>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 75 matching lines @@
   // We don't care about the return value. If this fails (and it can, due to
   // plugins that aren't unloaded yet, it will get cleaned up by
   // ExtensionService::GarbageCollectExtensions).
   file_util::Delete(extensions_dir.AppendASCII(id), true);  // recursive.
 }
 
 scoped_refptr<Extension> LoadExtension(const FilePath& extension_path,
                                        Extension::Location location,
                                        int flags,
                                        std::string* error) {
+  scoped_ptr<DictionaryValue> manifest(LoadManifest(extension_path, error));
+  if (!manifest.get())
+    return NULL;
+  if (!extension_l10n_util::LocalizeExtension(extension_path, manifest.get(),
+                                              error))
+    return NULL;
+
+  scoped_refptr<Extension> extension(Extension::Create(
+      extension_path,
+      location,
+      *manifest,
+      flags,
+      error));
+  if (!extension.get())
+    return NULL;
+
+  if (!ValidateExtension(extension.get(), error))
+    return NULL;
+
+  return extension;
+}
+
+DictionaryValue* LoadManifest(const FilePath& extension_path,
+                              std::string* error) {
   FilePath manifest_path =
       extension_path.Append(Extension::kManifestFilename);
   if (!file_util::PathExists(manifest_path)) {
     *error = l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_UNREADABLE);
     return NULL;
   }
 
   JSONFileValueSerializer serializer(manifest_path);
   scoped_ptr<Value> root(serializer.Deserialize(NULL, error));
   if (!root.get()) {
     if (error->empty()) {
       // If |error| is empty, than the file could not be read.
       // It would be cleaner to have the JSON reader give a specific error
       // in this case, but other code tests for a file error with
       // error->empty().  For now, be consistent.
       *error = l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_UNREADABLE);
     } else {
       *error = base::StringPrintf("%s  %s",
                                   errors::kManifestParseError,
                                   error->c_str());
     }
     return NULL;
   }
 
   if (!root->IsType(Value::TYPE_DICTIONARY)) {
     *error = l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_INVALID);
     return NULL;
   }
 
-  DictionaryValue* manifest = static_cast<DictionaryValue*>(root.get());
-  if (!extension_l10n_util::LocalizeExtension(extension_path, manifest, error))
-    return NULL;
-
-  scoped_refptr<Extension> extension(Extension::Create(
-      extension_path,
-      location,
-      *manifest,
-      flags,
-      error));
-  if (!extension.get())
-    return NULL;
-
-  if (!ValidateExtension(extension.get(), error))
-    return NULL;
-
-  return extension;
+  return static_cast<DictionaryValue*>(root.release());
 }
 
 bool ValidateExtension(const Extension* extension, std::string* error) {
   // Validate icons exist.
   for (ExtensionIconSet::IconMap::const_iterator iter =
            extension->icons().map().begin();
        iter != extension->icons().map().end();
        ++iter) {
     const FilePath path = extension->GetResource(iter->second).GetFilePath();
     if (!file_util::PathExists(path)) {
@@ skipping 489 matching lines @@
     return temp_path;
 
   return FilePath();
 }
 
 void DeleteFile(const FilePath& path, bool recursive) {
   file_util::Delete(path, recursive);
 }
 
 }  // namespace extension_file_util