Adding usage and quota entry to chrome://settings/cookies.

chrome/browser/cookies_tree_model.cc

 // Copyright (c) 2011 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/cookies_tree_model.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
@@ skipping 50 matching lines @@
   // model, and tell CookieMonster to delete the cookies. We can keep the
   // vector storing the cookies in-tact and not delete from there (that would
   // invalidate our pointers), and the fact that it contains semi out-of-date
   // data is not problematic as we don't re-build the model based on that.
   GetModel()->cookie_monster_->DeleteCanonicalCookie(*cookie_);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeCookieNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_COOKIE,
-                      cookie_, NULL, NULL, NULL, NULL, NULL, NULL);
+                      cookie_, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 namespace {
 // comparison functor, for use in CookieTreeRootNode
 class OriginNodeComparator {
  public:
   bool operator() (const CookieTreeNode* lhs,
                    const CookieTreeNode* rhs) {
     // We want to order by registry controlled domain, so we would get
     // google.com, ad.google.com, www.google.com,
@@ skipping 59 matching lines @@
 
 void CookieTreeAppCacheNode::DeleteStoredObjects() {
   DCHECK(GetModel()->appcache_helper_);
   GetModel()->appcache_helper_->DeleteAppCacheGroup(
       appcache_info_->manifest_url);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeAppCacheNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_APPCACHE,
-                      NULL, NULL, NULL, NULL, appcache_info_, NULL, NULL);
+                      NULL, NULL, NULL, NULL, appcache_info_, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeDatabaseNode, public:
 
 CookieTreeDatabaseNode::CookieTreeDatabaseNode(
     BrowsingDataDatabaseHelper::DatabaseInfo* database_info)
     : CookieTreeNode(database_info->database_name.empty() ?
           l10n_util::GetStringUTF16(IDS_COOKIES_WEB_DATABASE_UNNAMED_NAME) :
           UTF8ToUTF16(database_info->database_name)),
       database_info_(database_info) {
 }
 
 CookieTreeDatabaseNode::~CookieTreeDatabaseNode() {}
 
 void CookieTreeDatabaseNode::DeleteStoredObjects() {
   GetModel()->database_helper_->DeleteDatabase(
       database_info_->origin_identifier, database_info_->database_name);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeDatabaseNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_DATABASE,
-                      NULL, database_info_, NULL, NULL, NULL, NULL, NULL);
+                      NULL, database_info_, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeLocalStorageNode, public:
 
 CookieTreeLocalStorageNode::CookieTreeLocalStorageNode(
     BrowsingDataLocalStorageHelper::LocalStorageInfo* local_storage_info)
     : CookieTreeNode(UTF8ToUTF16(
           local_storage_info->origin.empty() ?
               local_storage_info->database_identifier :
               local_storage_info->origin)),
       local_storage_info_(local_storage_info) {
 }
 
 CookieTreeLocalStorageNode::~CookieTreeLocalStorageNode() {}
 
 void CookieTreeLocalStorageNode::DeleteStoredObjects() {
   GetModel()->local_storage_helper_->DeleteLocalStorageFile(
       local_storage_info_->file_path);
 }
 
 CookieTreeNode::DetailedInfo
 CookieTreeLocalStorageNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_LOCAL_STORAGE,
-                      NULL, NULL, local_storage_info_, NULL, NULL, NULL, NULL);
+                      NULL, NULL, local_storage_info_, NULL, NULL, NULL, NULL,
+                      NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeSessionStorageNode, public:
 
 CookieTreeSessionStorageNode::CookieTreeSessionStorageNode(
     BrowsingDataLocalStorageHelper::LocalStorageInfo* session_storage_info)
     : CookieTreeNode(UTF8ToUTF16(
           session_storage_info->origin.empty() ?
               session_storage_info->database_identifier :
               session_storage_info->origin)),
       session_storage_info_(session_storage_info) {
 }
 
 CookieTreeSessionStorageNode::~CookieTreeSessionStorageNode() {}
 
 CookieTreeNode::DetailedInfo
 CookieTreeSessionStorageNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_SESSION_STORAGE,
                       NULL, NULL, NULL, session_storage_info_, NULL, NULL,
-                      NULL);
+                      NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeIndexedDBNode, public:
 
 CookieTreeIndexedDBNode::CookieTreeIndexedDBNode(
     BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info)
     : CookieTreeNode(UTF8ToUTF16(
           indexed_db_info->origin.empty() ?
               indexed_db_info->database_identifier :
               indexed_db_info->origin)),
       indexed_db_info_(indexed_db_info) {
 }
 
 CookieTreeIndexedDBNode::~CookieTreeIndexedDBNode() {}
 
 void CookieTreeIndexedDBNode::DeleteStoredObjects() {
   GetModel()->indexed_db_helper_->DeleteIndexedDBFile(
       indexed_db_info_->file_path);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeIndexedDBNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_INDEXED_DB,
-                      NULL, NULL, NULL, NULL, NULL, indexed_db_info_, NULL);
+                      NULL, NULL, NULL, NULL, NULL, indexed_db_info_, NULL,
+                      NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeFileSystemNode, public:
 
 CookieTreeFileSystemNode::CookieTreeFileSystemNode(
     BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info)
     : CookieTreeNode(UTF8ToUTF16(
           file_system_info->origin.spec())),
       file_system_info_(file_system_info) {
 }
 
 CookieTreeFileSystemNode::~CookieTreeFileSystemNode() {}
 
 void CookieTreeFileSystemNode::DeleteStoredObjects() {
   GetModel()->file_system_helper_->DeleteFileSystemOrigin(
       file_system_info_->origin);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeFileSystemNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_FILE_SYSTEM,
-                      NULL, NULL, NULL, NULL, NULL, NULL, file_system_info_);
+                      NULL, NULL, NULL, NULL, NULL, NULL, file_system_info_,
+                      NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// CookieTreeQuotaNode, public:
+
+CookieTreeQuotaNode::CookieTreeQuotaNode(
+    BrowsingDataQuotaHelper::QuotaInfo* quota_info)
+    : CookieTreeNode(UTF8ToUTF16(quota_info->host)),
+      quota_info_(quota_info) {
+}
+
+CookieTreeQuotaNode::~CookieTreeQuotaNode() {}
+
+void CookieTreeQuotaNode::DeleteStoredObjects() {
+  GetModel()->quota_helper_->DeleteQuotaHost(quota_info_->host);
+}
+
+CookieTreeNode::DetailedInfo CookieTreeQuotaNode::GetDetailedInfo() const {
+  return DetailedInfo(parent()->parent()->GetTitle(),
+                      DetailedInfo::TYPE_QUOTA,
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL, quota_info_);
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // CookieTreeRootNode, public:
 
 CookieTreeRootNode::CookieTreeRootNode(CookiesTreeModel* model)
     : model_(model) {
 }
 
 CookieTreeRootNode::~CookieTreeRootNode() {}
 
 CookieTreeOriginNode* CookieTreeRootNode::GetOrCreateOriginNode(
     const GURL& url) {
@@ skipping 18 matching lines @@
   return retval;
 }
 
 CookiesTreeModel* CookieTreeRootNode::GetModel() const {
   return model_;
 }
 
 CookieTreeNode::DetailedInfo CookieTreeRootNode::GetDetailedInfo() const {
   return DetailedInfo(string16(),
                       DetailedInfo::TYPE_ROOT,
-                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeOriginNode, public:
 
 // static
 std::wstring CookieTreeOriginNode::TitleForUrl(
     const GURL& url) {
   return UTF8ToWide(url.SchemeIsFile() ? kFileOriginNodeName : url.host());
 }
 
 CookieTreeOriginNode::CookieTreeOriginNode(const GURL& url)
     : CookieTreeNode(WideToUTF16Hack(TitleForUrl(url))),
       cookies_child_(NULL),
       databases_child_(NULL),
       local_storages_child_(NULL),
       session_storages_child_(NULL),
       appcaches_child_(NULL),
       indexed_dbs_child_(NULL),
       file_systems_child_(NULL),
+      quota_child_(NULL),
       url_(url) {}
 
 CookieTreeOriginNode::~CookieTreeOriginNode() {}
 
 CookieTreeNode::DetailedInfo CookieTreeOriginNode::GetDetailedInfo() const {
   return DetailedInfo(GetTitle(),
                       DetailedInfo::TYPE_ORIGIN,
-                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 CookieTreeCookiesNode* CookieTreeOriginNode::GetOrCreateCookiesNode() {
   if (cookies_child_)
     return cookies_child_;
   cookies_child_ = new CookieTreeCookiesNode;
   AddChildSortedByTitle(cookies_child_);
   return cookies_child_;
 }
 
@@ skipping 40 matching lines @@
 }
 
 CookieTreeFileSystemsNode* CookieTreeOriginNode::GetOrCreateFileSystemsNode() {
   if (file_systems_child_)
     return file_systems_child_;
   file_systems_child_ = new CookieTreeFileSystemsNode;
   AddChildSortedByTitle(file_systems_child_);
   return file_systems_child_;
 }
 
+CookieTreeQuotaNode* CookieTreeOriginNode::UpdateOrCreateQuotaNode(
+    BrowsingDataQuotaHelper::QuotaInfo* quota_info) {
+  if (quota_child_)
+    return quota_child_;
+  quota_child_ = new CookieTreeQuotaNode(quota_info);
+  AddChildSortedByTitle(quota_child_);
+  return quota_child_;
+}
+
 void CookieTreeOriginNode::CreateContentException(
     HostContentSettingsMap* content_settings, ContentSetting setting) const {
   if (CanCreateContentException()) {
     content_settings->AddExceptionForURL(url_,
                                          url_,
                                          CONTENT_SETTINGS_TYPE_COOKIES,
                                          "",
                                          setting);
   }
 }
 
 bool CookieTreeOriginNode::CanCreateContentException() const {
   return !url_.SchemeIsFile();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeCookiesNode, public:
 
 CookieTreeCookiesNode::CookieTreeCookiesNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_COOKIES)) {
 }
 
 CookieTreeCookiesNode::~CookieTreeCookiesNode() {
 }
 
 CookieTreeNode::DetailedInfo CookieTreeCookiesNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->GetTitle(),
                       DetailedInfo::TYPE_COOKIES,
-                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeAppCachesNode, public:
 
 CookieTreeAppCachesNode::CookieTreeAppCachesNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(
                          IDS_COOKIES_APPLICATION_CACHES)) {
 }
 
 CookieTreeAppCachesNode::~CookieTreeAppCachesNode() {}
 
 CookieTreeNode::DetailedInfo CookieTreeAppCachesNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->GetTitle(),
                       DetailedInfo::TYPE_APPCACHES,
-                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeDatabasesNode, public:
 
 CookieTreeDatabasesNode::CookieTreeDatabasesNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_WEB_DATABASES)) {
 }
 
 CookieTreeDatabasesNode::~CookieTreeDatabasesNode() {}
 
 CookieTreeNode::DetailedInfo CookieTreeDatabasesNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->GetTitle(),
                       DetailedInfo::TYPE_DATABASES,
-                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeLocalStoragesNode, public:
 
 CookieTreeLocalStoragesNode::CookieTreeLocalStoragesNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_LOCAL_STORAGE)) {
 }
 
 CookieTreeLocalStoragesNode::~CookieTreeLocalStoragesNode() {}
 
 CookieTreeNode::DetailedInfo
 CookieTreeLocalStoragesNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->GetTitle(),
                       DetailedInfo::TYPE_LOCAL_STORAGES,
