Fix appcache_service and request_context referencing.

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 92 matching lines @@
       proxy_config.get(),
       use_v8,
       context,
       g_browser_process->io_thread()->message_loop(),
       g_browser_process->file_thread()->message_loop());
 }
 
 // static
 ChromeURLRequestContext* ChromeURLRequestContext::CreateOriginal(
     Profile* profile, const FilePath& cookie_store_path,
-    const FilePath& disk_cache_path, int cache_size) {
+    const FilePath& disk_cache_path, int cache_size,
+    ChromeAppCacheService* appcache_service) {
   DCHECK(!profile->IsOffTheRecord());
-  ChromeURLRequestContext* context = new ChromeURLRequestContext(profile);
+  ChromeURLRequestContext* context = new ChromeURLRequestContext(
+      profile, appcache_service);
+
+  // The appcache service uses the profile's original context for UpdateJobs.
+  DCHECK(!appcache_service->request_context());
+  appcache_service->set_request_context(context);
 
   // Global host resolver for the context.
   context->host_resolver_ = chrome_browser_net::GetGlobalHostResolver();
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   context->proxy_service_ = CreateProxyService(context, command_line);
 
   net::HttpCache* cache =
       new net::HttpCache(context->host_resolver_,
@@ skipping 36 matching lines @@
             cookie_store_path,
             g_browser_process->db_thread()->message_loop());
     context->cookie_store_ = new net::CookieMonster(cookie_db.get());
   }
 
   return context;
 }
 
 // static
 ChromeURLRequestContext* ChromeURLRequestContext::CreateOriginalForMedia(
-    Profile* profile, const FilePath& disk_cache_path, int cache_size) {
+    Profile* profile, const FilePath& disk_cache_path, int cache_size,
+    ChromeAppCacheService* appcache_service) {
   DCHECK(!profile->IsOffTheRecord());
   return CreateRequestContextForMedia(profile, disk_cache_path, cache_size,
-                                      false);
+                                      false, appcache_service);
 }
 
 // static
 ChromeURLRequestContext* ChromeURLRequestContext::CreateOriginalForExtensions(
     Profile* profile, const FilePath& cookie_store_path) {
   DCHECK(!profile->IsOffTheRecord());
-  ChromeURLRequestContext* context = new ChromeURLRequestContext(profile);
+  ChromeURLRequestContext* context = new ChromeURLRequestContext(
+      profile, NULL);
 
   // All we care about for extensions is the cookie store.
   DCHECK(!cookie_store_path.empty());
 
   scoped_refptr<SQLitePersistentCookieStore> cookie_db =
       new SQLitePersistentCookieStore(
           cookie_store_path,
           g_browser_process->db_thread()->message_loop());
   net::CookieMonster* cookie_monster = new net::CookieMonster(cookie_db.get());
 
   // Enable cookies for extension URLs only.
   const char* schemes[] = {chrome::kExtensionScheme};
   cookie_monster->SetCookieableSchemes(schemes, 1);
   context->cookie_store_ = cookie_monster;
 
   return context;
 }
 
 // static
 ChromeURLRequestContext* ChromeURLRequestContext::CreateOffTheRecord(
-    Profile* profile) {
+    Profile* profile, ChromeAppCacheService* appcache_service) {
   DCHECK(profile->IsOffTheRecord());
-  ChromeURLRequestContext* context = new ChromeURLRequestContext(profile);
+  ChromeURLRequestContext* context = new ChromeURLRequestContext(
+      profile, appcache_service);
+
+  // The appcache service uses the profile's original context for UpdateJobs.
+  DCHECK(!appcache_service->request_context());
+  appcache_service->set_request_context(context);
 
   // Share the same proxy service and host resolver as the original profile.
   // TODO(eroman): although ProxyService is reference counted, this sharing
   // still has a subtle dependency on the lifespan of the original profile --
   // ProxyService holds a (non referencing) pointer to the URLRequestContext
   // it uses to download PAC scripts, which in this case is the original
   // profile...
   context->host_resolver_ =
       profile->GetOriginalProfile()->GetRequestContext()->host_resolver();
   context->proxy_service_ =
@@ skipping 20 matching lines @@
       new net::FtpNetworkLayer(context->host_resolver_);
 #endif
 
   return context;
 }
 
 // static
 ChromeURLRequestContext*
 ChromeURLRequestContext::CreateOffTheRecordForExtensions(Profile* profile) {
   DCHECK(profile->IsOffTheRecord());
-  ChromeURLRequestContext* context = new ChromeURLRequestContext(profile);
+  ChromeURLRequestContext* context =
+      new ChromeURLRequestContext(profile, NULL);
   net::CookieMonster* cookie_monster = new net::CookieMonster;
 
   // Enable cookies for extension URLs only.
   const char* schemes[] = {chrome::kExtensionScheme};
   cookie_monster->SetCookieableSchemes(schemes, 1);
   context->cookie_store_ = cookie_monster;
 
   return context;
 }
 
 // static
 ChromeURLRequestContext* ChromeURLRequestContext::CreateRequestContextForMedia(
     Profile* profile, const FilePath& disk_cache_path, int cache_size,
-    bool off_the_record) {
+    bool off_the_record, ChromeAppCacheService* appcache_service) {
   URLRequestContext* original_context =
       profile->GetOriginalProfile()->GetRequestContext();
-  ChromeURLRequestContext* context = new ChromeURLRequestContext(profile);
+  ChromeURLRequestContext* context =
+      new ChromeURLRequestContext(profile, appcache_service);
   context->is_media_ = true;
 
   // Share the same proxy service of the common profile.
   context->proxy_service_ = original_context->proxy_service();
   // Also share the cookie store of the common profile.
   context->cookie_store_ = original_context->cookie_store();
 
   // Create a media cache with default size.
   // TODO(hclam): make the maximum size of media cache configurable.
   net::HttpCache* original_cache =
@@ skipping 20 matching lines @@
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableByteRangeSupport))
     cache->set_enable_range_support(true);
 
   cache->set_type(net::MEDIA_CACHE);
   context->http_transaction_factory_ = cache;
   return context;
 }
 
