Initial refactor to get profiles to propagate storage partition details.

chrome/browser/net/chrome_url_request_context.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/net/chrome_url_request_context.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/load_time_stats.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_io_data.h"
+#include "chrome/browser/storage_partition_details.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/common/content_client.h"
 #include "net/cookies/cookie_store.h"
 #include "net/http/http_util.h"
 
 using content::BrowserThread;
@@ skipping 41 matching lines @@
   }
 
  private:
   const ProfileIOData* const profile_io_data_;
 };
 
 // Factory that creates the ChromeURLRequestContext for a given isolated app.
 class FactoryForIsolatedApp : public ChromeURLRequestContextFactory {
  public:
   FactoryForIsolatedApp(const ProfileIOData* profile_io_data,
-                        const std::string& app_id,
+                        const StoragePartitionDetails& partition_details,
                         ChromeURLRequestContextGetter* main_context,
                         scoped_ptr<net::URLRequestJobFactory::Interceptor>
                             protocol_handler_interceptor)
       : profile_io_data_(profile_io_data),
-        app_id_(app_id),
+        partition_details_(partition_details),
         main_request_context_getter_(main_context),
         protocol_handler_interceptor_(protocol_handler_interceptor.Pass()) {}
 
   virtual ChromeURLRequestContext* Create() OVERRIDE {
     // We will copy most of the state from the main request context.
     //
     // Note that this factory is one-shot.  After Create() is called once, the
     // factory is actually destroyed. Thus it is safe to destructively pass
     // state onwards.
     return profile_io_data_->GetIsolatedAppRequestContext(
-        main_request_context_getter_->GetIOContext(), app_id_,
+        main_request_context_getter_->GetIOContext(), partition_details_,
         protocol_handler_interceptor_.Pass());
   }
 
  private:
   const ProfileIOData* const profile_io_data_;
-  const std::string app_id_;
+  const StoragePartitionDetails partition_details_;
   scoped_refptr<ChromeURLRequestContextGetter>
       main_request_context_getter_;
   scoped_ptr<net::URLRequestJobFactory::Interceptor>
       protocol_handler_interceptor_;
 };
 
 // Factory that creates the media ChromeURLRequestContext for a given isolated
 // app.  The media context is based on the corresponding isolated app's context.
 class FactoryForIsolatedMedia : public ChromeURLRequestContextFactory {
  public:
   FactoryForIsolatedMedia(const ProfileIOData* profile_io_data,
-                          const std::string& app_id,
+                          const StoragePartitionDetails& partition_details,
                           ChromeURLRequestContextGetter* app_context)
       : profile_io_data_(profile_io_data),
-        app_id_(app_id),
+        partition_details_(partition_details),
         app_context_getter_(app_context) {}
 
   virtual ChromeURLRequestContext* Create() OVERRIDE {
     // We will copy most of the state from the corresopnding app's
     // request context. We expect to have the same lifetime as
     // the associated |app_context_getter_| so we can just reuse
     // all its backing objects, including the
     // |protocol_handler_interceptor|.  This is why the API
     // looks different from FactoryForIsolatedApp's.
     return profile_io_data_->GetIsolatedMediaRequestContext(
-        app_context_getter_->GetIOContext(), app_id_);
+        app_context_getter_->GetIOContext(), partition_details_);
   }
 
  private:
   const ProfileIOData* const profile_io_data_;