-                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeSessionStoragesNode, public:
 
 CookieTreeSessionStoragesNode::CookieTreeSessionStoragesNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_SESSION_STORAGE)) {
 }
 
 CookieTreeSessionStoragesNode::~CookieTreeSessionStoragesNode() {}
 
 CookieTreeNode::DetailedInfo
 CookieTreeSessionStoragesNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->GetTitle(),
                       DetailedInfo::TYPE_SESSION_STORAGES,
-                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeIndexedDBsNode, public:
 
 CookieTreeIndexedDBsNode::CookieTreeIndexedDBsNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_INDEXED_DBS)) {
 }
 
 CookieTreeIndexedDBsNode::~CookieTreeIndexedDBsNode() {}
 
 CookieTreeNode::DetailedInfo
 CookieTreeIndexedDBsNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->GetTitle(),
                       DetailedInfo::TYPE_INDEXED_DBS,
-                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeFileSystemsNode, public:
 
 CookieTreeFileSystemsNode::CookieTreeFileSystemsNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_FILE_SYSTEMS)) {
 }
 
 CookieTreeFileSystemsNode::~CookieTreeFileSystemsNode() {}
 
 CookieTreeNode::DetailedInfo
 CookieTreeFileSystemsNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->GetTitle(),
                       DetailedInfo::TYPE_FILE_SYSTEMS,
