Cleanup: Typedef std::pairs in TaskManager code.

chrome/browser/task_manager/task_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_H_
 #define CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_H_
 #pragma once
 
 #include <map>
-#include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
 #include "base/observer_list.h"
 #include "base/process_util.h"
 #include "base/string16.h"
@@ skipping 108 matching lines @@
     static const char* GetResourceTypeAsString(const Type type) {
       switch (type) {
         TASKMANAGER_RESOURCE_TYPE_LIST(TASKMANAGER_RESOURCE_TYPE_LIST_AS_STRING)
         default: return "UNKNOWN";
       }
     }
 
     // Returns resource identifier that is unique within single task manager
     // session (between StartUpdating and StopUpdating).
     int get_unique_id() { return unique_id_; }
+
    protected:
     Resource() : unique_id_(0) {}
 
    private:
     friend class TaskManagerModel;
     int unique_id_;
   };
 
   // ResourceProviders are responsible for adding/removing resources to the task
   // manager. The task manager notifies the ResourceProvider that it is ready
@@ skipping 107 matching lines @@
 
   // Invoked when the initialization of the model has been finished and
   // periodical updates is started. The first periodical update will be done
   // in a few seconds. (depending on platform)
   virtual void OnReadyPeriodicalUpdate() {}
 };
 
 // The model that the TaskManager is using.
 class TaskManagerModel : public base::RefCountedThreadSafe<TaskManagerModel> {
  public:
+  // (start, length)
+  typedef std::pair<int, int> GroupRange;
+
   explicit TaskManagerModel(TaskManager* task_manager);
 
   void AddObserver(TaskManagerModelObserver* observer);
   void RemoveObserver(TaskManagerModelObserver* observer);
 
   // Returns number of registered resources.
   int ResourceCount() const;
   // Returns number of registered groups.
   int GroupCount() const;
 
@@ skipping 72 matching lines @@
   bool IsResourceFirstInGroup(int index) const;
   bool IsResourceLastInGroup(int index) const;
 
   // Returns true if the resource runs in the background (not visible to the
   // user, e.g. extension background pages and BackgroundContents).
   bool IsBackgroundResource(int index) const;
 
   // Returns icon to be used for resource (for example a favicon).
   SkBitmap GetResourceIcon(int index) const;
 
-  // Returns a pair (start, length) of the group range of resource.
-  std::pair<int, int> GetGroupRangeForResource(int index) const;
+  // Returns the group range of resource.
+  GroupRange GetGroupRangeForResource(int index) const;
 
   // Returns an index of groups to which the resource belongs.
   int GetGroupIndexForResource(int index) const;
 
   // Returns an index of resource which belongs to the |group_index|th group
   // and which is the |index_in_group|th resource in group.
   int GetResourceIndexForGroup(int group_index, int index_in_group) const;
 
   // Compares values in column |col_id| and rows |row1|, |row2|.
   // Returns -1 if value in |row1| is less than value in |row2|,
@@ skipping 73 matching lines @@
     int byte_count;
   };
 
   typedef std::vector<TaskManager::Resource*> ResourceList;
   typedef std::vector<scoped_refptr<TaskManager::ResourceProvider> >
       ResourceProviderList;
   typedef std::map<base::ProcessHandle, ResourceList*> GroupMap;
   typedef std::map<base::ProcessHandle, base::ProcessMetrics*> MetricsMap;
   typedef std::map<base::ProcessHandle, double> CPUUsageMap;
   typedef std::map<TaskManager::Resource*, int64> ResourceValueMap;
-  typedef std::map<base::ProcessHandle,
-                   std::pair<size_t, size_t> > MemoryUsageMap;
+  // Private memory in bytes, shared memory in bytes.
+  typedef std::pair<size_t, size_t> MemoryUsageEntry;
+  typedef std::map<base::ProcessHandle, MemoryUsageEntry> MemoryUsageMap;
 
   // Updates the values for all rows.
   void Refresh();
 
   void AddItem(TaskManager::Resource* resource, bool notify_table);
   void RemoveItem(TaskManager::Resource* resource);
 
   // Returns the network usage (in bytes per seconds) for the specified
   // resource. That's the value retrieved at the last timer's tick.
   int64 GetNetworkUsageForResource(TaskManager::Resource* resource) const;
@@ skipping 15 matching lines @@
   bool GetProcessMetricsForRow(int row,
                                base::ProcessMetrics** proc_metrics) const;
 
   // Given a number, this function returns the formatted string that should be
   // displayed in the task manager's memory cell.
   string16 GetMemCellText(int64 number) const;
 
   // Looks up the data for |handle| and puts it in the mutable cache
   // |memory_usage_map_|.
   bool GetAndCacheMemoryMetrics(base::ProcessHandle handle,
-                                std::pair<size_t, size_t>* usage) const;
+                                MemoryUsageEntry* usage) const;
 
   // Adds a resource provider to be managed.
   void AddResourceProvider(TaskManager::ResourceProvider* provider);
 
   // The list of providers to the task manager. They are ref counted.
   ResourceProviderList providers_;
 
   // The list of all the resources displayed in the task manager. They are owned
   // by the ResourceProviders.
   ResourceList resources_;
@@ skipping 28 matching lines @@
   ObserverList<TaskManagerModelObserver> observer_list_;
 
   // How many calls to StartUpdating have been made without matching calls to
   // StopUpdating.
   int update_requests_;
 
   // Whether we are currently in the process of updating.
   UpdateState update_state_;
 
   // A salt lick for the goats.
-  int goat_salt_;
+  uint64 goat_salt_;
 
   // Resource identifier that is unique within single session.
   int last_unique_id_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerModel);
 };
 
 #endif  // CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_H_