-  const std::string app_id_;
+  const StoragePartitionDetails partition_details_;
   scoped_refptr<ChromeURLRequestContextGetter> app_context_getter_;
 };
 
 // Factory that creates the ChromeURLRequestContext for media.
 class FactoryForMedia : public ChromeURLRequestContextFactory {
  public:
   explicit FactoryForMedia(const ProfileIOData* profile_io_data)
       : profile_io_data_(profile_io_data) {
   }
 
@@ skipping 76 matching lines @@
   return new ChromeURLRequestContextGetter(
       profile,
       new FactoryForExtensions(profile_io_data));
 }
 
 // static
 ChromeURLRequestContextGetter*
 ChromeURLRequestContextGetter::CreateOriginalForIsolatedApp(
     Profile* profile,
     const ProfileIOData* profile_io_data,
-    const std::string& app_id,
+    const StoragePartitionDetails& partition_details,
     scoped_ptr<net::URLRequestJobFactory::Interceptor>
         protocol_handler_interceptor) {
   DCHECK(!profile->IsOffTheRecord());
   ChromeURLRequestContextGetter* main_context =
       static_cast<ChromeURLRequestContextGetter*>(profile->GetRequestContext());
   return new ChromeURLRequestContextGetter(
       profile,
-      new FactoryForIsolatedApp(profile_io_data, app_id, main_context,
-                                protocol_handler_interceptor.Pass()));
+      new FactoryForIsolatedApp(profile_io_data, partition_details,
+           main_context, protocol_handler_interceptor.Pass()));
 }
 
 // static
 ChromeURLRequestContextGetter*
 ChromeURLRequestContextGetter::CreateOriginalForIsolatedMedia(
     Profile* profile,
     ChromeURLRequestContextGetter* app_context,
     const ProfileIOData* profile_io_data,
-    const std::string& app_id) {
+    const StoragePartitionDetails& partition_details) {
   DCHECK(!profile->IsOffTheRecord());
   return new ChromeURLRequestContextGetter(
       profile,
-      new FactoryForIsolatedMedia(profile_io_data, app_id, app_context));
+      new FactoryForIsolatedMedia(
+          profile_io_data, partition_details, app_context));
 }
 
 // static
 ChromeURLRequestContextGetter*
 ChromeURLRequestContextGetter::CreateOffTheRecord(
     Profile* profile, const ProfileIOData* profile_io_data) {
   DCHECK(profile->IsOffTheRecord());
   return new ChromeURLRequestContextGetter(
       profile, new FactoryForMain(profile_io_data));
 }
 
 // static
 ChromeURLRequestContextGetter*
 ChromeURLRequestContextGetter::CreateOffTheRecordForExtensions(
     Profile* profile, const ProfileIOData* profile_io_data) {
   DCHECK(profile->IsOffTheRecord());
   return new ChromeURLRequestContextGetter(
       profile, new FactoryForExtensions(profile_io_data));
 }
 
 // static
 ChromeURLRequestContextGetter*
 ChromeURLRequestContextGetter::CreateOffTheRecordForIsolatedApp(
     Profile* profile,
     const ProfileIOData* profile_io_data,
-    const std::string& app_id,
+    const StoragePartitionDetails& partition_details,
     scoped_ptr<net::URLRequestJobFactory::Interceptor>
         protocol_handler_interceptor) {
   DCHECK(profile->IsOffTheRecord());
   ChromeURLRequestContextGetter* main_context =
       static_cast<ChromeURLRequestContextGetter*>(profile->GetRequestContext());
   return new ChromeURLRequestContextGetter(
       profile,
-      new FactoryForIsolatedApp(profile_io_data, app_id, main_context,
-                                protocol_handler_interceptor.Pass()));
+      new FactoryForIsolatedApp(profile_io_data, partition_details,
+          main_context, protocol_handler_interceptor.Pass()));
 }
 
 void ChromeURLRequestContextGetter::CleanupOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Unregister for pref notifications.
   DCHECK(!registrar_.IsEmpty()) << "Called more than once!";
   registrar_.RemoveAll();
 }
 
 // content::NotificationObserver implementation.
@@ skipping 101 matching lines @@
       net::HttpUtil::GenerateAcceptLanguageHeader(accept_language));
 }
 
 void ChromeURLRequestContext::OnDefaultCharsetChange(
     const std::string& default_charset) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   set_referrer_charset(default_charset);
   set_accept_charset(
       net::HttpUtil::GenerateAcceptCharsetHeader(default_charset));
 }