Ensure ChromeURLRequestContext finds out first about extension loading

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/browser_process.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/browser/net/chrome_url_request_context.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"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/url_constants.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/extensions/external_registry_extension_provider_win.h"
@@ skipping 204 matching lines @@
   // Move it over to the enabled list.
   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));
+  NotifyExtensionLoaded(extension);
 }
 
 void ExtensionsService::DisableExtension(const std::string& extension_id) {
   Extension* extension = GetExtensionByIdInternal(extension_id, true, false);
   if (!extension) {
     NOTREACHED() << "Trying to disable an extension that isn't enabled.";
     return;
   }
 
   // Remember that we disabled it, unless it's temporary.
   if (extension->location() != Extension::LOAD)
     extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
 
   // Move it over to the disabled list.
   disabled_extensions_.push_back(extension);
   ExtensionList::iterator iter = std::find(extensions_.begin(),
                                            extensions_.end(),
                                            extension);
   extensions_.erase(iter);
 
   ExtensionDOMUI::UnregisterChromeURLOverrides(profile_,
       extension->GetChromeURLOverrides());
 
-  NotificationService::current()->Notify(
-      NotificationType::EXTENSION_UNLOADED,
-      Source<ExtensionsService>(this),
-      Details<Extension>(extension));
+  NotifyExtensionUnloaded(extension);
 }
 
 void ExtensionsService::LoadExtension(const FilePath& extension_path) {
   backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
       &ExtensionsServiceBackend::LoadSingleExtension,
       extension_path, scoped_refptr<ExtensionsService>(this)));
 }
 
 void ExtensionsService::LoadAllExtensions() {
   // Load the previously installed extensions.
@@ skipping 31 matching lines @@
   OnExtensionLoaded(extension, true);
 
   if (location == Extension::EXTERNAL_PREF ||
       location == Extension::EXTERNAL_REGISTRY) {
     backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
         &ExtensionsServiceBackend::CheckExternalUninstall,
         scoped_refptr<ExtensionsService>(this), id, location));
   }
 }
 
+void ExtensionsService::NotifyExtensionLoaded(Extension* extension) {
+  LOG(INFO) << "Sending EXTENSION_LOADED";
+
+  // The ChromeURLRequestContext needs to be first to know that the extension
+  // was loaded, otherwise a race can arise where a renderer that is created
+  // for the extension may try to load an extension URL with an extension id
+  // that the request context doesn't yet know about.
+  if (profile_ && !profile_->IsOffTheRecord()) {
+    ChromeURLRequestContext* context = static_cast<ChromeURLRequestContext*>(
+        profile_->GetRequestContext());
+    if (context) {
+      g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
+          NewRunnableMethod(context,
+                            &ChromeURLRequestContext::OnNewExtensions,
+                            extension->id(),
+                            extension->path()));
+    }
+  }
+
+  NotificationService::current()->Notify(
+      NotificationType::EXTENSION_LOADED,
+      Source<ExtensionsService>(this),
+      Details<Extension>(extension));
+}
+
+void ExtensionsService::NotifyExtensionUnloaded(Extension* extension) {
+  LOG(INFO) << "Sending EXTENSION_UNLOADED";
+
+  NotificationService::current()->Notify(
+      NotificationType::EXTENSION_UNLOADED,
+      Source<ExtensionsService>(this),
+      Details<Extension>(extension));
+
+  if (profile_ && !profile_->IsOffTheRecord()) {
+    ChromeURLRequestContext* context = static_cast<ChromeURLRequestContext*>(
+        profile_->GetRequestContext());
+    if (context) {
+      g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
+          NewRunnableMethod(context,
+                            &ChromeURLRequestContext::OnUnloadedExtension,
+                            extension->id()));
+    }
+  }
+}
+
 std::vector<ExtensionAction*> ExtensionsService::GetExtensionActions(
     ExtensionAction::ExtensionActionType action_type) const {
   std::vector<ExtensionAction*> result;
 
   // TODO(finnur): Sort the icons in some meaningful way.
   for (ExtensionList::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     if (action_type == ExtensionAction::PAGE_ACTION) {
       const ExtensionActionMap* page_actions = &(*iter)->page_actions();
       for (ExtensionActionMap::const_iterator i(page_actions->begin());
@@ skipping 69 matching lines @@
         Source<ExtensionsService>(this),
         Details<Extension>(extension.get()));
     return;
   }
 
   iter = std::find(extensions_.begin(), extensions_.end(), extension.get());
 
   // Remove the extension from our list.
   extensions_.erase(iter);
 
-  // Tell other services the extension is gone.
-  NotificationService::current()->Notify(NotificationType::EXTENSION_UNLOADED,
-                                         Source<ExtensionsService>(this),
-                                         Details<Extension>(extension.get()));
+  NotifyExtensionUnloaded(extension.get());
 }
 
 void ExtensionsService::UnloadAllExtensions() {
   ExtensionList::iterator iter;
   for (iter = extensions_.begin(); iter != extensions_.end(); ++iter)
     delete *iter;
   extensions_.clear();
 
   // TODO(erikkay) should there be a notification for this?  We can't use
   // EXTENSION_UNLOADED since that implies that the extension has been disabled
@@ skipping 61 matching lines @@
       }
     }
 
     switch (extension_prefs_->GetExtensionState(extension->id())) {
       case Extension::ENABLED:
         extensions_.push_back(scoped_extension.release());
 
         if (extension->location() != Extension::LOAD)
           extension_prefs_->MigrateToPrefs(extension);
 
-        LOG(INFO) << "Sending EXTENSION_LOADED";
-        NotificationService::current()->Notify(
-            NotificationType::EXTENSION_LOADED,
-            Source<ExtensionsService>(this),
-            Details<Extension>(extension));
+        NotifyExtensionLoaded(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());
         }
@@ skipping 252 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));
 }