-                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeNode, protected
 
 bool CookieTreeNode::NodeTitleComparator::operator() (
     const CookieTreeNode* lhs, const CookieTreeNode* rhs) {
   const CookieTreeNode* left =
       static_cast<const CookieTreeNode*>(lhs);
   const CookieTreeNode* right =
@@ skipping 15 matching lines @@
 // CookiesTreeModel, public:
 
 CookiesTreeModel::CookiesTreeModel(
     net::CookieMonster* cookie_monster,
     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,
     bool use_cookie_source)
     : ALLOW_THIS_IN_INITIALIZER_LIST(ui::TreeNodeModel<CookieTreeNode>(
           new CookieTreeRootNode(this))),
       cookie_monster_(cookie_monster),
       appcache_helper_(appcache_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),
       batch_update_(0),
       use_cookie_source_(use_cookie_source) {
   LoadCookies();
   DCHECK(database_helper_);
   database_helper_->StartFetching(NewCallback(
       this, &CookiesTreeModel::OnDatabaseModelInfoLoaded));
   DCHECK(local_storage_helper_);
   local_storage_helper_->StartFetching(NewCallback(
       this, &CookiesTreeModel::OnLocalStorageModelInfoLoaded));
   if (session_storage_helper_) {
@@ skipping 10 matching lines @@
 
   if (indexed_db_helper_) {
     indexed_db_helper_->StartFetching(NewCallback(
         this, &CookiesTreeModel::OnIndexedDBModelInfoLoaded));
   }
 
   if (file_system_helper_) {
     file_system_helper_->StartFetching(NewCallback(
         this, &CookiesTreeModel::OnFileSystemModelInfoLoaded));
   }
+
+  if (quota_helper_) {
+    quota_helper_->StartFetching(NewCallback(
+        this, &CookiesTreeModel::OnQuotaModelInfoLoaded));
+  }
 }
 
 CookiesTreeModel::~CookiesTreeModel() {
   database_helper_->CancelNotification();
   local_storage_helper_->CancelNotification();
   if (session_storage_helper_)
     session_storage_helper_->CancelNotification();
   if (appcache_helper_)
     appcache_helper_->CancelNotification();
   if (indexed_db_helper_)
     indexed_db_helper_->CancelNotification();
   if (file_system_helper_)
     file_system_helper_->CancelNotification();
+  if (quota_helper_)
+    quota_helper_->CancelNotification();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookiesTreeModel, TreeModel methods (public):
 
 // TreeModel methods:
 // Returns the set of icons for the nodes in the tree. You only need override
 // this if you don't want to use the default folder icons.
 void CookiesTreeModel::GetIcons(std::vector<SkBitmap>* icons) {
   icons->push_back(*ResourceBundle::GetSharedInstance().GetBitmapNamed(
@@ skipping 19 matching lines @@
     case CookieTreeNode::DetailedInfo::TYPE_LOCAL_STORAGE:
       return DATABASE;  // close enough
     case CookieTreeNode::DetailedInfo::TYPE_SESSION_STORAGE:
       return DATABASE;  // ditto
     case CookieTreeNode::DetailedInfo::TYPE_APPCACHE:
       return DATABASE;  // ditto
     case CookieTreeNode::DetailedInfo::TYPE_INDEXED_DB:
       return DATABASE;  // ditto
     case CookieTreeNode::DetailedInfo::TYPE_FILE_SYSTEM:
       return DATABASE;  // ditto
+    case CookieTreeNode::DetailedInfo::TYPE_QUOTA:
+      return -1;
     default:
       break;
   }
   return -1;
 }
 
 void CookiesTreeModel::LoadCookies() {
   LoadCookiesWithFilter(std::wstring());
 }
 
@@ skipping 56 matching lines @@
   NotifyObserverBeginBatch();
   for (int i = num_children - 1; i >= 0; --i)
     delete Remove(root, root->GetChild(i));
   LoadCookiesWithFilter(filter);
   PopulateDatabaseInfoWithFilter(filter);
   PopulateLocalStorageInfoWithFilter(filter);
   PopulateSessionStorageInfoWithFilter(filter);
   PopulateAppCacheInfoWithFilter(filter);
   PopulateIndexedDBInfoWithFilter(filter);
   PopulateFileSystemInfoWithFilter(filter);
+  PopulateQuotaInfoWithFilter(filter);
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
 void CookiesTreeModel::AddCookiesTreeObserver(Observer* observer) {
   cookies_observer_list_.AddObserver(observer);
   // Call super so that TreeNodeModel can notify, too.
   ui::TreeNodeModel<CookieTreeNode>::AddObserver(observer);
 }
 
@@ skipping 198 matching lines @@
       CookieTreeFileSystemsNode* file_systems_node =
           origin_node->GetOrCreateFileSystemsNode();
       file_systems_node->AddFileSystemNode(
           new CookieTreeFileSystemNode(&(*file_system_info)));
     }
   }
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
+void CookiesTreeModel::OnQuotaModelInfoLoaded(
+    const QuotaInfoArray& quota_info) {
+  quota_info_list_ = quota_info;
+  PopulateQuotaInfoWithFilter(std::wstring());
+}
+
+void CookiesTreeModel::PopulateQuotaInfoWithFilter(
+    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);
+    }
+  }
+  NotifyObserverTreeNodeChanged(root);
+  NotifyObserverEndBatch();
+}
+
 void CookiesTreeModel::NotifyObserverBeginBatch() {
   // Only notify the model once if we're batching in a nested manner.
   if (batch_update_++ == 0) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelBeginBatch(this));
   }
 }
 
 void CookiesTreeModel::NotifyObserverEndBatch() {
   // Only notify the observers if this is the outermost call to EndBatch() if
   // called in a nested manner.
   if (--batch_update_ == 0) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelEndBatch(this));
   }
 }