TaskManager: Replace the string "Page" with "Task"

chrome/browser/ui/gtk/task_manager_gtk.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/gtk/task_manager_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 37 matching lines @@
 const gint kTaskManagerResponseKill = 1;
 
 // The resource id for the 'Stats for nerds' link button.
 const gint kTaskManagerAboutMemoryLink = 2;
 
 // The resource id for the 'Purge Memory' button
 const gint kTaskManagerPurgeMemory = 3;
 
 enum TaskManagerColumn {
   kTaskManagerIcon,
-  kTaskManagerPage,
+  kTaskManagerTask,
   kTaskManagerProfileName,
   kTaskManagerSharedMem,
   kTaskManagerPrivateMem,
   kTaskManagerCPU,
   kTaskManagerNetwork,
   kTaskManagerProcessID,
   kTaskManagerJavaScriptMemory,
   kTaskManagerWebCoreImageCache,
   kTaskManagerWebCoreScriptsCache,
   kTaskManagerWebCoreCssCache,
   kTaskManagerFPS,
   kTaskManagerSqliteMemoryUsed,
   kTaskManagerGoatsTeleported,
   // Columns below this point are not visible in the task manager.
   kTaskManagerBackgroundColor,
   kTaskManagerColumnCount,
 };
 
 const TaskManagerColumn kTaskManagerLastVisibleColumn =
     kTaskManagerGoatsTeleported;
 
 static const GdkColor kHighlightColor = GDK_COLOR_RGB(0xff, 0xfa, 0xcd);
 
 TaskManagerColumn TaskManagerResourceIDToColumnID(int id) {
   switch (id) {
-    case IDS_TASK_MANAGER_PAGE_COLUMN:
-      return kTaskManagerPage;
+    case IDS_TASK_MANAGER_TASK_COLUMN:
+      return kTaskManagerTask;
     case IDS_TASK_MANAGER_PROFILE_NAME_COLUMN:
       return kTaskManagerProfileName;
     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;
@@ skipping 14 matching lines @@
     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 kTaskManagerTask:
+      return IDS_TASK_MANAGER_TASK_COLUMN;
     case kTaskManagerProfileName:
       return IDS_TASK_MANAGER_PROFILE_NAME_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;
@@ skipping 17 matching lines @@
       NOTREACHED();
       return -1;
   }
 }
 
 // Should be used for all gtk_tree_view functions that require a column index on
 // input.
 //
 // We need colid - 1 because the gtk_tree_view function is asking for the
 // column index, not the column id, and both kTaskManagerIcon and
-// kTaskManagerPage are in the same column index, so all column IDs are off by
+// kTaskManagerTask are in the same column index, so all column IDs are off by
 // one.
 int TreeViewColumnIndexFromID(TaskManagerColumn colid) {
   return colid - 1;
 }
 
 // Shows or hides a treeview column.
 void TreeViewColumnSetVisible(GtkWidget* treeview, TaskManagerColumn colid,
                               bool visible) {
   GtkTreeViewColumn* column = gtk_tree_view_get_column(
       GTK_TREE_VIEW(treeview), TreeViewColumnIndexFromID(colid));
@@ skipping 56 matching lines @@
 }
 
 }  // namespace
 
 class TaskManagerGtk::ContextMenuController
     : public ui::SimpleMenuModel::Delegate {
  public:
   explicit ContextMenuController(TaskManagerGtk* task_manager)
       : task_manager_(task_manager) {
     menu_model_.reset(new ui::SimpleMenuModel(this));
-    for (int i = kTaskManagerPage; i <= kTaskManagerLastVisibleColumn; i++) {
+    for (int i = kTaskManagerTask; i <= kTaskManagerLastVisibleColumn; i++) {
       menu_model_->AddCheckItemWithStringId(
           i, TaskManagerColumnIDToResourceID(i));
     }
     menu_.reset(new MenuGtk(NULL, menu_model_.get()));
   }
 
   virtual ~ContextMenuController() {}
 
   void RunMenu(const gfx::Point& point, guint32 event_time) {
     menu_->PopupAsContext(point, event_time);
@@ skipping 312 matching lines @@
   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,
       G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_COLOR);
 
   // 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,
+                                  kTaskManagerTask,
                                   ComparePage, this, NULL);
   gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
-                                  kTaskManagerPage,
+                                  kTaskManagerTask,
                                   CompareProfileName, this, NULL);
   gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
                                   kTaskManagerSharedMem,
                                   CompareSharedMemory, this, NULL);
   gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
                                   kTaskManagerPrivateMem,
                                   ComparePrivateMemory, this, NULL);
   gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
                                   kTaskManagerJavaScriptMemory,
                                   CompareV8Memory, this, NULL);
@@ skipping 20 matching lines @@
                                   CompareFPS, this, NULL);
   gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
                                   kTaskManagerSqliteMemoryUsed,
                                   CompareSqliteMemoryUsed, this, NULL);
   gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
                                   kTaskManagerGoatsTeleported,
                                   CompareGoatsTeleported, this, NULL);
   treeview_ = gtk_tree_view_new_with_model(process_list_sort_);
 
   // Insert all the columns.
