Support partitioning of storage contexts based on render_id.

content/browser/storage_partition_map.cc

Index: content/browser/storage_partition_map.cc
diff --git a/content/browser/storage_partition_map.cc b/content/browser/storage_partition_map.cc
new file mode 100644
index 0000000000000000000000000000000000000000..26113706f43d4390679ac456f418c0c325de490b
--- /dev/null
+++ b/content/browser/storage_partition_map.cc
@@ -0,0 +1,94 @@
+// 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 "content/browser/storage_partition_map.h"
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/file_path.h"
+#include "base/stl_util.h"
+#include "base/string_util.h"
+#include "content/browser/appcache/chrome_appcache_service.h"
+#include "content/browser/resource_context_impl.h"
+#include "content/browser/storage_partition.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/common/content_constants.h"
+
+namespace content {
+
+// Dirname for storing persistent data for renderers with isolated storage.
+const FilePath::CharType kStoragePartitionDirName[] =
+    FILE_PATH_LITERAL("Storage Partitions");
+
+StoragePartitionMap::StoragePartitionMap(
+    BrowserContext* browser_context)
+    : browser_context_(browser_context) {
+}
+
+StoragePartitionMap::~StoragePartitionMap() {
+  STLDeleteContainerPairSecondPointers(partitions_.begin(),
+                                       partitions_.end());
+}
+
+StoragePartition* StoragePartitionMap::Get(const std::string& partition_id) {
+  // Find the previously created partition if it's available.
+  std::map<std::string, StoragePartition*>::const_iterator it =
+      partitions_.find(partition_id);
+  if (it != partitions_.end())
+    return it->second;
+
+  // There was no previous partition, so let's make a new one.
+  FilePath partition_path = browser_context_->GetPath();
+  if (!partition_id.empty()) {
+    // TODO(ajwong): This should check the pth is valid?
+    CHECK(IsStringASCII(partition_id));
+    partition_path = partition_path.Append(kStoragePartitionDirName)
+        .AppendASCII(partition_id);
+  }
+
+  StoragePartition* storage_partition =
+      StoragePartition::Create(browser_context_, partition_path);
+  partitions_[partition_id] = storage_partition;
+
+  PostCreateInitialization(storage_partition, partition_path);
+
+  // TODO(ajwong): We need to remove this conditional by making
+  // InitializeResourceContext() understand having different partition data
+  // based on the renderer_id.
+  if (partition_id.empty()) {
+    InitializeResourceContext(browser_context_);
+  }
+
+  return storage_partition;
+}
+
+void StoragePartitionMap::ForEach(
+    const base::Callback<void(StoragePartition*)>& callback) {
+  for (std::map<std::string, StoragePartition*>::const_iterator it =
+           partitions_.begin();
+       it != partitions_.end();
+       ++it) {
+    callback.Run(it->second);
+  }
+}
+
+void StoragePartitionMap::PostCreateInitialization(
+    StoragePartition* partition,
+    const FilePath& partition_path) {
+  // Check first to avoid memory leak in unittests.
+  if (BrowserThread::IsMessageLoopValid(BrowserThread::IO)) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&ChromeAppCacheService::InitializeOnIOThread,
+                   partition->appcache_service(),
+                   browser_context_->IsOffTheRecord() ? FilePath() :
+                       partition_path.Append(kAppCacheDirname),
+                       browser_context_->GetResourceContext(),

[michaeln, 2012/08/10 00:42:11]

Passing in browser_context_->GetResourceContext() doesn't look completely
correct for the isolated app case.

* The URLRequestContext of this ResourceContext will be used when populating
appcaches under this service, it will be using the 'default' cookies and http
cache when doing so... that's not incorrect.

* The ResourceContext is also used as inputs to the
ContentBrowserClient::AllowAppCache() method. The chrome level impl of that
interface uses the ResourceContext to navigate to the content settings
structures associated with the user profile... which does seem correct (assuming
isolated apps dont have different settings).

[awong, 2012/08/10 13:59:36]

Yes...nothing that uses GetResourceContext() has been fixed for isolated apps.
At the time of this CL, it was just too large of a chunk to bite off at once,
but maybe now it's time to start looking at it.
If I'm understanding correctly, can this be solved by passing in the appropriate
URLRequestContext instead of the whole ResourceContext?
 
Interesting.  ResourceContext is a hard chunk to bite off since it is
conceptually the IO thread projection of BrowserContext.  However, when I looked
at ResourceContext, I recall thinking that, excluding URLRequestContext, all the
storage related state was only used by 1-2 spots in the Workers implementation. 
I was hoping that instead of introducing something like a StoragePartition
concept onto the IO thread, that we would be able to look at the uses of
URLRequestContext, AppCache, etc., individually on the IO thread and make them
not use ResourceContext.

Is this doable in the AppcCache case?

+                   make_scoped_refptr(
+                       browser_context_->GetSpecialStoragePolicy())));
+  }
+}
+
+}  // namespace content