Initial refactor to get profiles to propagate storage partition details.

chrome/browser/profiles/profile_impl_io_data.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 190 matching lines @@
   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(
-    const std::string& app_id) const {
+    const StoragePartitionDetails& partition_details) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  CHECK(!app_id.empty());
+  // TODO(nasko): Enable this check, once the browser tag is properly
+  // isolated in its own directory.
+  // CHECK_NE(partition_details.path.value(), profile_->GetPath().value());
   LazyInitialize();
 
-  // Keep a map of request context getters, one per requested app ID.
+  // Keep a map of request context getters, one per requested storage partition.
   ChromeURLRequestContextGetterMap::iterator iter =
-      app_request_context_getter_map_.find(app_id);
+      app_request_context_getter_map_.find(partition_details);
   if (iter != app_request_context_getter_map_.end())
     return iter->second;
 
   scoped_ptr<net::URLRequestJobFactory::Interceptor>
       protocol_handler_interceptor(
           ProtocolHandlerRegistryFactory::GetForProfile(profile_)->
               CreateURLInterceptor());
   ChromeURLRequestContextGetter* context =
       ChromeURLRequestContextGetter::CreateOriginalForIsolatedApp(
-          profile_, io_data_, app_id, protocol_handler_interceptor.Pass());
-  app_request_context_getter_map_[app_id] = context;
+          profile_, io_data_, partition_details,
+          protocol_handler_interceptor.Pass());
+  app_request_context_getter_map_[partition_details] = context;
 
   return context;
 }
 
 scoped_refptr<ChromeURLRequestContextGetter>
 ProfileImplIOData::Handle::GetIsolatedMediaRequestContextGetter(
-    const std::string& app_id) const {
+    const StoragePartitionDetails& partition_details) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  // We must have an app ID, or this will act like the default media context.
-  CHECK(!app_id.empty());
+  // We must have a non-default path, or this will act like the default media
+  // context.
+  // TODO(nasko): Enable this check, once the browser tag is properly
+  // isolated in its own directory.
+  // CHECK_NE(partition_details.path.value(), profile_->GetPath().value());
   LazyInitialize();
 
-  // Keep a map of request context getters, one per requested app ID.
+  // Keep a map of request context getters, one per requested storage partition.
   ChromeURLRequestContextGetterMap::iterator iter =
-      isolated_media_request_context_getter_map_.find(app_id);
+      isolated_media_request_context_getter_map_.find(partition_details);
   if (iter != isolated_media_request_context_getter_map_.end())
     return iter->second;
 
   // Get the app context as the starting point for the media context, so that
   // it uses the app's cookie store.
   ChromeURLRequestContextGetter* app_context =
-      GetIsolatedAppRequestContextGetter(app_id);
+      GetIsolatedAppRequestContextGetter(partition_details);
   ChromeURLRequestContextGetter* context =
       ChromeURLRequestContextGetter::CreateOriginalForIsolatedMedia(
-          profile_, app_context, io_data_, app_id);
-  isolated_media_request_context_getter_map_[app_id] = context;
+          profile_, app_context, io_data_, partition_details);
+  isolated_media_request_context_getter_map_[partition_details] = context;
 
   return context;
 }
 
 void ProfileImplIOData::Handle::ClearNetworkingHistorySince(
     base::Time time) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   LazyInitialize();
 
   BrowserThread::PostTask(
@@ skipping 195 matching lines @@
                   scoped_ptr<net::URLRequestJobFactoryImpl::Interceptor>(NULL),
                   NULL,
                   extensions_context->ftp_transaction_factory(),
                   extensions_context->ftp_auth_cache());
 
   main_context->set_job_factory(main_job_factory_.get());
   extensions_context->set_job_factory(extensions_job_factory_.get());
 
   // Create a media request context based on the main context, but using a
   // media cache.  It shares the same job factory as the main context.
