Cleanup: Typedef std::pairs in TaskManager code.

chrome/browser/task_manager/task_manager.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/task_manager/task_manager.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
 #include "base/process_util.h"
+#include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/background/background_contents_service.h"
 #include "chrome/browser/background/background_contents_service_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/prefs/pref_service.h"
@@ skipping 54 matching lines @@
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerModel class
 ////////////////////////////////////////////////////////////////////////////////
 
 TaskManagerModel::TaskManagerModel(TaskManager* task_manager)
     : update_requests_(0),
       update_state_(IDLE),
-      goat_salt_(rand()),
+      goat_salt_(base::RandUint64()),
       last_unique_id_(0) {
   AddResourceProvider(
       new TaskManagerBrowserProcessResourceProvider(task_manager));
   AddResourceProvider(
       new TaskManagerBackgroundContentsResourceProvider(task_manager));
   AddResourceProvider(new TaskManagerTabContentsResourceProvider(task_manager));
   AddResourceProvider(
       new TaskManagerChildProcessResourceProvider(task_manager));
   AddResourceProvider(
       new TaskManagerExtensionProcessResourceProvider(task_manager));
@@ skipping 205 matching lines @@
   CHECK_LT(index, ResourceCount());
   SkBitmap icon = resources_[index]->GetIcon();
   if (!icon.isNull())
     return icon;
 
   static SkBitmap* default_icon = ResourceBundle::GetSharedInstance().
       GetBitmapNamed(IDR_DEFAULT_FAVICON);
   return *default_icon;
 }
 
-std::pair<int, int> TaskManagerModel::GetGroupRangeForResource(int index)
-    const {
+TaskManagerModel::GroupRange
+TaskManagerModel::GetGroupRangeForResource(int index) const {
   CHECK_LT(index, ResourceCount());
   TaskManager::Resource* resource = resources_[index];
   GroupMap::const_iterator group_iter =
       group_map_.find(resource->GetProcess());
   DCHECK(group_iter != group_map_.end());
   ResourceList* group = group_iter->second;
   DCHECK(group);
   if (group->size() == 1) {
     return std::make_pair(index, 1);
   } else {
     for (int i = index; i >= 0; --i) {
       if (resources_[i] == (*group)[0])
         return std::make_pair(i, group->size());
     }
     NOTREACHED();
     return std::make_pair(-1, -1);
   }
 }
 
 int TaskManagerModel::GetGroupIndexForResource(int index) const {
   int group_index = -1;
   for (int i = 0; i <= index; ++i) {
     if (IsResourceFirstInGroup(i))
         group_index++;
   }
 
-  DCHECK(group_index != -1);
+  DCHECK_NE(group_index, -1);
   return group_index;
 }
 
 int TaskManagerModel::GetResourceIndexForGroup(int group_index,
                                                int index_in_group) const {
   int group_count = -1;
   int count_in_group = -1;
   for (int i = 0; i < ResourceCount(); ++i) {
     if (IsResourceFirstInGroup(i))
       group_count++;
@@ skipping 140 matching lines @@
       cpu_usage_map_.find(resource->GetProcess());
   if (iter == cpu_usage_map_.end())
     return 0;
   return iter->second;
 }
 
 bool TaskManagerModel::GetPrivateMemory(int index, size_t* result) const {
   base::ProcessHandle handle = resources_[index]->GetProcess();
   MemoryUsageMap::const_iterator iter = memory_usage_map_.find(handle);
   if (iter == memory_usage_map_.end()) {
-    std::pair<size_t, size_t> usage;
+    MemoryUsageEntry usage;
     if (!GetAndCacheMemoryMetrics(handle, &usage))
       return false;
 
     *result = usage.first;
   } else {
     *result = iter->second.first;
   }
 
   return true;
 }
 
 bool TaskManagerModel::GetSharedMemory(int index, size_t* result) const {
   base::ProcessHandle handle = resources_[index]->GetProcess();
   MemoryUsageMap::const_iterator iter = memory_usage_map_.find(handle);
   if (iter == memory_usage_map_.end()) {
-    std::pair<size_t, size_t> usage;
+    MemoryUsageEntry usage;
     if (!GetAndCacheMemoryMetrics(handle, &usage))
       return false;
 
     *result = usage.second;
   } else {
     *result = iter->second.second;
   }
 
   return true;
 }
@@ skipping 315 matching lines @@
 
 void TaskManagerModel::Refresh() {
   DCHECK_NE(IDLE, update_state_);
 
   if (update_state_ == STOPPING) {
     // We have been asked to stop.
     update_state_ = IDLE;
     return;
   }
 
-  goat_salt_ = rand();
+  goat_salt_ = base::RandUint64();
 
   // Compute the CPU usage values.
   // Note that we compute the CPU usage for all resources (instead of doing it
   // lazily) as process_util::GetCPUUsage() returns the CPU usage since the last
   // time it was called, and not calling it everytime would skew the value the
   // next time it is retrieved (as it would be for more than 1 cycle).
   cpu_usage_map_.clear();
   for (ResourceList::iterator iter = resources_.begin();
        iter != resources_.end(); ++iter) {
     base::ProcessHandle process = (*iter)->GetProcess();
@@ skipping 233 matching lines @@
     // TabContents in a tabbed browser, so we need to grab it with
     // GetLastActive before the call to show().
     if (!browser->is_type_tabbed()) {
       browser = BrowserList::GetLastActive();
       DCHECK(browser);
     }
   }
   browser->window()->Show();
 }
 
-bool TaskManagerModel::GetAndCacheMemoryMetrics(
-    base::ProcessHandle handle,
-    std::pair<size_t, size_t>* usage) const {
+bool TaskManagerModel::GetAndCacheMemoryMetrics(base::ProcessHandle handle,
+                                                MemoryUsageEntry* usage) const {
   MetricsMap::const_iterator iter = metrics_map_.find(handle);
   if (iter == metrics_map_.end())
     return false;
 
   if (!iter->second->GetMemoryBytes(&usage->first, &usage->second))
     return false;
 
   memory_usage_map_.insert(std::make_pair(handle, *usage));
   return true;
 }
@@ skipping 41 matching lines @@
     // Count the number of extensions with background pages (including
     // incognito).
     count += CountExtensionBackgroundPagesForProfile(profile);
     if (profile->HasOffTheRecordProfile()) {
       count += CountExtensionBackgroundPagesForProfile(
           profile->GetOffTheRecordProfile());
     }
   }
   return count;
 }