[TaskManager] Change ResourceMap to figure ResourceList

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/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
 #include "base/prefs/pref_registry_simple.h"
@@ skipping 730 matching lines @@
     values.goats_teleported = goat_salt_ * (index + 1);
     values.goats_teleported = (values.goats_teleported >> 16) & 255;
   }
   return values.goats_teleported;
 }
 
 bool TaskManagerModel::IsResourceFirstInGroup(int index) const {
   Resource* resource = GetResource(index);
   GroupMap::const_iterator iter = group_map_.find(resource->GetProcess());
   DCHECK(iter != group_map_.end());
-  const ResourceList* group = iter->second;
-  return ((*group)[0] == resource);
+  const ResourceList& group = iter->second;
+  return (group[0] == resource);
 }
 
 bool TaskManagerModel::IsResourceLastInGroup(int index) const {
   Resource* resource = GetResource(index);
   GroupMap::const_iterator iter = group_map_.find(resource->GetProcess());
   DCHECK(iter != group_map_.end());
-  const ResourceList* group = iter->second;
-  return (group->back() == resource);
+  const ResourceList& group = iter->second;
+  return (group.back() == resource);
 }
 
 gfx::ImageSkia TaskManagerModel::GetResourceIcon(int index) const {
   gfx::ImageSkia icon = GetResource(index)->GetIcon();
   if (!icon.isNull())
     return icon;
 
   static gfx::ImageSkia* default_icon = ResourceBundle::GetSharedInstance().
       GetImageSkiaNamed(IDR_DEFAULT_FAVICON);
   return *default_icon;
 }
 
 TaskManagerModel::GroupRange
 TaskManagerModel::GetGroupRangeForResource(int index) const {
   Resource* resource = GetResource(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) {
+  const ResourceList& group = group_iter->second;
+  if (group.size() == 1) {
     return std::make_pair(index, 1);
   } else {
     for (int i = index; i >= 0; --i) {
-      if (GetResource(i) == (*group)[0])
-        return std::make_pair(i, group->size());
+      if (GetResource(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))
@@ skipping 171 matching lines @@
   return GetResource(index)->GetType();
 }
 
 WebContents* TaskManagerModel::GetResourceWebContents(int index) const {
   return GetResource(index)->GetWebContents();
 }
 
 void TaskManagerModel::AddResource(Resource* resource) {
   base::ProcessHandle process = resource->GetProcess();
 
-  ResourceList* group_entries = NULL;
-  GroupMap::const_iterator group_iter = group_map_.find(process);
+  GroupMap::iterator group_iter = group_map_.find(process);
   int new_entry_index = 0;
   if (group_iter == group_map_.end()) {
-    group_entries = new ResourceList();
-    group_map_[process] = group_entries;
-    group_entries->push_back(resource);
+    group_map_.insert(make_pair(process, ResourceList(1, resource)));
 
     // Not part of a group, just put at the end of the list.
     resources_.push_back(resource);
     new_entry_index = static_cast<int>(resources_.size() - 1);
   } else {
-    group_entries = group_iter->second;
+    ResourceList* group_entries = &(group_iter->second);
     group_entries->push_back(resource);
 
     // Insert the new entry right after the last entry of its group.
     ResourceList::iterator iter =
         std::find(resources_.begin(),
                   resources_.end(),
                   (*group_entries)[group_entries->size() - 2]);
     DCHECK(iter != resources_.end());
     new_entry_index = static_cast<int>(iter - resources_.begin()) + 1;
     resources_.insert(++iter, resource);
@@ skipping 16 matching lines @@
   FOR_EACH_OBSERVER(TaskManagerModelObserver, observer_list_,
                     OnItemsAdded(new_entry_index, 1));
 }
 
 void TaskManagerModel::RemoveResource(Resource* resource) {
   base::ProcessHandle process = resource->GetProcess();
 
   // Find the associated group.
   GroupMap::iterator group_iter = group_map_.find(process);
   DCHECK(group_iter != group_map_.end());
-  ResourceList* group_entries = group_iter->second;
+  ResourceList& group_entries = group_iter->second;
 
   // Remove the entry from the group map.
-  ResourceList::iterator iter = std::find(group_entries->begin(),
-                                          group_entries->end(),
+  ResourceList::iterator iter = std::find(group_entries.begin(),
+                                          group_entries.end(),
                                           resource);
-  DCHECK(iter != group_entries->end());
-  group_entries->erase(iter);
+  DCHECK(iter != group_entries.end());
+  group_entries.erase(iter);
 
   // If there are no more entries for that process, do the clean-up.
-  if (group_entries->empty()) {
-    delete group_entries;
-    group_map_.erase(process);
+  if (group_entries.empty()) {
+    group_map_.erase(group_iter);
 
     // Nobody is using this process, we don't need the process metrics anymore.
     MetricsMap::iterator pm_iter = metrics_map_.find(process);
     DCHECK(pm_iter != metrics_map_.end());
     if (pm_iter != metrics_map_.end()) {
       delete pm_iter->second;
       metrics_map_.erase(process);
     }
   }
 
@@ skipping 95 matching lines @@
   // Must clear the resources before the next attempt to start listening.
   Clear();
 }
 
 void TaskManagerModel::Clear() {
   int size = ResourceCount();
   if (size > 0) {
     resources_.clear();
 
     // Clear the groups.
-    STLDeleteValues(&group_map_);
+    group_map_.clear();
 
     // Clear the process related info.
     STLDeleteValues(&metrics_map_);
 
     // Clear the network maps.
     current_byte_count_map_.clear();
 
     per_resource_cache_.clear();
     per_process_cache_.clear();
 
@@ skipping 415 matching lines @@
   params.host_desktop_type = desktop_type;
   chrome::Navigate(&params);
 }
 
 TaskManager::TaskManager()
     : model_(new TaskManagerModel(this)) {
 }
 
 TaskManager::~TaskManager() {
 }