Initial support for partitioning cookies for isolated apps.

chrome/browser/profiles/off_the_record_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/off_the_record_profile_io_data.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/extensions/extension_io_event_router.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/chrome_network_delegate.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
+#include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_cache.h"
 
 OffTheRecordProfileIOData::Handle::Handle(Profile* profile)
     : io_data_(new OffTheRecordProfileIOData),
       profile_(profile),
       initialized_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(profile);
   DCHECK(!io_data_->lazy_params_.get());
   LazyParams* lazy_params = new LazyParams;
   lazy_params->io_thread = g_browser_process->io_thread();
   io_data_->lazy_params_.reset(lazy_params);
 }
 
 OffTheRecordProfileIOData::Handle::~Handle() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (main_request_context_getter_)
     main_request_context_getter_->CleanupOnUIThread();
   if (extensions_request_context_getter_)
     extensions_request_context_getter_->CleanupOnUIThread();
+
+  // Clean up all isolated app request contexts.
+  for (ChromeURLRequestContextGetterMap::iterator iter =
+           app_request_context_getter_map_.begin();
+       iter != app_request_context_getter_map_.end();
+       ++iter) {
+    iter->second->CleanupOnUIThread();
+  }
+}
+
+void OffTheRecordProfileIOData::Handle::InitIsolatedApp(
+    const Extension* installed_app) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // This may be called multiple times before InitializeAppRequestContext.
+  // Only do the initialization once.
+  std::string id = installed_app->id();
+  if (io_data_->lazy_params_map_.find(id) != io_data_->lazy_params_map_.end())
+    return;
+
+  LazyParams* lazy_params = new LazyParams;
+  lazy_params->io_thread = g_browser_process->io_thread();
+
+  InitializeProfileParams(profile_, &lazy_params->profile_params);
+
+  // Keep track of this app's LazyParams until InitializeAppRequestContext.
+  io_data_->lazy_params_map_[id] = lazy_params;
 }
 
 scoped_refptr<ChromeURLRequestContextGetter>
 OffTheRecordProfileIOData::Handle::GetMainRequestContextGetter() const {
   // TODO(oshima): Re-enable when ChromeOS only accesses the profile on the UI
   // thread.
 #if !defined(OS_CHROMEOS)
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 #endif  // defined(OS_CHROMEOS)
   LazyInitialize();
   if (!main_request_context_getter_) {
     main_request_context_getter_ =
         ChromeURLRequestContextGetter::CreateOffTheRecord(profile_, io_data_);
   }
   return main_request_context_getter_;
 }
 
 scoped_refptr<ChromeURLRequestContextGetter>
 OffTheRecordProfileIOData::Handle::GetExtensionsRequestContextGetter() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   LazyInitialize();
   if (!extensions_request_context_getter_) {
     extensions_request_context_getter_ =
         ChromeURLRequestContextGetter::CreateOffTheRecordForExtensions(
             profile_, io_data_);
   }
   return extensions_request_context_getter_;
 }
 
+scoped_refptr<ChromeURLRequestContextGetter>
+OffTheRecordProfileIOData::Handle::GetIsolatedAppRequestContextGetter(
+    const Extension* installed_app) const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(installed_app);
+  LazyInitialize();
+
+  // Keep a map of request contexts, one per requested app ID.
+  std::string id = installed_app->id();
+  ChromeURLRequestContextGetterMap::iterator iter =
+      app_request_context_getter_map_.find(id);
+  if (iter != app_request_context_getter_map_.end())
+    return iter->second;
+
+  ChromeURLRequestContextGetter* context =
+      ChromeURLRequestContextGetter::CreateOffTheRecordForIsolatedApp(
+          profile_, io_data_, installed_app);
+  app_request_context_getter_map_[id] = context;
+
+  return context;
+}
+
 void OffTheRecordProfileIOData::Handle::LazyInitialize() const {
   if (!initialized_) {
     InitializeProfileParams(profile_, &io_data_->lazy_params_->profile_params);
     initialized_ = true;
   }
 }
 
 OffTheRecordProfileIOData::LazyParams::LazyParams() : io_thread(NULL) {}
 OffTheRecordProfileIOData::LazyParams::~LazyParams() {}
 
 OffTheRecordProfileIOData::OffTheRecordProfileIOData()
     : ProfileIOData(true),
       initialized_(false) {}
 OffTheRecordProfileIOData::~OffTheRecordProfileIOData() {}

[willchan no longer on Chromium, 2011/03/01 23:39:24]

Correct me if I'm wrong, but |lazy_params_map_| may be non-empty if
InitializeAppRequestContext() is never called, right? Does that mean we
potentially have a leak? Should you be calling
STLDeleteValues(&lazy_params_map_);?

[Charlie Reis, 2011/03/03 01:08:05]

