Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(173)

Side by Side Diff: chrome/browser/ui/task_manager/task_manager_table_model.cc

Issue 1367673003: Expose all reusable task manager view code so it can be used by Mac (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
1 // Copyright 2015 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "chrome/browser/ui/task_manager/task_manager_table_model.h"
6
7 #include "base/i18n/number_formatting.h"
8 #include "base/i18n/rtl.h"
9 #include "base/prefs/scoped_user_pref_update.h"
10 #include "base/process/process_handle.h"
11 #include "base/strings/string_number_conversions.h"
12 #include "base/strings/stringprintf.h"
13 #include "base/strings/utf_string_conversions.h"
14 #include "chrome/browser/browser_process.h"
15 #include "chrome/browser/task_management/task_manager_interface.h"
16 #include "chrome/browser/ui/task_manager/task_manager_columns.h"
17 #include "chrome/common/pref_names.h"
18 #include "chrome/grit/generated_resources.h"
19 #include "components/nacl/browser/nacl_browser.h"
20 #include "content/public/common/result_codes.h"
21 #include "third_party/WebKit/public/web/WebCache.h"
22 #include "ui/base/l10n/l10n_util.h"
23 #include "ui/base/models/table_model_observer.h"
24 #include "ui/base/text/bytes_formatting.h"
25
26 namespace task_management {
27
28 namespace {
29
30 #if defined(OS_MACOSX)
31 // Match Activity Monitor's default refresh rate.
32 const int64 kRefreshTimeMS = 2000;
33
34 // Activity Monitor shows %cpu with one decimal digit -- be consistent with
35 // that.
36 const char kCpuTextFormatString[] = "%.1f";
37 #else
38 const int64 kRefreshTimeMS = 1000;
39 const char kCpuTextFormatString[] = "%.0f";
40 #endif // defined(OS_MACOSX)
41
42 // The columns that are shared by a group will show the value of the column
43 // only once per group.
44 bool IsSharedByGroup(int column_id) {
45 switch (column_id) {
46 case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:
47 case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:
48 case IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN:
49 case IDS_TASK_MANAGER_CPU_COLUMN:
50 case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:
51 case IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN:
52 case IDS_TASK_MANAGER_VIDEO_MEMORY_COLUMN:
53 case IDS_TASK_MANAGER_SQLITE_MEMORY_USED_COLUMN:
54 case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:
55 case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:
56 case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN:
57 case IDS_TASK_MANAGER_NACL_DEBUG_STUB_PORT_COLUMN:
58 return true;
59 default:
60 return false;
61 }
62 }
63
64 // Used to sort various column values.
65 template <class T>
66 int ValueCompare(T value1, T value2) {
67 if (value1 == value2)
68 return 0;
69 return value1 < value2 ? -1 : 1;
70 }
71
72 // Used when one or both of the results to compare are unavailable.
73 int OrderUnavailableValue(bool v1, bool v2) {
74 if (!v1 && !v2)
75 return 0;
76 return v1 ? 1 : -1;
77 }
78
79 } // namespace
80
81 // A class to stringify the task manager's values into string16s and to
82 // cache the common strings that will be reused many times like "N/A" and so on.
83 class TaskManagerValuesStringifier {
84 public:
85 TaskManagerValuesStringifier()
86 : n_a_string_(l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT)),
87 zero_string_(base::ASCIIToUTF16("0")),
88 asterisk_string_(base::ASCIIToUTF16("*")),
89 unknown_string_(l10n_util::GetStringUTF16(
90 IDS_TASK_MANAGER_UNKNOWN_VALUE_TEXT)) {
91 }
92
93 ~TaskManagerValuesStringifier() {}
94
95 base::string16 GetCpuUsageText(double cpu_usage) {
96 return base::UTF8ToUTF16(base::StringPrintf(kCpuTextFormatString,
97 cpu_usage));
98 }
99
100 base::string16 GetMemoryUsageText(int64 memory_usage, bool has_duplicates) {
101 if (memory_usage == -1)
102 return n_a_string_;
103
104 #if defined(OS_MACOSX)
105 // System expectation is to show "100 kB", "200 MB", etc.
106 // TODO(thakis): [This TODO has been taken as is from the old task manager]:
107 // Switch to metric units (as opposed to powers of two).
108 base::string16 memory_text = ui::FormatBytes(memory_usage);
109 #else
110 base::string16 memory_text = base::FormatNumber(memory_usage / 1024);
111 // Adjust number string if necessary.
112 base::i18n::AdjustStringForLocaleDirection(&memory_text);
113 memory_text = l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_MEM_CELL_TEXT,
114 memory_text);
115 #endif // defined(OS_MACOSX)
116
117 if (has_duplicates)
118 memory_text += asterisk_string_;
119
120 return memory_text;
121 }
122
123 base::string16 GetIdleWakeupsText(int idle_wakeups) {
124 if (idle_wakeups == -1)
125 return n_a_string_;
126
127 return base::FormatNumber(idle_wakeups);
128 }
129
130 base::string16 GetNaClPortText(int nacl_port) {
131 if (nacl_port == nacl::kGdbDebugStubPortUnused)
132 return n_a_string_;
133
134 if (nacl_port == nacl::kGdbDebugStubPortUnknown)
135 return unknown_string_;
136
137 return base::IntToString16(nacl_port);
138 }
139
140 base::string16 GetWindowsHandlesText(int64 current, int64 peak) {
141 return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_HANDLES_CELL_TEXT,
142 base::Int64ToString16(current),
143 base::Int64ToString16(peak));
144 }
145
146 base::string16 GetNetworkUsageText(int64 network_usage) {
147 if (network_usage == -1)
148 return n_a_string_;
149
150 if (network_usage == 0)
151 return zero_string_;
152
153 base::string16 net_byte = ui::FormatSpeed(network_usage);
154 // Force number string to have LTR directionality.
155 return base::i18n::GetDisplayStringInLTRDirectionality(net_byte);
156 }
157
158 base::string16 GetProcessIdText(base::ProcessId proc_id) {
159 return base::IntToString16(proc_id);
160 }
161
162 base::string16 FormatAllocatedAndUsedMemory(int64 allocated, int64 used) {
163 return l10n_util::GetStringFUTF16(
164 IDS_TASK_MANAGER_CACHE_SIZE_CELL_TEXT,
165 ui::FormatBytesWithUnits(allocated, ui::DATA_UNITS_KIBIBYTE, false),
166 ui::FormatBytesWithUnits(used, ui::DATA_UNITS_KIBIBYTE, false));
167 }
168
169 base::string16 GetWebCacheStatText(
170 const blink::WebCache::ResourceTypeStat& stat) {
171 return FormatAllocatedAndUsedMemory(stat.size, stat.liveSize);
172 }
173
174 const base::string16& n_a_string() const { return n_a_string_; }
175 const base::string16& zero_string() const { return zero_string_; }
176 const base::string16& asterisk_string() const { return asterisk_string_; }
177 const base::string16& unknown_string() const { return unknown_string_; }
178
179 private:
180 // The localized string "N/A".
181 const base::string16 n_a_string_;
182
183 // The value 0 as a string "0".
184 const base::string16 zero_string_;
185
186 // The string "*" that is used to show that there exists duplicates in the
187 // GPU memory.
188 const base::string16 asterisk_string_;
189
190 // The string "Unknown".
191 const base::string16 unknown_string_;
192
193 DISALLOW_COPY_AND_ASSIGN(TaskManagerValuesStringifier);
194 };
195
196 ////////////////////////////////////////////////////////////////////////////////
197 // TableSortDescriptor:
198 ////////////////////////////////////////////////////////////////////////////////
199
200 TableSortDescriptor::TableSortDescriptor()
201 : sorted_column_id(-1),
202 is_ascending(false) {
203 }
204
205 TableSortDescriptor::TableSortDescriptor(int col_id, bool ascending)
206 : sorted_column_id(col_id),
207 is_ascending(ascending) {
208 }
209
210 ////////////////////////////////////////////////////////////////////////////////
211 // TaskManagerTableModel:
212 ////////////////////////////////////////////////////////////////////////////////
213
214 TaskManagerTableModel::TaskManagerTableModel(int64_t refresh_flags,
215 TableViewDelegate* delegate)
216 : TaskManagerObserver(base::TimeDelta::FromMilliseconds(kRefreshTimeMS),
217 refresh_flags),
218 table_view_delegate_(delegate),
219 columns_settings_(new base::DictionaryValue),
220 table_model_observer_(nullptr),
221 stringifier_(new TaskManagerValuesStringifier) {
222 DCHECK(delegate);
223 }
224
225 TaskManagerTableModel::~TaskManagerTableModel() {
226 }
227
228 int TaskManagerTableModel::RowCount() {
229 return static_cast<int>(tasks_.size());
230 }
231
232 base::string16 TaskManagerTableModel::GetText(int row, int column) {
233 if (IsSharedByGroup(column) && !IsTaskFirstInGroup(row))
234 return base::string16();
235
236 switch (column) {
237 case IDS_TASK_MANAGER_TASK_COLUMN:
238 return observed_task_manager()->GetTitle(tasks_[row]);
239
240 case IDS_TASK_MANAGER_PROFILE_NAME_COLUMN:
241 return observed_task_manager()->GetProfileName(tasks_[row]);
242
243 case IDS_TASK_MANAGER_NET_COLUMN:
244 return stringifier_->GetNetworkUsageText(
245 observed_task_manager()->GetNetworkUsage(tasks_[row]));
246
247 case IDS_TASK_MANAGER_CPU_COLUMN:
248 return stringifier_->GetCpuUsageText(
249 observed_task_manager()->GetCpuUsage(tasks_[row]));
250
251 case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:
252 return stringifier_->GetMemoryUsageText(
253 observed_task_manager()->GetPrivateMemoryUsage(tasks_[row]), false);
254
255 case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:
256 return stringifier_->GetMemoryUsageText(
257 observed_task_manager()->GetSharedMemoryUsage(tasks_[row]), false);
258
259 case IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN:
260 return stringifier_->GetMemoryUsageText(
261 observed_task_manager()->GetPhysicalMemoryUsage(tasks_[row]), false);
262
263 case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:
264 return stringifier_->GetProcessIdText(
265 observed_task_manager()->GetProcessId(tasks_[row]));
266
267 case IDS_TASK_MANAGER_GDI_HANDLES_COLUMN: {
268 int64 current, peak;
269 observed_task_manager()->GetGDIHandles(tasks_[row], &current, &peak);
270 return stringifier_->GetWindowsHandlesText(current, peak);
271 }
272
273 case IDS_TASK_MANAGER_USER_HANDLES_COLUMN: {
274 int64 current, peak;
275 observed_task_manager()->GetUSERHandles(tasks_[row], &current, &peak);
276 return stringifier_->GetWindowsHandlesText(current, peak);
277 }
278
279 case IDS_TASK_MANAGER_IDLE_WAKEUPS_COLUMN:
280 return stringifier_->GetIdleWakeupsText(
281 observed_task_manager()->GetIdleWakeupsPerSecond(tasks_[row]));
282
283 case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN: {
284 blink::WebCache::ResourceTypeStats stats;
285 if (observed_task_manager()->GetWebCacheStats(tasks_[row], &stats))
286 return stringifier_->GetWebCacheStatText(stats.images);
287 return stringifier_->n_a_string();
288 }
289
290 case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN: {
291 blink::WebCache::ResourceTypeStats stats;
292 if (observed_task_manager()->GetWebCacheStats(tasks_[row], &stats))
293 return stringifier_->GetWebCacheStatText(stats.scripts);
294 return stringifier_->n_a_string();
295 }
296
297 case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN: {
298 blink::WebCache::ResourceTypeStats stats;
299 if (observed_task_manager()->GetWebCacheStats(tasks_[row], &stats))
300 return stringifier_->GetWebCacheStatText(stats.cssStyleSheets);
301 return stringifier_->n_a_string();
302 }
303
304 case IDS_TASK_MANAGER_VIDEO_MEMORY_COLUMN: {
305 bool has_duplicates = false;
306 return stringifier_->GetMemoryUsageText(
307 observed_task_manager()->GetGpuMemoryUsage(tasks_[row],
308 &has_duplicates),
309 has_duplicates);
310 }
311
312 case IDS_TASK_MANAGER_SQLITE_MEMORY_USED_COLUMN:
313 return stringifier_->GetMemoryUsageText(
314 observed_task_manager()->GetSqliteMemoryUsed(tasks_[row]), false);
315
316 case IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN: {
317 int64 v8_allocated, v8_used;
318 if (observed_task_manager()->GetV8Memory(tasks_[row],
319 &v8_allocated,
320 &v8_used)) {
321 return stringifier_->FormatAllocatedAndUsedMemory(v8_allocated,
322 v8_used);
323 }
324 return stringifier_->n_a_string();
325 }
326
327 case IDS_TASK_MANAGER_NACL_DEBUG_STUB_PORT_COLUMN:
328 return stringifier_->GetNaClPortText(
329 observed_task_manager()->GetNaClDebugStubPort(tasks_[row]));
330
331 default:
332 NOTREACHED();
333 return base::string16();
334 }
335 }
336
337 gfx::ImageSkia TaskManagerTableModel::GetIcon(int row) {
338 return observed_task_manager()->GetIcon(tasks_[row]);
339 }
340
341 void TaskManagerTableModel::SetObserver(
342 ui::TableModelObserver* observer) {
343 table_model_observer_ = observer;
344 }
345
346 int TaskManagerTableModel::CompareValues(int row1,
347 int row2,
348 int column_id) {
349 switch (column_id) {
350 case IDS_TASK_MANAGER_TASK_COLUMN:
351 case IDS_TASK_MANAGER_PROFILE_NAME_COLUMN:
352 return ui::TableModel::CompareValues(row1, row2, column_id);
353
354 case IDS_TASK_MANAGER_NET_COLUMN:
355 return ValueCompare(
356 observed_task_manager()->GetNetworkUsage(tasks_[row1]),
357 observed_task_manager()->GetNetworkUsage(tasks_[row2]));
358
359 case IDS_TASK_MANAGER_CPU_COLUMN:
360 return ValueCompare(observed_task_manager()->GetCpuUsage(tasks_[row1]),
361 observed_task_manager()->GetCpuUsage(tasks_[row2]));
362
363 case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:
364 return ValueCompare(
365 observed_task_manager()->GetPrivateMemoryUsage(tasks_[row1]),
366 observed_task_manager()->GetPrivateMemoryUsage(tasks_[row2]));
367
368 case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:
369 return ValueCompare(
370 observed_task_manager()->GetSharedMemoryUsage(tasks_[row1]),
371 observed_task_manager()->GetSharedMemoryUsage(tasks_[row2]));
372
373 case IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN:
374 return ValueCompare(
375 observed_task_manager()->GetPhysicalMemoryUsage(tasks_[row1]),
376 observed_task_manager()->GetPhysicalMemoryUsage(tasks_[row2]));
377
378 case IDS_TASK_MANAGER_NACL_DEBUG_STUB_PORT_COLUMN:
379 return ValueCompare(
380 observed_task_manager()->GetNaClDebugStubPort(tasks_[row1]),
381 observed_task_manager()->GetNaClDebugStubPort(tasks_[row2]));
382
383 case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:
384 return ValueCompare(observed_task_manager()->GetProcessId(tasks_[row1]),
385 observed_task_manager()->GetProcessId(tasks_[row2]));
386
387 case IDS_TASK_MANAGER_GDI_HANDLES_COLUMN: {
388 int64 current1, peak1, current2, peak2;
389 observed_task_manager()->GetGDIHandles(tasks_[row1], &current1, &peak1);
390 observed_task_manager()->GetGDIHandles(tasks_[row2], &current2, &peak2);
391 return ValueCompare(current1, current2);
392 }
393
394 case IDS_TASK_MANAGER_USER_HANDLES_COLUMN: {
395 int64 current1, peak1, current2, peak2;
396 observed_task_manager()->GetUSERHandles(tasks_[row1], &current1, &peak1);
397 observed_task_manager()->GetUSERHandles(tasks_[row2], &current2, &peak2);
398 return ValueCompare(current1, current2);
399 }
400
401 case IDS_TASK_MANAGER_IDLE_WAKEUPS_COLUMN:
402 return ValueCompare(
403 observed_task_manager()->GetIdleWakeupsPerSecond(tasks_[row1]),
404 observed_task_manager()->GetIdleWakeupsPerSecond(tasks_[row2]));
405
406 case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:
407 case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:
408 case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN: {
409 blink::WebCache::ResourceTypeStats stats1;
410 blink::WebCache::ResourceTypeStats stats2;
411 bool row1_stats_valid =
412 observed_task_manager()->GetWebCacheStats(tasks_[row1], &stats1);
413 bool row2_stats_valid =
414 observed_task_manager()->GetWebCacheStats(tasks_[row2], &stats2);
415 if (!row1_stats_valid || !row2_stats_valid)
416 return OrderUnavailableValue(row1_stats_valid, row2_stats_valid);
417
418 switch (column_id) {
419 case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:
420 return ValueCompare(stats1.images.size, stats2.images.size);
421 case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:
422 return ValueCompare(stats1.scripts.size, stats2.scripts.size);
423 case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN:
424 return ValueCompare(stats1.cssStyleSheets.size,
425 stats2.cssStyleSheets.size);
426 default:
427 NOTREACHED();
428 return 0;
429 }
430 }
431
432 case IDS_TASK_MANAGER_VIDEO_MEMORY_COLUMN: {
433 bool has_duplicates;
434 return ValueCompare(
435 observed_task_manager()->GetGpuMemoryUsage(tasks_[row1],
436 &has_duplicates),
437 observed_task_manager()->GetGpuMemoryUsage(tasks_[row2],
438 &has_duplicates));
439 }
440
441 case IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN: {
442 int64 allocated1, allocated2, used1, used2;
443 observed_task_manager()->GetV8Memory(tasks_[row1], &allocated1, &used1);
444 observed_task_manager()->GetV8Memory(tasks_[row2], &allocated2, &used2);
445 return ValueCompare(allocated1, allocated2);
446 }
447
448 case IDS_TASK_MANAGER_SQLITE_MEMORY_USED_COLUMN:
449 return ValueCompare(
450 observed_task_manager()->GetSqliteMemoryUsed(tasks_[row1]),
451 observed_task_manager()->GetSqliteMemoryUsed(tasks_[row2]));
452
453 default:
454 NOTREACHED();
455 return 0;
456 }
457 }
458
459 void TaskManagerTableModel::GetRowsGroupRange(int row_index,
460 int* out_start,
461 int* out_length) {
462 int i = row_index;
463 for ( ; i >= 0; --i) {
464 if (IsTaskFirstInGroup(i))
465 break;
466 }
467
468 CHECK_GE(i, 0);
469
470 *out_start = i;
471 *out_length = observed_task_manager()->GetNumberOfTasksOnSameProcess(
472 tasks_[row_index]);
473 }
474
475 void TaskManagerTableModel::OnTaskAdded(TaskId id) {
476 // For the table view scrollbar to behave correctly we must inform it that
477 // a new task has been added.
478
479 // We will get a newly sorted list from the task manager as opposed to just
480 // adding |id| to |tasks_| because we want to keep |tasks_| sorted by proc IDs
481 // and then by Task IDs.
482 tasks_ = observed_task_manager()->GetTaskIdsList();
483 if (table_model_observer_)
484 table_model_observer_->OnItemsAdded(RowCount() - 1, 1);
485 }
486
487 void TaskManagerTableModel::OnTaskToBeRemoved(TaskId id) {
488 auto index = std::find(tasks_.begin(), tasks_.end(), id);
489 if (index == tasks_.end())
490 return;
491 auto removed_index = index - tasks_.begin();
492 tasks_.erase(index);
493 if (table_model_observer_)
494 table_model_observer_->OnItemsRemoved(removed_index, 1);
495 }
496
497 void TaskManagerTableModel::OnTasksRefreshed(
498 const TaskIdList& task_ids) {
499 tasks_ = task_ids;
500 OnRefresh();
501 }
502
503 void TaskManagerTableModel::StartUpdating() {
504 TaskManagerInterface::GetTaskManager()->AddObserver(this);
505 tasks_ = observed_task_manager()->GetTaskIdsList();
506 OnRefresh();
507 }
508
509 void TaskManagerTableModel::StopUpdating() {
510 observed_task_manager()->RemoveObserver(this);
511 }
512
513 void TaskManagerTableModel::ActivateTask(int row_index) {
514 observed_task_manager()->ActivateTask(tasks_[row_index]);
515 }
516
517 void TaskManagerTableModel::KillTask(int row_index) {
518 base::ProcessId proc_id = observed_task_manager()->GetProcessId(
519 tasks_[row_index]);
520
521 DCHECK_NE(proc_id, base::GetCurrentProcId());
522
523 base::Process process = base::Process::Open(proc_id);
524 process.Terminate(content::RESULT_CODE_KILLED, false);
525 }
526
527 void TaskManagerTableModel::UpdateRefreshTypes(int column_id, bool visibility) {
528 bool new_visibility = visibility;
529 RefreshType type = REFRESH_TYPE_NONE;
530 switch (column_id) {
531 case IDS_TASK_MANAGER_PROFILE_NAME_COLUMN:
532 case IDS_TASK_MANAGER_TASK_COLUMN:
533 case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:
534 return; // The data is these columns do not change.
535
536 case IDS_TASK_MANAGER_NET_COLUMN:
537 type = REFRESH_TYPE_NETWORK_USAGE;
538 break;
539
540 case IDS_TASK_MANAGER_CPU_COLUMN:
541 type = REFRESH_TYPE_CPU;
542 break;
543
544 case IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN:
545 case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:
546 case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:
547 type = REFRESH_TYPE_MEMORY;
548 if (table_view_delegate_->IsColumnVisible(
549 IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN) ||
550 table_view_delegate_->IsColumnVisible(
551 IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN) ||
552 table_view_delegate_->IsColumnVisible(
553 IDS_TASK_MANAGER_SHARED_MEM_COLUMN)) {
554 new_visibility = true;
555 }
556 break;
557
558 case IDS_TASK_MANAGER_GDI_HANDLES_COLUMN:
559 case IDS_TASK_MANAGER_USER_HANDLES_COLUMN:
560 type = REFRESH_TYPE_HANDLES;
561 if (table_view_delegate_->IsColumnVisible(
562 IDS_TASK_MANAGER_GDI_HANDLES_COLUMN) ||
563 table_view_delegate_->IsColumnVisible(
564 IDS_TASK_MANAGER_USER_HANDLES_COLUMN)) {
565 new_visibility = true;
566 }
567 break;
568
569 case IDS_TASK_MANAGER_IDLE_WAKEUPS_COLUMN:
570 type = REFRESH_TYPE_IDLE_WAKEUPS;
571 break;
572
573 case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:
574 case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:
575 case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN:
576 type = REFRESH_TYPE_WEBCACHE_STATS;
577 if (table_view_delegate_->IsColumnVisible(
578 IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN) ||
579 table_view_delegate_->IsColumnVisible(
580 IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN) ||
581 table_view_delegate_->IsColumnVisible(
582 IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN)) {
583 new_visibility = true;
584 }
585 break;
586
587 case IDS_TASK_MANAGER_VIDEO_MEMORY_COLUMN:
588 type = REFRESH_TYPE_GPU_MEMORY;
589 break;
590
591 case IDS_TASK_MANAGER_SQLITE_MEMORY_USED_COLUMN:
592 type = REFRESH_TYPE_SQLITE_MEMORY;
593 break;
594
595 case IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN:
596 type = REFRESH_TYPE_V8_MEMORY;
597 break;
598
599 case IDS_TASK_MANAGER_NACL_DEBUG_STUB_PORT_COLUMN:
600 type = REFRESH_TYPE_NACL;
601 break;
602
603 default:
604 NOTREACHED();
605 return;
606 }
607
608 if (new_visibility)
609 AddRefreshType(type);
610 else
611 RemoveRefreshType(type);
612 }
613
614 bool TaskManagerTableModel::IsBrowserProcess(int row_index) const {
615 return observed_task_manager()->GetProcessId(tasks_[row_index]) ==
616 base::GetCurrentProcId();
617 }
618
619 void TaskManagerTableModel::RetrieveSavedColumnsSettingsAndUpdateTable() {
620 if (!g_browser_process->local_state())
621 return;
622
623 const base::DictionaryValue* dictionary =
624 g_browser_process->local_state()->GetDictionary(
625 prefs::kTaskManagerColumnVisibility);
626 if (!dictionary)
627 return;
628
629 // Do a best effort of retrieving the correct settings from the local state.
630 // Use the default settings of the value if it fails to be retrieved.
631 std::string sorted_col_id;
632 bool sort_is_ascending = true;
633 dictionary->GetString(kSortColumnIdKey, &sorted_col_id);
634 dictionary->GetBoolean(kSortIsAscendingKey, &sort_is_ascending);
635
636 int current_visible_column_index = 0;
637 for (size_t i = 0; i < kColumnsSize; ++i) {
638 const int col_id = kColumns[i].id;
639 const std::string col_id_key(GetColumnIdAsString(col_id));
640
641 if (col_id_key.empty())
642 continue;
643
644 bool col_visibility = kColumns[i].default_visibility;
645 dictionary->GetBoolean(col_id_key, &col_visibility);
646
647 // If the above GetBoolean() fails, the |col_visibility| remains at the
648 // default visibility.
649 columns_settings_->SetBoolean(col_id_key, col_visibility);
650 table_view_delegate_->SetColumnVisibility(col_id, col_visibility);
651 UpdateRefreshTypes(col_id, col_visibility);
652
653 if (col_visibility) {
654 if (sorted_col_id == col_id_key) {
655 if (sort_is_ascending == kColumns[i].initial_sort_is_ascending) {
656 table_view_delegate_->ToggleSortOrder(current_visible_column_index);
657 } else {
658 // Unfortunately the API of ui::TableView doesn't provide a clean way
659 // to sort by a particular column ID and a sort direction. If the
660 // retrieved sort direction is different than the initial one, we have
661 // to toggle the sort order twice!
662 // Note that the function takes the visible_column_index rather than
663 // a column ID.
664 table_view_delegate_->ToggleSortOrder(current_visible_column_index);
665 table_view_delegate_->ToggleSortOrder(current_visible_column_index);
666 }
667 }
668
669 ++current_visible_column_index;
670 }
671 }
672 }
673
674 void TaskManagerTableModel::StoreColumnsSettings() {
675 PrefService* local_state = g_browser_process->local_state();
676 if (!local_state)
677 return;
678
679 DictionaryPrefUpdate dict_update(local_state,
680 prefs::kTaskManagerColumnVisibility);
681
682 base::DictionaryValue::Iterator it(*columns_settings_);
683 while (!it.IsAtEnd()) {
684 dict_update->Set(it.key(), it.value().CreateDeepCopy());
685 it.Advance();
686 }
687
688 // Store the current sort status to be restored again at startup.
689 if (!table_view_delegate_->IsTableSorted()) {
690 dict_update->SetString(kSortColumnIdKey, "");
691 } else {
692 const auto& sort_descriptor = table_view_delegate_->GetSortDescriptor();
693 dict_update->SetString(
694 kSortColumnIdKey,
695 GetColumnIdAsString(sort_descriptor.sorted_column_id));
696 dict_update->SetBoolean(kSortIsAscendingKey, sort_descriptor.is_ascending);
697 }
698 }
699
700 void TaskManagerTableModel::ToggleColumnVisibility(int column_id) {
701 bool new_visibility = !table_view_delegate_->IsColumnVisible(column_id);
702 table_view_delegate_->SetColumnVisibility(column_id, new_visibility);
703 columns_settings_->SetBoolean(GetColumnIdAsString(column_id), new_visibility);
704 UpdateRefreshTypes(column_id, new_visibility);
705 }
706
707 void TaskManagerTableModel::OnRefresh() {
708 if (table_model_observer_)
709 table_model_observer_->OnItemsChanged(0, RowCount());
710 }
711
712 bool TaskManagerTableModel::IsTaskFirstInGroup(int row_index) const {
713 if (row_index == 0)
714 return true;
715
716 return observed_task_manager()->GetProcessId(tasks_[row_index - 1]) !=
717 observed_task_manager()->GetProcessId(tasks_[row_index]);
718 }
719
720
721 } // namespace task_management
OLDNEW
« no previous file with comments | « chrome/browser/ui/task_manager/task_manager_table_model.h ('k') | chrome/browser/ui/views/new_task_manager_view.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698