Handle termination/crashes of an extension hosted in the ExtensionDialog.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2012 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/extension_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
+#include "base/json/json_value_serializer.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 656 matching lines @@
 
   if (out_crx_installer)
     *out_crx_installer = installer;
 
   return true;
 }
 
 void ExtensionService::ReloadExtension(const std::string& extension_id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FilePath path;
-  const Extension* current_extension = GetExtensionById(extension_id, false);
+  const Extension* current_extension = GetExtensionByIdInternal(extension_id,
+                                                                true,
+                                                                true,
+                                                                true);
+
+  // We have no knowledge of this extension ever having even existed,
+  // we can't 'reload' it.
+  if (!current_extension)
+    return;
 
   // Disable the extension if it's loaded. It might not be loaded if it crashed.
-  if (current_extension) {
+  if (IsExtensionEnabled(extension_id)) {
     // If the extension has an inspector open for its background page, detach
     // the inspector and hang onto a cookie for it, so that we can reattach
     // later.
     ExtensionProcessManager* manager = profile_->GetExtensionProcessManager();
     ExtensionHost* host = manager->GetBackgroundHostForExtension(extension_id);
     if (host && DevToolsAgentHostRegistry::HasDevToolsAgentHost(
             host->render_view_host())) {
       // Look for an open inspector for the background page.
       DevToolsAgentHost* agent =
           DevToolsAgentHostRegistry::GetDevToolsAgentHost(
               host->render_view_host());
       int devtools_cookie =
           content::DevToolsManager::GetInstance()->DetachClientHost(agent);
       if (devtools_cookie >= 0)
         orphaned_dev_tools_[extension_id] = devtools_cookie;
     }
 
     path = current_extension->path();
     DisableExtension(extension_id);
     disabled_extension_paths_[extension_id] = path;
   } else {
     path = unloaded_extension_paths_[extension_id];
   }
 
+  // If we're reloading a component extension, use the component extension
+  // loader's reloader.
+  if (current_extension->location() == Extension::COMPONENT) {
+    component_loader_->Reload(extension_id);
+    return;
+  }
+
   // Check the installed extensions to see if what we're reloading was already
   // installed.
   scoped_ptr<ExtensionInfo> installed_extension(
       extension_prefs_->GetInstalledExtensionInfo(extension_id));
   if (installed_extension.get() &&
       installed_extension->extension_manifest.get()) {
     extensions::InstalledLoader(this).Load(*installed_extension, false);
   } else {
     // Otherwise, the extension is unpacked (location LOAD).
     // We should always be able to remember the extension's path. If it's not in
@@ skipping 1963 matching lines @@
   //
   // To coexist with certain unit tests that don't have an IO thread message
   // loop available at ExtensionService shutdown, we lazy-initialize this
   // object so that those cases neither create nor destroy a SocketController.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!socket_controller_) {
     socket_controller_ = new extensions::SocketController();
   }
   return socket_controller_;
 }