Good catch.  Fixed in profile_impl_io_data.cc, since we've removed
lazy_params_map_ here.

 
 void OffTheRecordProfileIOData::LazyInitializeInternal() const {
   main_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();
 
@@ skipping 63 matching lines @@
                          main_request_context_->network_delegate(),
                          main_request_context_->net_log(),
                          main_backend);
 
   main_http_factory_.reset(cache);
   main_request_context_->set_http_transaction_factory(cache);
   main_request_context_->set_ftp_transaction_factory(
       new net::FtpNetworkLayer(main_request_context_->host_resolver()));
 }
 
+scoped_refptr<ProfileIOData::RequestContext>
+OffTheRecordProfileIOData::InitializeAppRequestContext(
+    const Extension *app) const {
+  scoped_refptr<ProfileIOData::RequestContext> context = new RequestContext;
+
+  // Get the app-specific LazyParams, which was created in InitIsolatedApp.
+  std::string id = app->id();
+  LazyParamsMap::iterator iter = lazy_params_map_.find(id);
+  DCHECK(iter != lazy_params_map_.end());
+  scoped_ptr<LazyParams> lazy_params(iter->second);
+
+  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();
+
+  ApplyProfileParamsToContext(profile_params, context);

[willchan no longer on Chromium, 2011/03/01 23:39:24]

I'm concerned about all this code duplication here.

I think the best thing to do is to add a
void ChromeURLRequestContext::Copy(ChromeURLRequestContext* out); member
function. Then just do main_request_context_->Copy(context);

The advantages here are less duplication of code, avoiding the need for the
LazyParamsMap (reduced complexity), and reusing more objects (which has some
implications, since some of these objects have concurrency limits. for example,
ProxyService only allows up to 4 concurrent PAC resolutions [on worker threads
running v8]).

It sounds to me like these isolated apps should share just about everything with
the main context. Anything not shared should be overridden in
InitializeAppRequestContext().

[Charlie Reis, 2011/03/03 01:08:05]

Yes, this is a better approach.  I think I still need LazyParamsMap in the
non-OffTheRecord case (to track cookie and cache paths), but I did get rid of it
here.

The main catch was getting to the cookie delegate, which wasn't accessible
anywhere.  I made it accessible on ChromeURLRequestContext, to avoid changing
anything in net/base.

+
+  scoped_refptr<ChromeCookiePolicy> cookie_policy =
+      new ChromeCookiePolicy(profile_params.host_content_settings_map);
+  context->set_chrome_cookie_policy(cookie_policy);
+
+  context->set_net_log(lazy_params->io_thread->net_log());
+
+  DCHECK(network_delegate_.get());
+  context->set_network_delegate(network_delegate_.get());
+
+  context->set_host_resolver(io_thread_globals->host_resolver.get());
+  context->set_cert_verifier(io_thread_globals->cert_verifier.get());
+  context->set_dnsrr_resolver(io_thread_globals->dnsrr_resolver.get());
+  context->set_http_auth_handler_factory(
+      io_thread_globals->http_auth_handler_factory.get());
+
+  DCHECK(dns_cert_checker_.get());
+  context->set_dns_cert_checker(dns_cert_checker_.get());

[willchan no longer on Chromium, 2011/03/01 23:39:24]

In answer to your earlier question, this is OK to share. No need to create a new
one.

[Charlie Reis, 2011/03/03 01:08:05]

Thanks.

+
+  context->set_proxy_service(

[willchan no longer on Chromium, 2011/03/01 23:39:24]

We should be sharing this guy.

[Charlie Reis, 2011/03/03 01:08:05]

Fixed (via the new Copy method).

+      CreateProxyService(
+          io_thread->net_log(),
+          io_thread_globals->proxy_script_fetcher_context.get(),
+          lazy_params->profile_params.proxy_config_service.release(),
+          command_line));
+
+  context->set_cookie_store(
+      new net::CookieMonster(NULL, profile_params.cookie_monster_delegate));
+
+  net::HttpCache::BackendFactory* app_backend =
+      net::HttpCache::DefaultBackend::InMemory(0);
+  net::HttpNetworkSession* main_network_session = main_http_factory_->GetSession();
+  net::HttpCache* app_cache =
+      new net::HttpCache(main_network_session, app_backend);
+
+  context->set_http_transaction_factory(app_cache);
+  context->set_ftp_transaction_factory(
+      new net::FtpNetworkLayer(context->host_resolver()));
+
+  lazy_params_map_.erase(iter);
+  return context;
+}
+
 scoped_refptr<ChromeURLRequestContext>
 OffTheRecordProfileIOData::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>
 OffTheRecordProfileIOData::AcquireMediaRequestContext() const {
   NOTREACHED();
   return NULL;
 }
 
 scoped_refptr<ChromeURLRequestContext>
 OffTheRecordProfileIOData::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;
 }
+
+scoped_refptr<ChromeURLRequestContext>
+OffTheRecordProfileIOData::AcquireIsolatedAppRequestContext(
+    const Extension* installed_app) const {
+  // We create per-app contexts on demand, unlike the others above.
+  scoped_refptr<RequestContext> app_request_context =
+      InitializeAppRequestContext(installed_app);
+  DCHECK(app_request_context);
+  app_request_context->set_profile_io_data(this);
+  return app_request_context;
+}