Add columns to gtk task manager....

chrome/browser/gtk/task_manager_gtk.cc

 // Copyright (c) 2009 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/gtk/task_manager_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 31 matching lines @@
 
 enum TaskManagerColumn {
   kTaskManagerIcon,
   kTaskManagerPage,
   kTaskManagerPhysicalMem,
   kTaskManagerSharedMem,
   kTaskManagerPrivateMem,
   kTaskManagerCPU,
   kTaskManagerNetwork,
   kTaskManagerProcessID,
+  kTaskManagerWebCoreImageCache,
+  kTaskManagerWebCoreScriptsCache,
+  kTaskManagerWebCoreCssCache,
   kTaskManagerGoatsTeleported,
   kTaskManagerColumnCount,
 };
 
 TaskManagerColumn TaskManagerResourceIDToColumnID(int id) {
   switch (id) {
     case IDS_TASK_MANAGER_PAGE_COLUMN:
       return kTaskManagerPage;
     case IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN:
       return kTaskManagerPhysicalMem;
     case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:
       return kTaskManagerSharedMem;
     case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:
       return kTaskManagerPrivateMem;
     case IDS_TASK_MANAGER_CPU_COLUMN:
       return kTaskManagerCPU;
     case IDS_TASK_MANAGER_NET_COLUMN:
       return kTaskManagerNetwork;
     case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:
       return kTaskManagerProcessID;
+    case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:
+      return kTaskManagerWebCoreImageCache;
+    case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:
+      return kTaskManagerWebCoreScriptsCache;
+    case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN:
+      return kTaskManagerWebCoreCssCache;
     case IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN:
       return kTaskManagerGoatsTeleported;
     default:
       NOTREACHED();
       return static_cast<TaskManagerColumn>(-1);
   }
 }
 
 int TaskManagerColumnIDToResourceID(int id) {
   switch (id) {
     case kTaskManagerPage:
       return IDS_TASK_MANAGER_PAGE_COLUMN;
     case kTaskManagerPhysicalMem:
       return IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN;
     case kTaskManagerSharedMem:
       return IDS_TASK_MANAGER_SHARED_MEM_COLUMN;
     case kTaskManagerPrivateMem:
       return IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN;
     case kTaskManagerCPU:
       return IDS_TASK_MANAGER_CPU_COLUMN;
     case kTaskManagerNetwork:
       return IDS_TASK_MANAGER_NET_COLUMN;
     case kTaskManagerProcessID:
       return IDS_TASK_MANAGER_PROCESS_ID_COLUMN;
+    case kTaskManagerWebCoreImageCache:
+      return IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN;
+    case kTaskManagerWebCoreScriptsCache:
+      return IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN;
+    case kTaskManagerWebCoreCssCache:
+      return IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN;
     case kTaskManagerGoatsTeleported:
       return IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN;
     default:
       NOTREACHED();
       return -1;
   }
 }
 
 // Should be used for all gtk_tree_view functions that require a column index on
 // input.
@@ skipping 336 matching lines @@
   gtk_accel_group_connect(accel_group_,
                           GDK_w, GDK_CONTROL_MASK, GtkAccelFlags(0),
                           g_cclosure_new(G_CALLBACK(OnGtkAccelerator),
                                          this, NULL));
 }
 
 void TaskManagerGtk::CreateTaskManagerTreeview() {
   process_list_ = gtk_list_store_new(kTaskManagerColumnCount,
       GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
       G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
-      G_TYPE_STRING);
+      G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 
   // Support sorting on all columns.
   process_list_sort_ = gtk_tree_model_sort_new_with_model(
       GTK_TREE_MODEL(process_list_));
   gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
                                   kTaskManagerPage,
                                   ComparePage, this, NULL);
   gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
                                   kTaskManagerPhysicalMem,
                                   ComparePhysicalMemory, this, NULL);
@@ skipping 18 matching lines @@
   treeview_ = gtk_tree_view_new_with_model(process_list_sort_);
 
   // Insert all the columns.
   TreeViewInsertColumnWithPixbuf(treeview_, IDS_TASK_MANAGER_PAGE_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_SHARED_MEM_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_CPU_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_NET_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_PROCESS_ID_COLUMN);
+  TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN);
+  TreeViewInsertColumn(treeview_,
+                       IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN);
+  TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN);
 
   // Hide some columns by default.
   TreeViewColumnSetVisible(treeview_, kTaskManagerSharedMem, false);
   TreeViewColumnSetVisible(treeview_, kTaskManagerPrivateMem, false);
   TreeViewColumnSetVisible(treeview_, kTaskManagerProcessID, false);
