gtk: Add the 'Stats for nerds' link to the task manager....

chrome/browser/gtk/task_manager_gtk.cc

 // Copyright (c) 2009 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/gtk/task_manager_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
+#include <algorithm>
 #include <vector>
 
 #include "app/l10n_util.h"
 #include "base/gfx/gtk_util.h"
 #include "base/logging.h"
+#include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/browser_window.h"
+#include "chrome/browser/gtk/gtk_chrome_link_button.h"
 #include "chrome/browser/gtk/menu_gtk.h"
 #include "chrome/common/gtk_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 
 namespace {
 
 // The task manager window default size.
 const int kDefaultWidth = 460;
 const int kDefaultHeight = 270;
 
 // The resource id for the 'End process' button.
 const gint kTaskManagerResponseKill = 1;
 
+// The resource id for the 'Stats for nerds' link button.
+const gint kTaskManagerAboutMemoryLink = 2;
+
 enum TaskManagerColumn {
   kTaskManagerIcon,
   kTaskManagerPage,
   kTaskManagerPhysicalMem,
   kTaskManagerSharedMem,
   kTaskManagerPrivateMem,
   kTaskManagerCPU,
   kTaskManagerNetwork,
   kTaskManagerProcessID,
   kTaskManagerGoatsTeleported,
@@ skipping 270 matching lines @@
 void TaskManagerGtk::Init() {
   dialog_ = gtk_dialog_new_with_buttons(
       l10n_util::GetStringUTF8(IDS_TASK_MANAGER_TITLE).c_str(),
       // Task Manager window is shared between all browsers.
       NULL,
       GTK_DIALOG_NO_SEPARATOR,
       l10n_util::GetStringUTF8(IDS_TASK_MANAGER_KILL).c_str(),
       kTaskManagerResponseKill,
       NULL);
 
+  GtkWidget* link = gtk_chrome_link_button_new(
+      l10n_util::GetStringUTF8(IDS_TASK_MANAGER_ABOUT_MEMORY_LINK).c_str());
+  gtk_dialog_add_action_widget(GTK_DIALOG(dialog_), link,
+                               kTaskManagerAboutMemoryLink);
+
+  // Setting the link widget to secondary positions the button on the left side
+  // of the action area (vice versa for RTL layout).
+  gtk_button_box_set_child_secondary(
+      GTK_BUTTON_BOX(GTK_DIALOG(dialog_)->action_area), link, TRUE);
+
   ConnectAccelerators();
 
   gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(dialog_)->vbox),
                       gtk_util::kContentAreaSpacing);
   gtk_util::SetWindowIcon(GTK_WINDOW(dialog_));
 
   g_signal_connect(G_OBJECT(dialog_), "response", G_CALLBACK(OnResponse), this);
   g_signal_connect(G_OBJECT(dialog_), "button-release-event",
                    G_CALLBACK(OnButtonReleaseEvent), this);
   gtk_widget_add_events(dialog_,
@@ skipping 196 matching lines @@
   GtkTreeSelection* selection = gtk_tree_view_get_selection(
       GTK_TREE_VIEW(treeview_));
 
   // If the user has just double clicked, only one item is selected.
   GtkTreeModel* model;
   GList* selected = gtk_tree_selection_get_selected_rows(selection, &model);
   int row = GetRowNumForPath(reinterpret_cast<GtkTreePath*>(selected->data));
   task_manager_->ActivateProcess(row);
 }
 
+void TaskManagerGtk::OnLinkActivated() {
+  Browser* browser = BrowserList::GetLastActive();
+  DCHECK(browser);
+  browser->OpenURL(GURL("about:memory"), GURL(), NEW_FOREGROUND_TAB,
+                   PageTransition::LINK);
+  // In case the browser window is minimzed, show it. If this is an application
+  // or popup, we can only have one tab, hence we need to process this in a
+  // tabbed browser window. Currently, |browser| is pointing to the application,
+  // popup window. Therefore, we have to retrieve the last active tab again,
+  // since a new window has been used.
+  if (browser->type() & Browser::TYPE_APP_POPUP) {
+    browser = BrowserList::GetLastActive();
+    DCHECK(browser);
+  }
+  browser->window()->Show();
+}
+
 // static
 void TaskManagerGtk::OnResponse(GtkDialog* dialog, gint response_id,
                                 TaskManagerGtk* task_manager) {
   if (response_id == GTK_RESPONSE_DELETE_EVENT) {
     // Store the dialog's size so we can restore it the next time it's opened.
     if (g_browser_process->local_state()) {
       gint x = 0, y = 0, width = 1, height = 1;
       gtk_window_get_position(GTK_WINDOW(dialog), &x, &y);
       gtk_window_get_size(GTK_WINDOW(dialog), &width, &height);
 
       DictionaryValue* placement_pref =
           g_browser_process->local_state()->GetMutableDictionary(
               prefs::kTaskManagerWindowPlacement);
       // Note that we store left/top for consistency with Windows, but that we
       // *don't* restore them.
       placement_pref->SetInteger(L"left", x);
       placement_pref->SetInteger(L"top", y);
       placement_pref->SetInteger(L"right", x + width);
       placement_pref->SetInteger(L"bottom", y + height);
       placement_pref->SetBoolean(L"maximized", false);
     }
 
     instance_ = NULL;
     delete task_manager;
   } else if (response_id == kTaskManagerResponseKill) {
     task_manager->KillSelectedProcesses();
+  } else if (response_id == kTaskManagerAboutMemoryLink) {
+    task_manager->OnLinkActivated();
   }
 }
 
 // static
 void TaskManagerGtk::OnSelectionChanged(GtkTreeSelection* selection,
                                         TaskManagerGtk* task_manager) {
   bool selection_contains_browser_process = false;
 
   GtkTreeModel* model;
   GList* paths = gtk_tree_selection_get_selected_rows(selection, &model);
@@ skipping 44 matching lines @@
   if (keyval == GDK_w && modifier == GDK_CONTROL_MASK) {
     // The GTK_RESPONSE_DELETE_EVENT response must be sent before the widget
     // is destroyed.  The deleted object will receive gtk signals otherwise.
     gtk_dialog_response(GTK_DIALOG(task_manager->dialog_),
                         GTK_RESPONSE_DELETE_EVENT);
     gtk_widget_destroy(task_manager->dialog_);
   }
 
   return TRUE;
 }