Cleanup: Typedef std::pairs in TaskManager code.

chrome/browser/ui/webui/task_manager_handler.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/task_manager_handler.h"
 
 #include <algorithm>
 #include <functional>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/browser/ui/webui/web_ui_util.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_view_host_delegate.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "webkit/glue/webpreferences.h"
 
 namespace {
 
 Value* CreateColumnValue(const TaskManagerModel* tm,
-                         const std::string column_name,
+                         const std::string& column_name,
                          const int i) {
   if (column_name == "uniqueId")
     return Value::CreateIntegerValue(tm->GetResourceUniqueId(i));
   if (column_name == "type")
     return Value::CreateStringValue(
         TaskManager::Resource::GetResourceTypeAsString(
         tm->GetResourceType(i)));
   if (column_name == "processId")
     return Value::CreateStringValue(tm->GetResourceProcessId(i));
   if (column_name == "processIdValue")
@@ skipping 87 matching lines @@
 
   NOTREACHED();
   return NULL;
 }
 
 void CreateGroupColumnList(const TaskManagerModel* tm,
                            const std::string& column_name,
                            const int index,
                            const int length,
                            DictionaryValue* val) {
-  ListValue *list = new ListValue();
+  ListValue* list = new ListValue();
   for (int i = index; i < (index + length); ++i) {
     list->Append(CreateColumnValue(tm, column_name, i));
   }
   val->Set(column_name, list);
 }
 
 struct ColumnType {
   const char* column_id;
   // Whether the column has the real value separately or not, instead of the
   // formatted value to display.
@@ skipping 29 matching lines @@
     const TaskManagerModel* tm,
     const int group_index,
     const std::set<std::string>& columns) {
   DictionaryValue* val = new DictionaryValue();
 
   const int group_count = tm->GroupCount();
   if (group_index >= group_count)
      return val;
 
   int index = tm->GetResourceIndexForGroup(group_index, 0);
-  std::pair<int, int> group_range;
-  group_range = tm->GetGroupRangeForResource(index);
-  int length = group_range.second;
+  int length = tm->GetGroupRangeForResource(index).second;
 
   // Forces to set following 3 columns regardless of |enable_columns|.
   val->SetInteger("index", index);
   val->SetBoolean("isBackgroundResource",
                   tm->IsBackgroundResource(index));
   CreateGroupColumnList(tm, "uniqueId", index, length, val);
   CreateGroupColumnList(tm, "processId", index, 1, val);
 
   for (size_t i = 0; i < arraysize(kColumnsList); ++i) {
     const std::string column_id = kColumnsList[i].column_id;
@@ skipping 197 matching lines @@
 void TaskManagerHandler::OnGroupAdded(const int group_start,
                                       const int group_length) {
 }
 
 void TaskManagerHandler::OnGroupRemoved(const int group_start,
                                         const int group_length) {
 }
 
 void TaskManagerHandler::OnReadyPeriodicalUpdate() {
 }