Remove unused icon references from webui cookie view.

chrome/browser/ui/webui/cookies_tree_model_util.cc

 // Copyright (c) 2012 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 <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 16 matching lines @@
 #include "ui/base/text/bytes_formatting.h"
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 #include "extensions/common/extension_set.h"
 #endif
 
 namespace {
 
 const char kKeyId[] = "id";
 const char kKeyTitle[] = "title";
-const char kKeyIcon[] = "icon";
 const char kKeyType[] = "type";
 const char kKeyHasChildren[] = "hasChildren";
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 const char kKeyAppsProtectingThis[] = "appsProtectingThis";
 #endif
 const char kKeyName[] = "name";
 const char kKeyContent[] = "content";
 const char kKeyDomain[] = "domain";
 const char kKeyPath[] = "path";
@@ skipping 46 matching lines @@
     bool include_quota_nodes,
     base::DictionaryValue* dict) {
   // Use node's address as an id for WebUI to look it up.
   dict->SetString(kKeyId, GetTreeNodeId(&node));
   dict->SetString(kKeyTitle, node.GetTitle());
   dict->SetBoolean(kKeyHasChildren, !node.empty());
 
   switch (node.GetDetailedInfo().node_type) {
     case CookieTreeNode::DetailedInfo::TYPE_HOST: {
       dict->SetString(kKeyType, "origin");
-#if defined(OS_MACOSX)
-      dict->SetString(kKeyIcon, "chrome://theme/IDR_BOOKMARK_BAR_FOLDER");
-#endif
       break;
     }
     case CookieTreeNode::DetailedInfo::TYPE_COOKIE: {
       dict->SetString(kKeyType, "cookie");
-      dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_ICON");
 
       const net::CanonicalCookie& cookie = *node.GetDetailedInfo().cookie;
 
       dict->SetString(kKeyName, cookie.Name());
       dict->SetString(kKeyContent, cookie.Value());
       dict->SetString(kKeyDomain, cookie.Domain());
       dict->SetString(kKeyPath, cookie.Path());
       dict->SetString(kKeySendFor,
                       l10n_util::GetStringUTF16(
                           CookiesTreeModel::GetSendForMessageID(cookie)));
       std::string accessible = cookie.IsHttpOnly() ?
           l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_ACCESSIBLE_TO_SCRIPT_NO) :
           l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_ACCESSIBLE_TO_SCRIPT_YES);
       dict->SetString(kKeyAccessibleToScript, accessible);
       dict->SetString(kKeyCreated, base::UTF16ToUTF8(
           base::TimeFormatFriendlyDateAndTime(cookie.CreationDate())));
       dict->SetString(kKeyExpires, cookie.IsPersistent() ? base::UTF16ToUTF8(
           base::TimeFormatFriendlyDateAndTime(cookie.ExpiryDate())) :
           l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_EXPIRES_SESSION));
 
       break;
     }
     case CookieTreeNode::DetailedInfo::TYPE_DATABASE: {
       dict->SetString(kKeyType, "database");
-      dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_STORAGE_ICON");

[dschuyler, 2016/12/15 02:24:48]

Are there associated icon resources that could be removed?

It looks like this icon might be used elsewhere, but if you didn't find it
anywhere when you were looking -- are the other references in this search also
dead?
https://cs.chromium.org/search/?q=IDR_COOKIE_STORAGE_ICON&sq=package:chromium...

 
       const BrowsingDataDatabaseHelper::DatabaseInfo& database_info =
           *node.GetDetailedInfo().database_info;
 
       dict->SetString(kKeyName, database_info.database_name.empty() ?
           l10n_util::GetStringUTF8(IDS_COOKIES_WEB_DATABASE_UNNAMED_NAME) :
           database_info.database_name);
       dict->SetString(kKeyDesc, database_info.description);
       dict->SetString(kKeySize, ui::FormatBytes(database_info.size));
       dict->SetString(kKeyModified, base::UTF16ToUTF8(
           base::TimeFormatFriendlyDateAndTime(database_info.last_modified)));
 
       break;
     }
     case CookieTreeNode::DetailedInfo::TYPE_LOCAL_STORAGE: {
       dict->SetString(kKeyType, "local_storage");
-      dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_STORAGE_ICON");
 
       const BrowsingDataLocalStorageHelper::LocalStorageInfo&
          local_storage_info = *node.GetDetailedInfo().local_storage_info;
 
       dict->SetString(kKeyOrigin, local_storage_info.origin_url.spec());
       dict->SetString(kKeySize, ui::FormatBytes(local_storage_info.size));
       dict->SetString(kKeyModified, base::UTF16ToUTF8(
           base::TimeFormatFriendlyDateAndTime(
               local_storage_info.last_modified)));
 
       break;
     }
     case CookieTreeNode::DetailedInfo::TYPE_APPCACHE: {
       dict->SetString(kKeyType, "app_cache");
-      dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_STORAGE_ICON");
 
       const content::AppCacheInfo& appcache_info =
           *node.GetDetailedInfo().appcache_info;
 
       dict->SetString(kKeyManifest, appcache_info.manifest_url.spec());
       dict->SetString(kKeySize, ui::FormatBytes(appcache_info.size));
       dict->SetString(kKeyCreated, base::UTF16ToUTF8(
           base::TimeFormatFriendlyDateAndTime(appcache_info.creation_time)));
       dict->SetString(kKeyAccessed, base::UTF16ToUTF8(
           base::TimeFormatFriendlyDateAndTime(appcache_info.last_access_time)));
 
       break;
     }
     case CookieTreeNode::DetailedInfo::TYPE_INDEXED_DB: {
       dict->SetString(kKeyType, "indexed_db");
-      dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_STORAGE_ICON");
 
       const content::IndexedDBInfo& indexed_db_info =
           *node.GetDetailedInfo().indexed_db_info;
 
       dict->SetString(kKeyOrigin, indexed_db_info.origin.spec());
       dict->SetString(kKeySize, ui::FormatBytes(indexed_db_info.size));
       dict->SetString(kKeyModified,
                       base::UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(
                           indexed_db_info.last_modified)));
       break;
     }
     case CookieTreeNode::DetailedInfo::TYPE_FILE_SYSTEM: {
       dict->SetString(kKeyType, "file_system");
-      dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_STORAGE_ICON");
 
       const BrowsingDataFileSystemHelper::FileSystemInfo& file_system_info =
           *node.GetDetailedInfo().file_system_info;
       const storage::FileSystemType kPerm = storage::kFileSystemTypePersistent;
       const storage::FileSystemType kTemp = storage::kFileSystemTypeTemporary;
 
       dict->SetString(kKeyOrigin, file_system_info.origin.spec());
       dict->SetString(
           kKeyPersistent,
           base::ContainsKey(file_system_info.usage_map, kPerm)
               ? base::UTF16ToUTF8(ui::FormatBytes(
                     file_system_info.usage_map.find(kPerm)->second))
               : l10n_util::GetStringUTF8(IDS_COOKIES_FILE_SYSTEM_USAGE_NONE));
       dict->SetString(
           kKeyTemporary,
           base::ContainsKey(file_system_info.usage_map, kTemp)
               ? base::UTF16ToUTF8(ui::FormatBytes(
                     file_system_info.usage_map.find(kTemp)->second))
               : l10n_util::GetStringUTF8(IDS_COOKIES_FILE_SYSTEM_USAGE_NONE));
       break;
     }
     case CookieTreeNode::DetailedInfo::TYPE_QUOTA: {
       if (!include_quota_nodes)
         return false;
 
       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,
                       base::UTF16ToUTF8(ui::FormatBytes(
                           quota_info.temporary_usage +
                           quota_info.persistent_usage)));
       dict->SetString(kKeyTemporaryUsage,
                       base::UTF16ToUTF8(ui::FormatBytes(
                           quota_info.temporary_usage)));
       dict->SetString(kKeyPersistentUsage,
                       base::UTF16ToUTF8(ui::FormatBytes(
                           quota_info.persistent_usage)));
       break;
     }
     case CookieTreeNode::DetailedInfo::TYPE_CHANNEL_ID: {
       dict->SetString(kKeyType, "channel_id");
-      dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_ICON");
 
       const net::ChannelIDStore::ChannelID& channel_id =
           *node.GetDetailedInfo().channel_id;
 
       dict->SetString(kKeyServerId, channel_id.server_identifier());
       dict->SetString(kKeyCertType,
                       l10n_util::GetStringUTF8(IDS_CLIENT_CERT_ECDSA_SIGN));
       dict->SetString(kKeyCreated, base::UTF16ToUTF8(
           base::TimeFormatFriendlyDateAndTime(
               channel_id.creation_time())));
       break;
     }
     case CookieTreeNode::DetailedInfo::TYPE_SERVICE_WORKER: {
       dict->SetString(kKeyType, "service_worker");
-      dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_STORAGE_ICON");
 
       const content::ServiceWorkerUsageInfo& service_worker_info =
           *node.GetDetailedInfo().service_worker_info;
 
       dict->SetString(kKeyOrigin, service_worker_info.origin.spec());
       dict->SetString(kKeySize,
                       ui::FormatBytes(service_worker_info.total_size_bytes));
       base::ListValue* scopes = new base::ListValue;
       for (std::vector<GURL>::const_iterator it =
                service_worker_info.scopes.begin();
            it != service_worker_info.scopes.end();
            ++it) {
         scopes->AppendString(it->spec());
       }
       dict->Set(kKeyScopes, scopes);
       break;
     }
     case CookieTreeNode::DetailedInfo::TYPE_CACHE_STORAGE: {
       dict->SetString(kKeyType, "cache_storage");
-      dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_STORAGE_ICON");
 
       const content::CacheStorageUsageInfo& cache_storage_info =
           *node.GetDetailedInfo().cache_storage_info;
 
       dict->SetString(kKeyOrigin, cache_storage_info.origin.spec());
       dict->SetString(kKeySize,
                       ui::FormatBytes(cache_storage_info.total_size_bytes));
       dict->SetString(kKeyModified,
                       base::UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(
                           cache_storage_info.last_modified)));
       break;
     }
     case CookieTreeNode::DetailedInfo::TYPE_FLASH_LSO: {
       dict->SetString(kKeyType, "flash_lso");
-      dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_ICON");
 
       dict->SetString(kKeyDomain, node.GetDetailedInfo().flash_lso_domain);
       break;
     }
     case CookieTreeNode::DetailedInfo::TYPE_MEDIA_LICENSE: {
       dict->SetString(kKeyType, "media_license");
-      dict->SetString(kKeyIcon, "chrome://theme/IDR_COOKIE_STORAGE_ICON");
 
       const BrowsingDataMediaLicenseHelper::MediaLicenseInfo&
           media_license_info = *node.GetDetailedInfo().media_license_info;
       dict->SetString(kKeyOrigin, media_license_info.origin.spec());
       dict->SetString(kKeySize, ui::FormatBytes(media_license_info.size));
       dict->SetString(kKeyModified,
                       base::UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(
                           media_license_info.last_modified_time)));
       break;
     }
     default:
-#if defined(OS_MACOSX)
-      dict->SetString(kKeyIcon, "chrome://theme/IDR_BOOKMARK_BAR_FOLDER");
-#endif
       break;
   }
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   const extensions::ExtensionSet* protecting_apps =
       node.GetModel()->ExtensionsProtectingNode(node);
   if (protecting_apps && !protecting_apps->is_empty()) {
     base::ListValue* app_infos = new base::ListValue;
     for (extensions::ExtensionSet::const_iterator it = protecting_apps->begin();
          it != protecting_apps->end(); ++it) {
@@ skipping 80 matching lines @@
   // lookup for O(1) space, but it could be further improved to O(1) lookup if
   // desired (by trading O(n) space for the time improvement).
   int site_count = root->child_count();
   for (int i = 0; i < site_count; ++i) {
     const CookieTreeNode* child = root->GetChild(i);
     if (title == child->GetTitle())
       return child;
   }
   return nullptr;
 }