-  media_request_context_.reset(InitializeMediaRequestContext(main_context, ""));
+  StoragePartitionDetails details(FilePath(), false);
+  media_request_context_.reset(InitializeMediaRequestContext(main_context,
+                                                             details));
 
   lazy_params_.reset();
 }
 
 ChromeURLRequestContext*
 ProfileImplIOData::InitializeAppRequestContext(
     ChromeURLRequestContext* main_context,
-    const std::string& app_id,
+    const StoragePartitionDetails& partition_details,
     scoped_ptr<net::URLRequestJobFactory::Interceptor>
         protocol_handler_interceptor) const {
-  // If this is for a guest process, we should not persist cookies and http
-  // cache.
-  bool is_guest_process = (app_id.find("guest-") != std::string::npos);
-
   // Copy most state from the main context.
   AppRequestContext* context = new AppRequestContext(load_time_stats());
   context->CopyFrom(main_context);
 
-  using content::StoragePartition;
-  FilePath app_path =
-      profile_path_.Append(StoragePartition::GetPartitionPath(app_id));
-
-  FilePath cookie_path = app_path.Append(chrome::kCookieFilename);
-  FilePath cache_path = app_path.Append(chrome::kCacheDirname);
+  FilePath cookie_path = partition_details.path.Append(chrome::kCookieFilename);
+  FilePath cache_path = partition_details.path.Append(chrome::kCacheDirname);
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   // Only allow Record Mode if we are in a Debug build or where we are running
   // a cycle, and the user has limited control.
   bool record_mode = command_line.HasSwitch(switches::kRecordMode) &&
                      (chrome::kRecordModeEnabled ||
                       command_line.HasSwitch(switches::kVisitURLs));
   bool playback_mode = command_line.HasSwitch(switches::kPlaybackMode);
 
   // Use a separate HTTP disk cache for isolated apps.
   net::HttpCache::BackendFactory* app_backend = NULL;
-  if (is_guest_process) {
+  if (partition_details.in_memory) {
     app_backend = net::HttpCache::DefaultBackend::InMemory(0);
   } else {
     app_backend = new net::HttpCache::DefaultBackend(
         net::DISK_CACHE,
         cache_path,
         app_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 (is_guest_process) {
+  if (partition_details.in_memory) {
     cookie_store = new net::CookieMonster(NULL, NULL);
   } else 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);
   }
@@ skipping 24 matching lines @@
                   context->ftp_transaction_factory(),
                   context->ftp_auth_cache());
   context->SetJobFactory(job_factory.Pass());
 
   return context;
 }
 
 ChromeURLRequestContext*
 ProfileImplIOData::InitializeMediaRequestContext(
     ChromeURLRequestContext* original_context,
-    const std::string& app_id) const {
-  // If this is for a guest process, we do not persist storage, so we can
-  // simply use the app's in-memory cache (like off-the-record mode).
-  if (app_id.find("guest-") != std::string::npos)
+    const StoragePartitionDetails& partition_details) const {
+  // If this is for a in_memory partition, we can simply use the original
+  // context (like off-the-record mode).
+  if (partition_details.in_memory)
     return original_context;
 
   // Copy most state from the original context.
   MediaRequestContext* context = new MediaRequestContext(load_time_stats());
   context->CopyFrom(original_context);
 
   using content::StoragePartition;
-  FilePath app_path =
-      profile_path_.Append(StoragePartition::GetPartitionPath(app_id));
   FilePath cache_path;
   int cache_max_size = app_media_cache_max_size_;
-  if (app_id.empty()) {
+  if (partition_details.path == profile_path_) {
     // lazy_params_ is only valid for the default media context creation.
     cache_path = lazy_params_->media_cache_path;
     cache_max_size = lazy_params_->media_cache_max_size;
   } else {
-    cache_path = app_path.Append(chrome::kMediaCacheDirname);
+    cache_path = partition_details.path.Append(chrome::kMediaCacheDirname);
   }
 
   // Use a separate HTTP disk cache for isolated apps.
   net::HttpCache::BackendFactory* media_backend =
       new net::HttpCache::DefaultBackend(
           net::MEDIA_CACHE,
           cache_path,
           cache_max_size,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
   net::HttpNetworkSession* main_network_session =
@@ skipping 15 matching lines @@
 
 ChromeURLRequestContext*
 ProfileImplIOData::AcquireMediaRequestContext() const {
   DCHECK(media_request_context_.get());
   return media_request_context_.get();
 }
 
 ChromeURLRequestContext*
 ProfileImplIOData::AcquireIsolatedAppRequestContext(
     ChromeURLRequestContext* main_context,
-    const std::string& app_id,
+    const StoragePartitionDetails& partition_details,
     scoped_ptr<net::URLRequestJobFactory::Interceptor>
         protocol_handler_interceptor) const {
   // We create per-app contexts on demand, unlike the others above.
   ChromeURLRequestContext* app_request_context =
-      InitializeAppRequestContext(main_context, app_id,
+      InitializeAppRequestContext(main_context, partition_details,
                                   protocol_handler_interceptor.Pass());
   DCHECK(app_request_context);
   return app_request_context;
 }
 
 ChromeURLRequestContext*
 ProfileImplIOData::AcquireIsolatedMediaRequestContext(
     ChromeURLRequestContext* app_context,
-    const std::string& app_id) const {
+    const StoragePartitionDetails& partition_details) const {
   // We create per-app media contexts on demand, unlike the others above.
   ChromeURLRequestContext* media_request_context =
-      InitializeMediaRequestContext(app_context, app_id);
+      InitializeMediaRequestContext(app_context, partition_details);
   DCHECK(media_request_context);
   return media_request_context;
 }
 
 chrome_browser_net::LoadTimeStats* ProfileImplIOData::GetLoadTimeStats(
     IOThread::Globals* io_thread_globals) const {
   return io_thread_globals->load_time_stats.get();
 }
 
 void ProfileImplIOData::SetUpJobFactory(
@@ skipping 14 matching lines @@
 void ProfileImplIOData::ClearNetworkingHistorySinceOnIOThread(
     base::Time time) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   LazyInitialize();
 
   DCHECK(transport_security_state());
   transport_security_state()->DeleteSince(time);
   DCHECK(http_server_properties_manager());
   http_server_properties_manager()->Clear();
 }