OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "chrome/browser/ui/webui/cookies_tree_model_util.h" |
| 6 |
| 7 #include "base/i18n/time_formatting.h" |
| 8 #include "base/string_number_conversions.h" |
| 9 #include "base/string_split.h" |
| 10 #include "base/string_util.h" |
| 11 #include "base/values.h" |
| 12 #include "chrome/browser/cookies_tree_model.h" |
| 13 #include "grit/generated_resources.h" |
| 14 #include "ui/base/l10n/l10n_util.h" |
| 15 |
| 16 namespace { |
| 17 |
| 18 static const char kKeyId[] = "id"; |
| 19 static const char kKeyTitle[] = "title"; |
| 20 static const char kKeyIcon[] = "icon"; |
| 21 static const char kKeyType[] = "type"; |
| 22 static const char kKeyHasChildren[] = "hasChildren"; |
| 23 |
| 24 static const char kKeyName[] = "name"; |
| 25 static const char kKeyContent[] = "content"; |
| 26 static const char kKeyDomain[] = "domain"; |
| 27 static const char kKeyPath[] = "path"; |
| 28 static const char kKeySendFor[] = "sendfor"; |
| 29 static const char kKeyAccessibleToScript[] = "accessibleToScript"; |
| 30 static const char kKeyDesc[] = "desc"; |
| 31 static const char kKeySize[] = "size"; |
| 32 static const char kKeyOrigin[] = "origin"; |
| 33 static const char kKeyManifest[] = "manifest"; |
| 34 |
| 35 static const char kKeyAccessed[] = "accessed"; |
| 36 static const char kKeyCreated[] = "created"; |
| 37 static const char kKeyExpires[] = "expires"; |
| 38 static const char kKeyModified[] = "modified"; |
| 39 |
| 40 // Encodes a pointer value into a hex string. |
| 41 std::string PointerToHexString(const void* pointer) { |
| 42 return base::HexEncode(&pointer, sizeof(pointer)); |
| 43 } |
| 44 |
| 45 // Decodes a pointer from a hex string. |
| 46 void* HexStringToPointer(const std::string& str) { |
| 47 std::vector<uint8> buffer; |
| 48 if (!base::HexStringToBytes(str, &buffer) || |
| 49 buffer.size() != sizeof(void*)) { |
| 50 return NULL; |
| 51 } |
| 52 |
| 53 return *reinterpret_cast<void**>(&buffer[0]); |
| 54 } |
| 55 |
| 56 } // namespace |
| 57 |
| 58 namespace cookies_tree_model_util { |
| 59 |
| 60 std::string GetTreeNodeId(CookieTreeNode* node) { |
| 61 return PointerToHexString(node); |
| 62 } |
| 63 |
| 64 void GetCookieTreeNodeDictionary(const CookieTreeNode& node, |
| 65 DictionaryValue* dict) { |
| 66 // Use node's address as an id for WebUI to look it up. |
| 67 dict->SetString(kKeyId, PointerToHexString(&node)); |
| 68 dict->SetString(kKeyTitle, node.GetTitle()); |
| 69 dict->SetBoolean(kKeyHasChildren, !!node.GetChildCount()); |
| 70 |
| 71 switch (node.GetDetailedInfo().node_type) { |
| 72 case CookieTreeNode::DetailedInfo::TYPE_ORIGIN: { |
| 73 dict->SetString(kKeyType, "origin"); |
| 74 #if defined(OS_MACOSX) |
| 75 dict->SetString(kKeyIcon, "chrome://theme/IDR_BOOKMARK_BAR_FOLDER"); |
| 76 #endif |
| 77 break; |
| 78 } |
| 79 case CookieTreeNode::DetailedInfo::TYPE_COOKIE: { |
| 80 dict->SetString(kKeyType, "cookie"); |
| 81 dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_ICON"); |
| 82 |
| 83 const net::CookieMonster::CanonicalCookie& cookie = |
| 84 *node.GetDetailedInfo().cookie; |
| 85 |
| 86 dict->SetString(kKeyName, cookie.Name()); |
| 87 dict->SetString(kKeyContent, cookie.Value()); |
| 88 dict->SetString(kKeyDomain, cookie.Domain()); |
| 89 dict->SetString(kKeyPath, cookie.Path()); |
| 90 dict->SetString(kKeySendFor, cookie.IsSecure() ? |
| 91 l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_SENDFOR_SECURE) : |
| 92 l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_SENDFOR_ANY)); |
| 93 std::string accessible = cookie.IsHttpOnly() ? |
| 94 l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_ACCESSIBLE_TO_SCRIPT_NO) : |
| 95 l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_ACCESSIBLE_TO_SCRIPT_YES); |
| 96 dict->SetString(kKeyAccessibleToScript, accessible); |
| 97 dict->SetString(kKeyCreated, UTF16ToUTF8( |
| 98 base::TimeFormatFriendlyDateAndTime(cookie.CreationDate()))); |
| 99 dict->SetString(kKeyExpires, cookie.DoesExpire() ? UTF16ToUTF8( |
| 100 base::TimeFormatFriendlyDateAndTime(cookie.ExpiryDate())) : |
| 101 l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_EXPIRES_SESSION)); |
| 102 |
| 103 break; |
| 104 } |
| 105 case CookieTreeNode::DetailedInfo::TYPE_DATABASE: { |
| 106 dict->SetString(kKeyType, "database"); |
| 107 dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_STORAGE_ICON"); |
| 108 |
| 109 const BrowsingDataDatabaseHelper::DatabaseInfo& database_info = |
| 110 *node.GetDetailedInfo().database_info; |
| 111 |
| 112 dict->SetString(kKeyName, database_info.database_name.empty() ? |
| 113 l10n_util::GetStringUTF8(IDS_COOKIES_WEB_DATABASE_UNNAMED_NAME) : |
| 114 database_info.database_name); |
| 115 dict->SetString(kKeyDesc, database_info.description); |
| 116 dict->SetString(kKeySize, |
| 117 FormatBytes(database_info.size, |
| 118 GetByteDisplayUnits(database_info.size), |
| 119 true)); |
| 120 dict->SetString(kKeyModified, UTF16ToUTF8( |
| 121 base::TimeFormatFriendlyDateAndTime(database_info.last_modified))); |
| 122 |
| 123 break; |
| 124 } |
| 125 case CookieTreeNode::DetailedInfo::TYPE_LOCAL_STORAGE: { |
| 126 dict->SetString(kKeyType, "local_storage"); |
| 127 dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_STORAGE_ICON"); |
| 128 |
| 129 const BrowsingDataLocalStorageHelper::LocalStorageInfo& |
| 130 local_storage_info = *node.GetDetailedInfo().local_storage_info; |
| 131 |
| 132 dict->SetString(kKeyOrigin, local_storage_info.origin); |
| 133 dict->SetString(kKeySize, |
| 134 FormatBytes(local_storage_info.size, |
| 135 GetByteDisplayUnits(local_storage_info.size), |
| 136 true)); |
| 137 dict->SetString(kKeyModified, UTF16ToUTF8( |
| 138 base::TimeFormatFriendlyDateAndTime( |
| 139 local_storage_info.last_modified))); |
| 140 |
| 141 break; |
| 142 } |
| 143 case CookieTreeNode::DetailedInfo::TYPE_APPCACHE: { |
| 144 dict->SetString(kKeyType, "app_cache"); |
| 145 dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_STORAGE_ICON"); |
| 146 |
| 147 const appcache::AppCacheInfo& appcache_info = |
| 148 *node.GetDetailedInfo().appcache_info; |
| 149 |
| 150 dict->SetString(kKeyManifest, appcache_info.manifest_url.spec()); |
| 151 dict->SetString(kKeySize, |
| 152 FormatBytes(appcache_info.size, |
| 153 GetByteDisplayUnits(appcache_info.size), |
| 154 true)); |
| 155 dict->SetString(kKeyCreated, UTF16ToUTF8( |
| 156 base::TimeFormatFriendlyDateAndTime(appcache_info.creation_time))); |
| 157 dict->SetString(kKeyAccessed, UTF16ToUTF8( |
| 158 base::TimeFormatFriendlyDateAndTime(appcache_info.last_access_time))); |
| 159 |
| 160 break; |
| 161 } |
| 162 case CookieTreeNode::DetailedInfo::TYPE_INDEXED_DB: { |
| 163 dict->SetString(kKeyType, "indexed_db"); |
| 164 dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_STORAGE_ICON"); |
| 165 |
| 166 const BrowsingDataIndexedDBHelper::IndexedDBInfo& indexed_db_info = |
| 167 *node.GetDetailedInfo().indexed_db_info; |
| 168 |
| 169 dict->SetString(kKeyOrigin, indexed_db_info.origin); |
| 170 dict->SetString(kKeySize, |
| 171 FormatBytes(indexed_db_info.size, |
| 172 GetByteDisplayUnits(indexed_db_info.size), |
| 173 true)); |
| 174 dict->SetString(kKeyModified, UTF16ToUTF8( |
| 175 base::TimeFormatFriendlyDateAndTime(indexed_db_info.last_modified))); |
| 176 |
| 177 break; |
| 178 } |
| 179 default: |
| 180 #if defined(OS_MACOSX) |
| 181 dict->SetString(kKeyIcon, "chrome://theme/IDR_BOOKMARK_BAR_FOLDER"); |
| 182 #endif |
| 183 break; |
| 184 } |
| 185 } |
| 186 |
| 187 void GetChildNodeList(CookieTreeNode* parent, int start, int count, |
| 188 ListValue* nodes) { |
| 189 for (int i = 0; i < count; ++i) { |
| 190 DictionaryValue* dict = new DictionaryValue; |
| 191 CookieTreeNode* child = parent->GetChild(start + i); |
| 192 GetCookieTreeNodeDictionary(*child, dict); |
| 193 nodes->Append(dict); |
| 194 } |
| 195 } |
| 196 |
| 197 CookieTreeNode* GetTreeNodeFromPath(CookieTreeNode* root, |
| 198 const std::string& path) { |
| 199 std::vector<std::string> node_ids; |
| 200 base::SplitString(path, ',', &node_ids); |
| 201 |
| 202 CookieTreeNode* child = NULL; |
| 203 CookieTreeNode* parent = root; |
| 204 int child_index = -1; |
| 205 |
| 206 // Validate the tree path and get the node pointer. |
| 207 for (size_t i = 0; i < node_ids.size(); ++i) { |
| 208 child = reinterpret_cast<CookieTreeNode*>( |
| 209 HexStringToPointer(node_ids[i])); |
| 210 |
| 211 child_index = parent->IndexOfChild(child); |
| 212 if (child_index == -1) |
| 213 break; |
| 214 |
| 215 parent = child; |
| 216 } |
| 217 |
| 218 return child_index >= 0 ? child : NULL; |
| 219 } |
| 220 |
| 221 } // namespace cookies_tree_model_util |
OLD | NEW |