Fix "crashed extension" infobar browser crashes....

chrome/browser/extensions/extensions_service.cc

 // Copyright (c) 2009 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/command_line.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "base/values.h"
@@ skipping 89 matching lines @@
     int update_frequency = kDefaultUpdateFrequencySeconds;
     if (command_line->HasSwitch(switches::kExtensionsUpdateFrequency)) {
       update_frequency = StringToInt(WideToASCII(command_line->GetSwitchValue(
           switches::kExtensionsUpdateFrequency)));
     }
     updater_ = new ExtensionUpdater(this, prefs, update_frequency,
         backend_loop_, ChromeThread::GetMessageLoop(ChromeThread::IO));
   }
 
   backend_ = new ExtensionsServiceBackend(install_directory_, frontend_loop);
+
+  registrar_.Add(this, NotificationType::EXTENSION_PROCESS_CRASHED,
+                 Source<ExtensionsService>(this));
 }
 
 ExtensionsService::~ExtensionsService() {
   UnloadAllExtensions();
   if (updater_.get()) {
     updater_->Stop();
   }
 }
 
 void ExtensionsService::Init() {
@@ skipping 32 matching lines @@
 
   CrxInstaller::Start(extension_path, install_directory_, Extension::INTERNAL,
                       id,
                       true,  // delete crx when complete
                       backend_loop_,
                       this,
                       NULL);  // no client (silent install)
 }
 
 void ExtensionsService::ReloadExtension(const std::string& extension_id) {
-  Extension* extension = GetExtensionById(extension_id);
-  FilePath extension_path = extension->path();
+  // Unload the extension if it's loaded.
+  if (GetExtensionById(extension_id))
+    UnloadExtension(extension_id);
 
-  UnloadExtension(extension_id);
-  LoadExtension(extension_path);
+  // At this point we have to reconstruct the path from prefs, because
+  // we have no information about this extension in memory.
+  LoadExtension(extension_prefs_->GetExtensionPath(extension_id));
 }
 
 void ExtensionsService::UninstallExtension(const std::string& extension_id,
                                            bool external_uninstall) {
   Extension* extension = GetExtensionByIdInternal(extension_id, true, true);
 
   // Callers should not send us nonexistant extensions.
   DCHECK(extension);
 
   extension_prefs_->OnExtensionUninstalled(extension, external_uninstall);
@@ skipping 325 matching lines @@
     }
   }
 
   CrxInstaller::Start(path, install_directory_, location, id,
                       false,  // don't delete crx when complete
                       backend_loop_,
                       this,
                       NULL);  // no client (silent install)
 }
 
+void ExtensionsService::Observe(NotificationType type,
+                                const NotificationSource& source,
+                                const NotificationDetails& details) {
+  switch (type.value) {
+    case NotificationType::EXTENSION_PROCESS_CRASHED: {
+        DCHECK_EQ(this, Source<ExtensionsService>(source).ptr());
+        ExtensionHost* host = Details<ExtensionHost>(details).ptr();
+
+        // Unload the entire extension to make sure its state is consistent
+        // (either fully operational, or fully unloaded, but not half-crashed).
+        UnloadExtension(host->extension()->id());
+      }
+      break;
+
+    default:
+      NOTREACHED();
+  }
+}
+
 
 // ExtensionsServicesBackend
 
 ExtensionsServiceBackend::ExtensionsServiceBackend(
     const FilePath& install_directory, MessageLoop* frontend_loop)
         : frontend_(NULL),
           install_directory_(install_directory),
           alert_on_error_(false),
           frontend_loop_(frontend_loop) {
   // TODO(aa): This ends up doing blocking IO on the UI thread because it reads
@@ skipping 186 matching lines @@
       linked_ptr<ExternalExtensionProvider>(test_provider);
 }
 
 void ExtensionsServiceBackend::OnExternalExtensionFound(
     const std::string& id, const Version* version, const FilePath& path,
     Extension::Location location) {
   frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(frontend_,
       &ExtensionsService::OnExternalExtensionFound, id, version->GetString(),
       path, location));
 }