chrome/browser/profiles/profile_impl_io_data.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/profiles/profile_impl_io_data.h"
   6
   7 #include "base/bind.h"
   8 #include "base/command_line.h"
   9 #include "base/file_util.h"
  10 #include "base/logging.h"
  11 #include "base/prefs/pref_member.h"
  12 #include "base/prefs/pref_service.h"
  13 #include "base/sequenced_task_runner.h"
  14 #include "base/stl_util.h"
  15 #include "base/threading/sequenced_worker_pool.h"
  16 #include "base/threading/worker_pool.h"
  17 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
  18 #include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
  19 #include "chrome/browser/io_thread.h"
  20 #include "chrome/browser/net/chrome_net_log.h"
  21 #include "chrome/browser/net/chrome_network_delegate.h"
  22 #include "chrome/browser/net/connect_interceptor.h"
  23 #include "chrome/browser/net/http_server_properties_manager.h"
  24 #include "chrome/browser/net/predictor.h"
  25 #include "chrome/browser/net/sqlite_server_bound_cert_store.h"
  26 #include "chrome/browser/profiles/profile.h"
  27 #include "chrome/common/chrome_constants.h"
  28 #include "chrome/common/chrome_notification_types.h"
  29 #include "chrome/common/chrome_switches.h"
  30 #include "chrome/common/pref_names.h"
  31 #include "chrome/common/url_constants.h"
  32 #include "content/public/browser/browser_thread.h"
  33 #include "content/public/browser/cookie_store_factory.h"
  34 #include "content/public/browser/notification_service.h"
  35 #include "content/public/browser/resource_context.h"
  36 #include "content/public/browser/storage_partition.h"
  37 #include "extensions/common/constants.h"
  38 #include "net/ftp/ftp_network_layer.h"
  39 #include "net/http/http_cache.h"
  40 #include "net/ssl/server_bound_cert_service.h"
  41 #include "net/url_request/protocol_intercept_job_factory.h"
  42 #include "net/url_request/url_request_job_factory_impl.h"
  43 #include "webkit/quota/special_storage_policy.h"
  44
  45 using content::BrowserThread;
  46
  47 ProfileImplIOData::Handle::Handle(Profile* profile)
  48     : io_data_(new ProfileImplIOData),
  49       profile_(profile),
  50       initialized_(false) {
  51   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  52   DCHECK(profile);
  53 }
  54
  55 ProfileImplIOData::Handle::~Handle() {
  56   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  57   if (io_data_->predictor_.get() != NULL) {
  58     // io_data_->predictor_ might be NULL if Init() was never called
  59     // (i.e. we shut down before ProfileImpl::DoFinalInit() got called).
  60     PrefService* user_prefs = profile_->GetPrefs();
  61     io_data_->predictor_->ShutdownOnUIThread(user_prefs);
  62   }
  63
  64   if (io_data_->http_server_properties_manager_)
  65     io_data_->http_server_properties_manager_->ShutdownOnUIThread();
  66   io_data_->ShutdownOnUIThread();
  67 }
  68
  69 void ProfileImplIOData::Handle::Init(
  70       const base::FilePath& cookie_path,
  71       const base::FilePath& server_bound_cert_path,
  72       const base::FilePath& cache_path,
  73       int cache_max_size,
  74       const base::FilePath& media_cache_path,
  75       int media_cache_max_size,
  76       const base::FilePath& extensions_cookie_path,
  77       const base::FilePath& profile_path,
  78       const base::FilePath& infinite_cache_path,
  79       chrome_browser_net::Predictor* predictor,
  80       bool restore_old_session_cookies,
  81       quota::SpecialStoragePolicy* special_storage_policy) {
  82   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  83   DCHECK(!io_data_->lazy_params_.get());
  84   DCHECK(predictor);
  85
  86   LazyParams* lazy_params = new LazyParams;
  87
  88   lazy_params->cookie_path = cookie_path;
  89   lazy_params->server_bound_cert_path = server_bound_cert_path;
  90   lazy_params->cache_path = cache_path;
  91   lazy_params->cache_max_size = cache_max_size;
  92   lazy_params->media_cache_path = media_cache_path;
  93   lazy_params->media_cache_max_size = media_cache_max_size;
  94   lazy_params->extensions_cookie_path = extensions_cookie_path;
  95   lazy_params->infinite_cache_path = infinite_cache_path;
  96   lazy_params->restore_old_session_cookies = restore_old_session_cookies;
  97   lazy_params->special_storage_policy = special_storage_policy;
  98
  99   io_data_->lazy_params_.reset(lazy_params);
 100
 101   // Keep track of profile path and cache sizes separately so we can use them
 102   // on demand when creating storage isolated URLRequestContextGetters.
 103   io_data_->profile_path_ = profile_path;
 104   io_data_->app_cache_max_size_ = cache_max_size;
 105   io_data_->app_media_cache_max_size_ = media_cache_max_size;
 106
 107   io_data_->predictor_.reset(predictor);
 108
 109   io_data_->InitializeMetricsEnabledStateOnUIThread();
 110 }
 111
 112 content::ResourceContext*
 113     ProfileImplIOData::Handle::GetResourceContext() const {
 114   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 115   LazyInitialize();
 116   return GetResourceContextNoInit();
 117 }
 118
 119 content::ResourceContext*
 120 ProfileImplIOData::Handle::GetResourceContextNoInit() const {
 121   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 122   // Don't call LazyInitialize here, since the resource context is created at
 123   // the beginning of initalization and is used by some members while they're
 124   // being initialized (i.e. AppCacheService).
 125   return io_data_->GetResourceContext();
 126 }
 127
 128 scoped_refptr<ChromeURLRequestContextGetter>
 129 ProfileImplIOData::Handle::CreateMainRequestContextGetter(
 130     content::ProtocolHandlerMap* protocol_handlers,
 131     PrefService* local_state,
 132     IOThread* io_thread) const {
 133   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 134   LazyInitialize();
 135   DCHECK(!main_request_context_getter_);
 136   main_request_context_getter_ = ChromeURLRequestContextGetter::CreateOriginal(
 137       profile_, io_data_, protocol_handlers);
 138
 139   io_data_->predictor_->InitNetworkPredictor(profile_->GetPrefs(),
 140                                              local_state,
 141                                              io_thread,
 142                                              main_request_context_getter_);
 143
 144   content::NotificationService::current()->Notify(
 145       chrome::NOTIFICATION_PROFILE_URL_REQUEST_CONTEXT_GETTER_INITIALIZED,
 146       content::Source<Profile>(profile_),
 147       content::NotificationService::NoDetails());
 148   return main_request_context_getter_;
 149 }
 150
 151 scoped_refptr<ChromeURLRequestContextGetter>
 152 ProfileImplIOData::Handle::GetMediaRequestContextGetter() const {
 153   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 154   LazyInitialize();
 155   if (!media_request_context_getter_) {
 156     media_request_context_getter_ =
 157         ChromeURLRequestContextGetter::CreateOriginalForMedia(
 158             profile_, io_data_);
 159   }
 160   return media_request_context_getter_;
 161 }
 162
 163 scoped_refptr<ChromeURLRequestContextGetter>
 164 ProfileImplIOData::Handle::GetExtensionsRequestContextGetter() const {
 165   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 166   LazyInitialize();
 167   if (!extensions_request_context_getter_) {
 168     extensions_request_context_getter_ =
 169         ChromeURLRequestContextGetter::CreateOriginalForExtensions(
 170             profile_, io_data_);
 171   }
 172   return extensions_request_context_getter_;
 173 }
 174
 175 scoped_refptr<ChromeURLRequestContextGetter>
 176 ProfileImplIOData::Handle::CreateIsolatedAppRequestContextGetter(
 177     const base::FilePath& partition_path,
 178     bool in_memory,
 179     content::ProtocolHandlerMap* protocol_handlers) const {
 180   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 181   // Check that the partition_path is not the same as the base profile path. We
 182   // expect isolated partition, which will never go to the default profile path.
 183   CHECK(partition_path != profile_->GetPath());
 184   LazyInitialize();
 185
 186   // Keep a map of request context getters, one per requested storage partition.
 187   StoragePartitionDescriptor descriptor(partition_path, in_memory);
 188   ChromeURLRequestContextGetterMap::iterator iter =
 189       app_request_context_getter_map_.find(descriptor);
 190   if (iter != app_request_context_getter_map_.end())
 191     return iter->second;
 192
 193   scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 194       protocol_handler_interceptor(
 195           ProtocolHandlerRegistryFactory::GetForProfile(profile_)->
 196               CreateJobInterceptorFactory());
 197   ChromeURLRequestContextGetter* context =
 198       ChromeURLRequestContextGetter::CreateOriginalForIsolatedApp(
 199           profile_, io_data_, descriptor,
 200           protocol_handler_interceptor.Pass(),
 201           protocol_handlers);
 202   app_request_context_getter_map_[descriptor] = context;
 203
 204   return context;
 205 }
 206
 207 scoped_refptr<ChromeURLRequestContextGetter>
 208 ProfileImplIOData::Handle::GetIsolatedMediaRequestContextGetter(
 209     const base::FilePath& partition_path,
 210     bool in_memory) const {
 211   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 212   // We must have a non-default path, or this will act like the default media
 213   // context.
 214   CHECK(partition_path != profile_->GetPath());
 215   LazyInitialize();
 216
 217   // Keep a map of request context getters, one per requested storage partition.
 218   StoragePartitionDescriptor descriptor(partition_path, in_memory);
 219   ChromeURLRequestContextGetterMap::iterator iter =
 220       isolated_media_request_context_getter_map_.find(descriptor);
 221   if (iter != isolated_media_request_context_getter_map_.end())
 222     return iter->second;
 223
 224   // Get the app context as the starting point for the media context, so that
 225   // it uses the app's cookie store.
 226   ChromeURLRequestContextGetterMap::const_iterator app_iter =
 227       app_request_context_getter_map_.find(descriptor);
 228   DCHECK(app_iter != app_request_context_getter_map_.end());
 229   ChromeURLRequestContextGetter* app_context = app_iter->second;
 230   ChromeURLRequestContextGetter* context =
 231       ChromeURLRequestContextGetter::CreateOriginalForIsolatedMedia(
 232           profile_, app_context, io_data_, descriptor);
 233   isolated_media_request_context_getter_map_[descriptor] = context;
 234
 235   return context;
 236 }
 237
 238 void ProfileImplIOData::Handle::ClearNetworkingHistorySince(
 239     base::Time time,
 240     const base::Closure& completion) {
 241   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 242   LazyInitialize();
 243
 244   BrowserThread::PostTask(
 245       BrowserThread::IO, FROM_HERE,
 246       base::Bind(
 247           &ProfileImplIOData::ClearNetworkingHistorySinceOnIOThread,
 248           base::Unretained(io_data_),
 249           time,
 250           completion));
 251 }
 252
 253 void ProfileImplIOData::Handle::LazyInitialize() const {
 254   if (initialized_)
 255     return;
 256
 257   // Set initialized_ to true at the beginning in case any of the objects
 258   // below try to get the ResourceContext pointer.
 259   initialized_ = true;
 260   PrefService* pref_service = profile_->GetPrefs();
 261   io_data_->http_server_properties_manager_ =
 262       new chrome_browser_net::HttpServerPropertiesManager(pref_service);
 263   io_data_->set_http_server_properties(
 264       io_data_->http_server_properties_manager_);
 265   io_data_->session_startup_pref()->Init(
 266       prefs::kRestoreOnStartup, pref_service);
 267   io_data_->session_startup_pref()->MoveToThread(
 268       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
 269 #if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
 270   io_data_->safe_browsing_enabled()->Init(prefs::kSafeBrowsingEnabled,
 271       pref_service);
 272   io_data_->safe_browsing_enabled()->MoveToThread(
 273       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
 274 #endif
 275   io_data_->InitializeOnUIThread(profile_);
 276 }
 277
 278 ProfileImplIOData::LazyParams::LazyParams()
 279     : cache_max_size(0),
 280       media_cache_max_size(0),
 281       restore_old_session_cookies(false) {}
 282
 283 ProfileImplIOData::LazyParams::~LazyParams() {}
 284
 285 ProfileImplIOData::ProfileImplIOData()
 286     : ProfileIOData(false),
 287       http_server_properties_manager_(NULL) {}
 288 ProfileImplIOData::~ProfileImplIOData() {
 289   DestroyResourceContext();
 290
 291   if (media_request_context_.get())
 292     media_request_context_->AssertNoURLRequests();
 293 }
 294
 295 void ProfileImplIOData::InitializeInternal(
 296     ProfileParams* profile_params,
 297     content::ProtocolHandlerMap* protocol_handlers) const {
 298   ChromeURLRequestContext* main_context = main_request_context();
 299
 300   IOThread* const io_thread = profile_params->io_thread;
 301   IOThread::Globals* const io_thread_globals = io_thread->globals();
 302   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 303   // Only allow Record Mode if we are in a Debug build or where we are running
 304   // a cycle, and the user has limited control.
 305   bool record_mode = command_line.HasSwitch(switches::kRecordMode) &&
 306                      (chrome::kRecordModeEnabled ||
 307                       command_line.HasSwitch(switches::kVisitURLs));
 308   bool playback_mode = command_line.HasSwitch(switches::kPlaybackMode);
 309
 310   network_delegate()->set_predictor(predictor_.get());
 311
 312   // Initialize context members.
 313
 314   ApplyProfileParamsToContext(main_context);
 315
 316   if (http_server_properties_manager_)
 317     http_server_properties_manager_->InitializeOnIOThread();
 318
 319   main_context->set_transport_security_state(transport_security_state());
 320
 321   main_context->set_net_log(io_thread->net_log());
 322
 323   main_context->set_network_delegate(network_delegate());
 324
 325   main_context->set_http_server_properties(http_server_properties());
 326
 327   main_context->set_host_resolver(
 328       io_thread_globals->host_resolver.get());
 329   main_context->set_http_auth_handler_factory(
 330       io_thread_globals->http_auth_handler_factory.get());
 331
 332   main_context->set_fraudulent_certificate_reporter(
 333       fraudulent_certificate_reporter());
 334
 335   main_context->set_throttler_manager(
 336       io_thread_globals->throttler_manager.get());
 337
 338   main_context->set_proxy_service(proxy_service());
 339
 340   scoped_refptr<net::CookieStore> cookie_store = NULL;
 341   net::ServerBoundCertService* server_bound_cert_service = NULL;
 342   if (record_mode || playback_mode) {
 343     // Don't use existing cookies and use an in-memory store.
 344     cookie_store = new net::CookieMonster(
 345         NULL, profile_params->cookie_monster_delegate);
 346     // Don't use existing server-bound certs and use an in-memory store.
 347     server_bound_cert_service = new net::ServerBoundCertService(
 348         new net::DefaultServerBoundCertStore(NULL),
 349         base::WorkerPool::GetTaskRunner(true));
 350   }
 351
 352   // setup cookie store
 353   if (!cookie_store) {
 354     DCHECK(!lazy_params_->cookie_path.empty());
 355
 356     cookie_store = content::CreatePersistentCookieStore(
 357         lazy_params_->cookie_path,
 358         lazy_params_->restore_old_session_cookies,
 359         lazy_params_->special_storage_policy,
 360         profile_params->cookie_monster_delegate);
 361     cookie_store->GetCookieMonster()->SetPersistSessionCookies(true);
 362   }
 363
 364   main_context->set_cookie_store(cookie_store);
 365
 366   // Setup server bound cert service.
 367   if (!server_bound_cert_service) {
 368     DCHECK(!lazy_params_->server_bound_cert_path.empty());
 369
 370     scoped_refptr<SQLiteServerBoundCertStore> server_bound_cert_db =
 371         new SQLiteServerBoundCertStore(
 372             lazy_params_->server_bound_cert_path,
 373             lazy_params_->special_storage_policy);
 374     server_bound_cert_service = new net::ServerBoundCertService(
 375         new net::DefaultServerBoundCertStore(server_bound_cert_db.get()),
 376         base::WorkerPool::GetTaskRunner(true));
 377   }
 378
 379   set_server_bound_cert_service(server_bound_cert_service);
 380   main_context->set_server_bound_cert_service(server_bound_cert_service);
 381
 382   net::HttpCache::DefaultBackend* main_backend =
 383       new net::HttpCache::DefaultBackend(
 384           net::DISK_CACHE,
 385           lazy_params_->cache_path,
 386           lazy_params_->cache_max_size,
 387           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
 388   net::HttpNetworkSession::Params network_session_params;
 389   PopulateNetworkSessionParams(profile_params, &network_session_params);
 390   net::HttpCache* main_cache = new net::HttpCache(
 391       network_session_params, main_backend);
 392   main_cache->InitializeInfiniteCache(lazy_params_->infinite_cache_path);
 393
 394   if (record_mode || playback_mode) {
 395     main_cache->set_mode(
 396         record_mode ? net::HttpCache::RECORD : net::HttpCache::PLAYBACK);
 397   }
 398
 399   main_http_factory_.reset(main_cache);
 400   main_context->set_http_transaction_factory(main_cache);
 401
 402 #if !defined(DISABLE_FTP_SUPPORT)
 403   ftp_factory_.reset(
 404       new net::FtpNetworkLayer(io_thread_globals->host_resolver.get()));
 405   main_context->set_ftp_transaction_factory(ftp_factory_.get());
 406 #endif  // !defined(DISABLE_FTP_SUPPORT)
 407
 408   scoped_ptr<net::URLRequestJobFactoryImpl> main_job_factory(
 409       new net::URLRequestJobFactoryImpl());
 410   InstallProtocolHandlers(main_job_factory.get(), protocol_handlers);
 411   main_job_factory_ = SetUpJobFactoryDefaults(
 412       main_job_factory.Pass(),
 413       profile_params->protocol_handler_interceptor.Pass(),
 414       network_delegate(),
 415       main_context->ftp_transaction_factory(),
 416       main_context->ftp_auth_cache());
 417   main_context->set_job_factory(main_job_factory_.get());
 418
 419 #if defined(ENABLE_EXTENSIONS)
 420   InitializeExtensionsRequestContext(profile_params);
 421 #endif
 422
 423   // Create a media request context based on the main context, but using a
 424   // media cache.  It shares the same job factory as the main context.
 425   StoragePartitionDescriptor details(profile_path_, false);
 426   media_request_context_.reset(InitializeMediaRequestContext(main_context,
 427                                                              details));
 428
 429   lazy_params_.reset();
 430 }
 431
 432 void ProfileImplIOData::
 433     InitializeExtensionsRequestContext(ProfileParams* profile_params) const {
 434   ChromeURLRequestContext* extensions_context = extensions_request_context();
 435   IOThread* const io_thread = profile_params->io_thread;
 436   IOThread::Globals* const io_thread_globals = io_thread->globals();
 437   ApplyProfileParamsToContext(extensions_context);
 438
 439   extensions_context->set_transport_security_state(transport_security_state());
 440
 441   extensions_context->set_net_log(io_thread->net_log());
 442
 443   extensions_context->set_throttler_manager(
 444       io_thread_globals->throttler_manager.get());
 445
 446   net::CookieStore* extensions_cookie_store =
 447       content::CreatePersistentCookieStore(
 448           lazy_params_->extensions_cookie_path,
 449           lazy_params_->restore_old_session_cookies,
 450           NULL,
 451           NULL);
 452   // Enable cookies for devtools and extension URLs.
 453   const char* schemes[] = {chrome::kChromeDevToolsScheme,
 454                            extensions::kExtensionScheme};
 455   extensions_cookie_store->GetCookieMonster()->SetCookieableSchemes(schemes, 2);
 456   extensions_context->set_cookie_store(extensions_cookie_store);
 457
 458 #if !defined(DISABLE_FTP_SUPPORT)
 459   DCHECK(ftp_factory_.get());
 460   extensions_context->set_ftp_transaction_factory(ftp_factory_.get());
 461 #endif  // !defined(DISABLE_FTP_SUPPORT)
 462
 463   scoped_ptr<net::URLRequestJobFactoryImpl> extensions_job_factory(
 464       new net::URLRequestJobFactoryImpl());
 465   // TODO(shalev): The extensions_job_factory has a NULL NetworkDelegate.
 466   // Without a network_delegate, this protocol handler will never
 467   // handle file: requests, but as a side effect it makes
 468   // job_factory::IsHandledProtocol return true, which prevents attempts to
 469   // handle the protocol externally. We pass NULL in to
 470   // SetUpJobFactory() to get this effect.
 471   extensions_job_factory_ = SetUpJobFactoryDefaults(
 472       extensions_job_factory.Pass(),
 473       scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>(NULL),
 474       NULL,
 475       extensions_context->ftp_transaction_factory(),
 476       extensions_context->ftp_auth_cache());
 477   extensions_context->set_job_factory(extensions_job_factory_.get());
 478 }
 479
 480 ChromeURLRequestContext*
 481 ProfileImplIOData::InitializeAppRequestContext(
 482     ChromeURLRequestContext* main_context,
 483     const StoragePartitionDescriptor& partition_descriptor,
 484     scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 485         protocol_handler_interceptor,
 486     content::ProtocolHandlerMap* protocol_handlers) const {
 487   // Copy most state from the main context.
 488   AppRequestContext* context = new AppRequestContext(load_time_stats());
 489   context->CopyFrom(main_context);
 490
 491   base::FilePath cookie_path = partition_descriptor.path.Append(
 492       chrome::kCookieFilename);
 493   base::FilePath cache_path =
 494       partition_descriptor.path.Append(chrome::kCacheDirname);
 495
 496   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 497   // Only allow Record Mode if we are in a Debug build or where we are running
 498   // a cycle, and the user has limited control.
 499   bool record_mode = command_line.HasSwitch(switches::kRecordMode) &&
 500                      (chrome::kRecordModeEnabled ||
 501                       command_line.HasSwitch(switches::kVisitURLs));
 502   bool playback_mode = command_line.HasSwitch(switches::kPlaybackMode);
 503
 504   // Use a separate HTTP disk cache for isolated apps.
 505   net::HttpCache::BackendFactory* app_backend = NULL;
 506   if (partition_descriptor.in_memory) {
 507     app_backend = net::HttpCache::DefaultBackend::InMemory(0);
 508   } else {
 509     app_backend = new net::HttpCache::DefaultBackend(
 510         net::DISK_CACHE,
 511         cache_path,
 512         app_cache_max_size_,
 513         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
 514   }
 515   net::HttpNetworkSession* main_network_session =
 516       main_http_factory_->GetSession();
 517   net::HttpCache* app_http_cache =
 518       new net::HttpCache(main_network_session, app_backend);
 519
 520   scoped_refptr<net::CookieStore> cookie_store = NULL;
 521   if (partition_descriptor.in_memory) {
 522     cookie_store = new net::CookieMonster(NULL, NULL);
 523   } else if (record_mode || playback_mode) {
 524     // Don't use existing cookies and use an in-memory store.
 525     // TODO(creis): We should have a cookie delegate for notifying the cookie
 526     // extensions API, but we need to update it to understand isolated apps
 527     // first.
 528     cookie_store = new net::CookieMonster(NULL, NULL);
 529     app_http_cache->set_mode(
 530         record_mode ? net::HttpCache::RECORD : net::HttpCache::PLAYBACK);
 531   }
 532
 533   // Use an app-specific cookie store.
 534   if (!cookie_store) {
 535     DCHECK(!cookie_path.empty());
 536
 537     // TODO(creis): We should have a cookie delegate for notifying the cookie
 538     // extensions API, but we need to update it to understand isolated apps
 539     // first.
 540     cookie_store = content::CreatePersistentCookieStore(
 541         cookie_path,
 542         false,
 543         NULL,
 544         NULL);
 545   }
 546
 547   // Transfer ownership of the cookies and cache to AppRequestContext.
 548   context->SetCookieStore(cookie_store);
 549   context->SetHttpTransactionFactory(
 550       scoped_ptr<net::HttpTransactionFactory>(app_http_cache));
 551
 552   scoped_ptr<net::URLRequestJobFactoryImpl> job_factory(
 553       new net::URLRequestJobFactoryImpl());
 554   InstallProtocolHandlers(job_factory.get(), protocol_handlers);
 555   scoped_ptr<net::URLRequestJobFactory> top_job_factory;
 556   // Overwrite the job factory that we inherit from the main context so
 557   // that we can later provide our own handlers for storage related protocols.
 558   // Install all the usual protocol handlers unless we are in a browser plugin
 559   // guest process, in which case only web-safe schemes are allowed.
 560   if (!partition_descriptor.in_memory) {
 561     top_job_factory = SetUpJobFactoryDefaults(
 562         job_factory.Pass(), protocol_handler_interceptor.Pass(),
 563         network_delegate(),
 564         context->ftp_transaction_factory(),
 565         context->ftp_auth_cache());
 566   } else {
 567     top_job_factory = job_factory.PassAs<net::URLRequestJobFactory>();
 568   }
 569   context->SetJobFactory(top_job_factory.Pass());
 570
 571   return context;
 572 }
 573
 574 ChromeURLRequestContext*
 575 ProfileImplIOData::InitializeMediaRequestContext(
 576     ChromeURLRequestContext* original_context,
 577     const StoragePartitionDescriptor& partition_descriptor) const {
 578   // If this is for a in_memory partition, we can simply use the original
 579   // context (like off-the-record mode).
 580   if (partition_descriptor.in_memory)
 581     return original_context;
 582
 583   // Copy most state from the original context.
 584   MediaRequestContext* context = new MediaRequestContext(load_time_stats());
 585   context->CopyFrom(original_context);
 586
 587   using content::StoragePartition;
 588   base::FilePath cache_path;
 589   int cache_max_size = app_media_cache_max_size_;
 590   if (partition_descriptor.path == profile_path_) {
 591     // lazy_params_ is only valid for the default media context creation.
 592     cache_path = lazy_params_->media_cache_path;
 593     cache_max_size = lazy_params_->media_cache_max_size;
 594   } else {
 595     cache_path = partition_descriptor.path.Append(chrome::kMediaCacheDirname);
 596   }
 597
 598   // Use a separate HTTP disk cache for isolated apps.
 599   net::HttpCache::BackendFactory* media_backend =
 600       new net::HttpCache::DefaultBackend(
 601           net::MEDIA_CACHE,
 602           cache_path,
 603           cache_max_size,
 604           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
 605   net::HttpNetworkSession* main_network_session =
 606       main_http_factory_->GetSession();
 607   scoped_ptr<net::HttpTransactionFactory> media_http_cache(
 608       new net::HttpCache(main_network_session, media_backend));
 609
 610   // Transfer ownership of the cache to MediaRequestContext.
 611   context->SetHttpTransactionFactory(media_http_cache.Pass());
 612
 613   // Note that we do not create a new URLRequestJobFactory because
 614   // the media context should behave exactly like its parent context
 615   // in all respects except for cache behavior on media subresources.
 616   // The CopyFrom() step above means that our media context will use
 617   // the same URLRequestJobFactory instance that our parent context does.
 618
 619   return context;
 620 }
 621
 622 ChromeURLRequestContext*
 623 ProfileImplIOData::AcquireMediaRequestContext() const {
 624   DCHECK(media_request_context_.get());
 625   return media_request_context_.get();
 626 }
 627
 628 ChromeURLRequestContext*
 629 ProfileImplIOData::AcquireIsolatedAppRequestContext(
 630     ChromeURLRequestContext* main_context,
 631     const StoragePartitionDescriptor& partition_descriptor,
 632     scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 633         protocol_handler_interceptor,
 634     content::ProtocolHandlerMap* protocol_handlers) const {
 635   // We create per-app contexts on demand, unlike the others above.
 636   ChromeURLRequestContext* app_request_context =
 637       InitializeAppRequestContext(main_context, partition_descriptor,
 638                                   protocol_handler_interceptor.Pass(),
 639                                   protocol_handlers);
 640   DCHECK(app_request_context);
 641   return app_request_context;
 642 }
 643
 644 ChromeURLRequestContext*
 645 ProfileImplIOData::AcquireIsolatedMediaRequestContext(
 646     ChromeURLRequestContext* app_context,
 647     const StoragePartitionDescriptor& partition_descriptor) const {
 648   // We create per-app media contexts on demand, unlike the others above.
 649   ChromeURLRequestContext* media_request_context =
 650       InitializeMediaRequestContext(app_context, partition_descriptor);
 651   DCHECK(media_request_context);
 652   return media_request_context;
 653 }
 654
 655 chrome_browser_net::LoadTimeStats* ProfileImplIOData::GetLoadTimeStats(
 656     IOThread::Globals* io_thread_globals) const {
 657   return io_thread_globals->load_time_stats.get();
 658 }
 659
 660 void ProfileImplIOData::ClearNetworkingHistorySinceOnIOThread(
 661     base::Time time,
 662     const base::Closure& completion) {
 663   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 664   DCHECK(initialized());
 665
 666   DCHECK(transport_security_state());
 667   // Completes synchronously.
 668   transport_security_state()->DeleteAllDynamicDataSince(time);
 669   DCHECK(http_server_properties_manager_);
 670   http_server_properties_manager_->Clear(completion);
 671 }