chrome/browser/ui/views/frame/browser_view.cc

   1 // Copyright 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/frame/browser_view.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/auto_reset.h"
  10 #include "base/command_line.h"
  11 #include "base/i18n/rtl.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/metrics/histogram.h"
  14 #include "base/prefs/pref_service.h"
  15 #include "base/strings/string_number_conversions.h"
  16 #include "chrome/app/chrome_command_ids.h"
  17 #include "chrome/app/chrome_dll_resource.h"
  18 #include "chrome/browser/app_mode/app_mode_utils.h"
  19 #include "chrome/browser/bookmarks/bookmark_stats.h"
  20 #include "chrome/browser/browser_process.h"
  21 #include "chrome/browser/chrome_notification_types.h"
  22 #include "chrome/browser/extensions/tab_helper.h"
  23 #include "chrome/browser/infobars/infobar_service.h"
  24 #include "chrome/browser/native_window_notification_source.h"
  25 #include "chrome/browser/password_manager/chrome_password_manager_client.h"
  26 #include "chrome/browser/password_manager/password_manager.h"
  27 #include "chrome/browser/profiles/avatar_menu.h"
  28 #include "chrome/browser/profiles/profile.h"
  29 #include "chrome/browser/profiles/profile_info_cache.h"
  30 #include "chrome/browser/profiles/profile_manager.h"
  31 #include "chrome/browser/profiles/profiles_state.h"
  32 #include "chrome/browser/search/search.h"
  33 #include "chrome/browser/sessions/tab_restore_service.h"
  34 #include "chrome/browser/sessions/tab_restore_service_factory.h"
  35 #include "chrome/browser/speech/tts_controller.h"
  36 #include "chrome/browser/themes/theme_properties.h"
  37 #include "chrome/browser/themes/theme_service_factory.h"
  38 #include "chrome/browser/translate/translate_tab_helper.h"
  39 #include "chrome/browser/ui/app_modal_dialogs/app_modal_dialog.h"
  40 #include "chrome/browser/ui/app_modal_dialogs/app_modal_dialog_queue.h"
  41 #include "chrome/browser/ui/bookmarks/bookmark_bar_constants.h"
  42 #include "chrome/browser/ui/bookmarks/bookmark_bubble_delegate.h"
  43 #include "chrome/browser/ui/bookmarks/bookmark_bubble_sign_in_delegate.h"
  44 #include "chrome/browser/ui/browser.h"
  45 #include "chrome/browser/ui/browser_command_controller.h"
  46 #include "chrome/browser/ui/browser_commands.h"
  47 #include "chrome/browser/ui/browser_dialogs.h"
  48 #include "chrome/browser/ui/browser_finder.h"
  49 #include "chrome/browser/ui/browser_list.h"
  50 #include "chrome/browser/ui/browser_window_state.h"
  51 #include "chrome/browser/ui/ntp_background_util.h"
  52 #include "chrome/browser/ui/omnibox/omnibox_popup_model.h"
  53 #include "chrome/browser/ui/omnibox/omnibox_popup_view.h"
  54 #include "chrome/browser/ui/omnibox/omnibox_view.h"
  55 #include "chrome/browser/ui/search/search_delegate.h"
  56 #include "chrome/browser/ui/search/search_model.h"
  57 #include "chrome/browser/ui/search/search_ui.h"
  58 #include "chrome/browser/ui/tabs/tab_menu_model.h"
  59 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  60 #include "chrome/browser/ui/view_ids.h"
  61 #include "chrome/browser/ui/views/accelerator_table.h"
  62 #include "chrome/browser/ui/views/accessibility/invert_bubble_view.h"
  63 #include "chrome/browser/ui/views/avatar_menu_bubble_view.h"
  64 #include "chrome/browser/ui/views/avatar_menu_button.h"
  65 #include "chrome/browser/ui/views/bookmarks/bookmark_bar_view.h"
  66 #include "chrome/browser/ui/views/bookmarks/bookmark_bubble_view.h"
  67 #include "chrome/browser/ui/views/browser_dialogs.h"
  68 #include "chrome/browser/ui/views/download/download_in_progress_dialog_view.h"
  69 #include "chrome/browser/ui/views/download/download_shelf_view.h"
  70 #include "chrome/browser/ui/views/extensions/bookmark_app_bubble_view.h"
  71 #include "chrome/browser/ui/views/frame/browser_view_layout.h"
  72 #include "chrome/browser/ui/views/frame/browser_view_layout_delegate.h"
  73 #include "chrome/browser/ui/views/frame/contents_layout_manager.h"
  74 #include "chrome/browser/ui/views/frame/immersive_mode_controller.h"
  75 #include "chrome/browser/ui/views/frame/native_browser_frame_factory.h"
  76 #include "chrome/browser/ui/views/frame/top_container_view.h"
  77 #include "chrome/browser/ui/views/fullscreen_exit_bubble_views.h"
  78 #include "chrome/browser/ui/views/infobars/infobar_container_view.h"
  79 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
  80 #include "chrome/browser/ui/views/location_bar/location_icon_view.h"
  81 #include "chrome/browser/ui/views/omnibox/omnibox_view_views.h"
  82 #include "chrome/browser/ui/views/password_generation_bubble_view.h"
  83 #include "chrome/browser/ui/views/profile_chooser_view.h"
  84 #include "chrome/browser/ui/views/status_bubble_views.h"
  85 #include "chrome/browser/ui/views/tabs/browser_tab_strip_controller.h"
  86 #include "chrome/browser/ui/views/tabs/tab.h"
  87 #include "chrome/browser/ui/views/tabs/tab_strip.h"
  88 #include "chrome/browser/ui/views/toolbar/reload_button.h"
  89 #include "chrome/browser/ui/views/toolbar/toolbar_view.h"
  90 #include "chrome/browser/ui/views/translate/translate_bubble_view.h"
  91 #include "chrome/browser/ui/views/update_recommended_message_box.h"
  92 #include "chrome/browser/ui/views/website_settings/permissions_bubble_view.h"
  93 #include "chrome/browser/ui/views/website_settings/website_settings_popup_view.h"
  94 #include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
  95 #include "chrome/browser/ui/window_sizer/window_sizer.h"
  96 #include "chrome/common/chrome_switches.h"
  97 #include "chrome/common/pref_names.h"
  98 #include "chrome/common/profile_management_switches.h"
  99 #include "chrome/common/url_constants.h"
 100 #include "content/public/browser/download_manager.h"
 101 #include "content/public/browser/native_web_keyboard_event.h"
 102 #include "content/public/browser/notification_service.h"
 103 #include "content/public/browser/render_view_host.h"
 104 #include "content/public/browser/render_widget_host.h"
 105 #include "content/public/browser/user_metrics.h"
 106 #include "content/public/browser/web_contents.h"
 107 #include "content/public/browser/web_contents_view.h"
 108 #include "content/public/common/content_switches.h"
 109 #include "grit/chromium_strings.h"
 110 #include "grit/generated_resources.h"
 111 #include "grit/locale_settings.h"
 112 #include "grit/theme_resources.h"
 113 #include "grit/ui_resources.h"
 114 #include "grit/ui_strings.h"
 115 #include "grit/webkit_resources.h"
 116 #include "ui/base/accelerators/accelerator.h"
 117 #include "ui/base/accessibility/accessible_view_state.h"
 118 #include "ui/base/hit_test.h"
 119 #include "ui/base/l10n/l10n_util.h"
 120 #include "ui/base/resource/resource_bundle.h"
 121 #include "ui/base/theme_provider.h"
 122 #include "ui/events/event_utils.h"
 123 #include "ui/gfx/canvas.h"
 124 #include "ui/gfx/color_utils.h"
 125 #include "ui/gfx/rect_conversions.h"
 126 #include "ui/gfx/sys_color_change_listener.h"
 127 #include "ui/views/controls/button/menu_button.h"
 128 #include "ui/views/controls/textfield/textfield.h"
 129 #include "ui/views/controls/webview/webview.h"
 130 #include "ui/views/focus/external_focus_tracker.h"
 131 #include "ui/views/focus/view_storage.h"
 132 #include "ui/views/layout/grid_layout.h"
 133 #include "ui/views/widget/native_widget.h"
 134 #include "ui/views/widget/root_view.h"
 135 #include "ui/views/widget/widget.h"
 136 #include "ui/views/window/dialog_delegate.h"
 137
 138 #if defined(USE_ASH)
 139 #include "ash/ash_switches.h"
 140 #include "ash/shelf/shelf.h"
 141 #include "ash/shelf/shelf_model.h"
 142 #include "ash/shell.h"
 143 #include "chrome/browser/ui/ash/ash_util.h"
 144 #endif
 145
 146 #if defined(USE_AURA)
 147 #include "ui/aura/window.h"
 148 #include "ui/aura/window_event_dispatcher.h"
 149 #include "ui/gfx/screen.h"
 150 #endif
 151
 152 #if defined(OS_WIN)
 153 #include "base/win/windows_version.h"
 154 #include "chrome/browser/jumplist_win.h"
 155 #include "ui/views/win/scoped_fullscreen_visibility.h"
 156 #include "win8/util/win8_util.h"
 157 #endif
 158
 159 #if defined(ENABLE_ONE_CLICK_SIGNIN)
 160 #include "chrome/browser/ui/sync/one_click_signin_bubble_delegate.h"
 161 #include "chrome/browser/ui/sync/one_click_signin_bubble_links_delegate.h"
 162 #include "chrome/browser/ui/views/sync/one_click_signin_bubble_view.h"
 163 #endif
 164
 165 #if defined(OS_CHROMEOS)
 166 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h"
 167 #endif
 168
 169 using base::TimeDelta;
 170 using base::UserMetricsAction;
 171 using content::NativeWebKeyboardEvent;
 172 using content::SSLStatus;
 173 using content::WebContents;
 174 using views::ColumnSet;
 175 using views::GridLayout;
 176 using web_modal::WebContentsModalDialogHost;
 177
 178 namespace {
 179 // The name of a key to store on the window handle so that other code can
 180 // locate this object using just the handle.
 181 const char* const kBrowserViewKey = "__BROWSER_VIEW__";
 182
 183 // The number of milliseconds between loading animation frames.
 184 const int kLoadingAnimationFrameTimeMs = 30;
 185
 186 // TODO(kuan): These functions are temporarily for the bookmark bar while its
 187 // detached state is at the top of the page;  it'll be moved to float on the
 188 // content page in the very near future, at which time, these local functions
 189 // will be removed.
 190 void PaintDetachedBookmarkBar(gfx::Canvas* canvas,
 191                               DetachableToolbarView* view,
 192                               ThemeService* theme_service) {
 193   // Paint background for detached state; if animating, this is fade in/out.
 194   canvas->DrawColor(
 195       chrome::GetDetachedBookmarkBarBackgroundColor(theme_service));
 196   // Draw the separators above and below bookmark bar;
 197   // if animating, these are fading in/out.
 198   SkColor separator_color =
 199       chrome::GetDetachedBookmarkBarSeparatorColor(theme_service);
 200   DetachableToolbarView::PaintHorizontalBorder(canvas, view, true,
 201                                                separator_color);
 202   // The bottom border needs to be 1-px thick in both regular and retina
 203   // displays, so we can't use DetachableToolbarView::PaintHorizontalBorder
 204   // which paints a 2-px thick border in retina display.
 205   SkPaint paint;
 206   paint.setAntiAlias(false);
 207   // Sets border to 1-px thick regardless of scale factor.
 208   paint.setStrokeWidth(0);
 209   // Bottom border is at 50% opacity of top border.
 210   paint.setColor(SkColorSetA(separator_color,
 211                              SkColorGetA(separator_color) / 2));
 212   // Calculate thickness of bottom border as per current scale factor to
 213   // determine where to draw the 1-px thick border.
 214   float thickness = views::NonClientFrameView::kClientEdgeThickness /
 215                     canvas->image_scale();
 216   SkScalar y = SkIntToScalar(view->height()) - SkFloatToScalar(thickness);
 217   canvas->sk_canvas()->drawLine(SkIntToScalar(0), y,
 218                                 SkIntToScalar(view->width()), y, paint);
 219 }
 220
 221 void PaintAttachedBookmarkBar(gfx::Canvas* canvas,
 222                               DetachableToolbarView* view,
 223                               BrowserView* browser_view,
 224                               chrome::HostDesktopType host_desktop_type,
 225                               int toolbar_overlap) {
 226   // Paint background for attached state, this is fade in/out.
 227   gfx::Point background_image_offset =
 228       browser_view->OffsetPointForToolbarBackgroundImage(
 229           gfx::Point(view->GetMirroredX(), view->y()));
 230   DetachableToolbarView::PaintBackgroundAttachedMode(canvas,
 231       view->GetThemeProvider(), view->GetLocalBounds(),
 232       background_image_offset, host_desktop_type);
 233   if (view->height() >= toolbar_overlap) {
 234     // Draw the separator below bookmark bar; this is fading in/out.
 235     DetachableToolbarView::PaintHorizontalBorder(canvas, view, false,
 236         ThemeProperties::GetDefaultColor(
 237             ThemeProperties::COLOR_TOOLBAR_SEPARATOR));
 238   }
 239 }
 240
 241 }  // namespace
 242
 243 // static
 244 const char BrowserView::kViewClassName[] = "BrowserView";
 245
 246 namespace {
 247
 248 bool ShouldSaveOrRestoreWindowPos() {
 249 #if defined(OS_WIN)
 250   // In Windows 8's single window Metro mode the window is always maximized
 251   // (without the WS_MAXIMIZE style).
 252   if (win8::IsSingleWindowMetroMode())
 253     return false;
 254 #endif
 255   return true;
 256 }
 257
 258 }  // namespace
 259
 260 ///////////////////////////////////////////////////////////////////////////////
 261
 262 // Delegate implementation for BrowserViewLayout. Usually just forwards calls
 263 // into BrowserView.
 264 class BrowserViewLayoutDelegateImpl : public BrowserViewLayoutDelegate {
 265  public:
 266   explicit BrowserViewLayoutDelegateImpl(BrowserView* browser_view)
 267       : browser_view_(browser_view) {}
 268   virtual ~BrowserViewLayoutDelegateImpl() {}
 269
 270   // BrowserViewLayoutDelegate overrides:
 271   virtual views::View* GetContentsWebView() const OVERRIDE {
 272     return browser_view_->contents_web_view_;
 273   }
 274
 275   virtual views::View* GetWindowSwitcherButton() const OVERRIDE {
 276     return browser_view_->window_switcher_button();
 277   }
 278
 279   virtual bool DownloadShelfNeedsLayout() const OVERRIDE {
 280     DownloadShelfView* download_shelf = browser_view_->download_shelf_.get();
 281     // Re-layout the shelf either if it is visible or if its close animation
 282     // is currently running.
 283     return download_shelf &&
 284            (download_shelf->IsShowing() || download_shelf->IsClosing());
 285   }
 286
 287   virtual bool IsTabStripVisible() const OVERRIDE {
 288     return browser_view_->IsTabStripVisible();
 289   }
 290
 291   virtual gfx::Rect GetBoundsForTabStripInBrowserView() const OVERRIDE {
 292     gfx::RectF bounds_f(browser_view_->frame()->GetBoundsForTabStrip(
 293         browser_view_->tabstrip()));
 294     views::View::ConvertRectToTarget(browser_view_->parent(), browser_view_,
 295         &bounds_f);
 296     return gfx::ToEnclosingRect(bounds_f);
 297   }
 298
 299   virtual int GetTopInsetInBrowserView() const OVERRIDE {
 300     return browser_view_->frame()->GetTopInset() -
 301         browser_view_->y();
 302   }
 303
 304   virtual int GetThemeBackgroundXInset() const OVERRIDE {
 305     // TODO(pkotwicz): Return the inset with respect to the left edge of the
 306     // BrowserView.
 307     return browser_view_->frame()->GetThemeBackgroundXInset();
 308   }
 309
 310   virtual bool IsToolbarVisible() const OVERRIDE {
 311     return browser_view_->IsToolbarVisible();
 312   }
 313
 314   virtual bool IsBookmarkBarVisible() const OVERRIDE {
 315     return browser_view_->IsBookmarkBarVisible();
 316   }
 317
 318   virtual FullscreenExitBubbleViews* GetFullscreenExitBubble() const OVERRIDE {
 319     return browser_view_->fullscreen_exit_bubble();
 320   }
 321
 322  private:
 323   BrowserView* browser_view_;
 324
 325   DISALLOW_COPY_AND_ASSIGN(BrowserViewLayoutDelegateImpl);
 326 };
 327
 328 ///////////////////////////////////////////////////////////////////////////////
 329 // BookmarkExtensionBackground, private:
 330 // This object serves as the views::Background object which is used to layout
 331 // and paint the bookmark bar.
 332 class BookmarkExtensionBackground : public views::Background {
 333  public:
 334   BookmarkExtensionBackground(BrowserView* browser_view,
 335                               DetachableToolbarView* host_view,
 336                               Browser* browser);
 337
 338   // View methods overridden from views:Background.
 339   virtual void Paint(gfx::Canvas* canvas, views::View* view) const OVERRIDE;
 340
 341  private:
 342   BrowserView* browser_view_;
 343
 344   // The view hosting this background.
 345   DetachableToolbarView* host_view_;
 346
 347   Browser* browser_;
 348
 349   DISALLOW_COPY_AND_ASSIGN(BookmarkExtensionBackground);
 350 };
 351
 352 BookmarkExtensionBackground::BookmarkExtensionBackground(
 353     BrowserView* browser_view,
 354     DetachableToolbarView* host_view,
 355     Browser* browser)
 356     : browser_view_(browser_view),
 357       host_view_(host_view),
 358       browser_(browser) {
 359 }
 360
 361 void BookmarkExtensionBackground::Paint(gfx::Canvas* canvas,
 362                                         views::View* view) const {
 363   int toolbar_overlap = host_view_->GetToolbarOverlap();
 364   if (!host_view_->IsDetached()) {
 365     PaintAttachedBookmarkBar(canvas, host_view_, browser_view_,
 366                              browser_->host_desktop_type(), toolbar_overlap);
 367     return;
 368   }
 369
 370   // As 'hidden' according to the animation is the full in-tab state, we invert
 371   // the value - when current_state is at '0', we expect the bar to be docked.
 372   double current_state = 1 - host_view_->GetAnimationValue();
 373
 374   ThemeService* ts =
 375       ThemeServiceFactory::GetForProfile(browser_->profile());
 376   if (current_state == 0.0 || current_state == 1.0) {
 377     PaintDetachedBookmarkBar(canvas, host_view_, ts);
 378     return;
 379   }
 380   // While animating, set opacity to cross-fade between attached and detached
 381   // backgrounds including their respective separators.
 382   int detached_alpha = static_cast<uint8>(current_state * 255);
 383   int attached_alpha = 255 - detached_alpha;
 384   if (browser_->bookmark_bar_state() == BookmarkBar::DETACHED) {
 385     // To animate from attached to detached state:
 386     // - fade out attached background
 387     // - fade in detached background.
 388     canvas->SaveLayerAlpha(attached_alpha);
 389     PaintAttachedBookmarkBar(canvas, host_view_, browser_view_,
 390                              browser_->host_desktop_type(),
 391                              toolbar_overlap);
 392     canvas->Restore();
 393     canvas->SaveLayerAlpha(detached_alpha);
 394     PaintDetachedBookmarkBar(canvas, host_view_, ts);
 395   } else {
 396     // To animate from detached to attached state:
 397     // - fade out detached background
 398     // - fade in attached background.
 399     canvas->SaveLayerAlpha(detached_alpha);
 400     PaintDetachedBookmarkBar(canvas, host_view_, ts);
 401     canvas->Restore();
 402     canvas->SaveLayerAlpha(attached_alpha);
 403     PaintAttachedBookmarkBar(canvas, host_view_, browser_view_,
 404                              browser_->host_desktop_type(),
 405                              toolbar_overlap);
 406   }
 407   canvas->Restore();
 408 }
 409
 410 ///////////////////////////////////////////////////////////////////////////////
 411 // BrowserView, public:
 412
 413 BrowserView::BrowserView()
 414     : views::ClientView(NULL, NULL),
 415       last_focused_view_storage_id_(
 416           views::ViewStorage::GetInstance()->CreateStorageID()),
 417       frame_(NULL),
 418       top_container_(NULL),
 419       tabstrip_(NULL),
 420       toolbar_(NULL),
 421       window_switcher_button_(NULL),
 422       find_bar_host_view_(NULL),
 423       infobar_container_(NULL),
 424       contents_web_view_(NULL),
 425       contents_container_(NULL),
 426       devtools_window_(NULL),
 427       initialized_(false),
 428       in_process_fullscreen_(false),
 429 #if defined(OS_WIN)
 430       hung_window_detector_(&hung_plugin_action_),
 431       ticker_(0),
 432 #endif
 433       force_location_bar_focus_(false),
 434       immersive_mode_controller_(chrome::CreateImmersiveModeController()),
 435 #if defined(OS_CHROMEOS)
 436       scroll_end_effect_controller_(ScrollEndEffectController::Create()),
 437 #endif
 438       color_change_listener_(this),
 439       activate_modal_dialog_factory_(this) {
 440 }
 441
 442 BrowserView::~BrowserView() {
 443   // All the tabs should have been destroyed already. If we were closed by the
 444   // OS with some tabs than the NativeBrowserFrame should have destroyed them.
 445   DCHECK_EQ(0, browser_->tab_strip_model()->count());
 446
 447   // Immersive mode may need to reparent views before they are removed/deleted.
 448   immersive_mode_controller_.reset();
 449
 450   browser_->tab_strip_model()->RemoveObserver(this);
 451
 452 #if defined(OS_WIN)
 453   // Stop hung plugin monitoring.
 454   ticker_.Stop();
 455   ticker_.UnregisterTickHandler(&hung_window_detector_);
 456
 457   // Terminate the jumplist (must be called before browser_->profile() is
 458   // destroyed.
 459   if (jumplist_) {
 460     jumplist_->Terminate();
 461   }
 462 #endif
 463
 464   // We destroy the download shelf before |browser_| to remove its child
 465   // download views from the set of download observers (since the observed
 466   // downloads can be destroyed along with |browser_| and the observer
 467   // notifications will call back into deleted objects).
 468   BrowserViewLayout* browser_view_layout = GetBrowserViewLayout();
 469   if (browser_view_layout)
 470     browser_view_layout->set_download_shelf(NULL);
 471   download_shelf_.reset();
 472
 473   // The TabStrip attaches a listener to the model. Make sure we shut down the
 474   // TabStrip first so that it can cleanly remove the listener.
 475   if (tabstrip_) {
 476     tabstrip_->parent()->RemoveChildView(tabstrip_);
 477     if (browser_view_layout)
 478       browser_view_layout->set_tab_strip(NULL);
 479     delete tabstrip_;
 480     tabstrip_ = NULL;
 481   }
 482   // Child views maintain PrefMember attributes that point to
 483   // OffTheRecordProfile's PrefService which gets deleted by ~Browser.
 484   RemoveAllChildViews(true);
 485   toolbar_ = NULL;
 486
 487   // Explicitly set browser_ to NULL.
 488   browser_.reset();
 489 }
 490
 491 void BrowserView::Init(Browser* browser) {
 492   browser_.reset(browser);
 493   browser_->tab_strip_model()->AddObserver(this);
 494 }
 495
 496 // static
 497 BrowserView* BrowserView::GetBrowserViewForNativeWindow(
 498     gfx::NativeWindow window) {
 499   views::Widget* widget = views::Widget::GetWidgetForNativeWindow(window);
 500   return widget ?
 501       reinterpret_cast<BrowserView*>(widget->GetNativeWindowProperty(
 502           kBrowserViewKey)) : NULL;
 503 }
 504
 505 // static
 506 BrowserView* BrowserView::GetBrowserViewForBrowser(const Browser* browser) {
 507   return static_cast<BrowserView*>(browser->window());
 508 }
 509
 510 void BrowserView::InitStatusBubble() {
 511   status_bubble_.reset(new StatusBubbleViews(contents_web_view_));
 512   contents_web_view_->SetStatusBubble(status_bubble_.get());
 513 }
 514
 515 void BrowserView::InitPermissionBubbleView() {
 516   permission_bubble_view_.reset(new PermissionBubbleViewViews(
 517       GetLocationBarView()->GetLocationIconView()));
 518 }
 519
 520 gfx::Rect BrowserView::GetToolbarBounds() const {
 521   gfx::Rect toolbar_bounds(toolbar_->bounds());
 522   if (toolbar_bounds.IsEmpty())
 523     return toolbar_bounds;
 524   // The apparent toolbar edges are outside the "real" toolbar edges.
 525   toolbar_bounds.Inset(-views::NonClientFrameView::kClientEdgeThickness, 0);
 526   return toolbar_bounds;
 527 }
 528
 529 gfx::Rect BrowserView::GetFindBarBoundingBox() const {
 530   return GetBrowserViewLayout()->GetFindBarBoundingBox();
 531 }
 532
 533 int BrowserView::GetTabStripHeight() const {
 534   // We want to return tabstrip_->height(), but we might be called in the midst
 535   // of layout, when that hasn't yet been updated to reflect the current state.
 536   // So return what the tabstrip height _ought_ to be right now.
 537   return IsTabStripVisible() ? tabstrip_->GetPreferredSize().height() : 0;
 538 }
 539
 540 gfx::Point BrowserView::OffsetPointForToolbarBackgroundImage(
 541     const gfx::Point& point) const {
 542   // The background image starts tiling horizontally at the window left edge and
 543   // vertically at the top edge of the horizontal tab strip (or where it would
 544   // be).  We expect our parent's origin to be the window origin.
 545   gfx::Point window_point(point + GetMirroredPosition().OffsetFromOrigin());
 546   window_point.Offset(frame_->GetThemeBackgroundXInset(),
 547                       -frame_->GetTopInset());
 548   return window_point;
 549 }
 550
 551 bool BrowserView::IsTabStripVisible() const {
 552   if (immersive_mode_controller_->ShouldHideTopViews() &&
 553       immersive_mode_controller_->ShouldHideTabIndicators())
 554     return false;
 555   return browser_->SupportsWindowFeature(Browser::FEATURE_TABSTRIP);
 556 }
 557
 558 bool BrowserView::IsOffTheRecord() const {
 559   return browser_->profile()->IsOffTheRecord();
 560 }
 561
 562 bool BrowserView::IsGuestSession() const {
 563   return browser_->profile()->IsGuestSession();
 564 }
 565
 566 bool BrowserView::IsRegularOrGuestSession() const {
 567   return profiles::IsRegularOrGuestSession(browser_.get());
 568 }
 569
 570 int BrowserView::GetOTRIconResourceID() const {
 571   int otr_resource_id = IDR_OTR_ICON;
 572   if (ui::GetDisplayLayout() == ui::LAYOUT_TOUCH) {
 573     if (IsFullscreen())
 574       otr_resource_id = IDR_OTR_ICON_FULLSCREEN;
 575 #if defined(OS_WIN)
 576     if (win8::IsSingleWindowMetroMode())
 577       otr_resource_id = IDR_OTR_ICON_FULLSCREEN;
 578 #endif
 579   }
 580
 581   return otr_resource_id;
 582 }
 583
 584 int BrowserView::GetGuestIconResourceID() const {
 585   return IDR_LOGIN_GUEST;
 586 }
 587
 588 bool BrowserView::ShouldShowAvatar() const {
 589   if (!IsBrowserTypeNormal())
 590     return false;
 591 #if defined(OS_CHROMEOS)
 592   if (IsOffTheRecord() && !IsGuestSession())
 593     return true;
 594
 595   // Note: In case of the M-31 mode the window manager won't exist.
 596   if (chrome::MultiUserWindowManager::GetMultiProfileMode() ==
 597           chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_SEPARATED) {
 598     // This function is called via BrowserNonClientFrameView::UpdateAvatarInfo
 599     // during the creation of the BrowserWindow, so browser->window() will not
 600     // yet be set. In this case we can safely return false.
 601     if (!browser_->window())
 602       return false;
 603
 604     // If the window is shown on a different desktop than the user, it should
 605     // have the avatar icon.
 606     aura::Window* window = browser_->window()->GetNativeWindow();
 607
 608     // Note: When the window manager the window is either on it's owners desktop
 609     // (and shows no icon) or it is now (in which it will show an icon). So we
 610     // can return here.
 611     chrome::MultiUserWindowManager* window_manager =
 612         chrome::MultiUserWindowManager::GetInstance();
 613     return !window_manager->IsWindowOnDesktopOfUser(
 614         window,
 615         window_manager->GetWindowOwner(window));
 616   }
 617 #else
 618   if (IsOffTheRecord())  // Desktop guest is incognito and needs avatar.
 619     return true;
 620 #endif
 621   // Tests may not have a profile manager.
 622   if (!g_browser_process->profile_manager())
 623     return false;
 624   ProfileInfoCache& cache =
 625       g_browser_process->profile_manager()->GetProfileInfoCache();
 626   if (cache.GetIndexOfProfileWithPath(browser_->profile()->GetPath()) ==
 627       std::string::npos) {
 628     return false;
 629   }
 630
 631   return AvatarMenu::ShouldShowAvatarMenu();
 632 }
 633
 634 bool BrowserView::GetAccelerator(int cmd_id, ui::Accelerator* accelerator) {
 635   // We retrieve the accelerator information for standard accelerators
 636   // for cut, copy and paste.
 637   if (chrome::GetStandardAcceleratorForCommandId(cmd_id, accelerator))
 638     return true;
 639   // Else, we retrieve the accelerator information from the accelerator table.
 640   for (std::map<ui::Accelerator, int>::const_iterator it =
 641            accelerator_table_.begin(); it != accelerator_table_.end(); ++it) {
 642     if (it->second == cmd_id) {
 643       *accelerator = it->first;
 644       return true;
 645     }
 646   }
 647   // Else, we retrieve the accelerator information from Ash (if applicable).
 648   return chrome::GetAshAcceleratorForCommandId(
 649       cmd_id, browser_->host_desktop_type(), accelerator);
 650 }
 651
 652 bool BrowserView::IsAcceleratorRegistered(const ui::Accelerator& accelerator) {
 653   return accelerator_table_.find(accelerator) != accelerator_table_.end();
 654 }
 655
 656 WebContents* BrowserView::GetActiveWebContents() const {
 657   return browser_->tab_strip_model()->GetActiveWebContents();
 658 }
 659
 660 gfx::ImageSkia BrowserView::GetOTRAvatarIcon() const {
 661   return *GetThemeProvider()->GetImageSkiaNamed(GetOTRIconResourceID());
 662 }
 663
 664 ///////////////////////////////////////////////////////////////////////////////
 665 // BrowserView, BrowserWindow implementation:
 666
 667 void BrowserView::Show() {
 668   // If the window is already visible, just activate it.
 669   if (frame_->IsVisible()) {
 670     frame_->Activate();
 671     return;
 672   }
 673
 674   // Showing the window doesn't make the browser window active right away.
 675   // This can cause SetFocusToLocationBar() to skip setting focus to the
 676   // location bar. To avoid this we explicilty let SetFocusToLocationBar()
 677   // know that it's ok to steal focus.
 678   force_location_bar_focus_ = true;
 679
 680   // Setting the focus doesn't work when the window is invisible, so any focus
 681   // initialization that happened before this will be lost.
 682   //
 683   // We really "should" restore the focus whenever the window becomes unhidden,
 684   // but I think initializing is the only time where this can happen where
 685   // there is some focus change we need to pick up, and this is easier than
 686   // plumbing through an un-hide message all the way from the frame.
 687   //
 688   // If we do find there are cases where we need to restore the focus on show,
 689   // that should be added and this should be removed.
 690   RestoreFocus();
 691
 692   frame_->Show();
 693
 694   force_location_bar_focus_ = false;
 695
 696   browser()->OnWindowDidShow();
 697
 698   chrome::MaybeShowInvertBubbleView(browser_.get(), contents_container_);
 699 }
 700
 701 void BrowserView::ShowInactive() {
 702   if (frame_->IsVisible())
 703     return;
 704   frame_->ShowInactive();
 705 }
 706
 707 void BrowserView::Hide() {
 708   // Not implemented.
 709 }
 710
 711 void BrowserView::SetBounds(const gfx::Rect& bounds) {
 712   ExitFullscreen();
 713   GetWidget()->SetBounds(bounds);
 714 }
 715
 716 void BrowserView::Close() {
 717   frame_->Close();
 718 }
 719
 720 void BrowserView::Activate() {
 721   frame_->Activate();
 722 }
 723
 724 void BrowserView::Deactivate() {
 725   frame_->Deactivate();
 726 }
 727
 728 bool BrowserView::IsActive() const {
 729   return frame_->IsActive();
 730 }
 731
 732 void BrowserView::FlashFrame(bool flash) {
 733   frame_->FlashFrame(flash);
 734 }
 735
 736 bool BrowserView::IsAlwaysOnTop() const {
 737   return false;
 738 }
 739
 740 void BrowserView::SetAlwaysOnTop(bool always_on_top) {
 741   // Not implemented for browser windows.
 742   NOTIMPLEMENTED();
 743 }
 744
 745 gfx::NativeWindow BrowserView::GetNativeWindow() {
 746   // While the browser destruction is going on, the widget can already be gone,
 747   // but utility functions like FindBrowserWithWindow will come here and crash.
 748   // We short circuit therefore.
 749   if (!GetWidget())
 750     return NULL;
 751   return GetWidget()->GetTopLevelWidget()->GetNativeWindow();
 752 }
 753
 754 BrowserWindowTesting* BrowserView::GetBrowserWindowTesting() {
 755   return this;
 756 }
 757
 758 StatusBubble* BrowserView::GetStatusBubble() {
 759   return status_bubble_.get();
 760 }
 761
 762 namespace {
 763   // Only used by ToolbarSizeChanged() below, but placed here because template
 764   // arguments (to base::AutoReset<>) must have external linkage.
 765   enum CallState { NORMAL, REENTRANT, REENTRANT_FORCE_FAST_RESIZE };
 766 }
 767
 768 void BrowserView::UpdateTitleBar() {
 769   frame_->UpdateWindowTitle();
 770   if (ShouldShowWindowIcon() && !loading_animation_timer_.IsRunning())
 771     frame_->UpdateWindowIcon();
 772 }
 773
 774 void BrowserView::BookmarkBarStateChanged(
 775     BookmarkBar::AnimateChangeType change_type) {
 776   if (bookmark_bar_view_.get()) {
 777     BookmarkBar::State new_state = browser_->bookmark_bar_state();
 778
 779     // We don't properly support animating the bookmark bar to and from the
 780     // detached state in immersive fullscreen.
 781     bool detached_changed = (new_state == BookmarkBar::DETACHED) ||
 782         bookmark_bar_view_->IsDetached();
 783     if (detached_changed && immersive_mode_controller_->IsEnabled())
 784       change_type = BookmarkBar::DONT_ANIMATE_STATE_CHANGE;
 785
 786     bookmark_bar_view_->SetBookmarkBarState(new_state, change_type);
 787   }
 788   if (MaybeShowBookmarkBar(GetActiveWebContents()))
 789     Layout();
 790 }
 791
 792 void BrowserView::UpdateDevTools() {
 793   UpdateDevToolsForContents(GetActiveWebContents(), true);
 794   Layout();
 795 }
 796
 797 void BrowserView::UpdateLoadingAnimations(bool should_animate) {
 798   if (should_animate) {
 799     if (!loading_animation_timer_.IsRunning()) {
 800       // Loads are happening, and the timer isn't running, so start it.
 801       last_animation_time_ = base::TimeTicks::Now();
 802       loading_animation_timer_.Start(FROM_HERE,
 803           TimeDelta::FromMilliseconds(kLoadingAnimationFrameTimeMs), this,
 804           &BrowserView::LoadingAnimationCallback);
 805     }
 806   } else {
 807     if (loading_animation_timer_.IsRunning()) {
 808       last_animation_time_ = base::TimeTicks();
 809       loading_animation_timer_.Stop();
 810       // Loads are now complete, update the state if a task was scheduled.
 811       LoadingAnimationCallback();
 812     }
 813   }
 814 }
 815
 816 void BrowserView::SetStarredState(bool is_starred) {
 817   GetLocationBarView()->SetStarToggled(is_starred);
 818 }
 819
 820 void BrowserView::SetTranslateIconToggled(bool is_lit) {
 821   GetLocationBarView()->SetTranslateIconToggled(is_lit);
 822 }
 823
 824 void BrowserView::OnActiveTabChanged(content::WebContents* old_contents,
 825                                      content::WebContents* new_contents,
 826                                      int index,
 827                                      int reason) {
 828   DCHECK(new_contents);
 829
 830   // If |contents_container_| already has the correct WebContents, we can save
 831   // some work.  This also prevents extra events from being reported by the
 832   // Visibility API under Windows, as ChangeWebContents will briefly hide
 833   // the WebContents window.
 834   bool change_tab_contents =
 835       contents_web_view_->web_contents() != new_contents;
 836
 837   // Update various elements that are interested in knowing the current
 838   // WebContents.
 839
 840   // When we toggle the NTP floating bookmarks bar and/or the info bar,
 841   // we don't want any WebContents to be attached, so that we
 842   // avoid an unnecessary resize and re-layout of a WebContents.
 843   if (change_tab_contents) {
 844     contents_web_view_->SetWebContents(NULL);
 845     devtools_web_view_->SetWebContents(NULL);
 846   }
 847   infobar_container_->ChangeInfoBarService(
 848       InfoBarService::FromWebContents(new_contents));
 849
 850   if (old_contents && PermissionBubbleManager::FromWebContents(old_contents))
 851     PermissionBubbleManager::FromWebContents(old_contents)->SetView(NULL);
 852
 853   if (new_contents && PermissionBubbleManager::FromWebContents(new_contents)) {
 854     PermissionBubbleManager::FromWebContents(new_contents)->SetView(
 855         permission_bubble_view_.get());
 856   }
 857
 858   if (bookmark_bar_view_.get()) {
 859     bookmark_bar_view_->SetBookmarkBarState(
 860         browser_->bookmark_bar_state(),
 861         BookmarkBar::DONT_ANIMATE_STATE_CHANGE);
 862   }
 863   UpdateUIForContents(new_contents);
 864
 865   // Layout for DevTools _before_ setting the both main and devtools WebContents
 866   // to avoid toggling the size of any of them.
 867   UpdateDevToolsForContents(new_contents, !change_tab_contents);
 868
 869   if (change_tab_contents) {
 870     contents_web_view_->SetWebContents(new_contents);
 871     // The second layout update should be no-op. It will just set the
 872     // DevTools WebContents.
 873     UpdateDevToolsForContents(new_contents, true);
 874   }
 875
 876   if (!browser_->tab_strip_model()->closing_all() && GetWidget()->IsActive() &&
 877       GetWidget()->IsVisible()) {
 878     // We only restore focus if our window is visible, to avoid invoking blur
 879     // handlers when we are eventually shown.
 880     new_contents->GetView()->RestoreFocus();
 881   }
 882
 883   // Update all the UI bits.
 884   UpdateTitleBar();
 885 }
 886
 887 void BrowserView::ZoomChangedForActiveTab(bool can_show_bubble) {
 888   GetLocationBarView()->ZoomChangedForActiveTab(
 889       can_show_bubble && !toolbar_->IsWrenchMenuShowing());
 890 }
 891
 892 gfx::Rect BrowserView::GetRestoredBounds() const {
 893   return frame_->GetRestoredBounds();
 894 }
 895
 896 ui::WindowShowState BrowserView::GetRestoredState() const {
 897   if (IsMaximized())
 898     return ui::SHOW_STATE_MAXIMIZED;
 899   if (IsMinimized())
 900     return ui::SHOW_STATE_MINIMIZED;
 901   return ui::SHOW_STATE_NORMAL;
 902 }
 903
 904 gfx::Rect BrowserView::GetBounds() const {
 905   return frame_->GetWindowBoundsInScreen();
 906 }
 907
 908 bool BrowserView::IsMaximized() const {
 909   return frame_->IsMaximized();
 910 }
 911
 912 bool BrowserView::IsMinimized() const {
 913   return frame_->IsMinimized();
 914 }
 915
 916 void BrowserView::Maximize() {
 917   frame_->Maximize();
 918 }
 919
 920 void BrowserView::Minimize() {
 921   frame_->Minimize();
 922 }
 923
 924 void BrowserView::Restore() {
 925   frame_->Restore();
 926 }
 927
 928 void BrowserView::EnterFullscreen(
 929     const GURL& url, FullscreenExitBubbleType bubble_type) {
 930   if (IsFullscreen())
 931     return;  // Nothing to do.
 932
 933   ProcessFullscreen(true, FOR_DESKTOP, url, bubble_type);
 934 }
 935
 936 void BrowserView::ExitFullscreen() {
 937   if (!IsFullscreen())
 938     return;  // Nothing to do.
 939
 940   ProcessFullscreen(false, FOR_DESKTOP, GURL(), FEB_TYPE_NONE);
 941 }
 942
 943 void BrowserView::UpdateFullscreenExitBubbleContent(
 944     const GURL& url,
 945     FullscreenExitBubbleType bubble_type) {
 946   // Immersive mode has no exit bubble because it has a visible strip at the
 947   // top that gives the user a hover target.
 948   // TODO(jamescook): Figure out what to do with mouse-lock.
 949   if (bubble_type == FEB_TYPE_NONE || ShouldUseImmersiveFullscreenForUrl(url)) {
 950     fullscreen_bubble_.reset();
 951   } else if (fullscreen_bubble_.get()) {
 952     fullscreen_bubble_->UpdateContent(url, bubble_type);
 953   } else {
 954     fullscreen_bubble_.reset(new FullscreenExitBubbleViews(
 955         this, url, bubble_type));
 956   }
 957 }
 958
 959 bool BrowserView::ShouldHideUIForFullscreen() const {
 960 #if defined(USE_ASH)
 961   // Immersive mode needs UI for the slide-down top panel.
 962   return IsFullscreen() && !immersive_mode_controller_->IsEnabled();
 963 #endif
 964   return IsFullscreen();
 965 }
 966
 967 bool BrowserView::IsFullscreen() const {
 968   return frame_->IsFullscreen();
 969 }
 970
 971 bool BrowserView::IsFullscreenBubbleVisible() const {
 972   return fullscreen_bubble_ != NULL;
 973 }
 974
 975 #if defined(OS_WIN)
 976 void BrowserView::SetMetroSnapMode(bool enable) {
 977   HISTOGRAM_COUNTS("Metro.SnapModeToggle", enable);
 978   ProcessFullscreen(enable, FOR_METRO, GURL(), FEB_TYPE_NONE);
 979 }
 980
 981 bool BrowserView::IsInMetroSnapMode() const {
 982   return false;
 983 }
 984 #endif  // defined(OS_WIN)
 985
 986 void BrowserView::RestoreFocus() {
 987   WebContents* selected_web_contents = GetActiveWebContents();
 988   if (selected_web_contents)
 989     selected_web_contents->GetView()->RestoreFocus();
 990 }
 991
 992 void BrowserView::SetWindowSwitcherButton(views::Button* button) {
 993   if (window_switcher_button_)
 994     RemoveChildView(window_switcher_button_);
 995   window_switcher_button_ = button;
 996 }
 997
 998 void BrowserView::FullscreenStateChanged() {
 999   CHECK(!IsFullscreen());
1000   ProcessFullscreen(false, FOR_DESKTOP, GURL(), FEB_TYPE_NONE);
1001 }
1002
1003 void BrowserView::ToolbarSizeChanged(bool is_animating) {
1004   // The call to InfoBarContainer::SetMaxTopArrowHeight() below can result in
1005   // reentrancy; |call_state| tracks whether we're reentrant.  We can't just
1006   // early-return in this case because we need to layout again so the infobar
1007   // container's bounds are set correctly.
1008   static CallState call_state = NORMAL;
1009
1010   // A reentrant call can (and should) use the fast resize path unless both it
1011   // and the normal call are both non-animating.
1012   bool use_fast_resize =
1013       is_animating || (call_state == REENTRANT_FORCE_FAST_RESIZE);
1014   if (use_fast_resize)
1015     contents_web_view_->SetFastResize(true);
1016   UpdateUIForContents(GetActiveWebContents());
1017   if (use_fast_resize)
1018     contents_web_view_->SetFastResize(false);
1019
1020   // Inform the InfoBarContainer that the distance to the location icon may have
1021   // changed.  We have to do this after the block above so that the toolbars are
1022   // laid out correctly for calculating the maximum arrow height below.
1023   {
1024     base::AutoReset<CallState> resetter(&call_state,
1025         is_animating ? REENTRANT_FORCE_FAST_RESIZE : REENTRANT);
1026     infobar_container_->SetMaxTopArrowHeight(GetMaxTopInfoBarArrowHeight());
1027   }
1028
1029   // When transitioning from animating to not animating we need to make sure the
1030   // contents_container_ gets layed out. If we don't do this and the bounds
1031   // haven't changed contents_container_ won't get a Layout out and we'll end up
1032   // with a gray rect because the clip wasn't updated.  Note that a reentrant
1033   // call never needs to do this, because after it returns, the normal call
1034   // wrapping it will do it.
1035   if ((call_state == NORMAL) && !is_animating) {
1036     contents_web_view_->InvalidateLayout();
1037     contents_container_->Layout();
1038   }
1039 }
1040
1041 LocationBar* BrowserView::GetLocationBar() const {
1042   return GetLocationBarView();
1043 }
1044
1045 void BrowserView::SetFocusToLocationBar(bool select_all) {
1046   // On Windows, changing focus to the location bar causes the browser
1047   // window to become active. This can steal focus if the user has
1048   // another window open already. On ChromeOS, changing focus makes a
1049   // view believe it has a focus even if the widget doens't have a
1050   // focus. Either cases, we need to ignore this when the browser
1051   // window isn't active.
1052   if (!force_location_bar_focus_ && !IsActive())
1053     return;
1054
1055   // Temporarily reveal the top-of-window views (if not already revealed) so
1056   // that the location bar view is visible and is considered focusable. If the
1057   // location bar view gains focus, |immersive_mode_controller_| will keep the
1058   // top-of-window views revealed.
1059   scoped_ptr<ImmersiveRevealedLock> focus_reveal_lock(
1060       immersive_mode_controller_->GetRevealedLock(
1061           ImmersiveModeController::ANIMATE_REVEAL_YES));
1062
1063   LocationBarView* location_bar = GetLocationBarView();
1064   if (location_bar->omnibox_view()->IsFocusable()) {
1065     // Location bar got focus.
1066     //
1067     // select_all is true when it's expected that the user may want to copy
1068     // the URL to the clipboard. If the URL is not being shown because the
1069     // origin chip is enabled, show it now to support the same functionality.
1070     if (select_all &&
1071         location_bar->GetToolbarModel()->WouldOmitURLDueToOriginChip())
1072       location_bar->omnibox_view()->ShowURL();
1073     else
1074       location_bar->FocusLocation(select_all);
1075   } else {
1076     // If none of location bar got focus, then clear focus.
1077     views::FocusManager* focus_manager = GetFocusManager();
1078     DCHECK(focus_manager);
1079     focus_manager->ClearFocus();
1080   }
1081 }
1082
1083 void BrowserView::UpdateReloadStopState(bool is_loading, bool force) {
1084   toolbar_->reload_button()->ChangeMode(
1085       is_loading ? ReloadButton::MODE_STOP : ReloadButton::MODE_RELOAD, force);
1086 }
1087
1088 void BrowserView::UpdateToolbar(content::WebContents* contents) {
1089   // We may end up here during destruction.
1090   if (toolbar_)
1091     toolbar_->Update(contents);
1092 }
1093
1094 void BrowserView::FocusToolbar() {
1095   // Temporarily reveal the top-of-window views (if not already revealed) so
1096   // that the toolbar is visible and is considered focusable. If the
1097   // toolbar gains focus, |immersive_mode_controller_| will keep the
1098   // top-of-window views revealed.
1099   scoped_ptr<ImmersiveRevealedLock> focus_reveal_lock(
1100       immersive_mode_controller_->GetRevealedLock(
1101           ImmersiveModeController::ANIMATE_REVEAL_YES));
1102
1103   // Start the traversal within the main toolbar. SetPaneFocus stores
1104   // the current focused view before changing focus.
1105   toolbar_->SetPaneFocus(NULL);
1106 }
1107
1108 void BrowserView::FocusBookmarksToolbar() {
1109   DCHECK(!immersive_mode_controller_->IsEnabled());
1110   if (bookmark_bar_view_.get() &&
1111       bookmark_bar_view_->visible() &&
1112       bookmark_bar_view_->GetPreferredSize().height() != 0) {
1113     bookmark_bar_view_->SetPaneFocusAndFocusDefault();
1114   }
1115 }
1116
1117 void BrowserView::FocusInfobars() {
1118   if (infobar_container_->child_count() > 0)
1119     infobar_container_->SetPaneFocusAndFocusDefault();
1120 }
1121
1122 void BrowserView::FocusAppMenu() {
1123   // Chrome doesn't have a traditional menu bar, but it has a menu button in the
1124   // main toolbar that plays the same role.  If the user presses a key that
1125   // would typically focus the menu bar, tell the toolbar to focus the menu
1126   // button.  If the user presses the key again, return focus to the previous
1127   // location.
1128   //
1129   // Not used on the Mac, which has a normal menu bar.
1130   if (toolbar_->IsAppMenuFocused()) {
1131     RestoreFocus();
1132   } else {
1133     DCHECK(!immersive_mode_controller_->IsEnabled());
1134     toolbar_->SetPaneFocusAndFocusAppMenu();
1135   }
1136 }
1137
1138 void BrowserView::RotatePaneFocus(bool forwards) {
1139   GetWidget()->GetFocusManager()->RotatePaneFocus(
1140       forwards ?
1141           views::FocusManager::kForward : views::FocusManager::kBackward,
1142       views::FocusManager::kWrap);
1143 }
1144
1145 void BrowserView::DestroyBrowser() {
1146   // After this returns other parts of Chrome are going to be shutdown. Close
1147   // the window now so that we are deleted immediately and aren't left holding
1148   // references to deleted objects.
1149   GetWidget()->RemoveObserver(this);
1150   GetLocationBar()->GetOmniboxView()->model()->popup_model()->RemoveObserver(
1151       this);
1152   frame_->CloseNow();
1153 }
1154
1155 bool BrowserView::IsBookmarkBarVisible() const {
1156   if (!browser_->SupportsWindowFeature(Browser::FEATURE_BOOKMARKBAR))
1157     return false;
1158   if (!bookmark_bar_view_.get())
1159     return false;
1160   if (bookmark_bar_view_->GetPreferredSize().height() == 0)
1161     return false;
1162   // New tab page needs visible bookmarks even when top-views are hidden.
1163   if (immersive_mode_controller_->ShouldHideTopViews() &&
1164       !bookmark_bar_view_->IsDetached())
1165     return false;
1166   return true;
1167 }
1168
1169 bool BrowserView::IsBookmarkBarAnimating() const {
1170   return bookmark_bar_view_.get() && bookmark_bar_view_->is_animating();
1171 }
1172
1173 bool BrowserView::IsTabStripEditable() const {
1174   return tabstrip_->IsTabStripEditable();
1175 }
1176
1177 bool BrowserView::IsToolbarVisible() const {
1178   if (immersive_mode_controller_->ShouldHideTopViews())
1179     return false;
1180   return browser_->SupportsWindowFeature(Browser::FEATURE_TOOLBAR) ||
1181          browser_->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR);
1182 }
1183
1184 gfx::Rect BrowserView::GetRootWindowResizerRect() const {
1185   // Views does not support resizer rects because they caused page cycler
1186   // performance regressions when they were added. See crrev.com/9654
1187   return gfx::Rect();
1188 }
1189
1190 void BrowserView::ConfirmAddSearchProvider(TemplateURL* template_url,
1191                                            Profile* profile) {
1192   chrome::EditSearchEngine(GetWidget()->GetNativeWindow(), template_url, NULL,
1193                            profile);
1194 }
1195
1196 void BrowserView::ShowUpdateChromeDialog() {
1197   UpdateRecommendedMessageBox::Show(GetWidget()->GetNativeWindow());
1198 }
1199
1200 void BrowserView::ShowBookmarkBubble(const GURL& url, bool already_bookmarked) {
1201   scoped_ptr<BookmarkBubbleDelegate> delegate;
1202   delegate.reset(new BookmarkBubbleSignInDelegate(browser_.get()));
1203
1204   BookmarkBubbleView::ShowBubble(GetToolbarView()->GetBookmarkBubbleAnchor(),
1205                                  bookmark_bar_view_.get(),
1206                                  delegate.Pass(),
1207                                  browser_->profile(),
1208                                  url,
1209                                  !already_bookmarked);
1210 }
1211
1212 void BrowserView::ShowBookmarkAppBubble(
1213     const WebApplicationInfo& web_app_info,
1214     const std::string& extension_id) {
1215   BookmarkAppBubbleView::ShowBubble(GetToolbarView(),
1216                                     browser_->profile(),
1217                                     web_app_info,
1218                                     extension_id);
1219 }
1220
1221 void BrowserView::ShowBookmarkPrompt() {
1222   GetLocationBarView()->ShowBookmarkPrompt();
1223 }
1224
1225 void BrowserView::ShowTranslateBubble(content::WebContents* web_contents,
1226                                       TranslateTabHelper::TranslateStep step,
1227                                       TranslateErrors::Type error_type) {
1228   TranslateTabHelper* translate_tab_helper =
1229       TranslateTabHelper::FromWebContents(web_contents);
1230   LanguageState& language_state = translate_tab_helper->GetLanguageState();
1231   language_state.SetTranslateEnabled(true);
1232
1233   TranslateBubbleView::ShowBubble(
1234       GetToolbarView()->GetTranslateBubbleAnchor(), web_contents, step,
1235       error_type);
1236 }
1237
1238 #if defined(ENABLE_ONE_CLICK_SIGNIN)
1239 void BrowserView::ShowOneClickSigninBubble(
1240     OneClickSigninBubbleType type,
1241     const base::string16& email,
1242     const base::string16& error_message,
1243     const StartSyncCallback& start_sync_callback) {
1244   scoped_ptr<OneClickSigninBubbleDelegate> delegate;
1245   delegate.reset(new OneClickSigninBubbleLinksDelegate(browser()));
1246
1247   views::View* anchor_view;
1248   if (type == BrowserWindow::ONE_CLICK_SIGNIN_BUBBLE_TYPE_BUBBLE)
1249     anchor_view = toolbar_->app_menu();
1250   else
1251     anchor_view = toolbar_->location_bar();
1252
1253   OneClickSigninBubbleView::ShowBubble(type, email, error_message,
1254                                        delegate.Pass(), anchor_view,
1255                                        start_sync_callback);
1256 }
1257 #endif
1258
1259 void BrowserView::SetDownloadShelfVisible(bool visible) {
1260   // This can be called from the superclass destructor, when it destroys our
1261   // child views. At that point, browser_ is already gone.
1262   if (browser_ == NULL)
1263     return;
1264
1265   if (visible && IsDownloadShelfVisible() != visible) {
1266     // Invoke GetDownloadShelf to force the shelf to be created.
1267     GetDownloadShelf();
1268   }
1269
1270   if (browser_ != NULL)
1271     browser_->UpdateDownloadShelfVisibility(visible);
1272
1273   // SetDownloadShelfVisible can force-close the shelf, so make sure we lay out
1274   // everything correctly, as if the animation had finished. This doesn't
1275   // matter for showing the shelf, as the show animation will do it.
1276   ToolbarSizeChanged(false);
1277 }
1278
1279 bool BrowserView::IsDownloadShelfVisible() const {
1280   return download_shelf_.get() && download_shelf_->IsShowing();
1281 }
1282
1283 DownloadShelf* BrowserView::GetDownloadShelf() {
1284   if (!download_shelf_.get()) {
1285     download_shelf_.reset(new DownloadShelfView(browser_.get(), this));
1286     download_shelf_->set_owned_by_client();
1287     GetBrowserViewLayout()->set_download_shelf(download_shelf_.get());
1288   }
1289   return download_shelf_.get();
1290 }
1291
1292 void BrowserView::ConfirmBrowserCloseWithPendingDownloads(
1293     int download_count,
1294     Browser::DownloadClosePreventionType dialog_type,
1295     bool app_modal,
1296     const base::Callback<void(bool)>& callback) {
1297   DownloadInProgressDialogView::Show(
1298       GetNativeWindow(), download_count, dialog_type, app_modal, callback);
1299 }
1300
1301 void BrowserView::UserChangedTheme() {
1302   frame_->FrameTypeChanged();
1303 }
1304
1305 int BrowserView::GetExtraRenderViewHeight() const {
1306   // Currently this is only used on linux.
1307   return 0;
1308 }
1309
1310 void BrowserView::WebContentsFocused(WebContents* contents) {
1311   if (contents_web_view_->GetWebContents() == contents)
1312     contents_web_view_->OnWebContentsFocused(contents);
1313   else
1314     devtools_web_view_->OnWebContentsFocused(contents);
1315 }
1316
1317 void BrowserView::ShowWebsiteSettings(Profile* profile,
1318                                       content::WebContents* web_contents,
1319                                       const GURL& url,
1320                                       const content::SSLStatus& ssl) {
1321   WebsiteSettingsPopupView::ShowPopup(
1322       GetLocationBarView()->GetLocationIconView(), profile,
1323       web_contents, url, ssl, browser_.get());
1324 }
1325
1326 void BrowserView::ShowAppMenu() {
1327   // Keep the top-of-window views revealed as long as the app menu is visible.
1328   scoped_ptr<ImmersiveRevealedLock> revealed_lock(
1329       immersive_mode_controller_->GetRevealedLock(
1330           ImmersiveModeController::ANIMATE_REVEAL_NO));
1331
1332   toolbar_->app_menu()->Activate();
1333 }
1334
1335 bool BrowserView::PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event,
1336                                          bool* is_keyboard_shortcut) {
1337   *is_keyboard_shortcut = false;
1338
1339   if ((event.type != blink::WebInputEvent::RawKeyDown) &&
1340       (event.type != blink::WebInputEvent::KeyUp)) {
1341     return false;
1342   }
1343
1344   views::FocusManager* focus_manager = GetFocusManager();
1345   DCHECK(focus_manager);
1346
1347   if (focus_manager->shortcut_handling_suspended())
1348     return false;
1349
1350   ui::Accelerator accelerator(
1351       static_cast<ui::KeyboardCode>(event.windowsKeyCode),
1352       content::GetModifiersFromNativeWebKeyboardEvent(event));
1353   if (event.type == blink::WebInputEvent::KeyUp)
1354     accelerator.set_type(ui::ET_KEY_RELEASED);
1355
1356   // What we have to do here is as follows:
1357   // - If the |browser_| is for an app, do nothing.
1358   // - If the |browser_| is not for an app, and the |accelerator| is not
1359   //   associated with the browser (e.g. an Ash shortcut), process it.
1360   // - If the |browser_| is not for an app, and the |accelerator| is associated
1361   //   with the browser, and it is a reserved one (e.g. Ctrl+w), process it.
1362   // - If the |browser_| is not for an app, and the |accelerator| is associated
1363   //   with the browser, and it is not a reserved one, do nothing.
1364
1365   if (browser_->is_app()) {
1366     // Let all keys fall through to a v1 app's web content, even accelerators.
1367     // We don't have to flip |is_keyboard_shortcut| here. If we do that, the app
1368     // might not be able to see a subsequent Char event. See OnHandleInputEvent
1369     // in content/renderer/render_widget.cc for details.
1370     return false;
1371   }
1372
1373   chrome::BrowserCommandController* controller = browser_->command_controller();
1374
1375   // Here we need to retrieve the command id (if any) associated to the
1376   // keyboard event. Instead of looking up the command id in the
1377   // |accelerator_table_| by ourselves, we block the command execution of
1378   // the |browser_| object then send the keyboard event to the
1379   // |focus_manager| as if we are activating an accelerator key.
1380   // Then we can retrieve the command id from the |browser_| object.
1381   bool original_block_command_state = controller->block_command_execution();
1382   controller->SetBlockCommandExecution(true);
1383   // If the |accelerator| is a non-browser shortcut (e.g. Ash shortcut), the
1384   // command execution cannot be blocked and true is returned. However, it is
1385   // okay as long as is_app() is false. See comments in this function.
1386   const bool processed = focus_manager->ProcessAccelerator(accelerator);
1387   const int id = controller->GetLastBlockedCommand(NULL);
1388   controller->SetBlockCommandExecution(original_block_command_state);
1389
1390   // Executing the command may cause |this| object to be destroyed.
1391   if (controller->IsReservedCommandOrKey(id, event)) {
1392     UpdateAcceleratorMetrics(accelerator, id);
1393     return chrome::ExecuteCommand(browser_.get(), id);
1394   }
1395
1396   if (id != -1) {
1397     // |accelerator| is a non-reserved browser shortcut (e.g. Ctrl+f).
1398     if (event.type == blink::WebInputEvent::RawKeyDown)
1399       *is_keyboard_shortcut = true;
1400   } else if (processed) {
1401     // |accelerator| is a non-browser shortcut (e.g. F4-F10 on Ash). Report
1402     // that we handled it.
1403     return true;
1404   }
1405
1406   return false;
1407 }
1408
1409 void BrowserView::HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {
1410   unhandled_keyboard_event_handler_.HandleKeyboardEvent(event,
1411                                                         GetFocusManager());
1412 }
1413
1414 // TODO(devint): http://b/issue?id=1117225 Cut, Copy, and Paste are always
1415 // enabled in the page menu regardless of whether the command will do
1416 // anything. When someone selects the menu item, we just act as if they hit
1417 // the keyboard shortcut for the command by sending the associated key press
1418 // to windows. The real fix to this bug is to disable the commands when they
1419 // won't do anything. We'll need something like an overall clipboard command
1420 // manager to do that.
1421 void BrowserView::Cut() {
1422   // If a WebContent is focused, call RenderWidgetHost::Cut. Otherwise, e.g. if
1423   // Omnibox is focused, send a Ctrl+x key event to Chrome. Using RWH interface
1424   // rather than the fake key event for a WebContent is important since the fake
1425   // event might be consumed by the web content (crbug.com/137908).
1426   DoCutCopyPaste(&content::RenderWidgetHost::Cut, IDS_APP_CUT);
1427 }
1428
1429 void BrowserView::Copy() {
1430   DoCutCopyPaste(&content::RenderWidgetHost::Copy, IDS_APP_COPY);
1431 }
1432
1433 void BrowserView::Paste() {
1434   DoCutCopyPaste(&content::RenderWidgetHost::Paste, IDS_APP_PASTE);
1435 }
1436
1437 WindowOpenDisposition BrowserView::GetDispositionForPopupBounds(
1438     const gfx::Rect& bounds) {
1439 #if defined(OS_WIN)
1440   // If we are in Win8's single window Metro mode, we can't allow popup windows.
1441   return win8::IsSingleWindowMetroMode() ? NEW_BACKGROUND_TAB : NEW_POPUP;
1442 #else
1443   return NEW_POPUP;
1444 #endif
1445 }
1446
1447 FindBar* BrowserView::CreateFindBar() {
1448   return chrome::CreateFindBar(this);
1449 }
1450
1451 WebContentsModalDialogHost* BrowserView::GetWebContentsModalDialogHost() {
1452   return GetBrowserViewLayout()->GetWebContentsModalDialogHost();
1453 }
1454
1455 ///////////////////////////////////////////////////////////////////////////////
1456 // BrowserView, BrowserWindowTesting implementation:
1457
1458 BookmarkBarView* BrowserView::GetBookmarkBarView() const {
1459   return bookmark_bar_view_.get();
1460 }
1461
1462 LocationBarView* BrowserView::GetLocationBarView() const {
1463   return toolbar_ ? toolbar_->location_bar() : NULL;
1464 }
1465
1466 views::View* BrowserView::GetTabContentsContainerView() const {
1467   return contents_web_view_;
1468 }
1469
1470 ToolbarView* BrowserView::GetToolbarView() const {
1471   return toolbar_;
1472 }
1473
1474 ///////////////////////////////////////////////////////////////////////////////
1475 // BrowserView, TabStripModelObserver implementation:
1476
1477 void BrowserView::TabDetachedAt(WebContents* contents, int index) {
1478   if (PermissionBubbleManager::FromWebContents(contents))
1479     PermissionBubbleManager::FromWebContents(contents)->SetView(NULL);
1480
1481   // We use index here rather than comparing |contents| because by this time
1482   // the model has already removed |contents| from its list, so
1483   // browser_->GetActiveWebContents() will return NULL or something else.
1484   if (index == browser_->tab_strip_model()->active_index()) {
1485     // We need to reset the current tab contents to NULL before it gets
1486     // freed. This is because the focus manager performs some operations
1487     // on the selected WebContents when it is removed.
1488     contents_web_view_->SetWebContents(NULL);
1489     infobar_container_->ChangeInfoBarService(NULL);
1490     UpdateDevToolsForContents(NULL, true);
1491   }
1492 }
1493
1494 void BrowserView::TabDeactivated(WebContents* contents) {
1495   if (PermissionBubbleManager::FromWebContents(contents))
1496     PermissionBubbleManager::FromWebContents(contents)->SetView(NULL);
1497
1498   // We do not store the focus when closing the tab to work-around bug 4633.
1499   // Some reports seem to show that the focus manager and/or focused view can
1500   // be garbage at that point, it is not clear why.
1501   if (!contents->IsBeingDestroyed())
1502     contents->GetView()->StoreFocus();
1503 }
1504
1505 void BrowserView::TabStripEmpty() {
1506   // Make sure all optional UI is removed before we are destroyed, otherwise
1507   // there will be consequences (since our view hierarchy will still have
1508   // references to freed views).
1509   UpdateUIForContents(NULL);
1510 }
1511
1512 ///////////////////////////////////////////////////////////////////////////////
1513 // BrowserView, ui::AcceleratorProvider implementation:
1514
1515 bool BrowserView::GetAcceleratorForCommandId(int command_id,
1516                                              ui::Accelerator* accelerator) {
1517   // Let's let the ToolbarView own the canonical implementation of this method.
1518   return toolbar_->GetAcceleratorForCommandId(command_id, accelerator);
1519 }
1520
1521 ///////////////////////////////////////////////////////////////////////////////
1522 // BrowserView, views::WidgetDelegate implementation:
1523
1524 bool BrowserView::CanResize() const {
1525   return true;
1526 }
1527
1528 bool BrowserView::CanMaximize() const {
1529   return true;
1530 }
1531
1532 bool BrowserView::CanActivate() const {
1533   if (!AppModalDialogQueue::GetInstance()->active_dialog() ||
1534       !AppModalDialogQueue::GetInstance()->active_dialog()->native_dialog())
1535     return true;
1536
1537 #if defined(USE_AURA) && defined(OS_CHROMEOS)
1538   // On Aura window manager controls all windows so settings focus via PostTask
1539   // will make only worse because posted task will keep trying to steal focus.
1540   AppModalDialogQueue::GetInstance()->ActivateModalDialog();
1541 #else
1542   // If another browser is app modal, flash and activate the modal browser. This
1543   // has to be done in a post task, otherwise if the user clicked on a window
1544   // that doesn't have the modal dialog the windows keep trying to get the focus
1545   // from each other on Windows. http://crbug.com/141650.
1546   base::MessageLoop::current()->PostTask(
1547       FROM_HERE,
1548       base::Bind(&BrowserView::ActivateAppModalDialog,
1549                  activate_modal_dialog_factory_.GetWeakPtr()));
1550 #endif
1551   return false;
1552 }
1553
1554 base::string16 BrowserView::GetWindowTitle() const {
1555   return browser_->GetWindowTitleForCurrentTab();
1556 }
1557
1558 base::string16 BrowserView::GetAccessibleWindowTitle() const {
1559   if (IsOffTheRecord()) {
1560     return l10n_util::GetStringFUTF16(
1561         IDS_ACCESSIBLE_INCOGNITO_WINDOW_TITLE_FORMAT,
1562         GetWindowTitle());
1563   }
1564   return GetWindowTitle();
1565 }
1566
1567 views::View* BrowserView::GetInitiallyFocusedView() {
1568   return NULL;
1569 }
1570
1571 bool BrowserView::ShouldShowWindowTitle() const {
1572   // For Ash only, app host windows do not show an icon, crbug.com/119411.
1573   // Child windows (i.e. popups) do show an icon.
1574   if (browser_->host_desktop_type() == chrome::HOST_DESKTOP_TYPE_ASH &&
1575       browser_->is_app() && browser_->app_type() == Browser::APP_TYPE_HOST)
1576     return false;
1577
1578   return browser_->SupportsWindowFeature(Browser::FEATURE_TITLEBAR);
1579 }
1580
1581 gfx::ImageSkia BrowserView::GetWindowAppIcon() {
1582   if (browser_->is_app()) {
1583     WebContents* contents = browser_->tab_strip_model()->GetActiveWebContents();
1584     extensions::TabHelper* extensions_tab_helper =
1585         contents ? extensions::TabHelper::FromWebContents(contents) : NULL;
1586     if (extensions_tab_helper && extensions_tab_helper->GetExtensionAppIcon())
1587       return gfx::ImageSkia::CreateFrom1xBitmap(
1588           *extensions_tab_helper->GetExtensionAppIcon());
1589   }
1590
1591   return GetWindowIcon();
1592 }
1593
1594 gfx::ImageSkia BrowserView::GetWindowIcon() {
1595   if (browser_->is_app() || browser_->is_type_popup())
1596     return browser_->GetCurrentPageIcon().AsImageSkia();
1597   return gfx::ImageSkia();
1598 }
1599
1600 bool BrowserView::ShouldShowWindowIcon() const {
1601   // For Ash only, app host windows do not show an icon, crbug.com/119411.
1602   // Child windows (i.e. popups) do show an icon.
1603   if (browser_->host_desktop_type() == chrome::HOST_DESKTOP_TYPE_ASH &&
1604       browser_->is_app() && browser_->app_type() == Browser::APP_TYPE_HOST)
1605     return false;
1606
1607   return browser_->SupportsWindowFeature(Browser::FEATURE_TITLEBAR);
1608 }
1609
1610 bool BrowserView::ExecuteWindowsCommand(int command_id) {
1611   // This function handles WM_SYSCOMMAND, WM_APPCOMMAND, and WM_COMMAND.
1612 #if defined(OS_WIN)
1613   if (command_id == IDC_DEBUG_FRAME_TOGGLE)
1614     GetWidget()->DebugToggleFrameType();
1615
1616   // In Windows 8 metro mode prevent sizing and moving.
1617   if (win8::IsSingleWindowMetroMode()) {
1618     // Windows uses the 4 lower order bits of |notification_code| for type-
1619     // specific information so we must exclude this when comparing.
1620     static const int sc_mask = 0xFFF0;
1621     if (((command_id & sc_mask) == SC_MOVE) ||
1622         ((command_id & sc_mask) == SC_SIZE) ||
1623         ((command_id & sc_mask) == SC_MAXIMIZE))
1624       return true;
1625   }
1626 #endif
1627   // Translate WM_APPCOMMAND command ids into a command id that the browser
1628   // knows how to handle.
1629   int command_id_from_app_command = GetCommandIDForAppCommandID(command_id);
1630   if (command_id_from_app_command != -1)
1631     command_id = command_id_from_app_command;
1632
1633   return chrome::ExecuteCommand(browser_.get(), command_id);
1634 }
1635
1636 std::string BrowserView::GetWindowName() const {
1637   return chrome::GetWindowPlacementKey(browser_.get());
1638 }
1639
1640 void BrowserView::SaveWindowPlacement(const gfx::Rect& bounds,
1641                                       ui::WindowShowState show_state) {
1642   // If IsFullscreen() is true, we've just changed into fullscreen mode, and
1643   // we're catching the going-into-fullscreen sizing and positioning calls,
1644   // which we want to ignore.
1645   if (!ShouldSaveOrRestoreWindowPos())
1646     return;
1647
1648   if (!IsFullscreen() && chrome::ShouldSaveWindowPlacement(browser_.get())) {
1649     WidgetDelegate::SaveWindowPlacement(bounds, show_state);
1650     chrome::SaveWindowPlacement(browser_.get(), bounds, show_state);
1651   }
1652 }
1653
1654 bool BrowserView::GetSavedWindowPlacement(
1655     const views::Widget* widget,
1656     gfx::Rect* bounds,
1657     ui::WindowShowState* show_state) const {
1658   if (!ShouldSaveOrRestoreWindowPos())
1659     return false;
1660   chrome::GetSavedWindowBoundsAndShowState(browser_.get(), bounds, show_state);
1661
1662   if (browser_->is_type_popup() &&
1663       !browser_->is_app() &&
1664       !browser_->is_devtools()) {
1665     // This is non-app popup window. The value passed in |bounds| represents
1666     // two pieces of information:
1667     // - the position of the window, in screen coordinates (outer position).
1668     // - the size of the content area (inner size).
1669     // We need to use these values to determine the appropriate size and
1670     // position of the resulting window.
1671     if (IsToolbarVisible()) {
1672       // If we're showing the toolbar, we need to adjust |*bounds| to include
1673       // its desired height, since the toolbar is considered part of the
1674       // window's client area as far as GetWindowBoundsForClientBounds is
1675       // concerned...
1676       bounds->set_height(
1677           bounds->height() + toolbar_->GetPreferredSize().height());
1678     }
1679
1680     gfx::Rect window_rect = frame_->non_client_view()->
1681         GetWindowBoundsForClientBounds(*bounds);
1682     window_rect.set_origin(bounds->origin());
1683
1684     // When we are given x/y coordinates of 0 on a created popup window,
1685     // assume none were given by the window.open() command.
1686     if (window_rect.x() == 0 && window_rect.y() == 0) {
1687       gfx::Size size = window_rect.size();
1688       window_rect.set_origin(
1689           WindowSizer::GetDefaultPopupOrigin(size,
1690                                              browser_->host_desktop_type()));
1691     }
1692
1693     *bounds = window_rect;
1694     *show_state = ui::SHOW_STATE_NORMAL;
1695   }
1696
1697   // We return true because we can _always_ locate reasonable bounds using the
1698   // WindowSizer, and we don't want to trigger the Window's built-in "size to
1699   // default" handling because the browser window has no default preferred
1700   // size.
1701   return true;
1702 }
1703
1704 views::View* BrowserView::GetContentsView() {
1705   return contents_web_view_;
1706 }
1707
1708 views::ClientView* BrowserView::CreateClientView(views::Widget* widget) {
1709   return this;
1710 }
1711
1712 void BrowserView::OnWidgetActivationChanged(views::Widget* widget,
1713                                             bool active) {
1714   if (active)
1715     BrowserList::SetLastActive(browser_.get());
1716 }
1717
1718 void BrowserView::OnWindowBeginUserBoundsChange() {
1719   WebContents* web_contents = GetActiveWebContents();
1720   if (!web_contents)
1721     return;
1722   web_contents->GetRenderViewHost()->NotifyMoveOrResizeStarted();
1723 }
1724
1725 void BrowserView::OnWidgetMove() {
1726   if (!initialized_) {
1727     // Creating the widget can trigger a move. Ignore it until we've initialized
1728     // things.
1729     return;
1730   }
1731
1732   // Cancel any tabstrip animations, some of them may be invalidated by the
1733   // window being repositioned.
1734   // Comment out for one cycle to see if this fixes dist tests.
1735   // tabstrip_->DestroyDragController();
1736
1737   // status_bubble_ may be NULL if this is invoked during construction.
1738   if (status_bubble_.get())
1739     status_bubble_->Reposition();
1740
1741   BookmarkBubbleView::Hide();
1742
1743   // Close the omnibox popup, if any.
1744   LocationBarView* location_bar_view = GetLocationBarView();
1745   if (location_bar_view)
1746     location_bar_view->GetOmniboxView()->CloseOmniboxPopup();
1747 }
1748
1749 views::Widget* BrowserView::GetWidget() {
1750   return View::GetWidget();
1751 }
1752
1753 const views::Widget* BrowserView::GetWidget() const {
1754   return View::GetWidget();
1755 }
1756
1757 void BrowserView::GetAccessiblePanes(std::vector<views::View*>* panes) {
1758   // This should be in the order of pane traversal of the panes using F6
1759   // (Windows) or Ctrl+Back/Forward (Chrome OS).  If one of these is
1760   // invisible or has no focusable children, it will be automatically
1761   // skipped.
1762   panes->push_back(toolbar_);
1763   if (bookmark_bar_view_.get())
1764     panes->push_back(bookmark_bar_view_.get());
1765   if (infobar_container_)
1766     panes->push_back(infobar_container_);
1767   if (download_shelf_.get())
1768     panes->push_back(download_shelf_.get());
1769   panes->push_back(GetTabContentsContainerView());
1770   if (devtools_web_view_->visible())
1771     panes->push_back(devtools_web_view_);
1772 }
1773
1774 ///////////////////////////////////////////////////////////////////////////////
1775 // BrowserView, views::ClientView overrides:
1776
1777 bool BrowserView::CanClose() {
1778   // You cannot close a frame for which there is an active originating drag
1779   // session.
1780   if (tabstrip_ && !tabstrip_->IsTabStripCloseable())
1781     return false;
1782
1783   // Give beforeunload handlers the chance to cancel the close before we hide
1784   // the window below.
1785   if (!browser_->ShouldCloseWindow())
1786     return false;
1787
1788   bool fast_tab_closing_enabled =
1789     CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableFastUnload);
1790
1791   if (!browser_->tab_strip_model()->empty()) {
1792     // Tab strip isn't empty.  Hide the frame (so it appears to have closed
1793     // immediately) and close all the tabs, allowing the renderers to shut
1794     // down. When the tab strip is empty we'll be called back again.
1795     frame_->Hide();
1796     browser_->OnWindowClosing();
1797     if (fast_tab_closing_enabled)
1798       browser_->tab_strip_model()->CloseAllTabs();
1799     return false;
1800   } else if (fast_tab_closing_enabled &&
1801         !browser_->HasCompletedUnloadProcessing()) {
1802     // The browser needs to finish running unload handlers.
1803     // Hide the frame (so it appears to have closed immediately), and
1804     // the browser will call us back again when it is ready to close.
1805     frame_->Hide();
1806     return false;
1807   }
1808
1809   // Empty TabStripModel, it's now safe to allow the Window to be closed.
1810   content::NotificationService::current()->Notify(
1811       chrome::NOTIFICATION_WINDOW_CLOSED,
1812       content::Source<gfx::NativeWindow>(frame_->GetNativeWindow()),
1813       content::NotificationService::NoDetails());
1814   return true;
1815 }
1816
1817 int BrowserView::NonClientHitTest(const gfx::Point& point) {
1818   return GetBrowserViewLayout()->NonClientHitTest(point);
1819 }
1820
1821 gfx::Size BrowserView::GetMinimumSize() {
1822   return GetBrowserViewLayout()->GetMinimumSize();
1823 }
1824
1825 ///////////////////////////////////////////////////////////////////////////////
1826 // BrowserView, views::View overrides:
1827
1828 const char* BrowserView::GetClassName() const {
1829   return kViewClassName;
1830 }
1831
1832 void BrowserView::Layout() {
1833   if (!initialized_ || in_process_fullscreen_)
1834     return;
1835
1836   views::View::Layout();
1837
1838   // TODO(jamescook): Why was this in the middle of layout code?
1839   toolbar_->location_bar()->omnibox_view()->SetFocusable(IsToolbarVisible());
1840 }
1841
1842 void BrowserView::PaintChildren(gfx::Canvas* canvas) {
1843   // Paint the |infobar_container_| last so that it may paint its
1844   // overlapping tabs.
1845   for (int i = 0; i < child_count(); ++i) {
1846     View* child = child_at(i);
1847     if (child != infobar_container_ && !child->layer())
1848       child->Paint(canvas);
1849   }
1850
1851   infobar_container_->Paint(canvas);
1852 }
1853
1854 void BrowserView::ViewHierarchyChanged(
1855     const ViewHierarchyChangedDetails& details) {
1856   if (!initialized_ && details.is_add && details.child == this && GetWidget()) {
1857     InitViews();
1858     initialized_ = true;
1859   }
1860 }
1861
1862 void BrowserView::ChildPreferredSizeChanged(View* child) {
1863   Layout();
1864 }
1865
1866 void BrowserView::GetAccessibleState(ui::AccessibleViewState* state) {
1867   state->role = ui::AccessibilityTypes::ROLE_CLIENT;
1868 }
1869
1870 ///////////////////////////////////////////////////////////////////////////////
1871 // BrowserView, ui::AcceleratorTarget overrides:
1872
1873 bool BrowserView::AcceleratorPressed(const ui::Accelerator& accelerator) {
1874 #if defined(OS_CHROMEOS)
1875   // If accessibility is enabled, stop speech and return false so that key
1876   // combinations involving Search can be used for extra accessibility
1877   // functionality.
1878   if (accelerator.key_code() == ui::VKEY_LWIN &&
1879       g_browser_process->local_state()->GetBoolean(
1880           prefs::kSpokenFeedbackEnabled)) {
1881     TtsController::GetInstance()->Stop();
1882     return false;
1883   }
1884 #endif
1885
1886   std::map<ui::Accelerator, int>::const_iterator iter =
1887       accelerator_table_.find(accelerator);
1888   DCHECK(iter != accelerator_table_.end());
1889   int command_id = iter->second;
1890
1891   chrome::BrowserCommandController* controller = browser_->command_controller();
1892   if (!controller->block_command_execution())
1893     UpdateAcceleratorMetrics(accelerator, command_id);
1894   return chrome::ExecuteCommand(browser_.get(), command_id);
1895 }
1896
1897 ///////////////////////////////////////////////////////////////////////////////
1898 // BrowserView, OmniboxPopupModelObserver overrides:
1899 void BrowserView::OnOmniboxPopupShownOrHidden() {
1900   infobar_container_->SetMaxTopArrowHeight(GetMaxTopInfoBarArrowHeight());
1901 }
1902
1903 ///////////////////////////////////////////////////////////////////////////////
1904 // BrowserView, InfoBarContainer::Delegate overrides:
1905
1906 SkColor BrowserView::GetInfoBarSeparatorColor() const {
1907   // NOTE: Keep this in sync with ToolbarView::OnPaint()!
1908   return (IsTabStripVisible() || !frame_->ShouldUseNativeFrame()) ?
1909       ThemeProperties::GetDefaultColor(
1910           ThemeProperties::COLOR_TOOLBAR_SEPARATOR) :
1911       SK_ColorBLACK;
1912 }
1913
1914 void BrowserView::InfoBarContainerStateChanged(bool is_animating) {
1915   ToolbarSizeChanged(is_animating);
1916 }
1917
1918 bool BrowserView::DrawInfoBarArrows(int* x) const {
1919   if (x) {
1920     gfx::Point anchor(toolbar_->location_bar()->GetLocationBarAnchorPoint());
1921     ConvertPointToTarget(toolbar_->location_bar(), this, &anchor);
1922     *x = anchor.x();
1923   }
1924   return true;
1925 }
1926
1927 void BrowserView::OnSysColorChange() {
1928   chrome::MaybeShowInvertBubbleView(browser_.get(), contents_container_);
1929 }
1930
1931 void BrowserView::InitViews() {
1932   GetWidget()->AddObserver(this);
1933
1934   // Stow a pointer to this object onto the window handle so that we can get at
1935   // it later when all we have is a native view.
1936   GetWidget()->SetNativeWindowProperty(kBrowserViewKey, this);
1937
1938   // Stow a pointer to the browser's profile onto the window handle so that we
1939   // can get it later when all we have is a native view.
1940   GetWidget()->SetNativeWindowProperty(Profile::kProfileKey,
1941                                        browser_->profile());
1942
1943   // Start a hung plugin window detector for this browser object (as long as
1944   // hang detection is not disabled).
1945   if (!CommandLine::ForCurrentProcess()->HasSwitch(
1946           switches::kDisableHangMonitor)) {
1947     InitHangMonitor();
1948   }
1949
1950   LoadAccelerators();
1951
1952   infobar_container_ = new InfoBarContainerView(this);
1953   AddChildView(infobar_container_);
1954
1955   contents_web_view_ = new ContentsWebView(browser_->profile());
1956   contents_web_view_->set_id(VIEW_ID_TAB_CONTAINER);
1957   contents_web_view_->SetEmbedFullscreenWidgetMode(
1958       implicit_cast<content::WebContentsDelegate*>(browser_.get())->
1959           EmbedsFullscreenWidget());
1960
1961   devtools_web_view_ = new views::WebView(browser_->profile());
1962   devtools_web_view_->set_id(VIEW_ID_DEV_TOOLS_DOCKED);
1963   devtools_web_view_->SetVisible(false);
1964
1965   contents_container_ = new views::View();
1966   contents_container_->set_background(views::Background::CreateSolidBackground(
1967       ThemeProperties::GetDefaultColor(
1968           ThemeProperties::COLOR_CONTROL_BACKGROUND)));
1969   contents_container_->AddChildView(devtools_web_view_);
1970   contents_container_->AddChildView(contents_web_view_);
1971   contents_container_->SetLayoutManager(new ContentsLayoutManager(
1972       devtools_web_view_, contents_web_view_));
1973   AddChildView(contents_container_);
1974   set_contents_view(contents_container_);
1975
1976   // Top container holds tab strip and toolbar and lives at the front of the
1977   // view hierarchy.
1978   top_container_ = new TopContainerView(this);
1979   AddChildView(top_container_);
1980
1981   // TabStrip takes ownership of the controller.
1982   BrowserTabStripController* tabstrip_controller =
1983       new BrowserTabStripController(browser_.get(),
1984                                     browser_->tab_strip_model());
1985   tabstrip_ = new TabStrip(tabstrip_controller);
1986   top_container_->AddChildView(tabstrip_);
1987   tabstrip_controller->InitFromModel(tabstrip_);
1988
1989   toolbar_ = new ToolbarView(browser_.get());
1990   top_container_->AddChildView(toolbar_);
1991   toolbar_->Init();
1992
1993   InitStatusBubble();
1994   InitPermissionBubbleView();
1995
1996   // Create do-nothing view for the sake of controlling the z-order of the find
1997   // bar widget.
1998   find_bar_host_view_ = new View();
1999   AddChildView(find_bar_host_view_);
2000
2001   if (window_switcher_button_)
2002     AddChildView(window_switcher_button_);
2003
2004   immersive_mode_controller_->Init(this);
2005
2006   BrowserViewLayout* browser_view_layout = new BrowserViewLayout;
2007   browser_view_layout->Init(new BrowserViewLayoutDelegateImpl(this),
2008                             browser(),
2009                             this,
2010                             top_container_,
2011                             tabstrip_,
2012                             toolbar_,
2013                             infobar_container_,
2014                             contents_container_,
2015                             GetContentsLayoutManager(),
2016                             immersive_mode_controller_.get());
2017   SetLayoutManager(browser_view_layout);
2018
2019 #if defined(OS_WIN)
2020   // Create a custom JumpList and add it to an observer of TabRestoreService
2021   // so we can update the custom JumpList when a tab is added or removed.
2022   if (JumpList::Enabled()) {
2023     load_complete_listener_.reset(new LoadCompleteListener(this));
2024   }
2025 #endif
2026
2027   GetLocationBar()->GetOmniboxView()->model()->popup_model()->AddObserver(this);
2028 }
2029
2030 void BrowserView::LoadingAnimationCallback() {
2031   base::TimeTicks now = base::TimeTicks::Now();
2032   if (!last_animation_time_.is_null()) {
2033     UMA_HISTOGRAM_TIMES(
2034         "Tabs.LoadingAnimationTime",
2035         now - last_animation_time_);
2036   }
2037   last_animation_time_ = now;
2038   if (browser_->is_type_tabbed()) {
2039     // Loading animations are shown in the tab for tabbed windows.  We check the
2040     // browser type instead of calling IsTabStripVisible() because the latter
2041     // will return false for fullscreen windows, but we still need to update
2042     // their animations (so that when they come out of fullscreen mode they'll
2043     // be correct).
2044     tabstrip_->UpdateLoadingAnimations();
2045   } else if (ShouldShowWindowIcon()) {
2046     // ... or in the window icon area for popups and app windows.
2047     WebContents* web_contents =
2048         browser_->tab_strip_model()->GetActiveWebContents();
2049     // GetActiveWebContents can return NULL for example under Purify when
2050     // the animations are running slowly and this function is called on a timer
2051     // through LoadingAnimationCallback.
2052     frame_->UpdateThrobber(web_contents && web_contents->IsLoading());
2053   }
2054 }
2055
2056 void BrowserView::OnLoadCompleted() {
2057 #if defined(OS_WIN)
2058   DCHECK(!jumplist_);
2059   jumplist_ = new JumpList();
2060   jumplist_->AddObserver(browser_->profile());
2061 #endif
2062 }
2063
2064 BrowserViewLayout* BrowserView::GetBrowserViewLayout() const {
2065   return static_cast<BrowserViewLayout*>(GetLayoutManager());
2066 }
2067
2068 ContentsLayoutManager* BrowserView::GetContentsLayoutManager() const {
2069   return static_cast<ContentsLayoutManager*>(
2070       contents_container_->GetLayoutManager());
2071 }
2072
2073 bool BrowserView::MaybeShowBookmarkBar(WebContents* contents) {
2074   bool show_bookmark_bar = contents &&
2075       browser_->SupportsWindowFeature(Browser::FEATURE_BOOKMARKBAR);
2076   if (!show_bookmark_bar && !bookmark_bar_view_.get())
2077     return false;
2078   if (!bookmark_bar_view_.get()) {
2079     bookmark_bar_view_.reset(new BookmarkBarView(browser_.get(), this));
2080     bookmark_bar_view_->set_owned_by_client();
2081     bookmark_bar_view_->set_background(
2082         new BookmarkExtensionBackground(this,
2083                                         bookmark_bar_view_.get(),
2084                                         browser_.get()));
2085     bookmark_bar_view_->SetBookmarkBarState(
2086         browser_->bookmark_bar_state(),
2087         BookmarkBar::DONT_ANIMATE_STATE_CHANGE);
2088     GetBrowserViewLayout()->set_bookmark_bar(bookmark_bar_view_.get());
2089   }
2090   bookmark_bar_view_->SetVisible(show_bookmark_bar);
2091   bookmark_bar_view_->SetPageNavigator(contents);
2092
2093   // Update parenting for the bookmark bar. This may detach it from all views.
2094   bool needs_layout = false;
2095   views::View* new_parent = NULL;
2096   if (show_bookmark_bar) {
2097     if (bookmark_bar_view_->IsDetached())
2098       new_parent = this;
2099     else
2100       new_parent = top_container_;
2101   }
2102   if (new_parent != bookmark_bar_view_->parent()) {
2103     SetBookmarkBarParent(new_parent);
2104     needs_layout = true;
2105   }
2106
2107   // Check for updates to the desired size.
2108   if (bookmark_bar_view_->GetPreferredSize().height() !=
2109       bookmark_bar_view_->height())
2110     needs_layout = true;
2111
2112   return needs_layout;
2113 }
2114
2115 void BrowserView::SetBookmarkBarParent(views::View* new_parent) {
2116   if (new_parent == this) {
2117     // Add it underneath |top_container_| or at the end if top container isn't
2118     // found.
2119     int top_container_index = GetIndexOf(top_container_);
2120     if (top_container_index >= 0)
2121       AddChildViewAt(bookmark_bar_view_.get(), top_container_index);
2122     else
2123       AddChildView(bookmark_bar_view_.get());
2124   } else if (new_parent) {
2125     // No special stacking is required for other parents.
2126     new_parent->AddChildView(bookmark_bar_view_.get());
2127   } else {
2128     // Bookmark bar is being detached from all views because it is hidden.
2129     bookmark_bar_view_->parent()->RemoveChildView(bookmark_bar_view_.get());
2130   }
2131 }
2132
2133 bool BrowserView::MaybeShowInfoBar(WebContents* contents) {
2134   // TODO(beng): Remove this function once the interface between
2135   //             InfoBarContainer, DownloadShelfView and WebContents and this
2136   //             view is sorted out.
2137   return true;
2138 }
2139
2140 void BrowserView::UpdateDevToolsForContents(
2141     WebContents* web_contents, bool update_devtools_web_contents) {
2142   DevToolsWindow* new_devtools_window = web_contents ?
2143       DevToolsWindow::GetDockedInstanceForInspectedTab(web_contents) : NULL;
2144
2145   // Replace devtools WebContents.
2146   WebContents* new_contents = new_devtools_window ?
2147       new_devtools_window->web_contents() : NULL;
2148   if (devtools_web_view_->web_contents() != new_contents &&
2149       update_devtools_web_contents) {
2150     devtools_web_view_->SetWebContents(new_contents);
2151   }
2152
2153   if (!devtools_window_ && new_devtools_window &&
2154       !devtools_focus_tracker_.get()) {
2155     // Install devtools focus tracker when dev tools window is shown for the
2156     // first time.
2157     devtools_focus_tracker_.reset(
2158         new views::ExternalFocusTracker(devtools_web_view_,
2159                                         GetFocusManager()));
2160   }
2161
2162   // Restore focus to the last focused view when hiding devtools window.
2163   if (devtools_window_ && !new_devtools_window &&
2164       devtools_focus_tracker_.get()) {
2165     devtools_focus_tracker_->FocusLastFocusedExternalView();
2166     devtools_focus_tracker_.reset();
2167   }
2168
2169   devtools_window_ = new_devtools_window;
2170   if (devtools_window_) {
2171     devtools_web_view_->SetPreferredSize(devtools_window_->GetMinimumSize());
2172     devtools_web_view_->SetVisible(true);
2173     GetContentsLayoutManager()->SetContentsResizingStrategy(
2174         devtools_window_->GetContentsResizingStrategy());
2175   } else {
2176     devtools_web_view_->SetVisible(false);
2177     GetContentsLayoutManager()->SetContentsResizingStrategy(
2178         DevToolsContentsResizingStrategy());
2179   }
2180   contents_container_->Layout();
2181 }
2182
2183 void BrowserView::UpdateUIForContents(WebContents* contents) {
2184   bool needs_layout = MaybeShowBookmarkBar(contents);
2185   // TODO(jamescook): This function always returns true. Remove it and figure
2186   // out when layout is actually required.
2187   needs_layout |= MaybeShowInfoBar(contents);
2188   if (needs_layout)
2189     Layout();
2190 }
2191
2192 void BrowserView::ProcessFullscreen(bool fullscreen,
2193                                     FullscreenType type,
2194                                     const GURL& url,
2195                                     FullscreenExitBubbleType bubble_type) {
2196   if (in_process_fullscreen_)
2197     return;
2198   in_process_fullscreen_ = true;
2199
2200   // Reduce jankiness during the following position changes by:
2201   //   * Hiding the window until it's in the final position
2202   //   * Ignoring all intervening Layout() calls, which resize the webpage and
2203   //     thus are slow and look ugly (enforced via |in_process_fullscreen_|).
2204   LocationBarView* location_bar = GetLocationBarView();
2205
2206   if (type == FOR_METRO || !fullscreen) {
2207     // Hide the fullscreen bubble as soon as possible, since the mode toggle can
2208     // take enough time for the user to notice.
2209     fullscreen_bubble_.reset();
2210   }
2211
2212   if (fullscreen) {
2213     // Move focus out of the location bar if necessary.
2214     views::FocusManager* focus_manager = GetFocusManager();
2215     DCHECK(focus_manager);
2216     // Look for focus in the location bar itself or any child view.
2217     if (location_bar->Contains(focus_manager->GetFocusedView()))
2218       focus_manager->ClearFocus();
2219   }
2220 #if defined(OS_WIN) && !defined(USE_AURA)
2221   views::ScopedFullscreenVisibility visibility(frame_->GetNativeView());
2222 #endif
2223
2224   if (type == FOR_METRO) {
2225 #if defined(OS_WIN) && !defined(USE_AURA)
2226     // Enter metro snap mode.
2227     static_cast<views::NativeWidgetWin*>(
2228         frame_->native_widget())->SetMetroSnapFullscreen(fullscreen);
2229 #endif
2230   } else {
2231     // Toggle fullscreen mode.
2232     frame_->SetFullscreen(fullscreen);
2233   }
2234
2235   // Enable immersive before the browser refreshes its list of enabled commands.
2236   if (ShouldUseImmersiveFullscreenForUrl(url))
2237     immersive_mode_controller_->SetEnabled(fullscreen);
2238
2239   browser_->WindowFullscreenStateChanged();
2240
2241   if (fullscreen && !chrome::IsRunningInAppMode() && type != FOR_METRO)
2242     UpdateFullscreenExitBubbleContent(url, bubble_type);
2243
2244   // Undo our anti-jankiness hacks and force a re-layout. We also need to
2245   // recompute the height of the infobar top arrow because toggling in and out
2246   // of fullscreen changes it. Calling ToolbarSizeChanged() will do both these
2247   // things since it computes the arrow height directly and forces a layout
2248   // indirectly via UpdateUIForContents(). Reset |in_process_fullscreen_| in
2249   // order to let the layout occur.
2250   in_process_fullscreen_ = false;
2251   ToolbarSizeChanged(false);
2252 }
2253
2254 bool BrowserView::ShouldUseImmersiveFullscreenForUrl(const GURL& url) const {
2255 #if defined(OS_CHROMEOS)
2256   // Kiosk mode needs the whole screen.
2257   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode))
2258     return false;
2259   bool is_browser_fullscreen = url.is_empty();
2260   if (ash::switches::UseImmersiveFullscreenForAllWindows())
2261     return is_browser_fullscreen;
2262   else
2263     return is_browser_fullscreen && IsBrowserTypeNormal();
2264 #else
2265   return false;
2266 #endif
2267 }
2268
2269 void BrowserView::LoadAccelerators() {
2270   views::FocusManager* focus_manager = GetFocusManager();
2271   DCHECK(focus_manager);
2272
2273   // Let's fill our own accelerator table.
2274   const bool is_app_mode = chrome::IsRunningInForcedAppMode();
2275   const std::vector<chrome::AcceleratorMapping> accelerator_list(
2276       chrome::GetAcceleratorList());
2277   for (std::vector<chrome::AcceleratorMapping>::const_iterator it =
2278            accelerator_list.begin(); it != accelerator_list.end(); ++it) {
2279     // In app mode, only allow accelerators of white listed commands to pass
2280     // through.
2281     if (is_app_mode && !chrome::IsCommandAllowedInAppMode(it->command_id))
2282       continue;
2283
2284     ui::Accelerator accelerator(it->keycode, it->modifiers);
2285     accelerator_table_[accelerator] = it->command_id;
2286
2287     // Also register with the focus manager.
2288     focus_manager->RegisterAccelerator(
2289         accelerator, ui::AcceleratorManager::kNormalPriority, this);
2290   }
2291 }
2292
2293 int BrowserView::GetCommandIDForAppCommandID(int app_command_id) const {
2294 #if defined(OS_WIN)
2295   switch (app_command_id) {
2296     // NOTE: The order here matches the APPCOMMAND declaration order in the
2297     // Windows headers.
2298     case APPCOMMAND_BROWSER_BACKWARD: return IDC_BACK;
2299     case APPCOMMAND_BROWSER_FORWARD:  return IDC_FORWARD;
2300     case APPCOMMAND_BROWSER_REFRESH:  return IDC_RELOAD;
2301     case APPCOMMAND_BROWSER_HOME:     return IDC_HOME;
2302     case APPCOMMAND_BROWSER_STOP:     return IDC_STOP;
2303     case APPCOMMAND_BROWSER_SEARCH:   return IDC_FOCUS_SEARCH;
2304     case APPCOMMAND_HELP:             return IDC_HELP_PAGE_VIA_KEYBOARD;
2305     case APPCOMMAND_NEW:              return IDC_NEW_TAB;
2306     case APPCOMMAND_OPEN:             return IDC_OPEN_FILE;
2307     case APPCOMMAND_CLOSE:            return IDC_CLOSE_TAB;
2308     case APPCOMMAND_SAVE:             return IDC_SAVE_PAGE;
2309     case APPCOMMAND_PRINT:            return IDC_PRINT;
2310     case APPCOMMAND_COPY:             return IDC_COPY;
2311     case APPCOMMAND_CUT:              return IDC_CUT;
2312     case APPCOMMAND_PASTE:            return IDC_PASTE;
2313
2314       // TODO(pkasting): http://b/1113069 Handle these.
2315     case APPCOMMAND_UNDO:
2316     case APPCOMMAND_REDO:
2317     case APPCOMMAND_SPELL_CHECK:
2318     default:                          return -1;
2319   }
2320 #else
2321   // App commands are Windows-specific so there's nothing to do here.
2322   return -1;
2323 #endif
2324 }
2325
2326 void BrowserView::InitHangMonitor() {
2327 #if defined(OS_WIN)
2328   PrefService* pref_service = g_browser_process->local_state();
2329   if (!pref_service)
2330     return;
2331
2332   int plugin_message_response_timeout =
2333       pref_service->GetInteger(prefs::kPluginMessageResponseTimeout);
2334   int hung_plugin_detect_freq =
2335       pref_service->GetInteger(prefs::kHungPluginDetectFrequency);
2336 #if defined(USE_AURA)
2337   HWND window = GetWidget()->GetNativeView()->GetDispatcher()->host()->
2338       GetAcceleratedWidget();
2339 #else
2340   HWND window = GetWidget()->GetNativeView();
2341 #endif
2342   if ((hung_plugin_detect_freq > 0) &&
2343       hung_window_detector_.Initialize(window,
2344                                        plugin_message_response_timeout)) {
2345     ticker_.set_tick_interval(hung_plugin_detect_freq);
2346     ticker_.RegisterTickHandler(&hung_window_detector_);
2347     ticker_.Start();
2348
2349     pref_service->SetInteger(prefs::kPluginMessageResponseTimeout,
2350                              plugin_message_response_timeout);
2351     pref_service->SetInteger(prefs::kHungPluginDetectFrequency,
2352                              hung_plugin_detect_freq);
2353   }
2354 #endif
2355 }
2356
2357 void BrowserView::UpdateAcceleratorMetrics(const ui::Accelerator& accelerator,
2358                                            int command_id) {
2359   const ui::KeyboardCode key_code = accelerator.key_code();
2360   if (command_id == IDC_HELP_PAGE_VIA_KEYBOARD && key_code == ui::VKEY_F1)
2361     content::RecordAction(UserMetricsAction("ShowHelpTabViaF1"));
2362
2363   if (command_id == IDC_BOOKMARK_PAGE)
2364     UMA_HISTOGRAM_ENUMERATION("Bookmarks.EntryPoint",
2365                               BOOKMARK_ENTRY_POINT_ACCELERATOR,
2366                               BOOKMARK_ENTRY_POINT_LIMIT);
2367
2368 #if defined(OS_CHROMEOS)
2369   // Collect information about the relative popularity of various accelerators
2370   // on Chrome OS.
2371   switch (command_id) {
2372     case IDC_BACK:
2373       if (key_code == ui::VKEY_BACK)
2374         content::RecordAction(UserMetricsAction("Accel_Back_Backspace"));
2375       else if (key_code == ui::VKEY_BROWSER_BACK)
2376         content::RecordAction(UserMetricsAction("Accel_Back_F1"));
2377       else if (key_code == ui::VKEY_LEFT)
2378         content::RecordAction(UserMetricsAction("Accel_Back_Left"));
2379       break;
2380     case IDC_FORWARD:
2381       if (key_code == ui::VKEY_BACK)
2382         content::RecordAction(UserMetricsAction("Accel_Forward_Backspace"));
2383       else if (key_code == ui::VKEY_BROWSER_FORWARD)
2384         content::RecordAction(UserMetricsAction("Accel_Forward_F2"));
2385       else if (key_code == ui::VKEY_RIGHT)
2386         content::RecordAction(UserMetricsAction("Accel_Forward_Right"));
2387       break;
2388     case IDC_RELOAD:
2389     case IDC_RELOAD_IGNORING_CACHE:
2390       if (key_code == ui::VKEY_R)
2391         content::RecordAction(UserMetricsAction("Accel_Reload_R"));
2392       else if (key_code == ui::VKEY_BROWSER_REFRESH)
2393         content::RecordAction(UserMetricsAction("Accel_Reload_F3"));
2394       break;
2395     case IDC_FOCUS_LOCATION:
2396       if (key_code == ui::VKEY_D)
2397         content::RecordAction(UserMetricsAction("Accel_FocusLocation_D"));
2398       else if (key_code == ui::VKEY_L)
2399         content::RecordAction(UserMetricsAction("Accel_FocusLocation_L"));
2400       break;
2401     case IDC_FOCUS_SEARCH:
2402       if (key_code == ui::VKEY_E)
2403         content::RecordAction(UserMetricsAction("Accel_FocusSearch_E"));
2404       else if (key_code == ui::VKEY_K)
2405         content::RecordAction(UserMetricsAction("Accel_FocusSearch_K"));
2406       break;
2407     default:
2408       // Do nothing.
2409       break;
2410   }
2411 #endif
2412 }
2413
2414 // static
2415 BrowserWindow* BrowserWindow::CreateBrowserWindow(Browser* browser) {
2416   // Create the view and the frame. The frame will attach itself via the view
2417   // so we don't need to do anything with the pointer.
2418   BrowserView* view = new BrowserView();
2419   view->Init(browser);
2420   (new BrowserFrame(view))->InitBrowserFrame();
2421   view->GetWidget()->non_client_view()->SetAccessibleName(
2422       l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
2423   return view;
2424 }
2425
2426 // static
2427 chrome::HostDesktopType BrowserWindow::AdjustHostDesktopType(
2428     chrome::HostDesktopType desktop_type) {
2429   return NativeBrowserFrameFactory::AdjustHostDesktopType(desktop_type);
2430 }
2431
2432 void BrowserView::ShowAvatarBubble(WebContents* web_contents,
2433                                    const gfx::Rect& rect) {
2434   gfx::Point origin(rect.origin());
2435   views::View::ConvertPointToScreen(GetTabContentsContainerView(), &origin);
2436   gfx::Rect bounds(origin, rect.size());
2437
2438   AvatarMenuBubbleView::ShowBubble(this, views::BubbleBorder::TOP_RIGHT,
2439       views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE, bounds, browser_.get());
2440 }
2441
2442 void BrowserView::ShowAvatarBubbleFromAvatarButton() {
2443   if (switches::IsNewProfileManagement()) {
2444     NewAvatarButton* button = frame_->GetNewAvatarMenuButton();
2445     if (button) {
2446       gfx::Point origin;
2447       views::View::ConvertPointToScreen(button, &origin);
2448       gfx::Rect bounds(origin, size());
2449
2450       ProfileChooserView::ShowBubble(
2451           button, views::BubbleBorder::TOP_RIGHT,
2452           views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE, bounds, browser());
2453     }
2454   } else {
2455     AvatarMenuButton* button = frame_->GetAvatarMenuButton();
2456     if (button)
2457       button->ShowAvatarBubble();
2458   }
2459 }
2460
2461 void BrowserView::ShowPasswordGenerationBubble(
2462     const gfx::Rect& rect,
2463     const autofill::PasswordForm& form,
2464     autofill::PasswordGenerator* password_generator) {
2465   // Create a rect in the content bounds that the bubble will point to.
2466   gfx::Point origin(rect.origin());
2467   views::View::ConvertPointToScreen(GetTabContentsContainerView(), &origin);
2468   gfx::Rect bounds(origin, rect.size());
2469
2470   // Create the bubble.
2471   WebContents* web_contents = GetActiveWebContents();
2472   if (!web_contents)
2473     return;
2474
2475   PasswordGenerationBubbleView* bubble = new PasswordGenerationBubbleView(
2476       form,
2477       bounds,
2478       this,
2479       web_contents->GetRenderViewHost(),
2480       ChromePasswordManagerClient::GetManagerFromWebContents(web_contents),
2481       password_generator,
2482       browser_.get(),
2483       GetWidget()->GetThemeProvider());
2484
2485   views::BubbleDelegateView::CreateBubble(bubble);
2486   bubble->SetAlignment(views::BubbleBorder::ALIGN_ARROW_TO_MID_ANCHOR);
2487   bubble->GetWidget()->Show();
2488 }
2489
2490 void BrowserView::OverscrollUpdate(int delta_y) {
2491   if (scroll_end_effect_controller_)
2492     scroll_end_effect_controller_->OverscrollUpdate(delta_y);
2493 }
2494
2495 int BrowserView::GetRenderViewHeightInsetWithDetachedBookmarkBar() {
2496   if (browser_->bookmark_bar_state() != BookmarkBar::DETACHED ||
2497       !bookmark_bar_view_.get() || !bookmark_bar_view_->IsDetached()) {
2498     return 0;
2499   }
2500   // Don't use bookmark_bar_view_->height() which won't be the final height if
2501   // the bookmark bar is animating.
2502   return chrome::kNTPBookmarkBarHeight -
2503       bookmark_bar_view_->GetFullyDetachedToolbarOverlap();
2504 }
2505
2506 void BrowserView::ShowPageActionPopup(
2507     const extensions::Extension* extension) {
2508   toolbar_->ShowPageActionPopup(extension);
2509 }
2510
2511 void BrowserView::ShowBrowserActionPopup(
2512     const extensions::Extension* extension) {
2513   toolbar_->ShowBrowserActionPopup(extension);
2514 }
2515
2516 void BrowserView::DoCutCopyPaste(void (content::RenderWidgetHost::*method)(),
2517                                  int command_id) {
2518   WebContents* contents = browser_->tab_strip_model()->GetActiveWebContents();
2519   if (!contents)
2520     return;
2521   if (DoCutCopyPasteForWebContents(contents, method))
2522     return;
2523
2524   DevToolsWindow* devtools_window =
2525       DevToolsWindow::GetDockedInstanceForInspectedTab(contents);
2526   if (devtools_window &&
2527       DoCutCopyPasteForWebContents(devtools_window->web_contents(), method)) {
2528     return;
2529   }
2530
2531   views::FocusManager* focus_manager = GetFocusManager();
2532   views::View* focused = focus_manager->GetFocusedView();
2533   if (focused &&
2534       (!strcmp(focused->GetClassName(), views::Textfield::kViewClassName) ||
2535        !strcmp(focused->GetClassName(), OmniboxViewViews::kViewClassName))) {
2536     views::Textfield* textfield = static_cast<views::Textfield*>(focused);
2537     textfield->ExecuteCommand(command_id);
2538   }
2539 }
2540
2541 bool BrowserView::DoCutCopyPasteForWebContents(
2542     WebContents* contents,
2543     void (content::RenderWidgetHost::*method)()) {
2544   gfx::NativeView native_view = contents->GetView()->GetContentNativeView();
2545   if (!native_view)
2546     return false;
2547 #if defined(USE_AURA)
2548   if (native_view->HasFocus()) {
2549 #elif defined(OS_WIN)
2550   if (native_view == ::GetFocus()) {
2551 #endif
2552     (contents->GetRenderViewHost()->*method)();
2553     return true;
2554   }
2555
2556   return false;
2557 }
2558
2559 void BrowserView::ActivateAppModalDialog() const {
2560   // If another browser is app modal, flash and activate the modal browser.
2561   AppModalDialog* active_dialog =
2562       AppModalDialogQueue::GetInstance()->active_dialog();
2563   if (!active_dialog)
2564     return;
2565
2566   Browser* modal_browser =
2567       chrome::FindBrowserWithWebContents(active_dialog->web_contents());
2568   if (modal_browser && (browser_ != modal_browser)) {
2569     modal_browser->window()->FlashFrame(true);
2570     modal_browser->window()->Activate();
2571   }
2572
2573   AppModalDialogQueue::GetInstance()->ActivateModalDialog();
2574 }
2575
2576 int BrowserView::GetMaxTopInfoBarArrowHeight() {
2577   int top_arrow_height = 0;
2578   // Only show the arrows when not in fullscreen and when there's no omnibox
2579   // popup.
2580   if (!IsFullscreen() &&
2581       !GetLocationBar()->GetOmniboxView()->model()->popup_model()->IsOpen()) {
2582     gfx::Point icon_bottom(
2583         toolbar_->location_bar()->GetLocationBarAnchorPoint());
2584     ConvertPointToTarget(toolbar_->location_bar(), this, &icon_bottom);
2585     gfx::Point infobar_top(0, infobar_container_->GetVerticalOverlap(NULL));
2586     ConvertPointToTarget(infobar_container_, this, &infobar_top);
2587     top_arrow_height = infobar_top.y() - icon_bottom.y();
2588   }
2589   return top_arrow_height;
2590 }