Mac: Add sort support for task manager.

chrome/browser/cocoa/task_manager_mac.mm

 // Copyright (c) 2010 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/cocoa/task_manager_mac.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "app/l10n_util_mac.h"
 #include "base/mac_util.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #import "chrome/browser/cocoa/window_size_autosaver.h"
 #include "chrome/common/pref_names.h"
 #include "grit/generated_resources.h"
 
-// TODO(thakis): Column sort comparator
-// TODO(thakis): Clicking column header doesn't sort
-// TODO(thakis): Default sort column
+namespace {
 
 // Width of "a" and most other letters/digits in "small" table views.
-static const int kCharWidth = 6;
+const int kCharWidth = 6;
 
 // Some of the strings below have spaces at the end or are missing letters, to
 // make the columns look nicer, and to take potentially longer localized strings
 // into account.
-static const struct ColumnWidth {
+const struct ColumnWidth {
   int columnId;
   int minWidth;
   int maxWidth;  // If this is -1, 1.5*minColumWidth is used as max width.
 } columnWidths[] = {
   // Note that arraysize includes the trailing \0. That's intended.
   { IDS_TASK_MANAGER_PAGE_COLUMN, 120, 600 },
   { IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN,
       arraysize("800 MiB") * kCharWidth, -1 },
   { IDS_TASK_MANAGER_SHARED_MEM_COLUMN,
       arraysize("800 MiB") * kCharWidth, -1 },
   { IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN,
       arraysize("800 MiB") * kCharWidth, -1 },
   { IDS_TASK_MANAGER_CPU_COLUMN,
       arraysize("99.9") * kCharWidth, -1 },
   { IDS_TASK_MANAGER_NET_COLUMN,
       arraysize("150 kiB/s") * kCharWidth, -1 },
   { IDS_TASK_MANAGER_PROCESS_ID_COLUMN,
       arraysize("73099  ") * kCharWidth, -1 },
   { IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN,
       arraysize("2000.0K (2000.0 live)") * kCharWidth, -1 },
   { IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN,
       arraysize("2000.0K (2000.0 live)") * kCharWidth, -1 },
   { IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN,
       arraysize("2000.0K (2000.0 live)") * kCharWidth, -1 },
   { IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN,
       arraysize("15 ") * kCharWidth, -1 },
 };
 
+class SortHelper {
+ public:
+  SortHelper(TaskManagerModel* model, NSSortDescriptor* column)
+      : sort_column_([[column key] intValue]),
+        ascending_([column ascending]),
+        model_(model) {}
+
+  bool operator()(int a, int b) {
+    int cmp_result = model_->CompareValues(a, b, sort_column_ );
+    if (!ascending_)
+      cmp_result = -cmp_result;
+    // TODO(thakis): Do grouping like on GTK.
+    return cmp_result < 0;
+  }
+ private:
+  int sort_column_;
+  bool ascending_;
+  TaskManagerModel* model_;  // weak;
+};
+
+}  // namespace
+
 @interface TaskManagerWindowController (Private)
 - (NSTableColumn*)addColumnWithId:(int)columnId visible:(BOOL)isVisible;
 - (void)setUpTableColumns;
 - (void)setUpTableHeaderContextMenu;
 - (void)toggleColumn:(id)sender;
 - (void)adjustSelectionAndEndProcessButton;
 @end
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerWindowController implementation:
 
 @implementation TaskManagerWindowController
 
 - (id)initWithTaskManagerObserver:(TaskManagerMac*)taskManagerObserver {
   NSString* nibpath = [mac_util::MainAppBundle()
                         pathForResource:@"TaskManager"
                                  ofType:@"nib"];
   if ((self = [super initWithWindowNibPath:nibpath owner:self])) {
     taskManagerObserver_ = taskManagerObserver;
     taskManager_ = taskManagerObserver_->task_manager();
     model_ = taskManager_->model();
 
     if (g_browser_process && g_browser_process->local_state()) {
       size_saver_.reset([[WindowSizeAutosaver alloc]
           initWithWindow:[self window]
              prefService:g_browser_process->local_state()
                     path:prefs::kTaskManagerWindowPlacement
                    state:kSaveWindowRect]);
     }
-    [[self window] makeKeyAndOrderFront:self];
+    [self showWindow:self];
   }
   return self;
 }
 
+- (void)sortShuffleArray {
+  indexShuffle_.resize(model_->ResourceCount());
+  for (size_t i = 0; i < indexShuffle_.size(); ++i)
+    indexShuffle_[i] = i;
+
+  std::sort(indexShuffle_.begin(), indexShuffle_.end(),
+            SortHelper(model_, currentSortDescriptor_.get()));
+}
+
 - (void)reloadData {
+  [self sortShuffleArray];
   [tableView_ reloadData];
   [self adjustSelectionAndEndProcessButton];
 }
 
 - (IBAction)statsLinkClicked:(id)sender {
   TaskManager::GetInstance()->OpenAboutMemory();
 }
 
 - (IBAction)killSelectedProcesses:(id)sender {
   NSIndexSet* selection = [tableView_ selectedRowIndexes];
   for (NSUInteger i = [selection lastIndex];
        i != NSNotFound;
        i = [selection indexLessThanIndex:i]) {
     taskManager_->KillProcess(i);
   }
 }
 
 - (void)selectDoubleClickedTab:(id)sender {
   NSInteger row = [tableView_ clickedRow];
   if (row < 0)
     return;  // Happens e.g. if the table header is double-clicked.
   taskManager_->ActivateProcess(row);
 }
 
+- (NSTableView*)tableView {
+  return tableView_;
+}
+
 - (void)awakeFromNib {
   [self setUpTableColumns];
   [self setUpTableHeaderContextMenu];
   [self adjustSelectionAndEndProcessButton];
 
   [tableView_ setDoubleAction:@selector(selectDoubleClickedTab:)];
 }
 
 // Adds a column which has the given string id as title. |isVisible| specifies
 // if the column is initially visible.
 - (NSTableColumn*)addColumnWithId:(int)columnId visible:(BOOL)isVisible {
   scoped_nsobject<NSTableColumn> column([[NSTableColumn alloc]
       initWithIdentifier:[NSNumber numberWithInt:columnId]]);
 
   NSTextAlignment textAlignment = columnId == IDS_TASK_MANAGER_PAGE_COLUMN ?
       NSLeftTextAlignment : NSRightTextAlignment;
 
   [[column.get() headerCell]
       setStringValue:l10n_util::GetNSStringWithFixup(columnId)];
   [[column.get() headerCell] setAlignment:textAlignment];
   [[column.get() dataCell] setAlignment:textAlignment];
 
   NSFont* font = [NSFont systemFontOfSize:[NSFont smallSystemFontSize]];
   [[column.get() dataCell] setFont:font];
 
   [column.get() setHidden:!isVisible];
   [column.get() setEditable:NO];
 
+  // The page column should by default be sorted ascending.
+  BOOL ascending = columnId == IDS_TASK_MANAGER_PAGE_COLUMN;
+
+  scoped_nsobject<NSSortDescriptor> sortDescriptor([[NSSortDescriptor alloc]
+      initWithKey:[NSString stringWithFormat:@"%d", columnId]
+        ascending:ascending]);
+  [column.get() setSortDescriptorPrototype:sortDescriptor.get()];
+
   // Default values, only used in release builds if nobody notices the DCHECK
   // during development when adding new columns.
   int minWidth = 200, maxWidth = 400;
 
   size_t i;
   for (i = 0; i < arraysize(columnWidths); ++i) {
     if (columnWidths[i].columnId == columnId) {
       minWidth = columnWidths[i].minWidth;
       maxWidth = columnWidths[i].maxWidth;
       if (maxWidth < 0)
@@ skipping 20 matching lines @@
   // |nameColumn| displays an icon for every row -- this is done by an
   // NSButtonCell.
   scoped_nsobject<NSButtonCell> nameCell(
       [[NSButtonCell alloc] initTextCell:@""]);
   [nameCell.get() setImagePosition:NSImageLeft];
   [nameCell.get() setButtonType:NSSwitchButton];
   [nameCell.get() setAlignment:[[nameColumn dataCell] alignment]];
   [nameCell.get() setFont:[[nameColumn dataCell] font]];
   [nameColumn setDataCell:nameCell.get()];
 
+  // Initially, sort on the tab name.
+  [tableView_ setSortDescriptors:
+      [NSArray arrayWithObject:[nameColumn sortDescriptorPrototype]]];
+
   [self addColumnWithId:IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN visible:YES];
   [self addColumnWithId:IDS_TASK_MANAGER_SHARED_MEM_COLUMN visible:NO];
   [self addColumnWithId:IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN visible:NO];
   [self addColumnWithId:IDS_TASK_MANAGER_CPU_COLUMN visible:YES];
   [self addColumnWithId:IDS_TASK_MANAGER_NET_COLUMN visible:YES];
   [self addColumnWithId:IDS_TASK_MANAGER_PROCESS_ID_COLUMN visible:NO];
   [self addColumnWithId:IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN
                 visible:NO];
   [self addColumnWithId:IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN
                 visible:NO];
@@ skipping 59 matching lines @@
 
   bool enabled = [selection count] > 0 && !selectionContainsBrowserProcess;
   [endProcessButton_ setEnabled:enabled];
 }
 
 // Table view delegate method.
 - (void)tableViewSelectionIsChanging:(NSNotification*)aNotification {
   [self adjustSelectionAndEndProcessButton];
 }
 
+- (void)windowWillClose:(NSNotification*)notification {
+  if (taskManagerObserver_) {
+    taskManagerObserver_->WindowWasClosed();
+    taskManagerObserver_ = nil;
+  }
+  [self autorelease];
+}
+
 @end
 
 @implementation TaskManagerWindowController (NSTableDataSource)
 
 - (NSInteger)numberOfRowsInTableView:(NSTableView*)tableView {
   DCHECK(tableView == tableView_ || tableView_ == nil);
   return model_->ResourceCount();
 }
 
 - (NSString*)modelTextForRow:(int)row column:(int)columnId {
+  DCHECK_LT(static_cast<size_t>(row), indexShuffle_.size());
+  row = indexShuffle_[row];
   switch (columnId) {
     case IDS_TASK_MANAGER_PAGE_COLUMN:  // Process
       return base::SysWideToNSString(model_->GetResourceTitle(row));
 
     case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:  // Memory
       if (!model_->IsResourceFirstInGroup(row))
         return @"";
       return base::SysWideToNSString(model_->GetResourcePrivateMemory(row));
 
     case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:  // Memory
@@ skipping 72 matching lines @@
                                     column:[[tableColumn identifier] intValue]];
     [buttonCell setTitle:title];
     [buttonCell setImage:taskManagerObserver_->GetImageForRow(rowIndex)];
     [buttonCell setRefusesFirstResponder:YES];  // Don't push in like a button.
     [buttonCell setHighlightsBy:NSNoCellMask];
   }
 
   return cell;
 }
 
+- (void)           tableView:(NSTableView*)tableView
+    sortDescriptorsDidChange:(NSArray*)oldDescriptors {
+  NSArray* newDescriptors = [tableView sortDescriptors];
+  if ([newDescriptors count] < 1)
+    return;
+
+  currentSortDescriptor_.reset([[newDescriptors objectAtIndex:0] retain]);
+  [self reloadData];  // Sorts.
+}
+
 @end
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerMac implementation:
 
-TaskManagerMac::TaskManagerMac()
-  : task_manager_(TaskManager::GetInstance()),
-    model_(TaskManager::GetInstance()->model()),
+TaskManagerMac::TaskManagerMac(TaskManager* task_manager)
+  : task_manager_(task_manager),
+    model_(task_manager->model()),
     icon_cache_(this) {
   window_controller_ =
       [[TaskManagerWindowController alloc] initWithTaskManagerObserver:this];
   model_->AddObserver(this);
 }
 
 // static
 TaskManagerMac* TaskManagerMac::instance_ = NULL;
 
 TaskManagerMac::~TaskManagerMac() {
-  task_manager_->OnWindowClosed();
+  if (this == instance_) {
+    // Do not do this when running in unit tests: |StartUpdating()| never got
+    // called in that case.
+    task_manager_->OnWindowClosed();
+  }
   model_->RemoveObserver(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerMac, TaskManagerModelObserver implementation:
 
 void TaskManagerMac::OnModelChanged() {
   icon_cache_.OnModelChanged();
   [window_controller_ reloadData];
 }
@@ skipping 25 matching lines @@
   instance_ = NULL;
 }
 
 // static
 void TaskManagerMac::Show() {
   if (instance_) {
     // If there's a Task manager window open already, just activate it.
     [[instance_->window_controller_ window]
         makeKeyAndOrderFront:instance_->window_controller_];
   } else {
-    instance_ = new TaskManagerMac;
+    instance_ = new TaskManagerMac(TaskManager::GetInstance());
     instance_->model_->StartUpdating();
   }
 }