Refactoring CookiesTreeModel to support multiple data sources.

chrome/browser/cookies_tree_model.cc

Index: chrome/browser/cookies_tree_model.cc
diff --git a/chrome/browser/cookies_tree_model.cc b/chrome/browser/cookies_tree_model.cc
index 8d66ec80f390d78513ca38bdb9d119ff6290fadc..8f606fb4c00b5be6394dd405e00cf947ba78acc6 100644
--- a/chrome/browser/cookies_tree_model.cc
+++ b/chrome/browser/cookies_tree_model.cc
@@ -38,10 +38,15 @@ void CookieTreeNode::DeleteStoredObjects() {
 }
 
 CookiesTreeModel* CookieTreeNode::GetModel() const {
-  if (parent())
-    return parent()->GetModel();
-  else
+  if (parent()) {
+    if (parent()->parent()) {
+      return parent()->parent()->GetModel();
+    } else {
+      return parent()->GetModel();
+    }
+  } else {
     return NULL;
+  }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -57,8 +62,15 @@ CookieTreeCookieNode::~CookieTreeCookieNode() {}
 
 void CookieTreeCookieNode::DeleteStoredObjects() {
   // notify CookieMonster that we should delete this cookie
-  GetModel()->cookie_helper_->DeleteCookie(*cookie_);
-  GetModel()->cookie_list_.erase(cookie_);
+  CookieTreeAppNode* app = static_cast<CookieTreeAppNode*>(
+      parent()->parent()->parent());
+  LocalDataContainer* container = GetModel()->GetLocalDataContainer(
+      app->app_id());
+
+  if (container) {
+    container->cookie_helper_->DeleteCookie(*cookie_);
+    container->cookie_list_.erase(cookie_);
+  }
 }
 
 CookieTreeNode::DetailedInfo CookieTreeCookieNode::GetDetailedInfo() const {
@@ -139,10 +151,18 @@ CookieTreeAppCacheNode::~CookieTreeAppCacheNode() {
 }
 
 void CookieTreeAppCacheNode::DeleteStoredObjects() {
-  DCHECK(GetModel()->appcache_helper_);
-  GetModel()->appcache_helper_->DeleteAppCacheGroup(
-      appcache_info_->manifest_url);
-  GetModel()->appcache_info_[origin_url_].erase(appcache_info_);
+  ////DCHECK(GetModel()->appcache_helper_);
+
+  CookieTreeAppNode* app = static_cast<CookieTreeAppNode*>(
+      parent()->parent()->parent());
+  LocalDataContainer* container = GetModel()->GetLocalDataContainer(
+      app->app_id());
+
+  if (container) {
+    container->appcache_helper_->DeleteAppCacheGroup(
+        appcache_info_->manifest_url);
+    container->appcache_info_[origin_url_].erase(appcache_info_);
+  }
 }
 
 CookieTreeNode::DetailedInfo CookieTreeAppCacheNode::GetDetailedInfo() const {
@@ -164,9 +184,16 @@ CookieTreeDatabaseNode::CookieTreeDatabaseNode(
 CookieTreeDatabaseNode::~CookieTreeDatabaseNode() {}
 
 void CookieTreeDatabaseNode::DeleteStoredObjects() {
-  GetModel()->database_helper_->DeleteDatabase(
-      database_info_->origin_identifier, database_info_->database_name);
-  GetModel()->database_info_list_.erase(database_info_);
+  CookieTreeAppNode* app = static_cast<CookieTreeAppNode*>(
+      parent()->parent()->parent());
+  LocalDataContainer* container = GetModel()->GetLocalDataContainer(
+      app->app_id());
+
+  if (container) {
+    container->database_helper_->DeleteDatabase(
+        database_info_->origin_identifier, database_info_->database_name);
+    container->database_info_list_.erase(database_info_);
+  }
 }
 
 CookieTreeNode::DetailedInfo CookieTreeDatabaseNode::GetDetailedInfo() const {
@@ -190,9 +217,16 @@ CookieTreeLocalStorageNode::CookieTreeLocalStorageNode(
 CookieTreeLocalStorageNode::~CookieTreeLocalStorageNode() {}
 
 void CookieTreeLocalStorageNode::DeleteStoredObjects() {
-  GetModel()->local_storage_helper_->DeleteLocalStorageFile(
-      local_storage_info_->file_path);
-  GetModel()->local_storage_info_list_.erase(local_storage_info_);
+  CookieTreeAppNode* app = static_cast<CookieTreeAppNode*>(
+      parent()->parent()->parent());
+  LocalDataContainer* container = GetModel()->GetLocalDataContainer(
+      app->app_id());
+
+  if (container) {
+    container->local_storage_helper_->DeleteLocalStorageFile(
+        local_storage_info_->file_path);
+    container->local_storage_info_list_.erase(local_storage_info_);
+  }
 }
 
 CookieTreeNode::DetailedInfo
@@ -217,7 +251,14 @@ CookieTreeSessionStorageNode::CookieTreeSessionStorageNode(
 CookieTreeSessionStorageNode::~CookieTreeSessionStorageNode() {}
 
 void CookieTreeSessionStorageNode::DeleteStoredObjects() {
-  GetModel()->session_storage_info_list_.erase(session_storage_info_);
+  CookieTreeAppNode* app = static_cast<CookieTreeAppNode*>(
+      parent()->parent()->parent());
+  LocalDataContainer* container = GetModel()->GetLocalDataContainer(
+      app->app_id());
+
+  if (container) {
+    container->session_storage_info_list_.erase(session_storage_info_);
+  }
 }
 
 CookieTreeNode::DetailedInfo
@@ -240,9 +281,16 @@ CookieTreeIndexedDBNode::CookieTreeIndexedDBNode(
 CookieTreeIndexedDBNode::~CookieTreeIndexedDBNode() {}
 
 void CookieTreeIndexedDBNode::DeleteStoredObjects() {
-  GetModel()->indexed_db_helper_->DeleteIndexedDB(
-      indexed_db_info_->origin);
-  GetModel()->indexed_db_info_list_.erase(indexed_db_info_);
+  CookieTreeAppNode* app = static_cast<CookieTreeAppNode*>(
+      parent()->parent()->parent());
+  LocalDataContainer* container = GetModel()->GetLocalDataContainer(
+      app->app_id());
+
+  if (container) {
+    container->indexed_db_helper_->DeleteIndexedDB(
+        indexed_db_info_->origin);
+    container->indexed_db_info_list_.erase(indexed_db_info_);
+  }
 }
 
 CookieTreeNode::DetailedInfo CookieTreeIndexedDBNode::GetDetailedInfo() const {
@@ -264,9 +312,16 @@ CookieTreeFileSystemNode::CookieTreeFileSystemNode(
 CookieTreeFileSystemNode::~CookieTreeFileSystemNode() {}
 
 void CookieTreeFileSystemNode::DeleteStoredObjects() {
-  GetModel()->file_system_helper_->DeleteFileSystemOrigin(
-      file_system_info_->origin);
-  GetModel()->file_system_info_list_.erase(file_system_info_);
+  CookieTreeAppNode* app = static_cast<CookieTreeAppNode*>(
+      parent()->parent()->parent());
+  LocalDataContainer* container = GetModel()->GetLocalDataContainer(
+      app->app_id());
+
+  if (container) {
+    container->file_system_helper_->DeleteFileSystemOrigin(
+        file_system_info_->origin);
+    container->file_system_info_list_.erase(file_system_info_);
+  }
 }
 
 CookieTreeNode::DetailedInfo CookieTreeFileSystemNode::GetDetailedInfo() const {
@@ -288,8 +343,15 @@ CookieTreeQuotaNode::~CookieTreeQuotaNode() {}
 void CookieTreeQuotaNode::DeleteStoredObjects() {
   // Calling this function may cause unexpected over-quota state of origin.
   // However, it'll caused no problem, just prevent usage growth of the origin.
-  GetModel()->quota_helper_->RevokeHostQuota(quota_info_->host);
-  GetModel()->quota_info_list_.erase(quota_info_);
+  CookieTreeAppNode* app = static_cast<CookieTreeAppNode*>(
+      parent()->parent());
+  LocalDataContainer* container = GetModel()->GetLocalDataContainer(
+      app->app_id());
+
+  if (container) {
+    container->quota_helper_->RevokeHostQuota(quota_info_->host);
+    container->quota_info_list_.erase(quota_info_);
+  }
 }
 
 CookieTreeNode::DetailedInfo CookieTreeQuotaNode::GetDetailedInfo() const {
@@ -309,9 +371,16 @@ CookieTreeServerBoundCertNode::CookieTreeServerBoundCertNode(
 CookieTreeServerBoundCertNode::~CookieTreeServerBoundCertNode() {}
 
 void CookieTreeServerBoundCertNode::DeleteStoredObjects() {
-  GetModel()->server_bound_cert_helper_->DeleteServerBoundCert(
-      server_bound_cert_->server_identifier());
-  GetModel()->server_bound_cert_list_.erase(server_bound_cert_);
+  CookieTreeAppNode* app = static_cast<CookieTreeAppNode*>(
+      parent()->parent()->parent());
+  LocalDataContainer* container = GetModel()->GetLocalDataContainer(
+      app->app_id());
+
+  if (container) {
+    container->server_bound_cert_helper_->DeleteServerBoundCert(
+        server_bound_cert_->server_identifier());
+    container->server_bound_cert_list_.erase(server_bound_cert_);
+  }
 }
 
 CookieTreeNode::DetailedInfo
@@ -329,6 +398,7 @@ CookieTreeRootNode::CookieTreeRootNode(CookiesTreeModel* model)
 
 CookieTreeRootNode::~CookieTreeRootNode() {}
 
+/*

[markusheintz_, 2012/06/13 23:40:39]

Please remove commented code.

 CookieTreeOriginNode* CookieTreeRootNode::GetOrCreateOriginNode(
     const GURL& url) {
   CookieTreeOriginNode origin_node(url);
@@ -351,6 +421,29 @@ CookieTreeOriginNode* CookieTreeRootNode::GetOrCreateOriginNode(
   model_->Add(this, retval, (origin_node_iterator - children().begin()));
   return retval;
 }
+*/
+CookieTreeAppNode* CookieTreeRootNode::GetOrCreateAppNode(
+    const string16& app_name,
+    const string16& app_id) {
+  CookieTreeAppNode app_node(app_name, app_id);
+
+  // First see if there is an existing match.
+  std::vector<CookieTreeNode*>::iterator app_node_iterator =
+      std::lower_bound(children().begin(),
+                       children().end(),
+                       &app_node,
+                       AppNodeComparator());
+
+  if (app_node_iterator != children().end())
+    return static_cast<CookieTreeAppNode*>(*app_node_iterator);
+
+  // Node doesn't exist, create a new one and insert it into the (ordered)
+  // children.
+  CookieTreeAppNode* retval = new CookieTreeAppNode(app_name, app_id);
+  DCHECK(model_);
+  model_->Add(this, retval, (app_node_iterator - children().begin()));
+  return retval;
+}
 
 CookiesTreeModel* CookieTreeRootNode::GetModel() const {
   return model_;
@@ -361,6 +454,45 @@ CookieTreeNode::DetailedInfo CookieTreeRootNode::GetDetailedInfo() const {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// CookieTreeAppNode, public:
+
+CookieTreeAppNode::CookieTreeAppNode(const string16& app_name,
+                                     const string16& app_id)
+    : CookieTreeNode(app_name),
+      app_name_(app_name),
+      app_id_(app_id) {}
+
+CookieTreeAppNode::~CookieTreeAppNode() {}
+
+CookieTreeOriginNode* CookieTreeAppNode::GetOrCreateOriginNode(
+    const GURL& url) {
+  CookieTreeOriginNode origin_node(app_id_, url);
+
+  // First see if there is an existing match.
+  std::vector<CookieTreeNode*>::iterator origin_node_iterator =
+      std::lower_bound(children().begin(),
+                       children().end(),
+                       &origin_node,
+                       OriginNodeComparator());
+
+  if (origin_node_iterator != children().end() &&
+      WideToUTF16Hack(CookieTreeOriginNode::TitleForUrl(url)) ==
+      (*origin_node_iterator)->GetTitle())
+    return static_cast<CookieTreeOriginNode*>(*origin_node_iterator);
+  // Node doesn't exist, create a new one and insert it into the (ordered)
+  // children.
+  CookieTreeOriginNode* retval = new CookieTreeOriginNode(app_id_, url);
+  GetModel()->Add(this, retval, (origin_node_iterator - children().begin()));
+  return retval;
+}
+
+CookieTreeNode::DetailedInfo CookieTreeAppNode::GetDetailedInfo() const {
+  // TODO(nasko): Fix the proper string to be passed instead of GetTitle if
+  // need be.
+  return DetailedInfo(GetTitle()).InitApp(app_name_, app_id_);
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // CookieTreeOriginNode, public:
 
 // static
@@ -369,7 +501,7 @@ std::wstring CookieTreeOriginNode::TitleForUrl(
   return UTF8ToWide(url.SchemeIsFile() ? kFileOriginNodeName : url.host());
 }
 
-CookieTreeOriginNode::CookieTreeOriginNode(const GURL& url)
+CookieTreeOriginNode::CookieTreeOriginNode(const string16& app, const GURL& url)
     : CookieTreeNode(WideToUTF16Hack(TitleForUrl(url))),
       cookies_child_(NULL),
       databases_child_(NULL),
@@ -380,7 +512,8 @@ CookieTreeOriginNode::CookieTreeOriginNode(const GURL& url)
       file_systems_child_(NULL),
       quota_child_(NULL),
       server_bound_certs_child_(NULL),
-      url_(url) {}
+      url_(url),
+      app_id_(app) {}
 
 CookieTreeOriginNode::~CookieTreeOriginNode() {}
 
@@ -612,6 +745,15 @@ bool CookieTreeNode::NodeTitleComparator::operator() (
   return (left->GetTitle() < right->GetTitle());
 }
 
+bool CookieTreeNode::AppNodeComparator::operator() (
+    const CookieTreeNode* lhs, const CookieTreeNode* rhs) {
+  const CookieTreeAppNode* left =
+      static_cast<const CookieTreeAppNode*>(lhs);
+  const CookieTreeAppNode* right =
+      static_cast<const CookieTreeAppNode*>(rhs);
+  return (left->app_id() < right->app_id());
+}
+
 void CookieTreeNode::AddChildSortedByTitle(CookieTreeNode* new_child) {
   DCHECK(new_child);
   std::vector<CookieTreeNode*>::iterator iter =
@@ -624,80 +766,14 @@ void CookieTreeNode::AddChildSortedByTitle(CookieTreeNode* new_child) {
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookiesTreeModel, public:
-
-CookiesTreeModel::CookiesTreeModel(
-    BrowsingDataCookieHelper* cookie_helper,
-    BrowsingDataDatabaseHelper* database_helper,
-    BrowsingDataLocalStorageHelper* local_storage_helper,
-    BrowsingDataLocalStorageHelper* session_storage_helper,
-    BrowsingDataAppCacheHelper* appcache_helper,
-    BrowsingDataIndexedDBHelper* indexed_db_helper,
-    BrowsingDataFileSystemHelper* file_system_helper,
-    BrowsingDataQuotaHelper* quota_helper,
-    BrowsingDataServerBoundCertHelper* server_bound_cert_helper,
-    bool use_cookie_source)
+CookiesTreeModel::CookiesTreeModel(ContainerMap& apps_map)
     : ALLOW_THIS_IN_INITIALIZER_LIST(ui::TreeNodeModel<CookieTreeNode>(
           new CookieTreeRootNode(this))),
-      appcache_helper_(appcache_helper),
-      cookie_helper_(cookie_helper),
-      database_helper_(database_helper),
-      local_storage_helper_(local_storage_helper),
-      session_storage_helper_(session_storage_helper),
-      indexed_db_helper_(indexed_db_helper),
-      file_system_helper_(file_system_helper),
-      quota_helper_(quota_helper),
-      server_bound_cert_helper_(server_bound_cert_helper),
-      batch_update_(0),
-      use_cookie_source_(use_cookie_source),
-      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
-  DCHECK(cookie_helper_);
-  cookie_helper_->StartFetching(
-      base::Bind(&CookiesTreeModel::OnCookiesModelInfoLoaded,
-                 weak_ptr_factory_.GetWeakPtr()));
-  DCHECK(database_helper_);
-  database_helper_->StartFetching(
-      base::Bind(&CookiesTreeModel::OnDatabaseModelInfoLoaded,
-                 weak_ptr_factory_.GetWeakPtr()));
-  DCHECK(local_storage_helper_);
-  local_storage_helper_->StartFetching(
-      base::Bind(&CookiesTreeModel::OnLocalStorageModelInfoLoaded,
-                 weak_ptr_factory_.GetWeakPtr()));
-  if (session_storage_helper_) {
-    session_storage_helper_->StartFetching(
-        base::Bind(&CookiesTreeModel::OnSessionStorageModelInfoLoaded,
-                   weak_ptr_factory_.GetWeakPtr()));
-  }
-
-  // TODO(michaeln): When all of the UI implementations have been updated, make
-  // this a required parameter.
-  if (appcache_helper_) {
-    appcache_helper_->StartFetching(
-        base::Bind(&CookiesTreeModel::OnAppCacheModelInfoLoaded,
-                   weak_ptr_factory_.GetWeakPtr()));
-  }
-
-  if (indexed_db_helper_) {
-    indexed_db_helper_->StartFetching(
-        base::Bind(&CookiesTreeModel::OnIndexedDBModelInfoLoaded,
-                   weak_ptr_factory_.GetWeakPtr()));
-  }
-
-  if (file_system_helper_) {
-    file_system_helper_->StartFetching(
-        base::Bind(&CookiesTreeModel::OnFileSystemModelInfoLoaded,
-                   weak_ptr_factory_.GetWeakPtr()));
-  }
-
-  if (quota_helper_) {
-    quota_helper_->StartFetching(
-        base::Bind(&CookiesTreeModel::OnQuotaModelInfoLoaded,
-                   weak_ptr_factory_.GetWeakPtr()));
-  }
-
-  if (server_bound_cert_helper_) {
-    server_bound_cert_helper_->StartFetching(
-        base::Bind(&CookiesTreeModel::OnServerBoundCertModelInfoLoaded,
-                   weak_ptr_factory_.GetWeakPtr()));
+      batch_update_(0) {
+  for (ContainerMap::iterator it = apps_map.begin();
+        it != apps_map.end(); ++it) {
+    app_data_map_[it->first] = it->second;
+    it->second->Init(this);
   }
 }
 
@@ -777,15 +853,15 @@ void CookiesTreeModel::UpdateSearchResults(const std::wstring& filter) {
   NotifyObserverBeginBatch();
   for (int i = num_children - 1; i >= 0; --i)
     delete Remove(root, root->GetChild(i));
-  PopulateCookieInfoWithFilter(filter);
-  PopulateDatabaseInfoWithFilter(filter);
-  PopulateLocalStorageInfoWithFilter(filter);
-  PopulateSessionStorageInfoWithFilter(filter);
-  PopulateAppCacheInfoWithFilter(filter);
-  PopulateIndexedDBInfoWithFilter(filter);
-  PopulateFileSystemInfoWithFilter(filter);
-  PopulateQuotaInfoWithFilter(filter);
-  PopulateServerBoundCertInfoWithFilter(filter);
+  PopulateCookieInfoWithFilter(NULL, filter);
+  PopulateDatabaseInfoWithFilter(NULL, filter);
+  PopulateLocalStorageInfoWithFilter(NULL, filter);
+  PopulateSessionStorageInfoWithFilter(NULL, filter);
+  PopulateAppCacheInfoWithFilter(NULL, filter);
+  PopulateIndexedDBInfoWithFilter(NULL, filter);
+  PopulateFileSystemInfoWithFilter(NULL, filter);
+  PopulateQuotaInfoWithFilter(NULL, filter);
+  PopulateServerBoundCertInfoWithFilter(NULL, filter);
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
@@ -802,329 +878,443 @@ void CookiesTreeModel::RemoveCookiesTreeObserver(Observer* observer) {
   ui::TreeNodeModel<CookieTreeNode>::RemoveObserver(observer);
 }
 
-void CookiesTreeModel::OnAppCacheModelInfoLoaded() {
-  using appcache::AppCacheInfo;
-  using appcache::AppCacheInfoCollection;
-  using appcache::AppCacheInfoVector;
-  typedef std::map<GURL, AppCacheInfoVector> InfoByOrigin;
-
-  scoped_refptr<AppCacheInfoCollection> appcache_info =
-      appcache_helper_->info_collection();
-  if (!appcache_info || appcache_info->infos_by_origin.empty())
-    return;
-
-  for (InfoByOrigin::const_iterator origin =
-           appcache_info->infos_by_origin.begin();
-       origin != appcache_info->infos_by_origin.end(); ++origin) {
-    std::list<AppCacheInfo>& info_list = appcache_info_[origin->first];
-    info_list.insert(
-        info_list.begin(), origin->second.begin(), origin->second.end());
-  }
-
-  PopulateAppCacheInfoWithFilter(std::wstring());
-}
-
 void CookiesTreeModel::PopulateAppCacheInfoWithFilter(
+    string16* app,
     const std::wstring& filter) {
+
   using appcache::AppCacheInfo;
   typedef std::map<GURL, std::list<AppCacheInfo> > InfoByOrigin;
+  CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
+  bool begin_batch = false;
 
-  if (appcache_info_.empty())
-    return;
+  for (ContainerMap::iterator ait = app_data_map_.begin();
+       ait != app_data_map_.end(); ++ait ) {
+    LocalDataContainer* container = ait->second;
 
-  CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
-  NotifyObserverBeginBatch();
-  for (InfoByOrigin::iterator origin = appcache_info_.begin();
-       origin != appcache_info_.end(); ++origin) {
-    std::wstring origin_node_name = UTF8ToWide(origin->first.host());
-    if (filter.empty() ||
-        (origin_node_name.find(filter) != std::wstring::npos)) {
-      CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(origin->first);
-      CookieTreeAppCachesNode* appcaches_node =
-          origin_node->GetOrCreateAppCachesNode();
-
-      for (std::list<AppCacheInfo>::iterator info = origin->second.begin();
-           info != origin->second.end(); ++info) {
-        appcaches_node->AddAppCacheNode(
-            new CookieTreeAppCacheNode(origin->first, info));
+    if (container->appcache_info_.empty())
+      continue;
+
+    if (app && *app != container->app_id())
+      continue;
+
+    if (!begin_batch) {
+      NotifyObserverBeginBatch();
+      begin_batch = true;
+    }
+
+    CookieTreeAppNode* app_node =
+        root->GetOrCreateAppNode(container->app_name(), container->app_id());
+
+    for (InfoByOrigin::iterator origin = container->appcache_info_.begin();
+        origin != container->appcache_info_.end(); ++origin) {
+      std::wstring origin_node_name = UTF8ToWide(origin->first.host());
+      if (filter.empty() ||
+          (origin_node_name.find(filter) != std::wstring::npos)) {
+        CookieTreeOriginNode* origin_node =
+            app_node->GetOrCreateOriginNode(origin->first);
+        CookieTreeAppCachesNode* appcaches_node =
+            origin_node->GetOrCreateAppCachesNode();
+
+        for (std::list<AppCacheInfo>::iterator info = origin->second.begin();
+            info != origin->second.end(); ++info) {
+          appcaches_node->AddAppCacheNode(
+              new CookieTreeAppCacheNode(origin->first, info));
+        }
       }
     }
   }
-  NotifyObserverTreeNodeChanged(root);
-  NotifyObserverEndBatch();
-}
 
-void CookiesTreeModel::OnCookiesModelInfoLoaded(
-    const net::CookieList& cookie_list) {
-  cookie_list_.insert(cookie_list_.begin(),
-                      cookie_list.begin(),
-                      cookie_list.end());
-  PopulateCookieInfoWithFilter(std::wstring());
+  if (begin_batch) {
+    NotifyObserverTreeNodeChanged(root);
+    NotifyObserverEndBatch();
+  }
 }
 
 void CookiesTreeModel::PopulateCookieInfoWithFilter(
+    string16* app,
     const std::wstring& filter) {
   // mmargh mmargh mmargh! delicious!
 
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
   NotifyObserverBeginBatch();
-  for (CookieList::iterator it = cookie_list_.begin();
-       it != cookie_list_.end(); ++it) {
-    std::string source_string = it->Source();
-    if (source_string.empty() || !use_cookie_source_) {
-      std::string domain = it->Domain();
-      if (domain.length() > 1 && domain[0] == '.')
-        domain = domain.substr(1);
-
-      // We treat secure cookies just the same as normal ones.
-      source_string = std::string(chrome::kHttpScheme) +
-          content::kStandardSchemeSeparator + domain + "/";
-    }
+  for (ContainerMap::iterator ait = app_data_map_.begin();

[markusheintz_, 2012/06/13 23:40:39]

Please replace "ait" with a better name.  

+       ait != app_data_map_.end(); ++ait ) {
+    LocalDataContainer* container = ait->second;
+
+    if (app && *app != container->app_id())
+      continue;
+
+    CookieTreeAppNode* app_node =
+        root->GetOrCreateAppNode(container->app_name(), container->app_id());
+
+    for (CookieList::iterator it = container->cookie_list_.begin();
+        it != container->cookie_list_.end(); ++it) {
+      std::string source_string = it->Source();
+      if (source_string.empty() || !use_cookie_source_) {
+        std::string domain = it->Domain();
+        if (domain.length() > 1 && domain[0] == '.')
+          domain = domain.substr(1);
+
+        // We treat secure cookies just the same as normal ones.
+        source_string = std::string(chrome::kHttpScheme) +
+            content::kStandardSchemeSeparator + domain + "/";
+      }
 
-    GURL source(source_string);
-    if (!filter.size() ||
-        (CookieTreeOriginNode::TitleForUrl(source).find(filter) !=
-         std::string::npos)) {
-      CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(source);
-      CookieTreeCookiesNode* cookies_node =
-          origin_node->GetOrCreateCookiesNode();
-      CookieTreeCookieNode* new_cookie = new CookieTreeCookieNode(it);
-      cookies_node->AddCookieNode(new_cookie);
+      GURL source(source_string);
+      if (!filter.size() ||
+          (CookieTreeOriginNode::TitleForUrl(source).find(filter) !=
+          std::string::npos)) {
+        CookieTreeOriginNode* origin_node =
+            app_node->GetOrCreateOriginNode(source);
+        CookieTreeCookiesNode* cookies_node =
+            origin_node->GetOrCreateCookiesNode();
+        CookieTreeCookieNode* new_cookie = new CookieTreeCookieNode(it);
+        cookies_node->AddCookieNode(new_cookie);
+      }
     }
   }
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
-void CookiesTreeModel::OnDatabaseModelInfoLoaded(
-    const DatabaseInfoList& database_info) {
-  database_info_list_ = database_info;
-  PopulateDatabaseInfoWithFilter(std::wstring());
-}
-
 void CookiesTreeModel::PopulateDatabaseInfoWithFilter(
+    string16* app,
     const std::wstring& filter) {
-  if (database_info_list_.empty())
-    return;
+
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
-  NotifyObserverBeginBatch();
-  for (DatabaseInfoList::iterator database_info = database_info_list_.begin();
-       database_info != database_info_list_.end();
-       ++database_info) {
-    GURL origin(database_info->origin);
-
-    if (!filter.size() ||
-        (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
-         std::wstring::npos)) {
-      CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(origin);
-      CookieTreeDatabasesNode* databases_node =
-          origin_node->GetOrCreateDatabasesNode();
-      databases_node->AddDatabaseNode(
-          new CookieTreeDatabaseNode(database_info));
+  bool begin_batch = false;
+
+  for (ContainerMap::iterator ait = app_data_map_.begin();
+       ait != app_data_map_.end(); ++ait ) {
+    LocalDataContainer* container = ait->second;
+
+    if (container->database_info_list_.empty())
+      continue;
+
+    if (app && *app != container->app_id())
+      continue;
+
+    if (!begin_batch) {
+      NotifyObserverBeginBatch();
+      begin_batch = true;
+    }
+
+    CookieTreeAppNode* app_node =
+        root->GetOrCreateAppNode(container->app_name(), container->app_id());
+
+    for (DatabaseInfoList::iterator database_info =
+             container->database_info_list_.begin();
+         database_info != container->database_info_list_.end();
+         ++database_info) {
+      GURL origin(database_info->origin);
+
+      if (!filter.size() ||
+          (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
+           std::wstring::npos)) {
+        CookieTreeOriginNode* origin_node =
+            app_node->GetOrCreateOriginNode(origin);
+        CookieTreeDatabasesNode* databases_node =
+            origin_node->GetOrCreateDatabasesNode();
+        databases_node->AddDatabaseNode(
+            new CookieTreeDatabaseNode(database_info));
+      }
     }
   }
-  NotifyObserverTreeNodeChanged(root);
-  NotifyObserverEndBatch();
-}
 
-void CookiesTreeModel::OnLocalStorageModelInfoLoaded(
-    const LocalStorageInfoList& local_storage_info) {
-  local_storage_info_list_ = local_storage_info;
-  PopulateLocalStorageInfoWithFilter(std::wstring());
+  if (begin_batch) {
+    NotifyObserverTreeNodeChanged(root);
+    NotifyObserverEndBatch();
+  }
 }
 
 void CookiesTreeModel::PopulateLocalStorageInfoWithFilter(
+    string16* app,
     const std::wstring& filter) {
-  if (local_storage_info_list_.empty())
-    return;
+
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
-  NotifyObserverBeginBatch();
-  for (LocalStorageInfoList::iterator local_storage_info =
-       local_storage_info_list_.begin();
-       local_storage_info != local_storage_info_list_.end();
-       ++local_storage_info) {
-    GURL origin(local_storage_info->origin);
-
-    if (!filter.size() ||
-        (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
-         std::wstring::npos)) {
-      CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(origin);
-      CookieTreeLocalStoragesNode* local_storages_node =
-          origin_node->GetOrCreateLocalStoragesNode();
-      local_storages_node->AddLocalStorageNode(
-          new CookieTreeLocalStorageNode(local_storage_info));
+  bool begin_batch = false;
+
+  for (ContainerMap::iterator ait = app_data_map_.begin();
+       ait != app_data_map_.end(); ++ait ) {
+    LocalDataContainer* container = ait->second;
+
+    if (container->local_storage_info_list_.empty())
+      continue;
+
+    if (app && *app != container->app_id())
+      continue;
+
+    if (!begin_batch) {
+      NotifyObserverBeginBatch();
+      begin_batch = true;
     }
-  }
-  NotifyObserverTreeNodeChanged(root);
-  NotifyObserverEndBatch();
-}
 
-void CookiesTreeModel::OnSessionStorageModelInfoLoaded(
-    const LocalStorageInfoList& session_storage_info) {
-  session_storage_info_list_ = session_storage_info;
-  PopulateSessionStorageInfoWithFilter(std::wstring());
+    CookieTreeAppNode* app_node =
+        root->GetOrCreateAppNode(container->app_name(), container->app_id());
+
+    for (LocalStorageInfoList::iterator local_storage_info =
+        container->local_storage_info_list_.begin();
+        local_storage_info != container->local_storage_info_list_.end();
+        ++local_storage_info) {
+      GURL origin(local_storage_info->origin);
+
+      if (!filter.size() ||
+          (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
+          std::wstring::npos)) {
+        CookieTreeOriginNode* origin_node =
+            app_node->GetOrCreateOriginNode(origin);
+        CookieTreeLocalStoragesNode* local_storages_node =
+            origin_node->GetOrCreateLocalStoragesNode();
+        local_storages_node->AddLocalStorageNode(
+            new CookieTreeLocalStorageNode(local_storage_info));
+      }
+    }
+  }
+  if (begin_batch) {
+    NotifyObserverTreeNodeChanged(root);
+    NotifyObserverEndBatch();
+  }
 }
 
 void CookiesTreeModel::PopulateSessionStorageInfoWithFilter(
+    string16* app,
     const std::wstring& filter) {
-  if (session_storage_info_list_.empty())
-    return;
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
-  NotifyObserverBeginBatch();
-  for (LocalStorageInfoList::iterator session_storage_info =
-       session_storage_info_list_.begin();
-       session_storage_info != session_storage_info_list_.end();
-       ++session_storage_info) {
-    GURL origin(session_storage_info->origin);
-
-    if (!filter.size() ||
-        (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
-         std::wstring::npos)) {
-      CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(origin);
-      CookieTreeSessionStoragesNode* session_storages_node =
-          origin_node->GetOrCreateSessionStoragesNode();
-      session_storages_node->AddSessionStorageNode(
-          new CookieTreeSessionStorageNode(session_storage_info));
+  bool begin_batch = false;
+
+  for (ContainerMap::iterator ait = app_data_map_.begin();
+       ait != app_data_map_.end(); ++ait ) {
+    LocalDataContainer* container = ait->second;
+
+    if (container->session_storage_info_list_.empty())
+      continue;
+
+    if (app && *app != container->app_id())
+      continue;
+
+    if (!begin_batch) {
+      NotifyObserverBeginBatch();
+      begin_batch = true;
     }
-  }
-  NotifyObserverTreeNodeChanged(root);
-  NotifyObserverEndBatch();
-}
 
-void CookiesTreeModel::OnIndexedDBModelInfoLoaded(
-    const IndexedDBInfoList& indexed_db_info) {
-  indexed_db_info_list_ = indexed_db_info;
-  PopulateIndexedDBInfoWithFilter(std::wstring());
+    CookieTreeAppNode* app_node =
+        root->GetOrCreateAppNode(container->app_name(), container->app_id());
+
+    for (LocalStorageInfoList::iterator session_storage_info =
+        container->session_storage_info_list_.begin();
+        session_storage_info != container->session_storage_info_list_.end();
+        ++session_storage_info) {
+      GURL origin(session_storage_info->origin);
+
+      if (!filter.size() ||
+          (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
+          std::wstring::npos)) {
+        CookieTreeOriginNode* origin_node =
+            app_node->GetOrCreateOriginNode(origin);
+        CookieTreeSessionStoragesNode* session_storages_node =
+            origin_node->GetOrCreateSessionStoragesNode();
+        session_storages_node->AddSessionStorageNode(
+            new CookieTreeSessionStorageNode(session_storage_info));
+      }
+    }
+  }
+  if (begin_batch) {
+    NotifyObserverTreeNodeChanged(root);
+    NotifyObserverEndBatch();
+  }
 }
 
 void CookiesTreeModel::PopulateIndexedDBInfoWithFilter(
+    string16* app,
     const std::wstring& filter) {
-  if (indexed_db_info_list_.empty())
-    return;
+
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
-  NotifyObserverBeginBatch();
-  for (IndexedDBInfoList::iterator indexed_db_info =
-       indexed_db_info_list_.begin();
-       indexed_db_info != indexed_db_info_list_.end();
-       ++indexed_db_info) {
-    const GURL& origin = indexed_db_info->origin;
-
-    if (!filter.size() ||
-        (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
-         std::wstring::npos)) {
-      CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(origin);
-      CookieTreeIndexedDBsNode* indexed_dbs_node =
-          origin_node->GetOrCreateIndexedDBsNode();
-      indexed_dbs_node->AddIndexedDBNode(
-          new CookieTreeIndexedDBNode(indexed_db_info));
+  bool begin_batch = false;
+
+  for (ContainerMap::iterator ait = app_data_map_.begin();
+      ait != app_data_map_.end(); ++ait ) {
+    LocalDataContainer* container = ait->second;
+
+    if (container->indexed_db_info_list_.empty())
+      continue;
+
+    if (app && *app != container->app_id())
+      continue;
+
+    if (!begin_batch) {
+      NotifyObserverBeginBatch();
+      begin_batch = true;
     }
-  }
-  NotifyObserverTreeNodeChanged(root);
-  NotifyObserverEndBatch();
-}
 
-void CookiesTreeModel::OnFileSystemModelInfoLoaded(
-    const FileSystemInfoList& file_system_info) {
-  file_system_info_list_ = file_system_info;
-  PopulateFileSystemInfoWithFilter(std::wstring());
+    CookieTreeAppNode* app_node =
+        root->GetOrCreateAppNode(container->app_name(), container->app_id());
+
+    for (IndexedDBInfoList::iterator indexed_db_info =
+        container->indexed_db_info_list_.begin();
+        indexed_db_info != container->indexed_db_info_list_.end();
+        ++indexed_db_info) {
+      const GURL& origin = indexed_db_info->origin;
+
+      if (!filter.size() ||
+          (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
+          std::wstring::npos)) {
+        CookieTreeOriginNode* origin_node =
+            app_node->GetOrCreateOriginNode(origin);
+        CookieTreeIndexedDBsNode* indexed_dbs_node =
+            origin_node->GetOrCreateIndexedDBsNode();
+        indexed_dbs_node->AddIndexedDBNode(
+            new CookieTreeIndexedDBNode(indexed_db_info));
+      }
+    }
+  }
+  if (begin_batch) {
+    NotifyObserverTreeNodeChanged(root);
+    NotifyObserverEndBatch();
+  }
 }
 
-void CookiesTreeModel::PopulateFileSystemInfoWithFilter(
+void CookiesTreeModel::PopulateServerBoundCertInfoWithFilter(
+    string16* app,
     const std::wstring& filter) {
-  if (file_system_info_list_.empty())
-    return;
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
-  NotifyObserverBeginBatch();
-  for (FileSystemInfoList::iterator file_system_info =
-       file_system_info_list_.begin();
-       file_system_info != file_system_info_list_.end();
-       ++file_system_info) {
-    GURL origin(file_system_info->origin);
-
-    if (!filter.size() ||
-        (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
-         std::wstring::npos)) {
-      CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(origin);
-      CookieTreeFileSystemsNode* file_systems_node =
-          origin_node->GetOrCreateFileSystemsNode();
-      file_systems_node->AddFileSystemNode(
-          new CookieTreeFileSystemNode(file_system_info));
+  bool begin_batch = false;
+
+  for (ContainerMap::iterator ait = app_data_map_.begin();
+      ait != app_data_map_.end(); ++ait ) {
+    LocalDataContainer* container = ait->second;
+
+    if (container->server_bound_cert_list_.empty())
+      continue;
+
+    if (app && *app != container->app_id())
+      continue;
+
+    if (!begin_batch) {
+      NotifyObserverBeginBatch();
+      begin_batch = true;
     }
-  }
-  NotifyObserverTreeNodeChanged(root);
-  NotifyObserverEndBatch();
-}
 
-void CookiesTreeModel::OnQuotaModelInfoLoaded(
-    const QuotaInfoArray& quota_info) {
-  quota_info_list_ = quota_info;
-  PopulateQuotaInfoWithFilter(std::wstring());
+    CookieTreeAppNode* app_node =
+        root->GetOrCreateAppNode(container->app_name(), container->app_id());
+
+    for (ServerBoundCertList::iterator cert_info =
+        container->server_bound_cert_list_.begin();
+        cert_info != container->server_bound_cert_list_.end();
+        ++cert_info) {
+      GURL origin(cert_info->server_identifier());
+      if (!origin.is_valid()) {
+        // Domain Bound Cert.  Make a valid URL to satisfy the
+        // CookieTreeRootNode::GetOrCreateOriginNode interface.
+        origin = GURL(std::string(chrome::kHttpsScheme) +
+            content::kStandardSchemeSeparator +
+            cert_info->server_identifier() + "/");
+      }
+      std::wstring title = CookieTreeOriginNode::TitleForUrl(origin);
+
+      if (!filter.size() || title.find(filter) != std::wstring::npos) {
+        CookieTreeOriginNode* origin_node =
+            app_node->GetOrCreateOriginNode(origin);
+        CookieTreeServerBoundCertsNode* server_bound_certs_node =
+            origin_node->GetOrCreateServerBoundCertsNode();
+        server_bound_certs_node->AddServerBoundCertNode(
+            new CookieTreeServerBoundCertNode(cert_info));
+      }
+    }
+  }
+  if (begin_batch) {
+    NotifyObserverTreeNodeChanged(root);
+    NotifyObserverEndBatch();
+  }
 }
 
-void CookiesTreeModel::PopulateQuotaInfoWithFilter(
+void CookiesTreeModel::PopulateFileSystemInfoWithFilter(
+    string16* app,
     const std::wstring& filter) {
-  if (quota_info_list_.empty())
-    return;
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
-  NotifyObserverBeginBatch();
-  for (QuotaInfoArray::iterator quota_info = quota_info_list_.begin();
-       quota_info != quota_info_list_.end();
-       ++quota_info) {
-    if (!filter.size() ||
-        (UTF8ToWide(quota_info->host).find(filter) != std::wstring::npos)) {
-      CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(GURL("http://" + quota_info->host));
-      origin_node->UpdateOrCreateQuotaNode(quota_info);
+  bool begin_batch = false;
+
+  for (ContainerMap::iterator ait = app_data_map_.begin();
+      ait != app_data_map_.end(); ++ait ) {
+    LocalDataContainer* container = ait->second;
+
+    if (container->file_system_info_list_.empty())
+      continue;
+
+    if (app && *app != container->app_id())
+      continue;
+
+    if (!begin_batch) {
+      NotifyObserverBeginBatch();
+      begin_batch = true;
     }
-  }
-  NotifyObserverTreeNodeChanged(root);
-  NotifyObserverEndBatch();
-}
 
-void CookiesTreeModel::OnServerBoundCertModelInfoLoaded(
-    const ServerBoundCertList& cert_list) {
-  server_bound_cert_list_ = cert_list;
-  PopulateServerBoundCertInfoWithFilter(std::wstring());
+    CookieTreeAppNode* app_node =
+        root->GetOrCreateAppNode(container->app_name(), container->app_id());
+
+    for (FileSystemInfoList::iterator file_system_info =
+        container->file_system_info_list_.begin();
+        file_system_info != container->file_system_info_list_.end();
+        ++file_system_info) {
+      GURL origin(file_system_info->origin);
+
+      if (!filter.size() ||
+          (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
+          std::wstring::npos)) {
+        CookieTreeOriginNode* origin_node =
+            app_node->GetOrCreateOriginNode(origin);
+        CookieTreeFileSystemsNode* file_systems_node =
+            origin_node->GetOrCreateFileSystemsNode();
+        file_systems_node->AddFileSystemNode(
+            new CookieTreeFileSystemNode(file_system_info));
+      }
+    }
+  }
+  if (begin_batch) {
+    NotifyObserverTreeNodeChanged(root);
+    NotifyObserverEndBatch();
+  }
 }
 
-void CookiesTreeModel::PopulateServerBoundCertInfoWithFilter(
+void CookiesTreeModel::PopulateQuotaInfoWithFilter(
+    string16* app,
     const std::wstring& filter) {
-  if (server_bound_cert_list_.empty())
-    return;
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
-  NotifyObserverBeginBatch();
-  for (ServerBoundCertList::iterator cert_info =
-       server_bound_cert_list_.begin();
-       cert_info != server_bound_cert_list_.end();
-       ++cert_info) {
-    GURL origin(cert_info->server_identifier());
-    if (!origin.is_valid()) {
-      // Domain Bound Cert.  Make a valid URL to satisfy the
-      // CookieTreeRootNode::GetOrCreateOriginNode interface.
-      origin = GURL(std::string(chrome::kHttpsScheme) +
-                    content::kStandardSchemeSeparator +
-                    cert_info->server_identifier() + "/");
+  bool begin_batch = false;
+
+  for (ContainerMap::iterator ait = app_data_map_.begin();
+      ait != app_data_map_.end(); ++ait ) {
+    LocalDataContainer* container = ait->second;
+
+    if (container->quota_info_list_.empty())
+      continue;
+
+    if (app && *app != container->app_id())
+      continue;
+
+    if (!begin_batch) {
+      NotifyObserverBeginBatch();
+      begin_batch = true;
     }
-    std::wstring title = CookieTreeOriginNode::TitleForUrl(origin);
-
-    if (!filter.size() || title.find(filter) != std::wstring::npos) {
-      CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(origin);
-      CookieTreeServerBoundCertsNode* server_bound_certs_node =
-          origin_node->GetOrCreateServerBoundCertsNode();
-      server_bound_certs_node->AddServerBoundCertNode(
-          new CookieTreeServerBoundCertNode(cert_info));
+
+    CookieTreeAppNode* app_node =
+        root->GetOrCreateAppNode(container->app_name(), container->app_id());
+
+    for (QuotaInfoArray::iterator quota_info =
+        container->quota_info_list_.begin();
+        quota_info != container->quota_info_list_.end();
+        ++quota_info) {
+      if (!filter.size() ||
+          (UTF8ToWide(quota_info->host).find(filter) != std::wstring::npos)) {
+        CookieTreeOriginNode* origin_node =
+            app_node->GetOrCreateOriginNode(GURL("http://" + quota_info->host));
+        origin_node->UpdateOrCreateQuotaNode(quota_info);
+      }
     }
   }
-  NotifyObserverTreeNodeChanged(root);
-  NotifyObserverEndBatch();
+  if (begin_batch) {
+    NotifyObserverTreeNodeChanged(root);
+    NotifyObserverEndBatch();
+  }
 }
 
 void CookiesTreeModel::NotifyObserverBeginBatch() {
@@ -1145,3 +1335,189 @@ void CookiesTreeModel::NotifyObserverEndBatch() {
                       TreeModelEndBatch(this));
   }
 }
+
+BrowsingDataCookieHelper* CookiesTreeModel::GetCookieHelper(
+    const string16& app_id) {
+  LocalDataContainer* container = app_data_map_[app_id];
+  if (container != NULL) {
+    return container->cookie_helper();
+  }
+  return NULL;
+}
+
+LocalDataContainer* CookiesTreeModel::GetLocalDataContainer(
+    const string16& app_id) {
+  LocalDataContainer* container = app_data_map_[app_id];
+  return container;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// LocalDataContainer, public:
+
+LocalDataContainer::LocalDataContainer(
+    const string16& app_name,
+    const string16& app_id,
+    BrowsingDataCookieHelper* cookie_helper,
+    BrowsingDataDatabaseHelper* database_helper,
+    BrowsingDataLocalStorageHelper* local_storage_helper,
+    BrowsingDataLocalStorageHelper* session_storage_helper,
+    BrowsingDataAppCacheHelper* appcache_helper,
+    BrowsingDataIndexedDBHelper* indexed_db_helper,
+    BrowsingDataFileSystemHelper* file_system_helper,
+    BrowsingDataQuotaHelper* quota_helper,
+    BrowsingDataServerBoundCertHelper* server_bound_cert_helper,
+    bool use_cookie_source)
+    : //app_name_(app_name),

[markusheintz_, 2012/06/13 23:40:39]

Uncomment these to lines please.

+      //app_id_(app_id_),
+      appcache_helper_(appcache_helper),

[markusheintz_, 2012/06/13 23:40:39]

s/(app_id_)/(app_id)

+      cookie_helper_(cookie_helper),
+      database_helper_(database_helper),
+      local_storage_helper_(local_storage_helper),
+      session_storage_helper_(session_storage_helper),
+      indexed_db_helper_(indexed_db_helper),
+      file_system_helper_(file_system_helper),
+      quota_helper_(quota_helper),
+      server_bound_cert_helper_(server_bound_cert_helper),
+  delegate_(NULL),

[markusheintz_, 2012/06/13 23:40:39]

Please indent.

+      //use_cookie_source_(use_cookie_source),

[markusheintz_, 2012/06/13 23:40:39]

Same as above. Please remove or uncomment.

+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
+  app_name_ = app_name;

[markusheintz_, 2012/06/13 23:40:39]

I think it is preferred to initialize these two field using initializers. Please
remove these two lines.

+  app_id_ = app_id;
+
+}
+
+LocalDataContainer::~LocalDataContainer() {}
+
+void LocalDataContainer::Init(CookiesTreeModelDelegate* d) {

[markusheintz_, 2012/06/13 23:40:39]

s/d/delegate

+  DCHECK(!delegate_);
+  delegate_ = d;
+
+  DCHECK(cookie_helper_);
+  cookie_helper_->StartFetching(
+      base::Bind(&LocalDataContainer::OnCookiesModelInfoLoaded,
+                 weak_ptr_factory_.GetWeakPtr()));
+  DCHECK(database_helper_);
+  database_helper_->StartFetching(
+      base::Bind(&LocalDataContainer::OnDatabaseModelInfoLoaded,
+                 weak_ptr_factory_.GetWeakPtr()));
+  DCHECK(local_storage_helper_);
+  local_storage_helper_->StartFetching(
+      base::Bind(&LocalDataContainer::OnLocalStorageModelInfoLoaded,
+                 weak_ptr_factory_.GetWeakPtr()));
+  if (session_storage_helper_) {
+    session_storage_helper_->StartFetching(
+        base::Bind(&LocalDataContainer::OnSessionStorageModelInfoLoaded,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  // TODO(michaeln): When all of the UI implementations have been updated, make
+  // this a required parameter.
+  if (appcache_helper_) {
+    appcache_helper_->StartFetching(
+        base::Bind(&LocalDataContainer::OnAppCacheModelInfoLoaded,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  if (indexed_db_helper_) {
+    indexed_db_helper_->StartFetching(
+        base::Bind(&LocalDataContainer::OnIndexedDBModelInfoLoaded,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  if (file_system_helper_) {
+    file_system_helper_->StartFetching(
+        base::Bind(&LocalDataContainer::OnFileSystemModelInfoLoaded,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  if (quota_helper_) {
+    quota_helper_->StartFetching(
+        base::Bind(&LocalDataContainer::OnQuotaModelInfoLoaded,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  if (server_bound_cert_helper_) {
+    server_bound_cert_helper_->StartFetching(
+        base::Bind(&LocalDataContainer::OnServerBoundCertModelInfoLoaded,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+}
+
+void LocalDataContainer::OnAppCacheModelInfoLoaded() {
+  using appcache::AppCacheInfo;
+  using appcache::AppCacheInfoCollection;
+  using appcache::AppCacheInfoVector;
+  typedef std::map<GURL, AppCacheInfoVector> InfoByOrigin;
+
+  scoped_refptr<AppCacheInfoCollection> appcache_info =
+      appcache_helper_->info_collection();
+  if (!appcache_info || appcache_info->infos_by_origin.empty())
+    return;
+
+  for (InfoByOrigin::const_iterator origin =
+           appcache_info->infos_by_origin.begin();
+       origin != appcache_info->infos_by_origin.end(); ++origin) {
+    std::list<AppCacheInfo>& info_list = appcache_info_[origin->first];
+    info_list.insert(
+        info_list.begin(), origin->second.begin(), origin->second.end());
+  }
+
+  delegate_->PopulateAppCacheInfoWithFilter(&app_name_, std::wstring());
+}
+
+void LocalDataContainer::OnCookiesModelInfoLoaded(
+    const net::CookieList& cookie_list) {
+  cookie_list_.insert(cookie_list_.begin(),
+                      cookie_list.begin(),
+                      cookie_list.end());
+  DCHECK(delegate_);
+  delegate_->PopulateCookieInfoWithFilter(&app_id_, std::wstring());
+}
+
+void LocalDataContainer::OnDatabaseModelInfoLoaded(
+    const DatabaseInfoList& database_info) {
+  database_info_list_ = database_info;
+  DCHECK(delegate_);
+  delegate_->PopulateDatabaseInfoWithFilter(&app_id_, std::wstring());
+}
+
+void LocalDataContainer::OnLocalStorageModelInfoLoaded(
+    const LocalStorageInfoList& local_storage_info) {
+  local_storage_info_list_ = local_storage_info;
+  DCHECK(delegate_);
+  delegate_->PopulateLocalStorageInfoWithFilter(&app_id_, std::wstring());
+}
+
+void LocalDataContainer::OnSessionStorageModelInfoLoaded(
+    const LocalStorageInfoList& session_storage_info) {
+  session_storage_info_list_ = session_storage_info;
+  DCHECK(delegate_);
+  delegate_->PopulateSessionStorageInfoWithFilter(&app_id_, std::wstring());
+}
+
+void LocalDataContainer::OnIndexedDBModelInfoLoaded(
+    const IndexedDBInfoList& indexed_db_info) {
+  indexed_db_info_list_ = indexed_db_info;
+  DCHECK(delegate_);
+  delegate_->PopulateIndexedDBInfoWithFilter(&app_id_, std::wstring());
+}
+void LocalDataContainer::OnFileSystemModelInfoLoaded(
+    const FileSystemInfoList& file_system_info) {
+  file_system_info_list_ = file_system_info;
+  DCHECK(delegate_);
+  delegate_->PopulateFileSystemInfoWithFilter(&app_id_, std::wstring());
+}
+
+void LocalDataContainer::OnQuotaModelInfoLoaded(
+    const QuotaInfoArray& quota_info) {
+  quota_info_list_ = quota_info;
+  DCHECK(delegate_);
+  delegate_->PopulateQuotaInfoWithFilter(&app_id_, std::wstring());
+}
+
+void LocalDataContainer::OnServerBoundCertModelInfoLoaded(
+    const ServerBoundCertList& cert_list) {
+  server_bound_cert_list_ = cert_list;
+  DCHECK(delegate_);
+  delegate_->PopulateServerBoundCertInfoWithFilter(&app_id_, std::wstring());
+}