Create a content::ResourceContext.

chrome/browser/profiles/profile_io_data.cc

 // Copyright (c) 2011 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/profiles/profile_io_data.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
+#include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/extensions/user_script_master.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/chrome_cookie_notification_details.h"
 #include "chrome/browser/net/pref_proxy_config_service.h"
 #include "chrome/browser/net/proxy_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/browser_thread.h"
+#include "content/browser/resource_context.h"
 #include "content/common/notification_service.h"
 #include "net/http/http_util.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_script_fetcher_impl.h"
 #include "net/proxy/proxy_service.h"
+#include "webkit/database/database_tracker.h"
 
 namespace {
 
 // ----------------------------------------------------------------------------
 // CookieMonster::Delegate implementation
 // ----------------------------------------------------------------------------
 class ChromeCookieMonsterDelegate : public net::CookieMonster::Delegate {
  public:
   explicit ChromeCookieMonsterDelegate(Profile* profile) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 133 matching lines @@
 
   params->proxy_config_service.reset(
       ProxyServiceFactory::CreateProxyConfigService(
           profile->GetProxyConfigTracker()));
   params->profile_id = profile->GetRuntimeId();
 }
 
 ProfileIOData::RequestContext::RequestContext() {}
 ProfileIOData::RequestContext::~RequestContext() {}
 
+ProfileIOData::ProfileResourceContextGetter::ProfileResourceContextGetter(
+    ProfileIOData* profile_io_data)
+    : profile_io_data_(profile_io_data) {
+  base::AutoLock auto_lock(profile_io_data_->lock_);
+  std::set<const ProfileResourceContextGetter*>& getters =
+      profile_io_data_->resource_context_getters_;
+  DCHECK(!ContainsKey(getters, this));
+  getters.insert(this);
+}
+
+ProfileIOData::ProfileResourceContextGetter::~ProfileResourceContextGetter() {
+  base::AutoLock auto_lock(profile_io_data_->lock_);
+  std::set<const ProfileResourceContextGetter*>& getters =
+      profile_io_data_->resource_context_getters_;
+  DCHECK(ContainsKey(getters, this));
+  getters.erase(this);
+}
+
+#ifndef NDEBUG
+void ProfileIOData::ProfileResourceContextGetter::PrintStacktrace() const {
+  stacktrace_.PrintBacktrace();
+}
+#endif
+
+const content::ResourceContext&
+ProfileIOData::ProfileResourceContextGetter::GetImpl() {
+  return profile_io_data_->GetResourceContext();
+}
+
 ProfileIOData::ProfileParams::ProfileParams()
     : is_incognito(false),
       clear_local_state_on_exit(false),
       profile_id(Profile::kInvalidProfileId) {}
 ProfileIOData::ProfileParams::~ProfileParams() {}
 
 ProfileIOData::ProfileIOData(bool is_incognito)
     : initialized_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 ProfileIOData::~ProfileIOData() {
   // If we have never initialized ProfileIOData, then Handle may hold the only
   // reference to it. The important thing is to make sure it hasn't been
   // initialized yet, because the lazily initialized variables are supposed to
   // live on the IO thread.
   if (BrowserThread::CurrentlyOn(BrowserThread::UI))
     DCHECK(!initialized_);
   else
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  base::AutoLock auto_lock(lock_);
+#ifndef NDEBUG
+  for (std::set<const ProfileResourceContextGetter*>::const_iterator it =
+       resource_context_getters_.begin(); it != resource_context_getters_.end();
+       ++it) {
+    LOG(ERROR) << "Leaked ProfileResourceContextGetter with allocation: ";
+    (*it)->PrintStacktrace();
+  }
+#endif
+  DCHECK(resource_context_getters_.empty());
 }
 
 scoped_refptr<ChromeURLRequestContext>
 ProfileIOData::GetMainRequestContext() const {
   LazyInitialize();
   scoped_refptr<ChromeURLRequestContext> context =
       AcquireMainRequestContext();
   DCHECK(context);
   return context;
 }
@@ skipping 20 matching lines @@
 ProfileIOData::GetIsolatedAppRequestContext(
     scoped_refptr<ChromeURLRequestContext> main_context,
     const std::string& app_id) const {
   LazyInitialize();
   scoped_refptr<ChromeURLRequestContext> context =
       AcquireIsolatedAppRequestContext(main_context, app_id);
   DCHECK(context);
   return context;
 }
 
+const content::ResourceContext& ProfileIOData::GetResourceContext() const {
+  LazyInitialize();
+  DCHECK(resource_context_.get());
+  return *resource_context_;
+}
+
+void ProfileIOData::set_resource_context(
+    const content::ResourceContext* resource_context) const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!resource_context_.get());
+  resource_context_.reset(resource_context);
+}
+
 void ProfileIOData::LazyInitialize() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (initialized_)
     return;
   LazyInitializeInternal();
   initialized_ = true;
 }
 
 // static
 void ProfileIOData::ApplyProfileParamsToContext(
     const ProfileParams& profile_params,
     ChromeURLRequestContext* context) {
   context->set_is_incognito(profile_params.is_incognito);
   context->set_accept_language(profile_params.accept_language);
   context->set_accept_charset(profile_params.accept_charset);
   context->set_referrer_charset(profile_params.referrer_charset);
   context->set_user_script_dir_path(profile_params.user_script_dir_path);
   context->set_host_content_settings_map(
       profile_params.host_content_settings_map);
   context->set_host_zoom_map(profile_params.host_zoom_map);
   context->set_transport_security_state(
       profile_params.transport_security_state);
   context->set_ssl_config_service(profile_params.ssl_config_service);
-  context->set_database_tracker(profile_params.database_tracker);
   context->set_appcache_service(profile_params.appcache_service);
   context->set_blob_storage_context(profile_params.blob_storage_context);
   context->set_file_system_context(profile_params.file_system_context);
   context->set_extension_info_map(profile_params.extension_info_map);
   context->set_prerender_manager(profile_params.prerender_manager);
 }