blob: e3142ad236237999c862412bc59fc3690e852e03 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
// 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 "base/memory/scoped_ptr.h"
#include "base/observer_list.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 task_management {
// Defines the interface for any implementation of the task manager.
// Concrete implementations have no control over the refresh rate nor the
// enabled calculations of the usage of the various resources.
class TaskManagerInterface {
public:
void AddObserver(TaskManagerObserver* observer);
void RemoveObserver(TaskManagerObserver* observer);
// Activates the task with |task_id| by bringing its container to the front if
// possible.
virtual void ActivateTask(TaskId task_id) = 0;
// returns the CPU usage in percent for the process on which the task with
// |task_id| is running during the current refresh cycle.
virtual double GetCpuUsage(TaskId task_id) const = 0;
// Returns the current physical/private/shared memory usage of the task with
// |task_id| in bytes. A value of -1 means no valid value is currently
// available.
virtual int64 GetPhysicalMemoryUsage(TaskId task_id) const = 0;
virtual int64 GetPrivateMemoryUsage(TaskId task_id) const = 0;
virtual int64 GetSharedMemoryUsage(TaskId task_id) const = 0;
// Returns the GPU memory usage of the task with |task_id| in bytes. A value
// of -1 means no valid value is currently available.
// |has_duplicates| will be set to true if this process' GPU resource count is
// inflated because it is counting other processes' resources.
virtual int64 GetGpuMemoryUsage(TaskId task_id,
bool* has_duplicates) const = 0;
// Returns the number of average idle CPU wakeups per second since the last
// refresh cycle. A value of -1 means no valid value is currently available.
virtual int GetIdleWakeupsPerSecond(TaskId task_id) const = 0;
// Returns the NaCl GDB debug stub port. A value of -1 means no valid value is
// currently available.
virtual int GetNaClDebugStubPort(TaskId task_id) const = 0;
// On Windows, gets the current and peak number of GDI and USER handles in
// use. A value of -1 means no valid value is currently available.
virtual void GetGDIHandles(TaskId task_id,
int64* current,
int64* peak) const = 0;
virtual void GetUSERHandles(TaskId task_id,
int64* current,
int64* peak) const = 0;
// Returns the title of the task with |task_id|.
virtual const base::string16& GetTitle(TaskId task_id) const = 0;
// Returns the name of the profile associated with the browser context of the
// render view host that the task with |task_id| represents (if that task
// represents a renderer).
virtual base::string16 GetProfileName(TaskId task_id) const = 0;
// Returns the favicon of the task with |task_id|.
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;
// 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 GetNetworkUsage(TaskId task_id) const = 0;
// Returns the Sqlite used memory (in bytes) for the task with |task_id|.
// A value of -1 means no valid value is currently available.
virtual int64 GetSqliteMemoryUsed(TaskId task_id) const = 0;
// Returns the allocated and used V8 memory (in bytes) for the task with
// |task_id|. A return value of false means no valid value is currently
// available.
virtual bool GetV8Memory(TaskId task_id,
int64* allocated,
int64* used) const = 0;
// Gets the Webkit resource cache stats for the task with |task_id|.
// A return value of false means that task does NOT report WebCache stats.
virtual bool GetWebCacheStats(
TaskId task_id,
blink::WebCache::ResourceTypeStats* stats) 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);
protected:
TaskManagerInterface();
virtual ~TaskManagerInterface();
// Notifying observers of various events.
void NotifyObserversOnTaskAdded(TaskId id);
void NotifyObserversOnTaskToBeRemoved(TaskId id);
void NotifyObserversOnRefresh(const TaskIdList& task_ids);
// Refresh all the enabled resources usage of all the available tasks.
virtual void Refresh() = 0;
// TODO(afakhry): Add more virtual methods here as needed.
// Returns the current refresh time that this task manager is running at. It
// will return base::TimeDelta::Max() if the task manager is not running.
base::TimeDelta GetCurrentRefreshTime() const;
int64 enabled_resources_flags() const { return enabled_resources_flags_; }
void set_timer_for_testing(scoped_ptr<base::Timer> timer) {
refresh_timer_ = timer.Pass();
}
private:
// Appends |flags| to the |enabled_resources_flags_|.
void ResourceFlagsAdded(int64 flags);
// Sets |enabled_resources_flags_| to |flags|.
void SetEnabledResourceFlags(int64 flags);
// Schedules the task manager refresh cycles using the given |refresh_time|.
// It stops any existing refresh schedule.
void ScheduleRefresh(base::TimeDelta refresh_time);
// The list of observers.
base::ObserverList<TaskManagerObserver> observers_;
// The timer that will be used to schedule the successive refreshes.
scoped_ptr<base::Timer> refresh_timer_;
// The flags containing the enabled resources types calculations.
int64 enabled_resources_flags_;
DISALLOW_COPY_AND_ASSIGN(TaskManagerInterface);
};
} // namespace task_management
#endif // CHROME_BROWSER_TASK_MANAGEMENT_TASK_MANAGER_INTERFACE_H_
|
