1 // Copyright (c) 2011 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 #ifndef CHROME_BROWSER_UI_VIEWS_FRAME_BROWSER_VIEW_H_ 6 #define CHROME_BROWSER_UI_VIEWS_FRAME_BROWSER_VIEW_H_ 7 #pragma once 8 9 #include <map> 10 #include <string> 11 #include <vector> 12 13 #include "base/memory/scoped_ptr.h" 14 #include "base/timer.h" 15 #include "build/build_config.h" 16 #include "chrome/browser/tabs/tab_strip_model_observer.h" 17 #include "chrome/browser/ui/browser.h" 18 #include "chrome/browser/ui/browser_window.h" 19 #include "chrome/browser/ui/views/frame/browser_bubble_host.h" 20 #include "chrome/browser/ui/views/frame/browser_frame.h" 21 #include "chrome/browser/ui/views/infobars/infobar_container.h" 22 #include "chrome/browser/ui/views/tab_contents/tab_contents_container.h" 23 #include "chrome/browser/ui/views/tabs/abstract_tab_strip_view.h" 24 #include "chrome/browser/ui/views/unhandled_keyboard_event_handler.h" 25 #include "content/common/notification_registrar.h" 26 #include "ui/base/models/simple_menu_model.h" 27 #include "ui/gfx/native_widget_types.h" 28 #include "views/controls/single_split_view.h" 29 #include "views/window/client_view.h" 30 #include "views/window/window_delegate.h" 31 32 #if defined(OS_WIN) 33 #include "chrome/browser/hang_monitor/hung_plugin_action.h" 34 #include "chrome/browser/hang_monitor/hung_window_detector.h" 35 #include "views/controls/menu/native_menu_win.h" 36 #endif 37 38 // NOTE: For more information about the objects and files in this directory, 39 // view: http://dev.chromium.org/developers/design-documents/browser-window 40 41 class AccessiblePaneView; 42 class BookmarkBarView; 43 class Browser; 44 class BrowserBubble; 45 class BrowserViewLayout; 46 class ContentsContainer; 47 class DownloadShelfView; 48 class EncodingMenuModel; 49 class FullscreenExitBubble; 50 class HtmlDialogUIDelegate; 51 class InfoBarContainerView; 52 class LocationBarView; 53 class SideTabStrip; 54 class StatusBubbleViews; 55 class TabContentsContainer; 56 class TabStripModel; 57 class ToolbarView; 58 class ZoomMenuModel; 59 class Extension; 60 61 #if defined(OS_WIN) 62 class AeroPeekManager; 63 class JumpList; 64 #endif 65 66 namespace views { 67 class ExternalFocusTracker; 68 class Menu; 69 } 70 71 /////////////////////////////////////////////////////////////////////////////// 72 // BrowserView 73 // 74 // A ClientView subclass that provides the contents of a browser window, 75 // including the TabStrip, toolbars, download shelves, the content area etc. 76 // 77 class BrowserView : public BrowserBubbleHost, 78 public BrowserWindow, 79 public BrowserWindowTesting, 80 public NotificationObserver, 81 public TabStripModelObserver, 82 public ui::SimpleMenuModel::Delegate, 83 public views::WindowDelegate, 84 public views::ClientView, 85 public InfoBarContainer::Delegate, 86 public views::SingleSplitView::Observer { 87 public: 88 // The browser view's class name. 89 static const char kViewClassName[]; 90 91 explicit BrowserView(Browser* browser); 92 virtual ~BrowserView(); 93 set_frame(BrowserFrame * frame)94 void set_frame(BrowserFrame* frame) { frame_ = frame; } frame()95 BrowserFrame* frame() const { return frame_; } 96 97 // Returns a pointer to the BrowserView* interface implementation (an 98 // instance of this object, typically) for a given native window, or NULL if 99 // there is no such association. 100 static BrowserView* GetBrowserViewForNativeWindow(gfx::NativeWindow window); 101 102 // Returns a Browser instance of this view. browser()103 Browser* browser() const { return browser_.get(); } 104 105 // Returns the apparent bounds of the toolbar, in BrowserView coordinates. 106 // These differ from |toolbar_.bounds()| in that they match where the toolbar 107 // background image is drawn -- slightly outside the "true" bounds 108 // horizontally, and, when using vertical tabs, behind the tab column. 109 virtual gfx::Rect GetToolbarBounds() const; 110 111 // Returns the bounds of the content area, in the coordinates of the 112 // BrowserView's parent. 113 gfx::Rect GetClientAreaBounds() const; 114 115 // Returns the constraining bounding box that should be used to lay out the 116 // FindBar within. This is _not_ the size of the find bar, just the bounding 117 // box it should be laid out within. The coordinate system of the returned 118 // rect is in the coordinate system of the frame, since the FindBar is a child 119 // window. 120 gfx::Rect GetFindBarBoundingBox() const; 121 122 // Returns the preferred height of the TabStrip. Used to position the OTR 123 // avatar icon. 124 virtual int GetTabStripHeight() const; 125 126 // Takes some view's origin (relative to this BrowserView) and offsets it such 127 // that it can be used as the source origin for seamlessly tiling the toolbar 128 // background image over that view. 129 gfx::Point OffsetPointForToolbarBackgroundImage( 130 const gfx::Point& point) const; 131 132 // Returns the width of the currently displayed sidebar or 0. 133 int GetSidebarWidth() const; 134 135 // Accessor for the TabStrip. tabstrip()136 AbstractTabStripView* tabstrip() const { return tabstrip_; } 137 138 // Accessor for the Toolbar. toolbar()139 ToolbarView* toolbar() const { return toolbar_; } 140 141 // Returns true if various window components are visible. 142 virtual bool IsTabStripVisible() const; 143 144 // Returns true if the vertical tabstrip is in use. 145 bool UseVerticalTabs() const; 146 147 // Returns true if the profile associated with this Browser window is 148 // incognito. 149 bool IsOffTheRecord() const; 150 151 // Returns true if the non-client view should render the Incognito 152 // avatar icon if the window is incognito. 153 virtual bool ShouldShowOffTheRecordAvatar() const; 154 155 // Handle the specified |accelerator| being pressed. 156 virtual bool AcceleratorPressed(const views::Accelerator& accelerator); 157 158 // Provides the containing frame with the accelerator for the specified 159 // command id. This can be used to provide menu item shortcut hints etc. 160 // Returns true if an accelerator was found for the specified |cmd_id|, false 161 // otherwise. 162 bool GetAccelerator(int cmd_id, ui::Accelerator* accelerator); 163 164 // Shows the next app-modal dialog box, if there is one to be shown, or moves 165 // an existing showing one to the front. Returns true if one was shown or 166 // activated, false if none was shown. 167 bool ActivateAppModalDialog() const; 168 169 // Returns the selected TabContents[Wrapper]. Used by our NonClientView's 170 // TabIconView::TabContentsProvider implementations. 171 // TODO(beng): exposing this here is a bit bogus, since it's only used to 172 // determine loading state. It'd be nicer if we could change this to be 173 // bool IsSelectedTabLoading() const; or something like that. We could even 174 // move it to a WindowDelegate subclass. 175 TabContents* GetSelectedTabContents() const; 176 TabContentsWrapper* GetSelectedTabContentsWrapper() const; 177 178 // Retrieves the icon to use in the frame to indicate an OTR window. 179 SkBitmap GetOTRAvatarIcon(); 180 181 #if defined(OS_WIN) 182 // Called right before displaying the system menu to allow the BrowserView 183 // to add or delete entries. 184 void PrepareToRunSystemMenu(HMENU menu); 185 #endif 186 187 // Returns true if the Browser object associated with this BrowserView is a 188 // normal-type window (i.e. a browser window, not an app or popup). IsBrowserTypeNormal()189 bool IsBrowserTypeNormal() const { 190 return browser_->type() == Browser::TYPE_NORMAL; 191 } 192 193 // Returns true if the Browser object associated with this BrowserView is a 194 // app panel window. IsBrowserTypePanel()195 bool IsBrowserTypePanel() const { 196 return browser_->type() == Browser::TYPE_APP_PANEL; 197 } 198 199 // Returns true if the Browser object associated with this BrowserView is a 200 // popup window. IsBrowserTypePopup()201 bool IsBrowserTypePopup() const { 202 return (browser_->type() & Browser::TYPE_POPUP) != 0; 203 } 204 205 // Register preferences specific to this view. 206 static void RegisterBrowserViewPrefs(PrefService* prefs); 207 208 // Returns true if the specified point(BrowserView coordinates) is in 209 // in the window caption area of the browser window. 210 bool IsPositionInWindowCaption(const gfx::Point& point); 211 212 // Returns whether the fullscreen bubble is visible or not. 213 virtual bool IsFullscreenBubbleVisible() const; 214 215 // Invoked from the frame when the full screen state changes. This is only 216 // used on Linux. 217 void FullScreenStateChanged(); 218 219 // Restores the focused view. This is also used to set the initial focus 220 // when a new browser window is created. 221 void RestoreFocus(); 222 223 // Overridden from BrowserWindow: 224 virtual void Show() OVERRIDE; 225 virtual void ShowInactive() OVERRIDE; 226 virtual void SetBounds(const gfx::Rect& bounds) OVERRIDE; 227 virtual void Close() OVERRIDE; 228 virtual void Activate() OVERRIDE; 229 virtual void Deactivate() OVERRIDE; 230 virtual bool IsActive() const OVERRIDE; 231 virtual void FlashFrame() OVERRIDE; 232 virtual gfx::NativeWindow GetNativeHandle() OVERRIDE; 233 virtual BrowserWindowTesting* GetBrowserWindowTesting() OVERRIDE; 234 virtual StatusBubble* GetStatusBubble() OVERRIDE; 235 virtual void ToolbarSizeChanged(bool is_animating) OVERRIDE; 236 virtual void UpdateTitleBar() OVERRIDE; 237 virtual void ShelfVisibilityChanged() OVERRIDE; 238 virtual void UpdateDevTools() OVERRIDE; 239 virtual void UpdateLoadingAnimations(bool should_animate) OVERRIDE; 240 virtual void SetStarredState(bool is_starred) OVERRIDE; 241 virtual gfx::Rect GetRestoredBounds() const OVERRIDE; 242 virtual gfx::Rect GetBounds() const OVERRIDE; 243 virtual bool IsMaximized() const OVERRIDE; 244 virtual void SetFullscreen(bool fullscreen) OVERRIDE; 245 virtual bool IsFullscreen() const OVERRIDE; 246 virtual LocationBar* GetLocationBar() const OVERRIDE; 247 virtual void SetFocusToLocationBar(bool select_all) OVERRIDE; 248 virtual void UpdateReloadStopState(bool is_loading, bool force) OVERRIDE; 249 virtual void UpdateToolbar(TabContentsWrapper* contents, 250 bool should_restore_state) OVERRIDE; 251 virtual void FocusToolbar() OVERRIDE; 252 virtual void FocusAppMenu() OVERRIDE; 253 virtual void FocusBookmarksToolbar() OVERRIDE; FocusChromeOSStatus()254 virtual void FocusChromeOSStatus() OVERRIDE {} 255 virtual void RotatePaneFocus(bool forwards) OVERRIDE; 256 virtual void DestroyBrowser() OVERRIDE; 257 virtual bool IsBookmarkBarVisible() const OVERRIDE; 258 virtual bool IsBookmarkBarAnimating() const OVERRIDE; 259 virtual bool IsTabStripEditable() const OVERRIDE; 260 virtual bool IsToolbarVisible() const OVERRIDE; 261 virtual void DisableInactiveFrame() OVERRIDE; 262 virtual void ConfirmSetDefaultSearchProvider( 263 TabContents* tab_contents, 264 TemplateURL* template_url, 265 TemplateURLModel* template_url_model) OVERRIDE; 266 virtual void ConfirmAddSearchProvider(const TemplateURL* template_url, 267 Profile* profile) OVERRIDE; 268 virtual void ToggleBookmarkBar() OVERRIDE; 269 virtual void ShowAboutChromeDialog() OVERRIDE; 270 virtual void ShowUpdateChromeDialog() OVERRIDE; 271 virtual void ShowTaskManager() OVERRIDE; 272 virtual void ShowBackgroundPages() OVERRIDE; 273 virtual void ShowBookmarkBubble(const GURL& url, bool already_bookmarked) 274 OVERRIDE; 275 // TODO(beng): Not an override, move somewhere else. 276 void SetDownloadShelfVisible(bool visible); 277 virtual bool IsDownloadShelfVisible() const OVERRIDE; 278 virtual DownloadShelf* GetDownloadShelf() OVERRIDE; 279 virtual void ShowRepostFormWarningDialog(TabContents* tab_contents) OVERRIDE; 280 virtual void ShowCollectedCookiesDialog(TabContents* tab_contents) OVERRIDE; 281 virtual void ShowThemeInstallBubble() OVERRIDE; 282 virtual void ConfirmBrowserCloseWithPendingDownloads() OVERRIDE; 283 virtual void ShowHTMLDialog(HtmlDialogUIDelegate* delegate, 284 gfx::NativeWindow parent_window) OVERRIDE; 285 virtual void UserChangedTheme() OVERRIDE; 286 virtual int GetExtraRenderViewHeight() const OVERRIDE; 287 virtual void TabContentsFocused(TabContents* source) OVERRIDE; 288 virtual void ShowPageInfo(Profile* profile, 289 const GURL& url, 290 const NavigationEntry::SSLStatus& ssl, 291 bool show_history) OVERRIDE; 292 virtual void ShowAppMenu() OVERRIDE; 293 virtual bool PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event, 294 bool* is_keyboard_shortcut) OVERRIDE; 295 virtual void HandleKeyboardEvent(const NativeWebKeyboardEvent& event) 296 OVERRIDE; 297 virtual void ShowCreateWebAppShortcutsDialog(TabContentsWrapper* tab_contents) 298 OVERRIDE; 299 virtual void ShowCreateChromeAppShortcutsDialog( 300 Profile*, const Extension* app) OVERRIDE; 301 virtual void Cut() OVERRIDE; 302 virtual void Copy() OVERRIDE; 303 virtual void Paste() OVERRIDE; 304 virtual void ToggleTabStripMode() OVERRIDE; 305 virtual void PrepareForInstant() OVERRIDE; 306 virtual void ShowInstant(TabContentsWrapper* preview) OVERRIDE; 307 virtual void HideInstant(bool instant_is_active) OVERRIDE; 308 virtual gfx::Rect GetInstantBounds() OVERRIDE; 309 #if defined(OS_CHROMEOS) 310 virtual void ShowKeyboardOverlay(gfx::NativeWindow owning_window) OVERRIDE; 311 #endif 312 313 // Overridden from BrowserWindowTesting: 314 virtual BookmarkBarView* GetBookmarkBarView() const OVERRIDE; 315 virtual LocationBarView* GetLocationBarView() const OVERRIDE; 316 virtual views::View* GetTabContentsContainerView() const OVERRIDE; 317 virtual views::View* GetSidebarContainerView() const OVERRIDE; 318 virtual ToolbarView* GetToolbarView() const OVERRIDE; 319 320 // Overridden from NotificationObserver: 321 virtual void Observe(NotificationType type, 322 const NotificationSource& source, 323 const NotificationDetails& details) OVERRIDE; 324 325 // Overridden from TabStripModelObserver: 326 virtual void TabDetachedAt(TabContentsWrapper* contents, int index) OVERRIDE; 327 virtual void TabDeselected(TabContentsWrapper* contents) OVERRIDE; 328 virtual void TabSelectedAt(TabContentsWrapper* old_contents, 329 TabContentsWrapper* new_contents, 330 int index, 331 bool user_gesture) OVERRIDE; 332 virtual void TabReplacedAt(TabStripModel* tab_strip_model, 333 TabContentsWrapper* old_contents, 334 TabContentsWrapper* new_contents, 335 int index) OVERRIDE; 336 virtual void TabStripEmpty() OVERRIDE; 337 338 // Overridden from ui::SimpleMenuModel::Delegate: 339 virtual bool IsCommandIdChecked(int command_id) const OVERRIDE; 340 virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE; 341 virtual bool GetAcceleratorForCommandId( 342 int command_id, ui::Accelerator* accelerator) OVERRIDE; 343 virtual bool IsItemForCommandIdDynamic(int command_id) const OVERRIDE; 344 virtual string16 GetLabelForCommandId(int command_id) const OVERRIDE; 345 virtual void ExecuteCommand(int command_id) OVERRIDE; 346 347 // Overridden from views::WindowDelegate: 348 virtual bool CanResize() const OVERRIDE; 349 virtual bool CanMaximize() const OVERRIDE; 350 virtual bool CanActivate() const OVERRIDE; 351 virtual bool IsModal() const OVERRIDE; 352 virtual std::wstring GetWindowTitle() const OVERRIDE; 353 virtual std::wstring GetAccessibleWindowTitle() const OVERRIDE; 354 virtual views::View* GetInitiallyFocusedView() OVERRIDE; 355 virtual bool ShouldShowWindowTitle() const OVERRIDE; 356 virtual SkBitmap GetWindowAppIcon() OVERRIDE; 357 virtual SkBitmap GetWindowIcon() OVERRIDE; 358 virtual bool ShouldShowWindowIcon() const OVERRIDE; 359 virtual bool ExecuteWindowsCommand(int command_id) OVERRIDE; 360 virtual std::wstring GetWindowName() const OVERRIDE; 361 virtual void SaveWindowPlacement(const gfx::Rect& bounds, 362 bool maximized) OVERRIDE; 363 virtual bool GetSavedWindowBounds(gfx::Rect* bounds) const OVERRIDE; 364 virtual bool GetSavedMaximizedState(bool* maximized) const OVERRIDE; 365 virtual views::View* GetContentsView() OVERRIDE; 366 virtual views::ClientView* CreateClientView(views::Window* window) OVERRIDE; 367 virtual void OnWindowActivationChanged(bool active) OVERRIDE; 368 virtual void OnWindowBeginUserBoundsChange() OVERRIDE; 369 virtual void OnWidgetMove() OVERRIDE; 370 371 // Overridden from views::ClientView: 372 virtual bool CanClose() OVERRIDE; 373 virtual int NonClientHitTest(const gfx::Point& point) OVERRIDE; 374 virtual gfx::Size GetMinimumSize() OVERRIDE; 375 376 // InfoBarContainer::Delegate overrides 377 virtual SkColor GetInfoBarSeparatorColor() const OVERRIDE; 378 virtual void InfoBarContainerStateChanged(bool is_animating) OVERRIDE; 379 virtual bool DrawInfoBarArrows(int* x) const OVERRIDE; 380 381 // views::SingleSplitView::Observer overrides: 382 virtual bool SplitHandleMoved(views::SingleSplitView* view) OVERRIDE; 383 384 protected: 385 // Appends to |toolbars| a pointer to each AccessiblePaneView that 386 // can be traversed using F6, in the order they should be traversed. 387 // Abstracted here so that it can be extended for Chrome OS. 388 virtual void GetAccessiblePanes( 389 std::vector<AccessiblePaneView*>* panes); 390 391 // Save the current focused view to view storage 392 void SaveFocusedView(); 393 last_focused_view_storage_id()394 int last_focused_view_storage_id() const { 395 return last_focused_view_storage_id_; 396 } 397 398 // Overridden from views::View: 399 virtual std::string GetClassName() const OVERRIDE; 400 virtual void Layout() OVERRIDE; 401 virtual void PaintChildren(gfx::Canvas* canvas) OVERRIDE; 402 virtual void ViewHierarchyChanged(bool is_add, 403 views::View* parent, 404 views::View* child) OVERRIDE; 405 virtual void ChildPreferredSizeChanged(View* child) OVERRIDE; 406 virtual void GetAccessibleState(ui::AccessibleViewState* state) OVERRIDE; 407 408 // Factory Method. 409 // Returns a new LayoutManager for this browser view. A subclass may 410 // override to implement different layout policy. 411 virtual views::LayoutManager* CreateLayoutManager() const; 412 413 // Initializes a new TabStrip for the browser view. This can be performed 414 // multiple times over the life of the browser, and is run when the display 415 // mode for the tabstrip changes from horizontal to vertical. 416 virtual void InitTabStrip(TabStripModel* tab_strip_model); 417 418 // Factory Method. 419 // Returns a new ToolbarView for this browser view. A subclass may 420 // override to implement different layout policy. 421 virtual ToolbarView* CreateToolbar() const; 422 423 // Browser window related initializations. 424 virtual void Init(); 425 426 // Callback for the loading animation(s) associated with this view. 427 virtual void LoadingAnimationCallback(); 428 429 private: 430 friend class BrowserViewLayout; 431 FRIEND_TEST_ALL_PREFIXES(BrowserViewsAccessibilityTest, 432 TestAboutChromeViewAccObj); 433 434 #if defined(OS_WIN) 435 // Creates the system menu. 436 void InitSystemMenu(); 437 #endif 438 439 // Returns the BrowserViewLayout. 440 BrowserViewLayout* GetBrowserViewLayout() const; 441 442 // Layout the Status Bubble. 443 void LayoutStatusBubble(); 444 445 // Prepare to show the Bookmark Bar for the specified TabContents. Returns 446 // true if the Bookmark Bar can be shown (i.e. it's supported for this 447 // Browser type) and there should be a subsequent re-layout to show it. 448 // |contents| can be NULL. 449 bool MaybeShowBookmarkBar(TabContentsWrapper* contents); 450 451 // Prepare to show an Info Bar for the specified TabContents. Returns true 452 // if there is an Info Bar to show and one is supported for this Browser 453 // type, and there should be a subsequent re-layout to show it. 454 // |contents| can be NULL. 455 bool MaybeShowInfoBar(TabContentsWrapper* contents); 456 457 // Updates sidebar UI according to the current tab and sidebar state. 458 void UpdateSidebar(); 459 // Displays active sidebar linked to the |tab_contents| or hides sidebar UI, 460 // if there's no such sidebar. 461 void UpdateSidebarForContents(TabContentsWrapper* tab_contents); 462 463 // Updated devtools window for given contents. 464 void UpdateDevToolsForContents(TabContentsWrapper* tab_contents); 465 466 // Updates various optional child Views, e.g. Bookmarks Bar, Info Bar or the 467 // Download Shelf in response to a change notification from the specified 468 // |contents|. |contents| can be NULL. In this case, all optional UI will be 469 // removed. 470 void UpdateUIForContents(TabContentsWrapper* contents); 471 472 // Updates an optional child View, e.g. Bookmarks Bar, Info Bar, Download 473 // Shelf. If |*old_view| differs from new_view, the old_view is removed and 474 // the new_view is added. This is intended to be used when swapping in/out 475 // child views that are referenced via a field. 476 // Returns true if anything was changed, and a re-Layout is now required. 477 bool UpdateChildViewAndLayout(views::View* new_view, views::View** old_view); 478 479 // Invoked to update the necessary things when our fullscreen state changes 480 // to |fullscreen|. On Windows this is invoked immediately when we toggle the 481 // full screen state. On Linux changing the fullscreen state is async, so we 482 // ask the window to change it's fullscreen state, then when we get 483 // notification that it succeeded this method is invoked. 484 void ProcessFullscreen(bool fullscreen); 485 486 // Copy the accelerator table from the app resources into something we can 487 // use. 488 void LoadAccelerators(); 489 490 #if defined(OS_WIN) 491 // Builds the correct menu for when we have minimal chrome. 492 void BuildSystemMenuForBrowserWindow(); 493 void BuildSystemMenuForAppOrPopupWindow(bool is_app); 494 #endif 495 496 // Retrieves the command id for the specified Windows app command. 497 int GetCommandIDForAppCommandID(int app_command_id) const; 498 499 // Initialize the hung plugin detector. 500 void InitHangMonitor(); 501 502 // Possibly records a user metrics action corresponding to the passed-in 503 // accelerator. Only implemented for Chrome OS, where we're interested in 504 // learning about how frequently the top-row keys are used. 505 void UpdateAcceleratorMetrics(const views::Accelerator& accelerator, 506 int command_id); 507 508 // Invoked from TabSelectedAt or when instant is made active. Is 509 // |change_tab_contents| is true, |new_contents| is added to the view 510 // hierarchy, if |change_tab_contents| is false, it's assumed |new_contents| 511 // has already been added to the view hierarchy. 512 void ProcessTabSelected(TabContentsWrapper* new_contents, 513 bool change_tab_contents); 514 515 // Exposes resize corner size to BrowserViewLayout. 516 gfx::Size GetResizeCornerSize() const; 517 518 // Shows the about chrome modal dialog and returns the Window object. 519 views::Window* DoShowAboutChromeDialog(); 520 521 // Set the value of |toolbar_| and hook it into the views hiearchy 522 void SetToolbar(ToolbarView* toolbar); 523 524 // Last focused view that issued a tab traversal. 525 int last_focused_view_storage_id_; 526 527 // The BrowserFrame that hosts this view. 528 BrowserFrame* frame_; 529 530 // The Browser object we are associated with. 531 scoped_ptr<Browser> browser_; 532 533 // BrowserView layout (LTR one is pictured here). 534 // 535 // -------------------------------------------------------------------------- 536 // | | Tabs (1) | 537 // | |--------------------------------------------------------------| 538 // | | Navigation buttons, menus and the address bar (toolbar_) | 539 // | |--------------------------------------------------------------| 540 // | | All infobars (infobar_container_) * | 541 // | |--------------------------------------------------------------| 542 // | | Bookmarks (bookmark_bar_view_) * | 543 // | |--------------------------------------------------------------| 544 // | |Page content (contents_) || | 545 // | |--------------------------------------|| Sidebar content | 546 // | || contents_container_ and/or ||| (sidebar_container_) | 547 // | || preview_container_ ||| | 548 // | || |(3) | 549 // | Tabs (2)|| ||| | 550 // | || ||| | 551 // | || ||| | 552 // | || ||| | 553 // | |--------------------------------------|| | 554 // | |==(4)=========================================================| 555 // | | | 556 // | | | 557 // | | Debugger (devtools_container_) | 558 // | | | 559 // | | | 560 // | |--------------------------------------------------------------| 561 // | | Active downloads (download_shelf_) | 562 // -------------------------------------------------------------------------- 563 // 564 // (1) - tabstrip_, default position 565 // (2) - tabstrip_, position when side tabs are enabled 566 // (3) - sidebar_split_ 567 // (4) - contents_split_ 568 // 569 // * - The bookmark bar and info bar are swapped when on the new tab page. 570 // Additionally contents_ is positioned on top of the bookmark bar when 571 // the bookmark bar is detached. This is done to allow the 572 // preview_container_ to appear over the bookmark bar. 573 574 // Tool/Info bars that we are currently showing. Used for layout. 575 // active_bookmark_bar_ is either NULL, if the bookmark bar isn't showing, 576 // or is bookmark_bar_view_ if the bookmark bar is showing. 577 views::View* active_bookmark_bar_; 578 579 // The TabStrip. 580 AbstractTabStripView* tabstrip_; 581 582 // The Toolbar containing the navigation buttons, menus and the address bar. 583 ToolbarView* toolbar_; 584 585 // The Bookmark Bar View for this window. Lazily created. 586 scoped_ptr<BookmarkBarView> bookmark_bar_view_; 587 588 // The download shelf view (view at the bottom of the page). 589 scoped_ptr<DownloadShelfView> download_shelf_; 590 591 // The InfoBarContainerView that contains InfoBars for the current tab. 592 InfoBarContainerView* infobar_container_; 593 594 // The view that contains sidebar for the current tab. 595 TabContentsContainer* sidebar_container_; 596 597 // Split view containing the contents container and sidebar container. 598 views::SingleSplitView* sidebar_split_; 599 600 // The view that contains the selected TabContents. 601 TabContentsContainer* contents_container_; 602 603 // The view that contains devtools window for the selected TabContents. 604 TabContentsContainer* devtools_container_; 605 606 // The view that contains instant's TabContents. 607 TabContentsContainer* preview_container_; 608 609 // The view managing both the contents_container_ and preview_container_. 610 ContentsContainer* contents_; 611 612 // Split view containing the contents container and devtools container. 613 views::SingleSplitView* contents_split_; 614 615 // Tracks and stores the last focused view which is not the 616 // devtools_container_ or any of its children. Used to restore focus once 617 // the devtools_container_ is hidden. 618 scoped_ptr<views::ExternalFocusTracker> devtools_focus_tracker_; 619 620 // The Status information bubble that appears at the bottom of the window. 621 scoped_ptr<StatusBubbleViews> status_bubble_; 622 623 // A mapping between accelerators and commands. 624 std::map<views::Accelerator, int> accelerator_table_; 625 626 // True if we have already been initialized. 627 bool initialized_; 628 629 // True if we should ignore requests to layout. This is set while toggling 630 // fullscreen mode on and off to reduce jankiness. 631 bool ignore_layout_; 632 633 scoped_ptr<FullscreenExitBubble> fullscreen_bubble_; 634 635 #if defined(OS_WIN) 636 // The additional items we insert into the system menu. 637 scoped_ptr<views::SystemMenuModel> system_menu_contents_; 638 scoped_ptr<ZoomMenuModel> zoom_menu_contents_; 639 scoped_ptr<EncodingMenuModel> encoding_menu_contents_; 640 // The wrapped system menu itself. 641 scoped_ptr<views::NativeMenuWin> system_menu_; 642 643 // This object is used to perform periodic actions in a worker 644 // thread. It is currently used to monitor hung plugin windows. 645 WorkerThreadTicker ticker_; 646 647 // This object is initialized with the frame window HWND. This 648 // object is also passed as a tick handler with the ticker_ object. 649 // It is used to periodically monitor for hung plugin windows 650 HungWindowDetector hung_window_detector_; 651 652 // This object is invoked by hung_window_detector_ when it detects a hung 653 // plugin window. 654 HungPluginAction hung_plugin_action_; 655 656 // The custom JumpList for Windows 7. 657 scoped_ptr<JumpList> jumplist_; 658 659 // The custom AeroPeek manager for Windows 7. 660 scoped_ptr<AeroPeekManager> aeropeek_manager_; 661 #endif 662 663 // The timer used to update frames for the Loading Animation. 664 base::RepeatingTimer<BrowserView> loading_animation_timer_; 665 666 UnhandledKeyboardEventHandler unhandled_keyboard_event_handler_; 667 668 NotificationRegistrar registrar_; 669 670 // Used to measure the loading spinner animation rate. 671 base::TimeTicks last_animation_time_; 672 673 DISALLOW_COPY_AND_ASSIGN(BrowserView); 674 }; 675 676 #endif // CHROME_BROWSER_UI_VIEWS_FRAME_BROWSER_VIEW_H_ 677