Revert r74728 which reverted r74561 for exposing a ChromeOS bug.

r74561 added a DCHECK to make sure users didn't try to access the ChromeURLRequestContextGetter from the Profile, since the Profile should only be read on the UI thread. ChromeOS apparently tried to access it from another thread, and therefore hit the new DCHECK.

I'm relanding without the DCHECK. I'm also eagerly initializing the off the record context getter to prevent the ChromeOS race. ChromeOS should fix that code so the eager initialization isn't necessary.

BUG=none
TEST=none

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

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@74842 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;
+}