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

chrome/browser/ui/webui/cookies_tree_model_util.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/ui/webui/cookies_tree_model_util.h"
 
 #include "base/i18n/time_formatting.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 23 matching lines @@
 static const char kKeyManifest[] = "manifest";
 
 static const char kKeyAccessed[] = "accessed";
 static const char kKeyCreated[] = "created";
 static const char kKeyExpires[] = "expires";
 static const char kKeyModified[] = "modified";
 
 static const char kKeyPersistent[] = "persistent";
 static const char kKeyTemporary[] = "temporary";
 
+static const char kKeyTotalUsage[] = "totalUsage";
+static const char kKeyTemporaryUsage[] = "temporaryUsage";
+static const char kKeyPersistentUsage[] = "persistentUsage";
+static const char kKeyPersistentQuota[] = "persistentQuota";
+
+static const int64 kNegligibleUsage = 1024;  // 1KiB
+
 // Encodes a pointer value into a hex string.
 std::string PointerToHexString(const void* pointer) {
   return base::HexEncode(&pointer, sizeof(pointer));
 }
 
 // Decodes a pointer from a hex string.
 void* HexStringToPointer(const std::string& str) {
   std::vector<uint8> buffer;
   if (!base::HexStringToBytes(str, &buffer) ||
       buffer.size() != sizeof(void*)) {
     return NULL;
   }
 
   return *reinterpret_cast<void**>(&buffer[0]);
 }
 
 }  // namespace
 
 namespace cookies_tree_model_util {
 
 std::string GetTreeNodeId(CookieTreeNode* node) {
   return PointerToHexString(node);
 }
 
-void GetCookieTreeNodeDictionary(const CookieTreeNode& node,
+bool GetCookieTreeNodeDictionary(const CookieTreeNode& node,
                                  DictionaryValue* dict) {
   // Use node's address as an id for WebUI to look it up.
   dict->SetString(kKeyId, PointerToHexString(&node));
   dict->SetString(kKeyTitle, node.GetTitle());
   dict->SetBoolean(kKeyHasChildren, !node.empty());
 
   switch (node.GetDetailedInfo().node_type) {
     case CookieTreeNode::DetailedInfo::TYPE_ORIGIN: {
       dict->SetString(kKeyType, "origin");
 #if defined(OS_MACOSX)
@@ skipping 104 matching lines @@
                           l10n_util::GetStringUTF8(
                               IDS_COOKIES_FILE_SYSTEM_USAGE_NONE));
       dict->SetString(kKeyTemporary,
                       file_system_info.has_temporary ?
                           UTF16ToUTF8(ui::FormatBytes(
                               file_system_info.usage_temporary)) :
                           l10n_util::GetStringUTF8(
                               IDS_COOKIES_FILE_SYSTEM_USAGE_NONE));
       break;
     }
+    case CookieTreeNode::DetailedInfo::TYPE_QUOTA: {
+      dict->SetString(kKeyType, "quota");
+      dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_STORAGE_ICON");
+
+      const BrowsingDataQuotaHelper::QuotaInfo& quota_info =
+          *node.GetDetailedInfo().quota_info;
+      if (quota_info.temporary_usage + quota_info.persistent_usage <=
+          kNegligibleUsage)
+        return false;
+
+      dict->SetString(kKeyOrigin, quota_info.host);
+      dict->SetString(kKeyTotalUsage,
+                      UTF16ToUTF8(ui::FormatBytes(
+                          quota_info.temporary_usage +
+                          quota_info.persistent_usage)));
+      dict->SetString(kKeyTemporaryUsage,
+                      UTF16ToUTF8(ui::FormatBytes(
+                          quota_info.temporary_usage)));
+      dict->SetString(kKeyPersistentUsage,
+                      UTF16ToUTF8(ui::FormatBytes(
+                          quota_info.persistent_usage)));
+      break;
+    }
     default:
 #if defined(OS_MACOSX)
       dict->SetString(kKeyIcon, "chrome://theme/IDR_BOOKMARK_BAR_FOLDER");
 #endif
       break;
   }
+  return true;
 }
 
 void GetChildNodeList(CookieTreeNode* parent, int start, int count,
                       ListValue* nodes) {
   for (int i = 0; i < count; ++i) {
     DictionaryValue* dict = new DictionaryValue;
     CookieTreeNode* child = parent->GetChild(start + i);
-    GetCookieTreeNodeDictionary(*child, dict);
-    nodes->Append(dict);
+    if (GetCookieTreeNodeDictionary(*child, dict))
+      nodes->Append(dict);
+    else
+      delete dict;
   }
 }
 
 CookieTreeNode* GetTreeNodeFromPath(CookieTreeNode* root,
                                     const std::string& path) {
   std::vector<std::string> node_ids;
   base::SplitString(path, ',', &node_ids);
 
   CookieTreeNode* child = NULL;
   CookieTreeNode* parent = root;
   int child_index = -1;
 
   // Validate the tree path and get the node pointer.
   for (size_t i = 0; i < node_ids.size(); ++i) {
     child = reinterpret_cast<CookieTreeNode*>(
         HexStringToPointer(node_ids[i]));
 
     child_index = parent->GetIndexOf(child);
     if (child_index == -1)
       break;
 
     parent = child;
   }
 
   return child_index >= 0 ? child : NULL;
 }
 
 }  // namespace cookies_tree_model_util