Support multiple storage partitions in chrome://indexeddb-internals/

content/browser/indexed_db/indexed_db_internals_ui.cc

 // Copyright (c) 2013 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/indexed_db/indexed_db_internals_ui.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/threading/platform_thread.h"
 #include "base/values.h"
+#include "base/memory/scoped_vector.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/common/url_constants.h"
 #include "grit/content_resources.h"
 
 namespace content {
@@ skipping 16 matching lines @@
   source->SetDefaultResource(IDR_INDEXED_DB_INTERNALS_HTML);
 
   BrowserContext* browser_context =
       web_ui->GetWebContents()->GetBrowserContext();
   WebUIDataSource::Add(browser_context, source);
 }
 
 IndexedDBInternalsUI::~IndexedDBInternalsUI() {
 }
 
+void IndexedDBInternalsUI::AddContextFromStoragePartition(
+    ContextList* contexts,
+    std::vector<base::FilePath>* paths,
+    StoragePartition* partition) {
+  scoped_refptr<IndexedDBContext> context = partition->GetIndexedDBContext();
+  contexts->push_back(context);
+  paths->push_back(partition->GetPath());
+}
+
 void IndexedDBInternalsUI::GetAllOrigins(const base::ListValue* args) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   BrowserContext* browser_context =
       web_ui()->GetWebContents()->GetBrowserContext();
 
-  // TODO(alecflett): do this for each storage partition in the context
-  StoragePartition* partition =
-      BrowserContext::GetDefaultStoragePartition(browser_context);
-  scoped_refptr<IndexedDBContext> context = partition->GetIndexedDBContext();
+  scoped_ptr<std::vector<base::FilePath> >
+      paths(new std::vector<base::FilePath>);
+  scoped_ptr<ContextList> contexts(new ContextList);
+  BrowserContext::StoragePartitionCallback cb =
+      base::Bind(&AddContextFromStoragePartition, contexts.get(), paths.get());
+  BrowserContext::ForEachStoragePartition(browser_context, cb);
 
   BrowserThread::PostTask(
       BrowserThread::WEBKIT_DEPRECATED, FROM_HERE,
       base::Bind(
           &IndexedDBInternalsUI::GetAllOriginsOnWebkitThread,
           base::Unretained(this),
-          context));
+          base::Passed(&contexts),
+          base::Passed(&paths)));
 }
 
 bool HostNameComparator(const IndexedDBInfo& i, const IndexedDBInfo& j) {
   return i.origin.host() < j.origin.host();
 }
 
 void IndexedDBInternalsUI::GetAllOriginsOnWebkitThread(
-    scoped_refptr<IndexedDBContext> context) {
+    scoped_ptr<ContextList> contexts,
+    scoped_ptr<std::vector<base::FilePath> > context_paths) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
+  DCHECK_EQ(contexts->size(), context_paths->size());

[jsbell, 2013/04/12 21:25:59]

As discussed offline, an alternative would be to make it a
scoped_ptr<std::vector<std::pair<S,T> > > instead, but that's probably less
readable than what you have here

 
-  scoped_ptr<std::vector<IndexedDBInfo> > origins(
-      new std::vector<IndexedDBInfo>(context->GetAllOriginsInfo()));
-  std::sort(origins->begin(), origins->end(), HostNameComparator);
+  std::vector<base::FilePath>::const_iterator path_iter =
+      context_paths->begin();
+  for (ContextList::const_iterator iter = contexts->begin();

[jsbell, 2013/04/12 21:25:59]

... although it would make this dual-iteration slightly clearer. Ah well,
probably still not worth it.

+       iter != contexts->end(); ++iter) {

[michaeln, 2013/04/12 23:00:31]

nit: would dbl-iter be more clear with ++iter, ++path_iter being in the loop
construct?

+    IndexedDBContext* context = *iter;
+    const base::FilePath& context_path = *path_iter;
 
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&IndexedDBInternalsUI::OnOriginsReady, base::Unretained(this),
-                 base::Passed(&origins)));
+    scoped_ptr<std::vector<IndexedDBInfo> > info_list(
+        new std::vector<IndexedDBInfo>(context->GetAllOriginsInfo()));
+    std::sort(info_list->begin(), info_list->end(), HostNameComparator);
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&IndexedDBInternalsUI::OnOriginsReady,
+                   base::Unretained(this),
+                   base::Passed(&info_list),
+                   context_path));
+    ++path_iter;
+  }
 }
 
 void IndexedDBInternalsUI::OnOriginsReady(
-    scoped_ptr<std::vector<IndexedDBInfo> > origins) {
+    scoped_ptr<std::vector<IndexedDBInfo> > origins,
+    const base::FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::ListValue urls;
   for (std::vector<IndexedDBInfo>::const_iterator iter = origins->begin();
        iter != origins->end(); ++iter) {
     base::DictionaryValue* info = new DictionaryValue;
     info->SetString("url", iter->origin.spec());
     info->SetDouble("size", iter->size);
     info->SetDouble("last_modified", iter->last_modified.ToJsTime());
+    info->SetString("path", iter->path.value());
     urls.Append(info);
   }
-  web_ui()->CallJavascriptFunction("indexeddb.onOriginsReady", urls);
+  web_ui()->CallJavascriptFunction("indexeddb.onOriginsReady",
+                                   urls,
+                                   base::StringValue(path.value()));
 }
 }