Make Task Manager sort more meaningful

chrome/browser/task_management/sampling/task_group.cc

 // Copyright 2015 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_management/sampling/task_group.h"
 
+#include <algorithm>
+#include <limits>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/task_management/task_manager_observer.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "content/public/browser/browser_thread.h"
 #include "gpu/ipc/common/memory_stats.h"
 
 namespace task_management {
@@ skipping 88 matching lines @@
                            base::Bind(&TaskGroup::OnProcessPriorityDone,
                                       weak_ptr_factory_.GetWeakPtr())));
   worker_thread_sampler_.swap(sampler);
 }
 
 TaskGroup::~TaskGroup() {
 }
 
 void TaskGroup::AddTask(Task* task) {
   DCHECK(task);
-  DCHECK(task->process_id() == process_id_);
-  DCHECK(!ContainsKey(tasks_, task->task_id()));
-
-  tasks_[task->task_id()] = task;
+  tasks_.push_back(task);
 }
 
 void TaskGroup::RemoveTask(Task* task) {
   DCHECK(task);
-  DCHECK(ContainsKey(tasks_, task->task_id()));
-
-  tasks_.erase(task->task_id());
+  tasks_.erase(std::remove(tasks_.begin(), tasks_.end(), task), tasks_.end());
 }
 
 void TaskGroup::Refresh(const gpu::VideoMemoryUsageStats& gpu_memory_stats,
                         base::TimeDelta update_interval,
                         int64_t refresh_flags) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   expected_on_bg_done_flags_ = refresh_flags & kBackgroundRefreshTypesMask;
   // If a refresh type was recently disabled, we need to account for that too.
   current_on_bg_done_flags_ &= expected_on_bg_done_flags_;
 
   // First refresh the enabled non-expensive resources usages on the UI thread.
   // 1- Refresh all the tasks as well as the total network usage (if enabled).
   const bool network_usage_refresh_enabled =
       TaskManagerObserver::IsResourceRefreshEnabled(REFRESH_TYPE_NETWORK_USAGE,
                                                     refresh_flags);
   per_process_network_usage_ = network_usage_refresh_enabled ? 0 : -1;
-  for (auto& task_pair : tasks_) {
-    Task* task = task_pair.second;
+  for (Task* task : tasks_) {
     task->Refresh(update_interval, refresh_flags);
 
     if (network_usage_refresh_enabled && task->ReportsNetworkUsage())
       per_process_network_usage_ += task->network_usage();
   }
 
   // 2- Refresh GPU memory (if enabled).
   if (TaskManagerObserver::IsResourceRefreshEnabled(REFRESH_TYPE_GPU_MEMORY,
                                                     refresh_flags)) {
     RefreshGpuMemory(gpu_memory_stats);
   }
 
   // 3- Refresh Windows handles (if enabled).
 #if defined(OS_WIN)
   if (TaskManagerObserver::IsResourceRefreshEnabled(REFRESH_TYPE_HANDLES,
                                                     refresh_flags)) {
     RefreshWindowsHandles();
   }
 #endif  // defined(OS_WIN)
 
   // 4- Refresh the NACL debug stub port (if enabled).
 #if !defined(DISABLE_NACL)
   if (TaskManagerObserver::IsResourceRefreshEnabled(REFRESH_TYPE_NACL,
                                                     refresh_flags) &&
       !tasks_.empty()) {
-    RefreshNaClDebugStubPort(tasks_.begin()->second->GetChildProcessUniqueID());
+    RefreshNaClDebugStubPort(tasks_[0]->GetChildProcessUniqueID());
   }
 #endif  // !defined(DISABLE_NACL)
 
   // The remaining resource refreshes are time consuming and cannot be done on
   // the UI thread. Do them all on the worker thread using the TaskGroupSampler.
   // 5- CPU usage.
   // 6- Memory usage.
   // 7- Idle Wakeups per second.
   // 8- (Linux and ChromeOS only) The number of file descriptors current open.
   // 9- Process priority (foreground vs. background).
   worker_thread_sampler_->Refresh(refresh_flags);
 }
 
-void TaskGroup::AppendSortedTaskIds(TaskIdList* out_list) const {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  DCHECK(out_list);
-
-  for (const auto& task_pair : tasks_)
-    out_list->push_back(task_pair.first);
-}
-
 Task* TaskGroup::GetTaskById(TaskId task_id) const {
-  auto it = tasks_.find(task_id);
-  DCHECK(it != tasks_.end());
-  return it->second;
+  for (Task* task : tasks_) {
+    if (task->task_id() == task_id)
+      return task;
+  }
+  NOTREACHED();
+  return nullptr;
 }
 
 void TaskGroup::ClearCurrentBackgroundCalculationsFlags() {
   current_on_bg_done_flags_ = 0;
 }
 
 bool TaskGroup::AreBackgroundCalculationsDone() const {
   return expected_on_bg_done_flags_ == current_on_bg_done_flags_;
 }
 
@@ skipping 67 matching lines @@
 
 void TaskGroup::OnBackgroundRefreshTypeFinished(int64_t finished_refresh_type) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   current_on_bg_done_flags_ |= finished_refresh_type;
   if (AreBackgroundCalculationsDone())
     on_background_calculations_done_.Run();
 }
 
 }  // namespace task_management