Initial support for partitioning cookies for isolated apps.

chrome/browser/profiles/profile_impl_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_impl_io_data.h"
 
 #include "base/command_line.h"
+#include "base/file_util.h"
 #include "base/logging.h"
+#include "base/stl_util-inl.h"
 #include "chrome/browser/browser_process.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/sqlite_persistent_cookie_store.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_thread.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();
+
+  // 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 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) {
+                                     const FilePath& extensions_cookie_path,
+                                     const FilePath& app_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);
+
+  // Keep track of isolated app path separately so we can use it on demand.
+  io_data_->app_path_ = app_path;
 }
 
 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_);
@@ skipping 18 matching lines @@
   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_;
 }
 
+scoped_refptr<ChromeURLRequestContextGetter>
+ProfileImplIOData::Handle::GetIsolatedAppRequestContextGetter(
+    std::string app_id) const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!app_id.empty());
+  LazyInitialize();
+
+  // Keep a map of request context getters, one per requested app ID.
+  ChromeURLRequestContextGetterMap::iterator iter =
+      app_request_context_getter_map_.find(app_id);
+  if (iter != app_request_context_getter_map_.end())
+    return iter->second;
+
+  ChromeURLRequestContextGetter* context =
+      ChromeURLRequestContextGetter::CreateOriginalForIsolatedApp(
+          profile_, io_data_, app_id);
+  app_request_context_getter_map_[app_id] = context;
+
+  return context;
+}
+
 void ProfileImplIOData::Handle::LazyInitialize() const {
   if (!initialized_) {
     InitializeProfileParams(profile_, &io_data_->lazy_params_->profile_params);
+    // Keep track of clear_local_state_on_exit for isolated apps.
+    io_data_->clear_local_state_on_exit_ =
+        io_data_->lazy_params_->profile_params.clear_local_state_on_exit;
     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() {}
+ProfileImplIOData::~ProfileImplIOData() {
+  STLDeleteValues(&app_http_factory_map_);
+}
 
 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();
@@ skipping 124 matching lines @@
   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<ProfileIOData::RequestContext>
+ProfileImplIOData::InitializeAppRequestContext(
+    scoped_refptr<ChromeURLRequestContext> main_context,
+    std::string app_id) const {
+  scoped_refptr<ProfileIOData::RequestContext> context = new RequestContext;
+
+  // Copy most state from the main context.
+  context->CopyFrom(main_context);
+
+  FilePath app_path = app_path_.AppendASCII(app_id);
+  FilePath cookie_path = app_path.Append(chrome::kCookieFilename);
+  FilePath cache_path = app_path.Append(chrome::kCacheDirname);
+  // TODO(creis): Determine correct cache size.
+  int cache_max_size = 0;
+
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  bool record_mode = chrome::kRecordModeEnabled &&
+                     command_line.HasSwitch(switches::kRecordMode);
+  bool playback_mode = command_line.HasSwitch(switches::kPlaybackMode);
+
+  // Use a separate HTTP disk cache for isolated apps.
+  net::HttpCache::DefaultBackend* app_backend =
+      new net::HttpCache::DefaultBackend(
+          net::DISK_CACHE,
+          cache_path,
+          cache_max_size,
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
+  net::HttpNetworkSession* main_network_session =
+      main_http_factory_->GetSession();
+  net::HttpCache* app_http_cache =
+      new net::HttpCache(main_network_session, app_backend);
+
+  scoped_refptr<net::CookieStore> cookie_store = NULL;
+  if (record_mode || playback_mode) {
+    // Don't use existing cookies and use an in-memory store.
+    // TODO(creis): We should have a cookie delegate for notifying the cookie
+    // extensions API, but we need to update it to understand isolated apps
+    // first.
+    cookie_store = new net::CookieMonster(NULL, NULL);
+    app_http_cache->set_mode(
+        record_mode ? net::HttpCache::RECORD : net::HttpCache::PLAYBACK);
+  }
+
+  // Use an app-specific cookie store.
+  if (!cookie_store) {
+    DCHECK(!cookie_path.empty());
+
+    scoped_refptr<SQLitePersistentCookieStore> cookie_db =
+        new SQLitePersistentCookieStore(cookie_path);
+    cookie_db->SetClearLocalStateOnExit(clear_local_state_on_exit_);
+    // TODO(creis): We should have a cookie delegate for notifying the cookie
+    // extensions API, but we need to update it to understand isolated apps
+    // first.
+    cookie_store = new net::CookieMonster(cookie_db.get(), NULL);
+  }
+
+  context->set_cookie_store(cookie_store);
+
+  // Keep track of app_http_cache to delete it when we go away.
+  app_http_factory_map_[app_id] = app_http_cache;

[Matt Perry, 2011/03/15 00:40:56]

Should we DCHECK that app_http_factory_map_[app_id] is unset? I assume you only
ever want to init a context once per app_id.

[Charlie Reis, 2011/03/15 06:23:42]

Sure, that's a good idea.  Added.

+  context->set_http_transaction_factory(app_http_cache);
+
+  return context;
+}
+
 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;
 }
+
+scoped_refptr<ChromeURLRequestContext>
+ProfileImplIOData::AcquireIsolatedAppRequestContext(
+    scoped_refptr<ChromeURLRequestContext> main_context,
+    std::string app_id) const {
+  // We create per-app contexts on demand, unlike the others above.
+  scoped_refptr<RequestContext> app_request_context =
+      InitializeAppRequestContext(main_context, app_id);
+  DCHECK(app_request_context);
+  app_request_context->set_profile_io_data(this);
+  return app_request_context;
+}