Task Manager Double Click

chrome/browser/task_manager.cc

 // Copyright (c) 2006-2008 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_manager.h"
 
 #include "base/process_util.h"
 #include "base/stats_table.h"
 #include "base/string_util.h"
 #include "base/timer.h"
@@ skipping 520 matching lines @@
                       TaskManagerTableModel* table_model);
   virtual ~TaskManagerContents();
 
   void Init(TaskManagerTableModel* table_model);
   virtual void Layout();
   virtual void GetPreferredSize(CSize* out);
   virtual void DidChangeBounds(const CRect& previous, const CRect& current);
   virtual void ViewHierarchyChanged(bool is_add, ChromeViews::View* parent,
                                     ChromeViews::View* child);
   void GetSelection(std::vector<int>* selection);
+  void GetFocused(std::vector<int>* focused);
 
   // NativeButton::Listener implementation.
   virtual void ButtonPressed(ChromeViews::NativeButton* sender);
 
   // ChromeViews::TableViewObserver implementation.
   virtual void OnSelectionChanged();
+  virtual void OnDoubleClick();
+  virtual void OnKeyDown(unsigned short virtual_keycode);
 
   // ChromeViews::LinkController implementation.
   virtual void LinkActivated(ChromeViews::Link* source, int event_flags);
 
   // Called by the column picker to pick up any new stat counters that
   // may have appeared since last time.
   void UpdateStatsCounters();
 
   // Menu::Delegate
   virtual void ShowContextMenu(ChromeViews::View* source,
@@ skipping 184 matching lines @@
 
 void TaskManagerContents::GetSelection(std::vector<int>* selection) {
   DCHECK(selection);
   for (ChromeViews::TableSelectionIterator iter  = tab_table_->SelectionBegin();
        iter != tab_table_->SelectionEnd(); ++iter) {
     // The TableView returns the selection starting from the end.
     selection->insert(selection->begin(), *iter);
   }
 }
 
+void TaskManagerContents::GetFocused(std::vector<int>* focused) {
+  DCHECK(focused);
+  int row_count = tab_table_->RowCount();
+  for (int i = 0; i < row_count; ++i) {
+    // The TableView returns the selection starting from the end.
+    if (tab_table_->ItemHasTheFocus(i))
+      focused->insert(focused->begin(), i);
+  }
+}
+
 // NativeButton::Listener implementation.
 void TaskManagerContents::ButtonPressed(ChromeViews::NativeButton* sender) {
   if (sender == kill_button_)
     task_manager_->KillSelectedProcesses();
 }
 
 // ChromeViews::TableViewObserver implementation.
 void TaskManagerContents::OnSelectionChanged() {
   kill_button_->SetEnabled(!task_manager_->BrowserProcessIsSelected() &&
                            tab_table_->SelectedRowCount() > 0);
 }
 
+void TaskManagerContents::OnDoubleClick() {
+  task_manager_->ActivateFocusedTab();
+}
+
+void TaskManagerContents::OnKeyDown(unsigned short virtual_keycode) {
+  if (virtual_keycode == VK_RETURN)
+    task_manager_->ActivateFocusedTab();
+}
+
 // ChromeViews::LinkController implementation
 void TaskManagerContents::LinkActivated(ChromeViews::Link* source,
                                         int event_flags) {
   DCHECK(source == about_memory_link_);
   Browser* browser = BrowserList::GetLastActive();
   DCHECK(browser);
   browser->OpenURL(GURL("about:memory"), NEW_FOREGROUND_TAB,
                    PageTransition::LINK);
 }
 
@@ skipping 73 matching lines @@
   std::vector<int> selection;
   contents_->GetSelection(&selection);
   for (std::vector<int>::const_iterator iter = selection.begin();
        iter != selection.end(); ++iter) {
     HANDLE process = table_model_->GetProcessAt(*iter);
     DCHECK(process);
     TerminateProcess(process, 0);
   }
 }
 
+void TaskManager::ActivateFocusedTab() {
+  std::vector<int> focused;
+  contents_->GetFocused(&focused);
+  int focused_size = static_cast<int>(focused.size());
+
+  DCHECK(focused_size == 1);
+
+  // Gracefully return if there is not exactly one item in focus.
+  if (focused_size != 1)
+    return;
+
+  // Otherwise, the one focused thing should be one the user intends to bring
+  // forth, so get see if GetTabContents returns non-null.  If it does, activate
+  // those contents.
+  int index = focused[0];
+
+  // GetTabContents returns a pointer to the relevant tab contents for the
+  // resource.  If the index doesn't correspond to a Tab (i.e. refers to the
+  // Browser process or a plugin), GetTabContents will return NULL.
+  TabContents* chosen_tab_contents =
+      table_model_->resources_[index]->GetTabContents();
+
+  if (!chosen_tab_contents)
+    return;
+
+  chosen_tab_contents->Activate();
+}
+
 void TaskManager::AddResourceProvider(ResourceProvider* provider) {
   table_model_->AddResourceProvider(provider);
 }
 
 void TaskManager::RemoveResourceProvider(ResourceProvider* provider) {
   table_model_->RemoveResourceProvider(provider);
 }
 
 void TaskManager::AddResource(Resource* resource) {
   table_model_->AddResource(resource);
@@ skipping 61 matching lines @@
 
 ChromeViews::View* TaskManager::GetContentsView() {
   return contents_.get();
 }
 
 // static
 TaskManager* TaskManager::GetInstance() {
   return Singleton<TaskManager>::get();
 }