Cleanup: Typedef std::pairs in TaskManager code.

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 848 matching lines @@
                                  GtkTreeIter* b, int id) {
   int row1 = gtk_tree::GetRowNumForIter(model, b);
   int row2 = gtk_tree::GetRowNumForIter(model, a);
 
   // When sorting by non-grouped attributes (e.g., Network), just do a normal
   // sort.
   if (!IsSharedByGroup(id))
     return model_->CompareValues(row1, row2, id);
 
   // Otherwise, make sure grouped resources are shown together.
-  std::pair<int, int> group_range1 = model_->GetGroupRangeForResource(row1);
-  std::pair<int, int> group_range2 = model_->GetGroupRangeForResource(row2);
+  TaskManagerModel::GroupRange group_range1 =
+      model_->GetGroupRangeForResource(row1);
+  TaskManagerModel::GroupRange group_range2 =
+      model_->GetGroupRangeForResource(row2);
 
   if (group_range1 == group_range2) {
     // Sort within groups.
     // We want the first-in-group row at the top, whether we are sorting up or
     // down.
     GtkSortType sort_type;
     gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(process_list_sort_),
                                          NULL, &sort_type);
     if (row1 == group_range1.first)
       return sort_type == GTK_SORT_ASCENDING ? -1 : 1;
@@ skipping 41 matching lines @@
     MemoryPurger::PurgeAll();
   }
 }
 
 void TaskManagerGtk::OnSelectionChanged(GtkTreeSelection* selection) {
   if (ignore_selection_changed_)
     return;
   AutoReset<bool> autoreset(&ignore_selection_changed_, true);
 
   // The set of groups that should be selected.
-  std::set<std::pair<int, int> > ranges;
+  std::set<TaskManagerModel::GroupRange> ranges;
   bool selection_contains_browser_process = false;
 
   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(
         GTK_TREE_MODEL_SORT(process_list_sort_),
         reinterpret_cast<GtkTreePath*>(item->data));
     int row = gtk_tree::GetRowNumForPath(path);
     gtk_tree_path_free(path);
     if (task_manager_->IsBrowserProcess(row))
       selection_contains_browser_process = true;
     ranges.insert(model_->GetGroupRangeForResource(row));
   }
   g_list_foreach(paths, reinterpret_cast<GFunc>(gtk_tree_path_free), NULL);
   g_list_free(paths);
 
-  for (std::set<std::pair<int, int> >::iterator iter = ranges.begin();
+  for (std::set<TaskManagerModel::GroupRange>::iterator iter = ranges.begin();
        iter != ranges.end(); ++iter) {
     for (int i = 0; i < iter->second; ++i) {
       GtkTreePath* child_path = gtk_tree_path_new_from_indices(iter->first + i,
                                                                -1);
       GtkTreePath* sort_path = gtk_tree_model_sort_convert_child_path_to_path(
         GTK_TREE_MODEL_SORT(process_list_sort_), child_path);
       gtk_tree_selection_select_path(selection, sort_path);
       gtk_tree_path_free(child_path);
       gtk_tree_path_free(sort_path);
     }
@@ skipping 32 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;
 }