override chrome:// URLs via extensions.

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"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
+#include "chrome/browser/extensions/extension_dom_ui.h"
 #include "chrome/browser/extensions/extension_file_util.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/extensions/external_extension_provider.h"
 #include "chrome/browser/extensions/external_pref_extension_provider.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_reporter.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
@@ skipping 162 matching lines @@
 
   extension_prefs_->OnExtensionUninstalled(extension, external_uninstall);
 
   // Tell the backend to start deleting installed extensions on the file thread.
   if (Extension::LOAD != extension->location()) {
     backend_loop_->PostTask(FROM_HERE, NewRunnableFunction(
       &extension_file_util::UninstallExtension, extension_id,
       install_directory_));
   }
 
+  ExtensionDOMUI::UnregisterChromeURLOverrides(profile_,
+      extension->GetChromeURLOverrides());
+
   UnloadExtension(extension_id);
 }
 
 void ExtensionsService::EnableExtension(const std::string& extension_id) {
   Extension* extension = GetExtensionByIdInternal(extension_id, false, true);
   if (!extension) {
     NOTREACHED() << "Trying to enable an extension that isn't disabled.";
     return;
   }
 
   // Move it over to the enabled list.
   extension_prefs_->SetExtensionState(extension, Extension::ENABLED);
   extensions_.push_back(extension);
   ExtensionList::iterator iter = std::find(disabled_extensions_.begin(),
                                            disabled_extensions_.end(),
                                            extension);
   disabled_extensions_.erase(iter);
 
+  ExtensionDOMUI::RegisterChromeURLOverrides(profile_,
+      extension->GetChromeURLOverrides());
+
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_LOADED,
       Source<ExtensionsService>(this),
       Details<Extension>(extension));
 }
 
 void ExtensionsService::LoadExtension(const FilePath& extension_path) {
   backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
       &ExtensionsServiceBackend::LoadSingleExtension,
       extension_path, scoped_refptr<ExtensionsService>(this)));
@@ skipping 81 matching lines @@
       scoped_refptr<ExtensionsService>(this)));
 }
 
 void ExtensionsService::UnloadExtension(const std::string& extension_id) {
   scoped_ptr<Extension> extension(
       GetExtensionByIdInternal(extension_id, true, true));
 
   // Callers should not send us nonexistant extensions.
   CHECK(extension.get());
 
+  ExtensionDOMUI::UnregisterChromeURLOverrides(profile_,
+      extension->GetChromeURLOverrides());
+
   ExtensionList::iterator iter = std::find(disabled_extensions_.begin(),
                                            disabled_extensions_.end(),
                                            extension.get());
   if (iter != disabled_extensions_.end()) {
     disabled_extensions_.erase(iter);
     NotificationService::current()->Notify(
         NotificationType::EXTENSION_UNLOADED_DISABLED,
         Source<ExtensionsService>(this),
         Details<Extension>(extension.get()));
     return;
@@ skipping 90 matching lines @@
         NotificationService::current()->Notify(
             NotificationType::EXTENSION_LOADED,
             Source<ExtensionsService>(this),
             Details<Extension>(extension));
 
         if (extension->IsTheme() && extension->location() == Extension::LOAD) {
           NotificationService::current()->Notify(
               NotificationType::THEME_INSTALLED,
               Source<ExtensionsService>(this),
               Details<Extension>(extension));
+        } else {
+          ExtensionDOMUI::RegisterChromeURLOverrides(profile_,
+              extension->GetChromeURLOverrides());
         }
         break;
       case Extension::DISABLED:
         disabled_extensions_.push_back(scoped_extension.release());
         break;
       default:
         break;
     }
   }
 }
@@ skipping 236 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));
 }