chrome/browser/ui/views/hung_renderer_view.cc

   1 // Copyright (c) 2012 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/views/hung_renderer_view.h"
   6
   7 #if defined(OS_WIN) && !defined(USE_AURA)
   8 #include <windows.h>
   9 #endif
  10
  11 #include "base/i18n/rtl.h"
  12 #include "base/memory/scoped_vector.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "chrome/browser/favicon/favicon_tab_helper.h"
  15 #include "chrome/browser/platform_util.h"
  16 #include "chrome/browser/ui/browser_dialogs.h"
  17 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
  18 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
  19 #include "chrome/common/chrome_constants.h"
  20 #include "chrome/common/logging_chrome.h"
  21 #include "content/public/browser/render_process_host.h"
  22 #include "content/public/browser/render_view_host.h"
  23 #include "content/public/browser/web_contents.h"
  24 #include "content/public/browser/web_contents_view.h"
  25 #include "content/public/common/result_codes.h"
  26 #include "grit/chromium_strings.h"
  27 #include "grit/generated_resources.h"
  28 #include "grit/theme_resources.h"
  29 #include "ui/base/l10n/l10n_util.h"
  30 #include "ui/base/resource/resource_bundle.h"
  31 #include "ui/gfx/canvas.h"
  32 #include "ui/views/controls/button/label_button.h"
  33 #include "ui/views/controls/image_view.h"
  34 #include "ui/views/controls/label.h"
  35 #include "ui/views/layout/grid_layout.h"
  36 #include "ui/views/layout/layout_constants.h"
  37 #include "ui/views/widget/widget.h"
  38 #include "ui/views/window/client_view.h"
  39
  40 #if defined(USE_AURA)
  41 #include "ui/aura/window.h"
  42 #endif
  43
  44 using content::WebContents;
  45
  46 // These functions allow certain chrome platforms to override the default hung
  47 // renderer dialog. For e.g. Chrome on Windows 8 metro
  48 bool PlatformShowCustomHungRendererDialog(WebContents* contents);
  49 bool PlatformHideCustomHungRendererDialog(WebContents* contents);
  50
  51 #if !defined(OS_WIN)
  52 bool PlatformShowCustomHungRendererDialog(WebContents* contents) {
  53   return false;
  54 }
  55
  56 bool PlatformHideCustomHungRendererDialog(WebContents* contents) {
  57   return false;
  58 }
  59 #endif  // OS_WIN
  60
  61 HungRendererDialogView* HungRendererDialogView::g_instance_ = NULL;
  62
  63 ///////////////////////////////////////////////////////////////////////////////
  64 // HungPagesTableModel, public:
  65
  66 HungPagesTableModel::HungPagesTableModel(Delegate* delegate)
  67     : observer_(NULL),
  68       delegate_(delegate) {
  69 }
  70
  71 HungPagesTableModel::~HungPagesTableModel() {
  72 }
  73
  74 content::RenderProcessHost* HungPagesTableModel::GetRenderProcessHost() {
  75   return tab_observers_.empty() ? NULL :
  76       tab_observers_[0]->web_contents()->GetRenderProcessHost();
  77 }
  78
  79 content::RenderViewHost* HungPagesTableModel::GetRenderViewHost() {
  80   return tab_observers_.empty() ? NULL :
  81       tab_observers_[0]->web_contents()->GetRenderViewHost();
  82 }
  83
  84 void HungPagesTableModel::InitForWebContents(WebContents* hung_contents) {
  85   tab_observers_.clear();
  86   if (hung_contents) {
  87     // Force hung_contents to be first.
  88     if (hung_contents) {
  89       tab_observers_.push_back(new WebContentsObserverImpl(this,
  90                                                            hung_contents));
  91     }
  92     for (TabContentsIterator it; !it.done(); it.Next()) {
  93       if (*it != hung_contents &&
  94           it->GetRenderProcessHost() == hung_contents->GetRenderProcessHost())
  95         tab_observers_.push_back(new WebContentsObserverImpl(this, *it));
  96     }
  97   }
  98   // The world is different.
  99   if (observer_)
 100     observer_->OnModelChanged();
 101 }
 102
 103 ///////////////////////////////////////////////////////////////////////////////
 104 // HungPagesTableModel, ui::TableModel implementation:
 105
 106 int HungPagesTableModel::RowCount() {
 107   return static_cast<int>(tab_observers_.size());
 108 }
 109
 110 string16 HungPagesTableModel::GetText(int row, int column_id) {
 111   DCHECK(row >= 0 && row < RowCount());
 112   string16 title = tab_observers_[row]->web_contents()->GetTitle();
 113   if (title.empty())
 114     title = CoreTabHelper::GetDefaultTitle();
 115   // TODO(xji): Consider adding a special case if the title text is a URL,
 116   // since those should always have LTR directionality. Please refer to
 117   // http://crbug.com/6726 for more information.
 118   base::i18n::AdjustStringForLocaleDirection(&title);
 119   return title;
 120 }
 121
 122 gfx::ImageSkia HungPagesTableModel::GetIcon(int row) {
 123   DCHECK(row >= 0 && row < RowCount());
 124   return FaviconTabHelper::FromWebContents(
 125       tab_observers_[row]->web_contents())->GetFavicon().AsImageSkia();
 126 }
 127
 128 void HungPagesTableModel::SetObserver(ui::TableModelObserver* observer) {
 129   observer_ = observer;
 130 }
 131
 132 void HungPagesTableModel::GetGroupRange(int model_index,
 133                                         views::GroupRange* range) {
 134   DCHECK(range);
 135   range->start = 0;
 136   range->length = RowCount();
 137 }
 138
 139 void HungPagesTableModel::TabDestroyed(WebContentsObserverImpl* tab) {
 140   // Clean up tab_observers_ and notify our observer.
 141   TabObservers::iterator i = std::find(
 142       tab_observers_.begin(), tab_observers_.end(), tab);
 143   DCHECK(i != tab_observers_.end());
 144   int index = static_cast<int>(i - tab_observers_.begin());
 145   tab_observers_.erase(i);
 146   if (observer_)
 147     observer_->OnItemsRemoved(index, 1);
 148
 149   // Notify the delegate.
 150   delegate_->TabDestroyed();
 151   // WARNING: we've likely been deleted.
 152 }
 153
 154 HungPagesTableModel::WebContentsObserverImpl::WebContentsObserverImpl(
 155     HungPagesTableModel* model, WebContents* tab)
 156     : content::WebContentsObserver(tab),
 157       model_(model) {
 158 }
 159
 160 void HungPagesTableModel::WebContentsObserverImpl::RenderProcessGone(
 161     base::TerminationStatus status) {
 162   model_->TabDestroyed(this);
 163 }
 164
 165 void HungPagesTableModel::WebContentsObserverImpl::WebContentsDestroyed(
 166     WebContents* tab) {
 167   model_->TabDestroyed(this);
 168 }
 169
 170 ///////////////////////////////////////////////////////////////////////////////
 171 // HungRendererDialogView
 172
 173 // static
 174 gfx::ImageSkia* HungRendererDialogView::frozen_icon_ = NULL;
 175
 176 // The distance in pixels from the top of the relevant contents to place the
 177 // warning window.
 178 static const int kOverlayContentsOffsetY = 50;
 179
 180 // The dimensions of the hung pages list table view, in pixels.
 181 static const int kTableViewWidth = 300;
 182 static const int kTableViewHeight = 100;
 183
 184 // Padding space in pixels between frozen icon to the info label, hung pages
 185 // list table view and the Kill pages button.
 186 static const int kCentralColumnPadding =
 187     views::kUnrelatedControlLargeHorizontalSpacing;
 188
 189 ///////////////////////////////////////////////////////////////////////////////
 190 // HungRendererDialogView, public:
 191
 192 // static
 193 HungRendererDialogView* HungRendererDialogView::Create(
 194     gfx::NativeView context) {
 195   if (!g_instance_) {
 196     g_instance_ = new HungRendererDialogView;
 197     views::DialogDelegate::CreateDialogWidget(g_instance_, context, NULL);
 198   }
 199   return g_instance_;
 200 }
 201
 202 // static
 203 HungRendererDialogView* HungRendererDialogView::GetInstance() {
 204   return g_instance_;
 205 }
 206
 207 // static
 208 bool HungRendererDialogView::IsFrameActive(WebContents* contents) {
 209   gfx::NativeView frame_view =
 210       platform_util::GetTopLevel(contents->GetView()->GetNativeView());
 211   return platform_util::IsWindowActive(frame_view);
 212 }
 213
 214 #if !defined(OS_WIN)
 215 // static
 216 void HungRendererDialogView::KillRendererProcess(
 217     base::ProcessHandle process_handle) {
 218   base::KillProcess(process_handle, content::RESULT_CODE_HUNG, false);
 219 }
 220 #endif  // OS_WIN
 221
 222
 223 HungRendererDialogView::HungRendererDialogView()
 224     : hung_pages_table_(NULL),
 225       kill_button_(NULL),
 226       initialized_(false) {
 227   InitClass();
 228 }
 229
 230 HungRendererDialogView::~HungRendererDialogView() {
 231   hung_pages_table_->SetModel(NULL);
 232 }
 233
 234 void HungRendererDialogView::ShowForWebContents(WebContents* contents) {
 235   DCHECK(contents && GetWidget());
 236
 237   // Don't show the warning unless the foreground window is the frame, or this
 238   // window (but still invisible). If the user has another window or
 239   // application selected, activating ourselves is rude.
 240   if (!IsFrameActive(contents) &&
 241       !platform_util::IsWindowActive(GetWidget()->GetNativeWindow()))
 242     return;
 243
 244   if (!GetWidget()->IsActive()) {
 245     gfx::Rect bounds = GetDisplayBounds(contents);
 246
 247     gfx::NativeView frame_view =
 248         platform_util::GetTopLevel(contents->GetView()->GetNativeView());
 249
 250     views::Widget* insert_after =
 251         views::Widget::GetWidgetForNativeView(frame_view);
 252     GetWidget()->SetBoundsConstrained(bounds);
 253     if (insert_after)
 254       GetWidget()->StackAboveWidget(insert_after);
 255
 256     // We only do this if the window isn't active (i.e. hasn't been shown yet,
 257     // or is currently shown but deactivated for another WebContents). This is
 258     // because this window is a singleton, and it's possible another active
 259     // renderer may hang while this one is showing, and we don't want to reset
 260     // the list of hung pages for a potentially unrelated renderer while this
 261     // one is showing.
 262     hung_pages_table_model_->InitForWebContents(contents);
 263     GetWidget()->Show();
 264   }
 265 }
 266
 267 void HungRendererDialogView::EndForWebContents(WebContents* contents) {
 268   DCHECK(contents);
 269   if (hung_pages_table_model_->RowCount() == 0 ||
 270       hung_pages_table_model_->GetRenderProcessHost() ==
 271       contents->GetRenderProcessHost()) {
 272     GetWidget()->Close();
 273     // Close is async, make sure we drop our references to the tab immediately
 274     // (it may be going away).
 275     hung_pages_table_model_->InitForWebContents(NULL);
 276   }
 277 }
 278
 279 ///////////////////////////////////////////////////////////////////////////////
 280 // HungRendererDialogView, views::DialogDelegate implementation:
 281
 282 string16 HungRendererDialogView::GetWindowTitle() const {
 283   return l10n_util::GetStringUTF16(IDS_BROWSER_HANGMONITOR_RENDERER_TITLE);
 284 }
 285
 286 void HungRendererDialogView::WindowClosing() {
 287   // We are going to be deleted soon, so make sure our instance is destroyed.
 288   g_instance_ = NULL;
 289 }
 290
 291 int HungRendererDialogView::GetDialogButtons() const {
 292   // We specifically don't want a CANCEL button here because that code path is
 293   // also called when the window is closed by the user clicking the X button in
 294   // the window's titlebar, and also if we call Window::Close. Rather, we want
 295   // the OK button to wait for responsiveness (and close the dialog) and our
 296   // additional button (which we create) to kill the process (which will result
 297   // in the dialog being destroyed).
 298   return ui::DIALOG_BUTTON_OK;
 299 }
 300
 301 string16 HungRendererDialogView::GetDialogButtonLabel(
 302     ui::DialogButton button) const {
 303   if (button == ui::DIALOG_BUTTON_OK)
 304     return l10n_util::GetStringUTF16(IDS_BROWSER_HANGMONITOR_RENDERER_WAIT);
 305   return views::DialogDelegateView::GetDialogButtonLabel(button);
 306 }
 307
 308 views::View* HungRendererDialogView::CreateExtraView() {
 309   DCHECK(!kill_button_);
 310   kill_button_ = new views::LabelButton(this,
 311       l10n_util::GetStringUTF16(IDS_BROWSER_HANGMONITOR_RENDERER_END));
 312   kill_button_->SetStyle(views::Button::STYLE_NATIVE_TEXTBUTTON);
 313   return kill_button_;
 314 }
 315
 316 bool HungRendererDialogView::Accept(bool window_closing) {
 317   // Don't do anything if we're being called only because the dialog is being
 318   // destroyed and we don't supply a Cancel function...
 319   if (window_closing)
 320     return true;
 321
 322   // Start waiting again for responsiveness.
 323   if (hung_pages_table_model_->GetRenderViewHost())
 324     hung_pages_table_model_->GetRenderViewHost()->RestartHangMonitorTimeout();
 325   return true;
 326 }
 327
 328 ///////////////////////////////////////////////////////////////////////////////
 329 // HungRendererDialogView, views::ButtonListener implementation:
 330
 331 void HungRendererDialogView::ButtonPressed(
 332     views::Button* sender, const ui::Event& event) {
 333   if (sender == kill_button_ &&
 334       hung_pages_table_model_->GetRenderProcessHost()) {
 335
 336     base::ProcessHandle process_handle =
 337         hung_pages_table_model_->GetRenderProcessHost()->GetHandle();
 338
 339     KillRendererProcess(process_handle);
 340   }
 341 }
 342
 343 ///////////////////////////////////////////////////////////////////////////////
 344 // HungRendererDialogView, HungPagesTableModel::Delegate overrides:
 345
 346 void HungRendererDialogView::TabDestroyed() {
 347   GetWidget()->Close();
 348 }
 349
 350 ///////////////////////////////////////////////////////////////////////////////
 351 // HungRendererDialogView, views::View overrides:
 352
 353 void HungRendererDialogView::ViewHierarchyChanged(
 354     const ViewHierarchyChangedDetails& details) {
 355   if (!initialized_ && details.is_add && details.child == this && GetWidget())
 356     Init();
 357 }
 358
 359 ///////////////////////////////////////////////////////////////////////////////
 360 // HungRendererDialogView, private:
 361
 362 void HungRendererDialogView::Init() {
 363   views::ImageView* frozen_icon_view = new views::ImageView;
 364   frozen_icon_view->SetImage(frozen_icon_);
 365
 366   views::Label* info_label = new views::Label(
 367       l10n_util::GetStringUTF16(IDS_BROWSER_HANGMONITOR_RENDERER));
 368   info_label->SetMultiLine(true);
 369   info_label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
 370
 371   hung_pages_table_model_.reset(new HungPagesTableModel(this));
 372   std::vector<ui::TableColumn> columns;
 373   columns.push_back(ui::TableColumn());
 374   hung_pages_table_ = new views::TableView(
 375       hung_pages_table_model_.get(), columns, views::ICON_AND_TEXT, true);
 376   hung_pages_table_->SetGrouper(hung_pages_table_model_.get());
 377
 378   using views::GridLayout;
 379   using views::ColumnSet;
 380
 381   GridLayout* layout = GridLayout::CreatePanel(this);
 382   SetLayoutManager(layout);
 383
 384   const int double_column_set_id = 0;
 385   ColumnSet* column_set = layout->AddColumnSet(double_column_set_id);
 386   column_set->AddColumn(GridLayout::LEADING, GridLayout::LEADING, 0,
 387                         GridLayout::FIXED, frozen_icon_->width(), 0);
 388   column_set->AddPaddingColumn(0, kCentralColumnPadding);
 389   column_set->AddColumn(GridLayout::FILL, GridLayout::FILL, 1,
 390                         GridLayout::USE_PREF, 0, 0);
 391
 392   layout->StartRow(0, double_column_set_id);
 393   layout->AddView(frozen_icon_view, 1, 3);
 394   // Add the label with a preferred width of 1, this way it doesn't effect the
 395   // overall preferred size of the dialog.
 396   layout->AddView(
 397       info_label, 1, 1, GridLayout::FILL, GridLayout::LEADING, 1, 0);
 398
 399   layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing);
 400
 401   layout->StartRow(0, double_column_set_id);
 402   layout->SkipColumns(1);
 403   layout->AddView(hung_pages_table_->CreateParentIfNecessary(), 1, 1,
 404                   views::GridLayout::FILL,
 405                   views::GridLayout::FILL, kTableViewWidth, kTableViewHeight);
 406
 407   initialized_ = true;
 408 }
 409
 410 gfx::Rect HungRendererDialogView::GetDisplayBounds(
 411     WebContents* contents) {
 412 #if defined(USE_AURA)
 413   gfx::Rect contents_bounds(
 414       contents->GetView()->GetNativeView()->GetBoundsInRootWindow());
 415 #elif defined(OS_WIN)
 416   HWND contents_hwnd = contents->GetView()->GetNativeView();
 417   RECT contents_bounds_rect;
 418   GetWindowRect(contents_hwnd, &contents_bounds_rect);
 419   gfx::Rect contents_bounds(contents_bounds_rect);
 420 #endif
 421   gfx::Rect window_bounds = GetWidget()->GetWindowBoundsInScreen();
 422
 423   int window_x = contents_bounds.x() +
 424       (contents_bounds.width() - window_bounds.width()) / 2;
 425   int window_y = contents_bounds.y() + kOverlayContentsOffsetY;
 426   return gfx::Rect(window_x, window_y, window_bounds.width(),
 427                    window_bounds.height());
 428 }
 429
 430 // static
 431 void HungRendererDialogView::InitClass() {
 432   static bool initialized = false;
 433   if (!initialized) {
 434     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 435     frozen_icon_ = rb.GetImageSkiaNamed(IDR_FROZEN_TAB_ICON);
 436     initialized = true;
 437   }
 438 }
 439
 440 namespace chrome {
 441
 442 void ShowHungRendererDialog(WebContents* contents) {
 443   if (!logging::DialogsAreSuppressed() &&
 444       !PlatformShowCustomHungRendererDialog(contents)) {
 445     HungRendererDialogView* view = HungRendererDialogView::Create(
 446         platform_util::GetTopLevel(contents->GetView()->GetNativeView()));
 447     view->ShowForWebContents(contents);
 448   }
 449 }
 450
 451 void HideHungRendererDialog(WebContents* contents) {
 452   if (!logging::DialogsAreSuppressed() &&
 453       !PlatformHideCustomHungRendererDialog(contents) &&
 454       HungRendererDialogView::GetInstance())
 455     HungRendererDialogView::GetInstance()->EndForWebContents(contents);
 456 }
 457
 458 }  // namespace chrome