Remove the restriction that ChromeURLRequestContextGetter needs to be release...

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 "app/theme_provider.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 111 matching lines @@
          file_util::PathExists(GetMediaCachePath(dir));
 }
 
 }  // namespace
 
 // A pointer to the request context for the default profile.  See comments on
 // Profile::GetDefaultRequestContext.
 URLRequestContextGetter* Profile::default_request_context_;
 
 static void CleanupRequestContext(ChromeURLRequestContextGetter* context) {
-  if (context) {
+  if (context)
     context->CleanupOnUIThread();
-
-    // Clean up request context on IO thread.
-    ChromeThread::ReleaseSoon(ChromeThread::IO, FROM_HERE, context);
-  }
 }
 
 // static
 const ProfileId Profile::InvalidProfileId = static_cast<ProfileId>(0);
 
 // static
 void Profile::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kSearchSuggestEnabled, true);
   prefs->RegisterBooleanPref(prefs::kSessionExitedCleanly, true);
   prefs->RegisterBooleanPref(prefs::kSafeBrowsingEnabled, true);
@@ skipping 45 matching lines @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 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_ = ChromeURLRequestContextGetter::CreateOffTheRecord(this);
-    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_);
@@ skipping 179 matching lines @@
 
   virtual URLRequestContextGetter* GetRequestContextForMedia() {
     // In OTR mode, media request context is the same as the original one.
     return request_context_;
   }
 
   URLRequestContextGetter* GetRequestContextForExtensions() {
     if (!extensions_request_context_) {
       extensions_request_context_ =
           ChromeURLRequestContextGetter::CreateOffTheRecordForExtensions(this);
-      extensions_request_context_->AddRef();
     }
 
     return extensions_request_context_;
   }
 
   virtual net::SSLConfigService* GetSSLConfigService() {
     return GetOriginalProfile()->GetSSLConfigService();
   }
 
   virtual Blacklist* GetBlacklist() {
@@ skipping 128 matching lines @@
       ExitedOffTheRecordMode();
   }
 
  private:
   NotificationRegistrar registrar_;
 
   // The real underlying profile.
   Profile* profile_;
 
   // The context to use for requests made from this OTR session.
-  ChromeURLRequestContextGetter* request_context_;
+  scoped_refptr<ChromeURLRequestContextGetter> request_context_;
 
-  ChromeURLRequestContextGetter* extensions_request_context_;
+  scoped_refptr<ChromeURLRequestContextGetter> extensions_request_context_;
 
   // The download manager that only stores downloaded items in memory.
   scoped_refptr<DownloadManager> download_manager_;
 
   // 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
   // profile because then the main profile would learn some of the host names
   // the user visited while OTR.
@@ skipping 366 matching lines @@
   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_ = ChromeURLRequestContextGetter::CreateOriginal(
         this, cookie_path, cache_path, max_size);
-    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_;
       // TODO(eroman): this isn't terribly useful anymore now that the
       // URLRequestContext is constructed by the IO thread...
       NotificationService::current()->Notify(
           NotificationType::DEFAULT_REQUEST_CONTEXT_AVAILABLE,
           NotificationService::AllSources(), NotificationService::NoDetails());
     }
   }
 
   return request_context_;
 }
 
 URLRequestContextGetter* 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_ =
         ChromeURLRequestContextGetter::CreateOriginalForMedia(
             this, cache_path, max_size);
-    media_request_context_->AddRef();
   }
 
   return media_request_context_;
 }
 
 FaviconService* ProfileImpl::GetFaviconService(ServiceAccessType sat) {
   if (!favicon_service_created_) {
     favicon_service_created_ = true;
     scoped_refptr<FaviconService> service(new FaviconService(this));
     favicon_service_.swap(service);
   }
   return favicon_service_.get();
 }
 
 URLRequestContextGetter* ProfileImpl::GetRequestContextForExtensions() {
   if (!extensions_request_context_) {
     FilePath cookie_path = GetPath();
     cookie_path = cookie_path.Append(chrome::kExtensionsCookieFilename);
 
     extensions_request_context_ =
         ChromeURLRequestContextGetter::CreateOriginalForExtensions(
             this, cookie_path);
-    extensions_request_context_->AddRef();
   }
 
   return extensions_request_context_;
 }
 
 net::SSLConfigService* ProfileImpl::GetSSLConfigService() {
   return ssl_config_service_manager_->Get();
 }
 
 Blacklist* ProfileImpl::GetBlacklist() {
@@ skipping 438 matching lines @@
   }
   if (!sync_service_.get())
     InitSyncService();
   return sync_service_.get();
 }
 
 void ProfileImpl::InitSyncService() {
   sync_service_.reset(new ProfileSyncService(this));
   sync_service_->Initialize();
 }