Introduce OffTheRecordProfileIOData and ProfileImplIOData.

They both inherit from ProfileIOData. The former is for the off the record (incognito) profile. The latter is for the normal ProfileImpl profile.
All of the IO related Profile objects are now initialized at the same time, in the subtype implementations of ProfileIOData::LazyInitializeInternal().
I also took this opportunity to clean URLRequestContext up so it is a class and keeps its member variables private. This required touching a fair number of files.

TODO: Remove lots of the refcounting of member variables, since they can now be owned by ProfileIOData.

BUG=67237
TEST=none

Review URL: http://codereview.chromium.org/6286133

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@74561 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 282 insertions, 0 deletions

diff --git a/chrome/browser/profiles/profile_impl_io_data.cc b/chrome/browser/profiles/profile_impl_io_data.cc
new file mode 100644
index 0000000..c746a63
--- /dev/null
+++ b/chrome/browser/profiles/profile_impl_io_data.cc
@@ -0,0 +1,282 @@
+// 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_impl_io_data.h"
+
+#include "base/command_line.h"
+#include "base/logging.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/browser_thread.h"
+#include "chrome/browser/io_thread.h"
+#include "chrome/browser/net/chrome_cookie_policy.h"
+#include "chrome/browser/net/chrome_dns_cert_provenance_checker_factory.h"
+#include "chrome/browser/net/chrome_net_log.h"
+#include "chrome/browser/net/sqlite_persistent_cookie_store.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/url_constants.h"
+#include "net/ftp/ftp_network_layer.h"
+#include "net/http/http_cache.h"
+
+ProfileImplIOData::Handle::Handle(Profile* profile)
+    : io_data_(new ProfileImplIOData),
+      profile_(profile),
+      initialized_(false) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(profile);
+}
+
+ProfileImplIOData::Handle::~Handle() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (main_request_context_getter_)
+    main_request_context_getter_->CleanupOnUIThread();
+  if (media_request_context_getter_)
+    media_request_context_getter_->CleanupOnUIThread();
+  if (extensions_request_context_getter_)
+    extensions_request_context_getter_->CleanupOnUIThread();
+}
+
+void ProfileImplIOData::Handle::Init(const FilePath& cookie_path,
+                                     const FilePath& cache_path,
+                                     int cache_max_size,
+                                     const FilePath& media_cache_path,
+                                     int media_cache_max_size,
+                                     const FilePath& extensions_cookie_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!io_data_->lazy_params_.get());
+  LazyParams* lazy_params = new LazyParams;
+
+  lazy_params->cookie_path = cookie_path;
+  lazy_params->cache_path = cache_path;
+  lazy_params->cache_max_size = cache_max_size;
+  lazy_params->media_cache_path = media_cache_path;
+  lazy_params->media_cache_max_size = media_cache_max_size;
+  lazy_params->extensions_cookie_path = extensions_cookie_path;
+
+  lazy_params->io_thread = g_browser_process->io_thread();
+
+  io_data_->lazy_params_.reset(lazy_params);
+}
+
+scoped_refptr<ChromeURLRequestContextGetter>
+ProfileImplIOData::Handle::GetMainRequestContextGetter() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  LazyInitialize();
+  if (!main_request_context_getter_) {
+    main_request_context_getter_ =
+        ChromeURLRequestContextGetter::CreateOriginal(
+            profile_, io_data_);
+  }
+  return main_request_context_getter_;
+}
+
+scoped_refptr<ChromeURLRequestContextGetter>
+ProfileImplIOData::Handle::GetMediaRequestContextGetter() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  LazyInitialize();
+  if (!media_request_context_getter_) {
+    media_request_context_getter_ =
+        ChromeURLRequestContextGetter::CreateOriginalForMedia(
+            profile_, io_data_);
+  }
+  return media_request_context_getter_;
+}
+
+scoped_refptr<ChromeURLRequestContextGetter>
+ProfileImplIOData::Handle::GetExtensionsRequestContextGetter() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  LazyInitialize();
+  if (!extensions_request_context_getter_) {
+    extensions_request_context_getter_ =
+        ChromeURLRequestContextGetter::CreateOriginalForExtensions(
+            profile_, io_data_);
+  }
+  return extensions_request_context_getter_;
+}
+
+void ProfileImplIOData::Handle::LazyInitialize() const {
+  if (!initialized_) {
+    InitializeProfileParams(profile_, &io_data_->lazy_params_->profile_params);
+    initialized_ = true;
+  }
+}
+
+ProfileImplIOData::LazyParams::LazyParams()
+    : cache_max_size(0),
+      media_cache_max_size(0),
+      io_thread(NULL) {}
+ProfileImplIOData::LazyParams::~LazyParams() {}
+
+ProfileImplIOData::ProfileImplIOData() : ProfileIOData(false) {}
+ProfileImplIOData::~ProfileImplIOData() {}
+
+void ProfileImplIOData::LazyInitializeInternal() const {
+  main_request_context_ = new RequestContext;
+  media_request_context_ = new RequestContext;
+  extensions_request_context_ = new RequestContext;
+
+  IOThread* const io_thread = lazy_params_->io_thread;
+  IOThread::Globals* const io_thread_globals = io_thread->globals();
+  const ProfileParams& profile_params = lazy_params_->profile_params;
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  bool record_mode = chrome::kRecordModeEnabled &&
+                     command_line.HasSwitch(switches::kRecordMode);
+  bool playback_mode = command_line.HasSwitch(switches::kPlaybackMode);
+
+  // Initialize context members.
+
+  ApplyProfileParamsToContext(profile_params, main_request_context_);
+  ApplyProfileParamsToContext(profile_params, media_request_context_);
+  ApplyProfileParamsToContext(profile_params, extensions_request_context_);
+  profile_params.appcache_service->set_request_context(main_request_context_);
+  scoped_refptr<ChromeCookiePolicy> cookie_policy =
+      new ChromeCookiePolicy(profile_params.host_content_settings_map);
+
+  main_request_context_->set_chrome_cookie_policy(cookie_policy);
+  media_request_context_->set_chrome_cookie_policy(cookie_policy);
+  extensions_request_context_->set_chrome_cookie_policy(cookie_policy);
+
+  main_request_context_->set_net_log(lazy_params_->io_thread->net_log());
+  media_request_context_->set_net_log(lazy_params_->io_thread->net_log());
+  extensions_request_context_->set_net_log(lazy_params_->io_thread->net_log());
+
+  main_request_context_->set_host_resolver(
+      io_thread_globals->host_resolver.get());
+  media_request_context_->set_host_resolver(
+      io_thread_globals->host_resolver.get());
+  main_request_context_->set_cert_verifier(
+      io_thread_globals->cert_verifier.get());
+  media_request_context_->set_cert_verifier(
+      io_thread_globals->cert_verifier.get());
+  main_request_context_->set_dnsrr_resolver(
+      io_thread_globals->dnsrr_resolver.get());
+  media_request_context_->set_dnsrr_resolver(
+      io_thread_globals->dnsrr_resolver.get());
+  main_request_context_->set_network_delegate(
+      &io_thread_globals->network_delegate);
+  // TODO(willchan): Enable for media request context.
+#if 0
+  media_request_context_->set_network_delegate(
+      &io_thread_globals->network_delegate);
+#endif
+  main_request_context_->set_http_auth_handler_factory(
+      io_thread_globals->http_auth_handler_factory.get());
+  media_request_context_->set_http_auth_handler_factory(
+      io_thread_globals->http_auth_handler_factory.get());
+
+  dns_cert_checker_.reset(
+      CreateDnsCertProvenanceChecker(io_thread_globals->dnsrr_resolver.get(),
+                                     main_request_context_));
+  main_request_context_->set_dns_cert_checker(dns_cert_checker_.get());
+  media_request_context_->set_dns_cert_checker(dns_cert_checker_.get());
+
+  net::ProxyService* proxy_service =
+      CreateProxyService(
+          io_thread->net_log(),
+          io_thread_globals->proxy_script_fetcher_context.get(),
+          lazy_params_->profile_params.proxy_config_service.release(),
+          command_line);
+  main_request_context_->set_proxy_service(proxy_service);
+  media_request_context_->set_proxy_service(proxy_service);
+
+  net::HttpCache::DefaultBackend* main_backend =
+      new net::HttpCache::DefaultBackend(
+          net::DISK_CACHE,
+          lazy_params_->cache_path,
+          lazy_params_->cache_max_size,
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
+  net::HttpCache* main_cache = new net::HttpCache(
+      main_request_context_->host_resolver(),
+      main_request_context_->cert_verifier(),
+      main_request_context_->dnsrr_resolver(),
+      main_request_context_->dns_cert_checker(),
+      main_request_context_->proxy_service(),
+      main_request_context_->ssl_config_service(),
+      main_request_context_->http_auth_handler_factory(),
+      main_request_context_->network_delegate(),
+      main_request_context_->net_log(),
+      main_backend);
+
+  net::HttpCache::DefaultBackend* media_backend =
+      new net::HttpCache::DefaultBackend(
+          net::MEDIA_CACHE, lazy_params_->media_cache_path,
+          lazy_params_->media_cache_max_size,
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
+  net::HttpNetworkSession* main_network_session = main_cache->GetSession();
+  net::HttpCache* media_cache =
+      new net::HttpCache(main_network_session, media_backend);
+
+  scoped_refptr<net::CookieStore> cookie_store = NULL;
+  if (record_mode || playback_mode) {
+    // Don't use existing cookies and use an in-memory store.
+    cookie_store = new net::CookieMonster(
+        NULL, profile_params.cookie_monster_delegate);
+    main_cache->set_mode(
+        record_mode ? net::HttpCache::RECORD : net::HttpCache::PLAYBACK);
+  }
+
+  // setup cookie store
+  if (!cookie_store) {
+    DCHECK(!lazy_params_->cookie_path.empty());
+
+    scoped_refptr<SQLitePersistentCookieStore> cookie_db =
+        new SQLitePersistentCookieStore(lazy_params_->cookie_path);
+    cookie_db->SetClearLocalStateOnExit(
+        profile_params.clear_local_state_on_exit);
+    cookie_store =
+        new net::CookieMonster(cookie_db.get(),
+                               profile_params.cookie_monster_delegate);
+  }
+
+  net::CookieMonster* extensions_cookie_store =
+      new net::CookieMonster(
+          new SQLitePersistentCookieStore(
+              lazy_params_->extensions_cookie_path), NULL);
+  // Enable cookies for devtools and extension URLs.
+  const char* schemes[] = {chrome::kChromeDevToolsScheme,
+                           chrome::kExtensionScheme};
+  extensions_cookie_store->SetCookieableSchemes(schemes, 2);
+
+  main_request_context_->set_cookie_store(cookie_store);
+  media_request_context_->set_cookie_store(cookie_store);
+  extensions_request_context_->set_cookie_store(
+      extensions_cookie_store);
+
+  main_http_factory_.reset(main_cache);
+  media_http_factory_.reset(media_cache);
+  main_request_context_->set_http_transaction_factory(main_cache);
+  media_request_context_->set_http_transaction_factory(media_cache);
+
+  main_request_context_->set_ftp_transaction_factory(
+      new net::FtpNetworkLayer(io_thread_globals->host_resolver.get()));
+
+  lazy_params_.reset();
+}
+
+scoped_refptr<ChromeURLRequestContext>
+ProfileImplIOData::AcquireMainRequestContext() const {
+  DCHECK(main_request_context_);
+  scoped_refptr<ChromeURLRequestContext> context = main_request_context_;
+  main_request_context_->set_profile_io_data(this);
+  main_request_context_ = NULL;
+  return context;
+}
+
+scoped_refptr<ChromeURLRequestContext>
+ProfileImplIOData::AcquireMediaRequestContext() const {
+  DCHECK(media_request_context_);
+  scoped_refptr<ChromeURLRequestContext> context = media_request_context_;
+  media_request_context_->set_profile_io_data(this);
+  media_request_context_ = NULL;
+  return context;
+}
+
+scoped_refptr<ChromeURLRequestContext>
+ProfileImplIOData::AcquireExtensionsRequestContext() const {
+  DCHECK(extensions_request_context_);
+  scoped_refptr<ChromeURLRequestContext> context = extensions_request_context_;
+  extensions_request_context_->set_profile_io_data(this);
+  extensions_request_context_ = NULL;
+  return context;
+}