Reuse more dialog code for new task manager.

chrome/browser/ui/views/new_task_manager_view.cc

 // 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.
 
 #include "chrome/browser/ui/views/new_task_manager_view.h"
 
 #include <stddef.h>
 
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_window.h"
 #include "chrome/browser/task_management/task_manager_observer.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/browser/ui/browser_navigator_params.h"
 #include "chrome/browser/ui/task_manager/task_manager_columns.h"
 #include "chrome/browser/ui/user_manager.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/prefs/pref_service.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/table_model_observer.h"
+#include "ui/views/border.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/table/table_view.h"
+#include "ui/views/layout/fill_layout.h"
 #include "ui/views/layout/layout_constants.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
+#include "ui/views/window/dialog_client_view.h"
 
 #if defined(USE_ASH)
 #include "ash/shelf/shelf_util.h"
 #include "ash/wm/window_util.h"
 #include "grit/ash_resources.h"
 #endif  // defined(USE_ASH)
 
 #if defined(OS_WIN)
 #include "chrome/browser/shell_integration_win.h"
 #include "ui/base/win/shell.h"
@@ skipping 91 matching lines @@
     return TableSortDescriptor();
 
   const auto& descriptor = tab_table_->sort_descriptors().front();
   return TableSortDescriptor(descriptor.column_id, descriptor.ascending);
 }
 
 void NewTaskManagerView::ToggleSortOrder(int visible_column_index) {
   tab_table_->ToggleSortOrder(visible_column_index);
 }
 
-void NewTaskManagerView::Layout() {
-  gfx::Size size = kill_button_->GetPreferredSize();
-  gfx::Rect parent_bounds = parent()->GetContentsBounds();
-  const int horizontal_margin = views::kPanelHorizMargin;
-  const int vertical_margin = views::kButtonVEdgeMargin;
-  int x = width() - size.width() - horizontal_margin;
-  int y_buttons = parent_bounds.bottom() - size.height() - vertical_margin;
-  kill_button_->SetBounds(x, y_buttons, size.width(), size.height());
-
-  gfx::Rect rect = GetLocalBounds();
-  rect.Inset(horizontal_margin, views::kPanelVertMargin);
-  rect.Inset(0, 0, 0,
-             kill_button_->height() + views::kUnrelatedControlVerticalSpacing);
-  tab_table_parent_->SetBoundsRect(rect);
-}
-
 gfx::Size NewTaskManagerView::GetPreferredSize() const {
   return gfx::Size(460, 270);
 }
 
 bool NewTaskManagerView::AcceleratorPressed(
     const ui::Accelerator& accelerator) {
   DCHECK_EQ(ui::VKEY_W, accelerator.key_code());
   DCHECK_EQ(ui::EF_CONTROL_DOWN, accelerator.modifiers());
   GetWidget()->Close();
   return true;
 }
 
-void NewTaskManagerView::ViewHierarchyChanged(
-    const ViewHierarchyChangedDetails& details) {
-  views::DialogDelegateView::ViewHierarchyChanged(details);
-  // Since we want the Kill button to show up in the same visual row as the
-  // close button, which is provided by the framework, we must add it to the
-  // non-client view, which is the parent of this view. Similarly, when we're
-  // removed from the view hierarchy, we must take care to clean up that item.
-  if (details.child == this) {
-    if (details.is_add) {
-      details.parent->AddChildView(kill_button_);
-      tab_table_parent_ = tab_table_->CreateParentIfNecessary();
-      AddChildView(tab_table_parent_);
-    } else {
-      details.parent->RemoveChildView(kill_button_);
-    }
-  }
-}
-
-void NewTaskManagerView::ButtonPressed(views::Button* sender,
-                                       const ui::Event& event) {
-  DCHECK_EQ(kill_button_, sender);
-
-  using SelectedIndices =  ui::ListSelectionModel::SelectedIndices;
-  SelectedIndices selection(tab_table_->selection_model().selected_indices());
-  for (SelectedIndices::const_reverse_iterator i = selection.rbegin();
-       i != selection.rend();
-       ++i) {
-    table_model_->KillTask(*i);
-  }
-}
-
 bool NewTaskManagerView::CanResize() const {
   return true;
 }
 
 bool NewTaskManagerView::CanMaximize() const {
   return true;
 }
 
 bool NewTaskManagerView::CanMinimize() const {
   return true;
 }
 
 bool NewTaskManagerView::ExecuteWindowsCommand(int command_id) {
   return false;
 }
 
 base::string16 NewTaskManagerView::GetWindowTitle() const {
   return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_TITLE);
 }
 
 std::string NewTaskManagerView::GetWindowName() const {
   return prefs::kTaskManagerWindowPlacement;
 }
 
