Implement the ability to obliterate a storage partition from disk.

chrome/browser/chrome_content_browser_client.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/chrome_content_browser_client.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 486 matching lines @@
 
   return GURL(partition_id).is_valid();
 }
 
 void ChromeContentBrowserClient::GetStoragePartitionConfigForSite(
     content::BrowserContext* browser_context,
     const GURL& site,
     std::string* partition_domain,
     std::string* partition_name,
     bool* in_memory) {
+  // Handle sites that may not use the default storage partition.
+  if (site.SchemeIs(chrome::kGuestScheme)) {
+    ParseNonDefaultStoragePartitionConfig(site, partition_domain,
+                                        partition_name, in_memory);

[Charlie Reis, 2012/11/16 01:45:10]

nit: Wrong indent.

+    return;
+  }
+
+  const Extension* extension = NULL;
+  Profile* profile = Profile::FromBrowserContext(browser_context);
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
+  if (extension_service) {
+    extension = extension_service->extensions()->
+        GetExtensionOrAppByURL(ExtensionURLInfo(site));
+    if (extension && extension->is_storage_isolated()) {
+      ParseNonDefaultStoragePartitionConfig(site, partition_domain,
+                                          partition_name, in_memory);
+      return;
+    }
+  }
+
+  // All other cases use the default, browser-wide, storage partition.
+  partition_domain->clear();
+  partition_name->clear();
+  *in_memory = false;
+}
+
+void ChromeContentBrowserClient::ParseNonDefaultStoragePartitionConfig(
+    const GURL& site,
+    std::string* partition_domain,
+    std::string* partition_name,
+    bool* in_memory) {
   // For the webview tag, we create special guest processes, which host the
   // tag content separately from the main application that embeds the tag.
   // A webview tag can specify both the partition name and whether the storage
   // for that partition should be persisted. Each tag gets a SiteInstance with
   // a specially formatted URL, based on the application it is hosted by and
   // the partition requested by it. The format for that URL is:
   // chrome-guest://partition_domain/persist?partition_name
   if (site.SchemeIs(chrome::kGuestScheme)) {
     // Since guest URLs are only used for packaged apps, there must be an app
     // id in the URL.
     CHECK(site.has_host());
     *partition_domain = site.host();
     // Since persistence is optional, the path must either be empty or the
     // literal string.
     *in_memory = (site.path() != "/persist");
     // The partition name is user supplied value, which we have encoded when the
     // URL was created, so it needs to be decoded.
     *partition_name = net::UnescapeURLComponent(site.query(),
                                                 net::UnescapeRule::NORMAL);
+  } else if (site.SchemeIs(extensions::kExtensionScheme)) {
+    CHECK(site.has_host());
+    // This function assumes the extension has isolated storage. For such sites,
+    // the host of the |site| is the |partition_domain|. The |in_memory| and
+    // |partition_name| are only used in guest schemes so they are cleared
+    // here.
+    *partition_domain = site.host();
+    *in_memory = false;
+    partition_name->clear();
+  } else {
+    // Serious logic error if this is being called on a |site| with an
+    // unexpected format.
+    LOG(FATAL) << "site has unexpected format: " << site;
     return;
   }
-
-  const Extension* extension = NULL;
-  Profile* profile = Profile::FromBrowserContext(browser_context);
-  ExtensionService* extension_service =
-      extensions::ExtensionSystem::Get(profile)->extension_service();
-  if (extension_service) {
-    extension = extension_service->extensions()->
-        GetExtensionOrAppByURL(ExtensionURLInfo(site));
-    if (extension && extension->is_storage_isolated()) {
-      // Extensions which have storage isolation enabled (e.g., apps), use
-      // the extension id as the |partition_domain|.
-      *partition_domain = extension->id();
-      partition_name->clear();
-      *in_memory = false;
-      return;
-    }
-  }
-
-  // All other cases use the default, browser-wide, storage partition.
-  partition_domain->clear();
-  partition_name->clear();
-  *in_memory = false;
 }
 
 content::WebContentsViewDelegate*
     ChromeContentBrowserClient::GetWebContentsViewDelegate(
         content::WebContents* web_contents) {
   return chrome::CreateWebContentsViewDelegate(web_contents);
 }
 
 void ChromeContentBrowserClient::RenderViewHostCreated(
     RenderViewHost* render_view_host) {
@@ skipping 1353 matching lines @@
     io_thread_application_locale_ = locale;
 }
 
 void ChromeContentBrowserClient::SetApplicationLocaleOnIOThread(
     const std::string& locale) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   io_thread_application_locale_ = locale;
 }
 
 }  // namespace chrome