-ChromeURLRequestContext::ChromeURLRequestContext(Profile* profile)
-    : prefs_(profile->GetPrefs()),
+ChromeURLRequestContext::ChromeURLRequestContext(
+    Profile* profile, ChromeAppCacheService* appcache_service)
+    : appcache_service_(appcache_service),
+      prefs_(profile->GetPrefs()),
       is_media_(false),
       is_off_the_record_(profile->IsOffTheRecord()) {
   // Set up Accept-Language and Accept-Charset header values
   accept_language_ = net::HttpUtil::GenerateAcceptLanguageHeader(
       WideToASCII(prefs_->GetString(prefs::kAcceptLanguages)));
   std::string default_charset =
       WideToASCII(prefs_->GetString(prefs::kDefaultCharset));
   accept_charset_ =
       net::HttpUtil::GenerateAcceptCharsetHeader(default_charset);
 
@@ skipping 35 matching lines @@
   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();
-
-  appcache_service_ = profile->GetAppCacheService();
 }
 
 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_;
   ftp_transaction_factory_ = other->ftp_transaction_factory_;
   cookie_store_ = other->cookie_store_;
   cookie_policy_.set_type(other->cookie_policy_.type());
   strict_transport_security_state_ = other->strict_transport_security_state_;
   accept_language_ = other->accept_language_;
   accept_charset_ = other->accept_charset_;
   referrer_charset_ = other->referrer_charset_;
 
   // Set ChromeURLRequestContext members
+  appcache_service_ = other->appcache_service_;
   extension_paths_ = other->extension_paths_;
   user_script_dir_path_ = other->user_script_dir_path_;
   prefs_ = other->prefs_;
   blacklist_ = other->blacklist_;
   is_media_ = other->is_media_;
   is_off_the_record_ = other->is_off_the_record_;
-  appcache_service_ = other->appcache_service_;
 }
 
 // NotificationObserver implementation.
 void ChromeURLRequestContext::Observe(NotificationType type,
                                       const NotificationSource& source,
                                       const NotificationDetails& details) {
   if (NotificationType::PREF_CHANGED == type) {
     std::wstring* pref_name_in = Details<std::wstring>(details).ptr();
     PrefService* prefs = Source<PrefService>(source).ptr();
     DCHECK(pref_name_in && prefs);
@@ skipping 134 matching lines @@
 void ChromeURLRequestContext::OnUnloadedExtension(
     const std::string& extension_id) {
   ExtensionPaths::iterator iter = extension_paths_.find(extension_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_;
 }