Ensure ChromeURLRequestContext finds out first about extension loading

chrome/browser/net/chrome_url_request_context.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/net/chrome_url_request_context.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/privacy_blacklist/blacklist.h"
@@ skipping 349 matching lines @@
     }
   }
 
   if (profile->GetUserScriptMaster())
     user_script_dir_path_ = profile->GetUserScriptMaster()->user_script_dir();
 
   prefs_->AddPrefObserver(prefs::kAcceptLanguages, this);
   prefs_->AddPrefObserver(prefs::kCookieBehavior, this);
   prefs_->AddPrefObserver(prefs::kDefaultCharset, this);
 
-  if (!is_off_the_record_) {
-    registrar_.Add(this, NotificationType::EXTENSION_LOADED,
-                   NotificationService::AllSources());
-    registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
-                   NotificationService::AllSources());
-  }
-
   ssl_config_service_ = profile->GetSSLConfigService();
 }
 
 ChromeURLRequestContext::ChromeURLRequestContext(
     ChromeURLRequestContext* other) {
   // Set URLRequestContext members
   host_resolver_ = other->host_resolver_;
   proxy_service_ = other->proxy_service_;
   ssl_config_service_ = other->ssl_config_service_;
   http_transaction_factory_ = other->http_transaction_factory_;
@@ skipping 38 matching lines @@
                             &ChromeURLRequestContext::OnCookiePolicyChange,
                             policy_type));
     } else if (*pref_name_in == prefs::kDefaultCharset) {
       std::string default_charset =
           WideToASCII(prefs->GetString(prefs::kDefaultCharset));
       g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
           NewRunnableMethod(this,
                             &ChromeURLRequestContext::OnDefaultCharsetChange,
                             default_charset));
     }
-  } else if (NotificationType::EXTENSION_LOADED == type) {
-    ExtensionPaths* new_paths = new ExtensionPaths;
-    Extension* extension = Details<Extension>(details).ptr();
-    DCHECK(extension);
-    new_paths->insert(ExtensionPaths::value_type(extension->id(),
-                                                 extension->path()));
-    g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &ChromeURLRequestContext::OnNewExtensions,
-                          new_paths));
-  } else if (NotificationType::EXTENSION_UNLOADED == type) {
-    Extension* extension = Details<Extension>(details).ptr();
-    g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &ChromeURLRequestContext::OnUnloadedExtension,
-                          extension->id()));
   } else {
     NOTREACHED();
   }
 }
 
 void ChromeURLRequestContext::CleanupOnUIThread() {
   // Unregister for pref notifications.
   prefs_->RemovePrefObserver(prefs::kAcceptLanguages, this);
   prefs_->RemovePrefObserver(prefs::kCookieBehavior, this);
   prefs_->RemovePrefObserver(prefs::kDefaultCharset, this);
@@ skipping 73 matching lines @@
 
 void ChromeURLRequestContext::OnDefaultCharsetChange(
     const std::string& default_charset) {
   DCHECK(MessageLoop::current() ==
          ChromeThread::GetMessageLoop(ChromeThread::IO));
   referrer_charset_ = default_charset;
   accept_charset_ =
       net::HttpUtil::GenerateAcceptCharsetHeader(default_charset);
 }
 
-void ChromeURLRequestContext::OnNewExtensions(ExtensionPaths* new_paths) {
-  extension_paths_.insert(new_paths->begin(), new_paths->end());
-  delete new_paths;
+void ChromeURLRequestContext::OnNewExtensions(const std::string& id,
+                                              const FilePath& path) {
+  if (!is_off_the_record_) {

[Matt Perry, 2009/10/01 22:33:59]

nit: remove braces

+    extension_paths_[id] = path;
+  }
 }
 
-void ChromeURLRequestContext::OnUnloadedExtension(
-    const std::string& extension_id) {
-  ExtensionPaths::iterator iter = extension_paths_.find(extension_id);
+void ChromeURLRequestContext::OnUnloadedExtension(const std::string& id) {
+  if (is_off_the_record_)
+    return;
+  ExtensionPaths::iterator iter = extension_paths_.find(id);
   DCHECK(iter != extension_paths_.end());
   extension_paths_.erase(iter);
 }
 
 ChromeURLRequestContext::~ChromeURLRequestContext() {
   DCHECK(NULL == prefs_);
 
   if (appcache_service_.get() && appcache_service_->request_context() == this)
     appcache_service_->set_request_context(NULL);
 
   NotificationService::current()->Notify(
       NotificationType::URL_REQUEST_CONTEXT_RELEASED,
       Source<URLRequestContext>(this),
       NotificationService::NoDetails());
 
   delete ftp_transaction_factory_;
   delete http_transaction_factory_;
 }