Fix appcache_service and request_context referencing.

chrome/browser/profile.cc

 // Copyright (c) 2006-2008 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/profile.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 116 matching lines @@
 static void CleanupRequestContext(ChromeURLRequestContext* context) {
   if (context) {
     context->CleanupOnUIThread();
 
     // Clean up request context on IO thread.
     g_browser_process->io_thread()->message_loop()->ReleaseSoon(FROM_HERE,
                                                                 context);
   }
 }
 
-static void CleanupAppCacheService(ChromeAppCacheService* service) {
-  if (service) {
-    MessageLoop* io_thread = ChromeThread::GetMessageLoop(ChromeThread::IO);
+static void CleanupAppCacheService(ChromeAppCacheService* appcache_service) {
+  if (appcache_service) {
+    // The I/O thread may be NULL during testing.
+    base::Thread* io_thread = g_browser_process->io_thread();
     if (io_thread)
-      io_thread->ReleaseSoon(FROM_HERE, service);
+      io_thread->message_loop()->ReleaseSoon(FROM_HERE, appcache_service);
     else
-      service->Release();
+      appcache_service->Release();
   }
 }
 
 // static
 void Profile::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kSearchSuggestEnabled, true);
   prefs->RegisterBooleanPref(prefs::kSessionExitedCleanly, true);
   prefs->RegisterBooleanPref(prefs::kSafeBrowsingEnabled, true);
   // TODO(estade): IDS_SPELLCHECK_DICTIONARY should be an ASCII string.
   prefs->RegisterLocalizedStringPref(prefs::kSpellCheckDictionary,
@@ skipping 42 matching lines @@
 // to make it suitable for the off the record mode.
 //
 ////////////////////////////////////////////////////////////////////////////////
 class OffTheRecordProfileImpl : public Profile,
                                 public NotificationObserver {
  public:
   explicit OffTheRecordProfileImpl(Profile* real_profile)
       : profile_(real_profile),
         extensions_request_context_(NULL),
         start_time_(Time::Now()) {
-    request_context_ = ChromeURLRequestContext::CreateOffTheRecord(this);
+    // Created here but lazily inititialized later, finally released on
+    // on the io thread, see CleanupAppCacheService.
+    appcache_service_ = new ChromeAppCacheService();
+    appcache_service_->AddRef();
+
+    request_context_ = ChromeURLRequestContext::CreateOffTheRecord(
+        this, appcache_service_);
     request_context_->AddRef();
 
     // Register for browser close notifications so we can detect when the last
     // off-the-record window is closed, in which case we can clean our states
     // (cookies, downloads...).
     registrar_.Add(this, NotificationType::BROWSER_CLOSED,
                    NotificationService::AllSources());
   }
 
   virtual ~OffTheRecordProfileImpl() {
     CleanupRequestContext(request_context_);
     CleanupRequestContext(extensions_request_context_);
-    CleanupAppCacheService(appcache_service_.release());
+    CleanupAppCacheService(appcache_service_);
   }
 
   virtual FilePath GetPath() { return profile_->GetPath(); }
 
   virtual bool IsOffTheRecord() {
     return true;
   }
 
   virtual Profile* GetOffTheRecordProfile() {
     return this;
   }
 
   virtual void DestroyOffTheRecordProfile() {
     // Suicide is bad!
     NOTREACHED();
   }
 
   virtual Profile* GetOriginalProfile() {
     return profile_;
   }
 
   virtual ChromeAppCacheService* GetAppCacheService() {
-    if (!appcache_service_.get()) {
-      appcache_service_ = new ChromeAppCacheService();
-      appcache_service_->InitializeOnUIThread(
-          GetPath(), GetRequestContext(), true);
-    }
-    return appcache_service_.get();
+    DCHECK(request_context_);  // should be created in ctor
+    if (!appcache_service_->is_initialized())
+      appcache_service_->InitializeOnUIThread(GetPath(), true);
+    return appcache_service_;
   }
 
   virtual VisitedLinkMaster* GetVisitedLinkMaster() {
     // We don't provide access to the VisitedLinkMaster when we're OffTheRecord
     // because we don't want to leak the sites that the user has visited before.
     return NULL;
   }
 
   virtual ExtensionsService* GetExtensionsService() {
     return NULL;
@@ skipping 261 matching lines @@
 
   // The real underlying profile.
   Profile* profile_;
 
   // The context to use for requests made from this OTR session.
   ChromeURLRequestContext* request_context_;
 
   ChromeURLRequestContext* extensions_request_context_;
 
   // Use a seperate appcache service for OTR.
-  scoped_refptr<ChromeAppCacheService> appcache_service_;
+  ChromeAppCacheService* appcache_service_;
 
   // The download manager that only stores downloaded items in memory.
   scoped_refptr<DownloadManager> download_manager_;
 
   scoped_refptr<BrowserThemeProvider> theme_provider_;
 
   // Use a special WebKit context for OTR browsing.
   scoped_refptr<WebKitContext> webkit_context_;
 
   // We don't want SSLHostState from the OTR profile to leak back to the main
@@ skipping 32 matching lines @@
                             "profile files to the root directory!";
   create_session_service_timer_.Start(
       TimeDelta::FromMilliseconds(kCreateSessionServiceDelayMS), this,
       &ProfileImpl::EnsureSessionServiceCreated);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableExtensionTimelineApi)) {
     extension_devtools_manager_ = new ExtensionDevToolsManager(this);
   }
 
+  // Created here but lazily inititialized later, finally released on
+  // on the io thread, see CleanupAppCacheService.
+  appcache_service_ = new ChromeAppCacheService();
+  appcache_service_->AddRef();
+
   extension_process_manager_.reset(new ExtensionProcessManager(this));
   extension_message_service_ = new ExtensionMessageService(this);
 
   PrefService* prefs = GetPrefs();
   prefs->AddPrefObserver(prefs::kSpellCheckDictionary, this);
   prefs->AddPrefObserver(prefs::kEnableSpellCheck, this);
   prefs->AddPrefObserver(prefs::kEnableAutoSpellCorrect, this);
 
   if (CommandLine::ForCurrentProcess()->
       HasSwitch(switches::kPrivacyBlacklist)) {
@@ skipping 170 matching lines @@
     // We use default_request_context_ for OCSP.
     // Release URLRequestContext used in OCSP handlers.
     net::SetURLRequestContextForOCSP(NULL);
 #endif
     default_request_context_ = NULL;
   }
 
   CleanupRequestContext(request_context_);
   CleanupRequestContext(media_request_context_);
   CleanupRequestContext(extensions_request_context_);
-  CleanupAppCacheService(appcache_service_.release());
+  CleanupAppCacheService(appcache_service_);
 
   // When the request contexts are gone, the blacklist wont be needed anymore.
   delete blacklist_;
   blacklist_ = 0;
 
   // HistoryService may call into the BookmarkModel, as such we need to
   // delete HistoryService before the BookmarkModel. The destructor for
   // HistoryService will join with HistoryService's backend thread so that
   // by the time the destructor has finished we're sure it will no longer call
   // into the BookmarkModel.
@@ skipping 30 matching lines @@
 
 void ProfileImpl::DestroyOffTheRecordProfile() {
   off_the_record_profile_.reset();
 }
 
 Profile* ProfileImpl::GetOriginalProfile() {
   return this;
 }
 
 ChromeAppCacheService* ProfileImpl::GetAppCacheService() {
-  if (!appcache_service_.get()) {
-    appcache_service_ = new ChromeAppCacheService();
-    appcache_service_->InitializeOnUIThread(
-        GetPath(), GetRequestContext(), false);
+  if (!appcache_service_->is_initialized()) {
+    EnsureRequestContextCreated();
+    appcache_service_->InitializeOnUIThread(GetPath(), false);
   }
-  return appcache_service_.get();
+  return appcache_service_;
 }
 
 VisitedLinkMaster* ProfileImpl::GetVisitedLinkMaster() {
   if (!visited_link_master_.get()) {
     scoped_ptr<VisitedLinkMaster> visited_links(
       new VisitedLinkMaster(g_browser_process->file_thread(),
                             visited_link_event_listener_.get(), this));
     if (!visited_links->Init())
       return NULL;
     visited_link_master_.swap(visited_links);
@@ skipping 80 matching lines @@
 URLRequestContext* ProfileImpl::GetRequestContext() {
   if (!request_context_) {
     FilePath cookie_path = GetPath();
     cookie_path = cookie_path.Append(chrome::kCookieFilename);
     FilePath cache_path = base_cache_path_;
     int max_size;
     GetCacheParameters(kNormalContext, &cache_path, &max_size);
 
     cache_path = GetCachePath(cache_path);
     request_context_ = ChromeURLRequestContext::CreateOriginal(
-        this, cookie_path, cache_path, max_size);
+        this, cookie_path, cache_path, max_size, appcache_service_);
     request_context_->AddRef();
 
     // The first request context is always a normal (non-OTR) request context.
     // Even when Chromium is started in OTR mode, a normal profile is always
     // created first.
     if (!default_request_context_) {
       default_request_context_ = request_context_;
       NotificationService::current()->Notify(
           NotificationType::DEFAULT_REQUEST_CONTEXT_AVAILABLE,
           NotificationService::AllSources(), NotificationService::NoDetails());
@@ skipping 10 matching lines @@
 }
 
 URLRequestContext* ProfileImpl::GetRequestContextForMedia() {
   if (!media_request_context_) {
     FilePath cache_path = base_cache_path_;
     int max_size;
     GetCacheParameters(kMediaContext, &cache_path, &max_size);
 
     cache_path = GetMediaCachePath(cache_path);
     media_request_context_ = ChromeURLRequestContext::CreateOriginalForMedia(
-        this, cache_path, max_size);
+        this, cache_path, max_size, appcache_service_);
     media_request_context_->AddRef();
 
     DCHECK(media_request_context_->cookie_store());
   }
 
   return media_request_context_;
 }
 
 FaviconService* ProfileImpl::GetFaviconService(ServiceAccessType sat) {
   if (!favicon_service_created_) {
@@ skipping 399 matching lines @@
 #endif
   return NULL;
 }
 
 void ProfileImpl::InitSyncService() {
 #ifdef CHROME_PERSONALIZATION
   sync_service_.reset(new ProfileSyncService(this));
   sync_service_->Initialize();
 #endif
 }