+bool NewTaskManagerView::Accept() {
+  using SelectedIndices = ui::ListSelectionModel::SelectedIndices;
+  SelectedIndices selection(tab_table_->selection_model().selected_indices());
+  for (SelectedIndices::const_reverse_iterator i = selection.rbegin();
+       i != selection.rend(); ++i) {
+    table_model_->KillTask(*i);
+  }
+
+  // Just kill the process, don't close the task manager dialog.
+  return false;
+}
+
+bool NewTaskManagerView::Close() {
+  return true;
+}
+
 int NewTaskManagerView::GetDialogButtons() const {
-  return ui::DIALOG_BUTTON_NONE;
+  return ui::DIALOG_BUTTON_OK;
+}
+
+base::string16 NewTaskManagerView::GetDialogButtonLabel(
+    ui::DialogButton button) const {
+  return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_KILL);
+}
+
+bool NewTaskManagerView::IsDialogButtonEnabled(ui::DialogButton button) const {
+  const ui::ListSelectionModel::SelectedIndices& selections(
+      tab_table_->selection_model().selected_indices());
+  for (const auto& selection : selections) {
+    if (table_model_->IsBrowserProcess(selection))
+      return false;
+  }
+
+  return !selections.empty() && TaskManager::IsEndProcessEnabled();
 }
 
 void NewTaskManagerView::WindowClosing() {
   // Now that the window is closed, we can allow a new one to be opened.
   // (WindowClosing comes in asynchronously from the call to Close() and we
   // may have already opened a new instance).
   if (g_task_manager_view == this) {
     // We don't have to delete |g_task_manager_view| as we don't own it. It's
     // owned by the Views hierarchy.
     g_task_manager_view = nullptr;
   }
   table_model_->StoreColumnsSettings();
 }
 
 bool NewTaskManagerView::UseNewStyleForThisDialog() const {
   return false;
 }
 
 void NewTaskManagerView::GetGroupRange(int model_index,
                                        views::GroupRange* range) {
   table_model_->GetRowsGroupRange(model_index, &range->start, &range->length);
 }
 
 void NewTaskManagerView::OnSelectionChanged() {
-  const ui::ListSelectionModel::SelectedIndices& selections(
-      tab_table_->selection_model().selected_indices());
-  bool selection_contains_browser_process = false;
-  for (const auto& selection : selections) {
-    if (table_model_->IsBrowserProcess(selection)) {
-      selection_contains_browser_process = true;
-      break;
-    }
-  }
-
-  kill_button_->SetEnabled(!selection_contains_browser_process &&
-                           !selections.empty() &&
-                           TaskManager::IsEndProcessEnabled());
+  GetDialogClientView()->UpdateDialogButtons();
 }
 
 void NewTaskManagerView::OnDoubleClick() {
   ActivateFocusedTab();
 }
 
 void NewTaskManagerView::OnKeyDown(ui::KeyboardCode keycode) {
   if (keycode == ui::VKEY_RETURN)
     ActivateFocusedTab();
 }
@@ skipping 33 matching lines @@
     int command_id,
     ui::Accelerator* accelerator) {
   return false;
 }
 
 void NewTaskManagerView::ExecuteCommand(int id, int event_flags) {
   table_model_->ToggleColumnVisibility(id);
 }
 
 NewTaskManagerView::NewTaskManagerView()
-    : kill_button_(nullptr),
-      tab_table_(nullptr),
+    : tab_table_(nullptr),
       tab_table_parent_(nullptr),
       is_always_on_top_(false) {
   Init();
 }
 
 // static
 NewTaskManagerView* NewTaskManagerView::GetInstanceForTests() {
   return g_task_manager_view;
 }
 
@@ skipping 14 matching lines @@
   table_model_.reset(new TaskManagerTableModel(REFRESH_TYPE_CPU |
                                                REFRESH_TYPE_MEMORY |
                                                REFRESH_TYPE_NETWORK_USAGE,
                                                this));
   tab_table_->SetModel(table_model_.get());
   tab_table_->SetGrouper(this);
   tab_table_->SetObserver(this);
   tab_table_->set_context_menu_controller(this);
   set_context_menu_controller(this);
 
+  tab_table_parent_ = tab_table_->CreateParentIfNecessary();
+  AddChildView(tab_table_parent_);
+
+  SetLayoutManager(new views::FillLayout());
+  SetBorder(views::Border::CreateEmptyBorder(views::kPanelVertMargin,
+                                             views::kButtonHEdgeMarginNew, 0,
+                                             views::kButtonHEdgeMarginNew));
+
   table_model_->RetrieveSavedColumnsSettingsAndUpdateTable();
 
-  kill_button_ = new views::LabelButton(this,
-      l10n_util::GetStringUTF16(IDS_TASK_MANAGER_KILL));
-  kill_button_->SetStyle(views::Button::STYLE_BUTTON);
-
-  // Makes sure our state is consistent.
-  OnSelectionChanged();
-
   AddAccelerator(ui::Accelerator(ui::VKEY_W, ui::EF_CONTROL_DOWN));
 }
 
 void NewTaskManagerView::InitAlwaysOnTopState() {
-  RetriveSavedAlwaysOnTopState();
+  RetrieveSavedAlwaysOnTopState();

[afakhry, 2016/05/19 00:49:43]

Thanks for catching that typo.

   GetWidget()->SetAlwaysOnTop(is_always_on_top_);
 }
 
 void NewTaskManagerView::ActivateFocusedTab() {
   const int active_row = tab_table_->selection_model().active();
   if (active_row != ui::ListSelectionModel::kUnselectedIndex)
     table_model_->ActivateTask(active_row);
 }
 
-void NewTaskManagerView::RetriveSavedAlwaysOnTopState() {
+void NewTaskManagerView::RetrieveSavedAlwaysOnTopState() {
   is_always_on_top_ = false;
 
   if (!g_browser_process->local_state())
     return;
 
   const base::DictionaryValue* dictionary =
     g_browser_process->local_state()->GetDictionary(GetWindowName());
   if (dictionary)
     dictionary->GetBoolean("always_on_top", &is_always_on_top_);
 }
 
 }  // namespace task_management