Migrate ProcessesEventRouter to the new task manager

chrome/browser/task_management/task_manager_interface.h

 // 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.
 
 #ifndef CHROME_BROWSER_TASK_MANAGEMENT_TASK_MANAGER_INTERFACE_H_
 #define CHROME_BROWSER_TASK_MANAGEMENT_TASK_MANAGER_INTERFACE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
+#include "base/process/kill.h"
 #include "base/process/process_handle.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/task_management/providers/task.h"
 #include "chrome/browser/task_management/task_manager_observer.h"
 #include "third_party/WebKit/public/web/WebCache.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace net {
 class URLRequest;
@@ skipping 86 matching lines @@
   virtual const gfx::ImageSkia& GetIcon(TaskId task_id) const = 0;
 
   // Returns the ID and handle of the process on which the task with |task_id|
   // is running.
   virtual const base::ProcessHandle& GetProcessHandle(TaskId task_id) const = 0;
   virtual const base::ProcessId& GetProcessId(TaskId task_id) const = 0;
 
   // Returns the type of the task with |task_id|.
   virtual Task::Type GetType(TaskId task_id) const = 0;
 
+  // Gets the unique ID of the tab if the task with |task_id| represents a
+  // WebContents of a tab. Returns -1 otherwise.
+  virtual int GetTabId(TaskId task_id) const = 0;
+
+  // Returns the unique ID of the BrowserChildProcessHost/RenderProcessHost on
+  // which the task with |task_id| is running. It is not the PID nor the handle
+  // of the process.
+  // For a task that represents the browser process, the return value is 0.
+  // For a task that doesn't have a host on the browser process, the return
+  // value is also 0. For other tasks that represent renderers and other child
+  // processes, the return value is whatever unique IDs of their hosts in the
+  // browser process.
+  virtual int GetChildProcessUniqueId(TaskId task_id) const = 0;
+
+  // If the process, in which the task with |task_id| is running, is terminated
+  // this gets the termination status. Currently implemented only for Renderer
+  // processes. The values will only be valid if the process has actually
+  // terminated.
+  virtual void GetTerminationStatus(TaskId task_id,
+                                    base::TerminationStatus* out_status,
+                                    int* out_error_code) const = 0;
+
   // Returns the network usage (in bytes per second) during the current refresh
   // cycle for the task with |task_id|. A value of -1 means no valid value is
   // currently available or that task has never been notified of any network
   // usage.
   virtual int64_t GetNetworkUsage(TaskId task_id) const = 0;
 
   // Returns the total network usage (in bytes per second) during the current
   // refresh cycle for the process on which the task with |task_id| is running.
   // This is the sum of all the network usage of the individual tasks (that
   // can be gotten by the above GetNetworkUsage()). A value of -1 means network
@@ skipping 16 matching lines @@
   virtual bool GetWebCacheStats(
       TaskId task_id,
       blink::WebCache::ResourceTypeStats* stats) const = 0;
 
   // Gets the list of task IDs currently tracked by the task manager. The list
   // will be sorted such that the task representing the browser process is at
   // the top of the list and the rest of the IDs will be sorted by the process
   // IDs on which the tasks are running, then by the task IDs themselves.
   virtual const TaskIdList& GetTaskIdsList() const = 0;
 
+  // Gets the list of task IDs of the tasks that run on the same process as the
+  // task with |task_id|. The returned list will at least include |task_id|.
+  virtual TaskIdList GetIdsOfTasksSharingSameProcess(TaskId task_id) const = 0;
+
   // Gets the number of task-manager tasks running on the same process on which
   // the Task with |task_id| is running.
   virtual size_t GetNumberOfTasksOnSameProcess(TaskId task_id) const = 0;
 
   // Returns true if the resource |type| usage calculation is enabled and
   // the implementation should refresh its value (this means that at least one
   // of the observers require this value). False otherwise.
-  bool IsResourceRefreshEnabled(RefreshType type);
+  bool IsResourceRefreshEnabled(RefreshType type) const;
 
  protected:
   TaskManagerInterface();
   virtual ~TaskManagerInterface();
 
   // Notifying observers of various events.
   void NotifyObserversOnTaskAdded(TaskId id);
   void NotifyObserversOnTaskToBeRemoved(TaskId id);
   void NotifyObserversOnRefresh(const TaskIdList& task_ids);
+  void NotifyObserversOnRefreshWithBackgroundCalculations(
+      const TaskIdList& task_ids);
+  void NotifyObserversOnTaskUnresponsive(TaskId id);
 
   // Refresh all the enabled resources usage of all the available tasks.
   virtual void Refresh() = 0;
 
   // StartUpdating will be called once an observer is added, and StopUpdating
   // will be called when the last observer is removed.
   virtual void StartUpdating() = 0;
   virtual void StopUpdating() = 0;
 
   // Returns the current refresh time that this task manager is running at. It
@@ skipping 31 matching lines @@
 
   // The flags containing the enabled resources types calculations.
   int64_t enabled_resources_flags_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerInterface);
 };
 
 }  // namespace task_management
 
 #endif  // CHROME_BROWSER_TASK_MANAGEMENT_TASK_MANAGER_INTERFACE_H_