-  TreeViewInsertColumnWithPixbuf(treeview_, IDS_TASK_MANAGER_PAGE_COLUMN);
+  TreeViewInsertColumnWithPixbuf(treeview_, IDS_TASK_MANAGER_TASK_COLUMN);
   TreeViewInsertColumnWithPixbuf(treeview_,
                                  IDS_TASK_MANAGER_PROFILE_NAME_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_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN);
@@ skipping 33 matching lines @@
     default:
       return false;
   }
 }
 
 std::string TaskManagerGtk::GetModelText(int row, int col_id) {
   if (IsSharedByGroup(col_id) && !model_->IsResourceFirstInGroup(row))
     return std::string();
 
   switch (col_id) {
-    case IDS_TASK_MANAGER_PAGE_COLUMN:  // Process
+    case IDS_TASK_MANAGER_TASK_COLUMN:  // Process
       return UTF16ToUTF8(model_->GetResourceTitle(row));
 
     case IDS_TASK_MANAGER_PROFILE_NAME_COLUMN:  // Profile name
       return UTF16ToUTF8(model_->GetResourceProfileName(row));
 
     case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:  // Memory
       return UTF16ToUTF8(model_->GetResourcePrivateMemory(row));
 
     case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:  // Memory
       return UTF16ToUTF8(model_->GetResourceSharedMemory(row));
@@ skipping 41 matching lines @@
           IDR_DEFAULT_FAVICON)->pixelRef()) {
     return static_cast<GdkPixbuf*>(g_object_ref(
         ThemeServiceGtk::GetDefaultFavicon(true)->ToGdkPixbuf()));
   }
 
   return gfx::GdkPixbufFromSkBitmap(&icon);
 }
 
 void TaskManagerGtk::SetRowDataFromModel(int row, GtkTreeIter* iter) {
   GdkPixbuf* icon = GetModelIcon(row);
-  std::string page = GetModelText(row, IDS_TASK_MANAGER_PAGE_COLUMN);
+  std::string task = GetModelText(row, IDS_TASK_MANAGER_TASK_COLUMN);
   std::string profile_name =
       GetModelText(row, IDS_TASK_MANAGER_PROFILE_NAME_COLUMN);
-  gchar* page_markup = g_markup_escape_text(page.c_str(), page.length());
+  gchar* task_markup = g_markup_escape_text(task.c_str(), task.length());
   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 renderer metrics is slow as it has to do IPC, so only do it
   // when the columns are visible.
   std::string javascript_memory;
@@ skipping 25 matching lines @@
         GetModelText(row, IDS_TASK_MANAGER_SQLITE_MEMORY_USED_COLUMN);
   }
 
   std::string goats =
       GetModelText(row, IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN);
 
   bool is_background = model_->IsBackgroundResource(row) &&
       highlight_background_resources_;
   gtk_list_store_set(process_list_, iter,
                      kTaskManagerIcon, icon,
-                     kTaskManagerPage, page_markup,
+                     kTaskManagerTask, task_markup,
                      kTaskManagerProfileName, profile_name.c_str(),
                      kTaskManagerSharedMem, shared_mem.c_str(),
                      kTaskManagerPrivateMem, priv_mem.c_str(),
                      kTaskManagerCPU, cpu.c_str(),
                      kTaskManagerNetwork, net.c_str(),
                      kTaskManagerProcessID, procid.c_str(),
                      kTaskManagerJavaScriptMemory, javascript_memory.c_str(),
                      kTaskManagerWebCoreImageCache, wk_img_cache.c_str(),
                      kTaskManagerWebCoreScriptsCache, wk_scripts_cache.c_str(),
                      kTaskManagerWebCoreCssCache, wk_css_cache.c_str(),
                      kTaskManagerFPS, fps.c_str(),
                      kTaskManagerSqliteMemoryUsed, sqlite_memory.c_str(),
                      kTaskManagerGoatsTeleported, goats.c_str(),
                      kTaskManagerBackgroundColor,
                      is_background ? &kHighlightColor : NULL,
                      -1);
   g_object_unref(icon);
-  g_free(page_markup);
+  g_free(task_markup);
 }
 
 void TaskManagerGtk::KillSelectedProcesses() {
   GtkTreeSelection* selection = gtk_tree_view_get_selection(
       GTK_TREE_VIEW(treeview_));
 
   GtkTreeModel* model;
   GList* paths = gtk_tree_selection_get_selected_rows(selection, &model);
   for (GList* item = paths; item; item = item->next) {
     GtkTreePath* path = gtk_tree_model_sort_convert_path_to_child_path(
@@ skipping 159 matching lines @@
                                           guint keyval,
                                           GdkModifierType modifier) {
   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(dialog_), GTK_RESPONSE_DELETE_EVENT);
   }
 
   return TRUE;
 }