+  TreeViewColumnSetVisible(treeview_, kTaskManagerWebCoreImageCache, false);
+  TreeViewColumnSetVisible(treeview_, kTaskManagerWebCoreScriptsCache, false);
+  TreeViewColumnSetVisible(treeview_, kTaskManagerWebCoreCssCache, false);
   TreeViewColumnSetVisible(treeview_, kTaskManagerGoatsTeleported, false);
 
   g_object_unref(process_list_);
   g_object_unref(process_list_sort_);
 }
 
 std::string TaskManagerGtk::GetModelText(int row, int col_id) {
   switch (col_id) {
     case IDS_TASK_MANAGER_PAGE_COLUMN:  // Process
       return WideToUTF8(model_->GetResourceTitle(row));
@@ skipping 19 matching lines @@
       return WideToUTF8(model_->GetResourceCPUUsage(row));
 
     case IDS_TASK_MANAGER_NET_COLUMN:  // Net
       return WideToUTF8(model_->GetResourceNetworkUsage(row));
 
     case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:  // Process ID
       if (!model_->IsResourceFirstInGroup(row))
         return std::string();
       return WideToUTF8(model_->GetResourceProcessId(row));
 
+    case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:
+      return WideToUTF8(model_->GetResourceWebCoreImageCacheSize(row));
+
+    case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:
+      return WideToUTF8(model_->GetResourceWebCoreScriptsCacheSize(row));
+
+    case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN:
+      return WideToUTF8(model_->GetResourceWebCoreCSSCacheSize(row));
+
     case IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN:  // Goats Teleported!
       return WideToUTF8(model_->GetResourceGoatsTeleported(row));
 
     default:
       return WideToUTF8(model_->GetResourceStatsValue(row, col_id));
   }
 }
 
 GdkPixbuf* TaskManagerGtk::GetModelIcon(int row) {
   SkBitmap icon = model_->GetResourceIcon(row);
@@ skipping 11 matching lines @@
   GdkPixbuf* icon = GetModelIcon(row);
   std::string page = GetModelText(row, IDS_TASK_MANAGER_PAGE_COLUMN);
   std::string phys_mem = GetModelText(
       row, IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN);
   std::string shared_mem = GetModelText(
       row, IDS_TASK_MANAGER_SHARED_MEM_COLUMN);
   std::string priv_mem = GetModelText(row, IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN);
   std::string cpu = GetModelText(row, IDS_TASK_MANAGER_CPU_COLUMN);
   std::string net = GetModelText(row, IDS_TASK_MANAGER_NET_COLUMN);
   std::string procid = GetModelText(row, IDS_TASK_MANAGER_PROCESS_ID_COLUMN);
+
+  // Querying the WebCore metrics is slow as it has to do IPC, so only do it
+  // when the columns are visible.
+  std::string wk_img_cache;
+  if (TreeViewColumnIsVisible(treeview_, kTaskManagerWebCoreImageCache))
+    wk_img_cache = GetModelText(
+        row, IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN);
+  std::string wk_scripts_cache;
+  if (TreeViewColumnIsVisible(treeview_, kTaskManagerWebCoreScriptsCache))
+    wk_scripts_cache = GetModelText(
+        row, IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN);
+  std::string wk_css_cache;
+  if (TreeViewColumnIsVisible(treeview_, kTaskManagerWebCoreCssCache))
+    wk_css_cache = GetModelText(
+        row, IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN);
+
   std::string goats = GetModelText(
       row, IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN);
   gtk_list_store_set(process_list_, iter,
                      kTaskManagerIcon, icon,
                      kTaskManagerPage, page.c_str(),
                      kTaskManagerPhysicalMem, phys_mem.c_str(),
                      kTaskManagerSharedMem, shared_mem.c_str(),
                      kTaskManagerPrivateMem, priv_mem.c_str(),
                      kTaskManagerCPU, cpu.c_str(),
                      kTaskManagerNetwork, net.c_str(),
                      kTaskManagerProcessID, procid.c_str(),
+                     kTaskManagerWebCoreImageCache, wk_img_cache.c_str(),
+                     kTaskManagerWebCoreScriptsCache, wk_scripts_cache.c_str(),
+                     kTaskManagerWebCoreCssCache, wk_css_cache.c_str(),
                      kTaskManagerGoatsTeleported, goats.c_str(),
                      -1);
   g_object_unref(icon);
 }
 
 void TaskManagerGtk::KillSelectedProcesses() {
   GtkTreeSelection* selection = gtk_tree_view_get_selection(
       GTK_TREE_VIEW(treeview_));
 
   GtkTreeModel* model;
@@ skipping 167 matching lines @@
                                           TaskManagerGtk* task_manager) {
   if (keyval == GDK_w && modifier == GDK_CONTROL_MASK) {
     // The GTK_RESPONSE_DELETE_EVENT response must be sent before the widget
     // is destroyed.  The deleted object will receive gtk signals otherwise.
     gtk_dialog_response(GTK_DIALOG(task_manager->dialog_),
                         GTK_RESPONSE_DELETE_EVENT);
   }
 
   return TRUE;
 }