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 FilePath& partition_path,
+    bool in_memory) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  CHECK(!app_id.empty());
+  // TODO(nasko): Check that the partition_path is not the same as the
+  // base profile path. We expect isolated partition, which will never go
+  // to the default profile path.
   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.
+  StoragePartitionDescriptor descriptor(partition_path, in_memory);
   ChromeURLRequestContextGetterMap::iterator iter =
-      app_request_context_getter_map_.find(app_id);
+      app_request_context_getter_map_.find(descriptor);
   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_, descriptor,
+          protocol_handler_interceptor.Pass());
+  app_request_context_getter_map_[descriptor] = context;
 
   return context;
 }
 
 scoped_refptr<ChromeURLRequestContextGetter>
 ProfileImplIOData::Handle::GetIsolatedMediaRequestContextGetter(
-    const std::string& app_id) const {
+    const FilePath& partition_path,
+    bool in_memory) 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): Check that the partition_path is not the same as the
+  // base profile path. We expect isolated partition, which will never go
+  // to the default profile path.
   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.
+  StoragePartitionDescriptor descriptor(partition_path, in_memory);
   ChromeURLRequestContextGetterMap::iterator iter =
-      isolated_media_request_context_getter_map_.find(app_id);
+      isolated_media_request_context_getter_map_.find(descriptor);
   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_path, in_memory);
   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_, descriptor);
+  isolated_media_request_context_getter_map_[descriptor] = context;
 
   return context;
 }
 
 void ProfileImplIOData::Handle::ClearNetworkingHistorySince(
     base::Time time) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   LazyInitialize();
 
   BrowserThread::PostTask(
@@ skipping 201 matching lines @@
                   extensions_context->ftp_transaction_factory(),
                   extensions_context->ftp_auth_cache());
 
   main_job_factory_ = main_job_factory.Pass();
   main_context->set_job_factory(main_job_factory_.get());
   extensions_job_factory_ = extensions_job_factory.Pass();
   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, ""));
+  StoragePartitionDescriptor 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 StoragePartitionDescriptor& partition_descriptor,
     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_descriptor.path.Append(
+      chrome::kCookieFilename);
+  FilePath cache_path = partition_descriptor.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_descriptor.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_descriptor.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 14 matching lines @@
   context->SetCookieStore(cookie_store);
   context->SetHttpTransactionFactory(
       scoped_ptr<net::HttpTransactionFactory>(app_http_cache));
 
   // Overwrite the job factory that we inherit from the main context so
   // that we can later provide our own handles for storage related protocols.
   // Install all the usual protocol handlers unless we are in a browser plugin
   // guest process, in which case only web-safe schemes are allowed.
   scoped_ptr<net::URLRequestJobFactoryImpl> job_factory(
       new net::URLRequestJobFactoryImpl());
-  if (!is_guest_process) {
+  if (!partition_descriptor.in_memory) {
     SetUpJobFactory(job_factory.get(), protocol_handler_interceptor.Pass(),
                     network_delegate(),
                     context->ftp_transaction_factory(),
                     context->ftp_auth_cache());
   }
   context->SetJobFactory(job_factory.PassAs<net::URLRequestJobFactory>());
 
   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 StoragePartitionDescriptor& partition_descriptor) const {
+  // If this is for a in_memory partition, we can simply use the original
+  // context (like off-the-record mode).
+  if (partition_descriptor.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_descriptor.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_descriptor.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 StoragePartitionDescriptor& partition_descriptor,
     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_descriptor,
                                   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 StoragePartitionDescriptor& partition_descriptor) 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_descriptor);
   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();
 }