// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef CHROME_BROWSER_UI_BROWSER_H_ #define CHROME_BROWSER_UI_BROWSER_H_ #pragma once #include #include #include #include #include "base/basictypes.h" #include "base/compiler_specific.h" #include "base/gtest_prod_util.h" #include "base/memory/scoped_ptr.h" #include "base/memory/weak_ptr.h" #include "base/string16.h" #include "chrome/browser/command_updater.h" #include "chrome/browser/debugger/devtools_toggle_action.h" #include "chrome/browser/event_disposition.h" #include "chrome/browser/extensions/extension_tab_helper_delegate.h" #include "chrome/browser/instant/instant_delegate.h" #include "chrome/browser/prefs/pref_change_registrar.h" #include "chrome/browser/prefs/pref_member.h" #include "chrome/browser/sessions/session_id.h" #include "chrome/browser/sessions/tab_restore_service_observer.h" #include "chrome/browser/sync/profile_sync_service_observer.h" #include "chrome/browser/tabs/tab_handler.h" #include "chrome/browser/tabs/tab_strip_model_delegate.h" // TODO(beng): remove #include "chrome/browser/tabs/tab_strip_model_observer.h" // TODO(beng): remove #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper_delegate.h" #include "chrome/browser/ui/bookmarks/bookmark_bar.h" #include "chrome/browser/ui/bookmarks/bookmark_tab_helper_delegate.h" #include "chrome/browser/ui/browser_navigator.h" #include "chrome/browser/ui/constrained_window_tab_helper_delegate.h" #include "chrome/browser/ui/dialog_style.h" #include "chrome/browser/ui/fullscreen_exit_bubble_type.h" #include "chrome/browser/ui/search_engines/search_engine_tab_helper_delegate.h" #include "chrome/browser/ui/select_file_dialog.h" #include "chrome/browser/ui/tab_contents/core_tab_helper_delegate.h" #include "chrome/browser/ui/toolbar/toolbar_model.h" #include "chrome/common/content_settings.h" #include "chrome/common/content_settings_types.h" #include "chrome/common/extensions/extension_constants.h" #include "content/public/browser/notification_registrar.h" #include "content/public/browser/page_navigator.h" #include "content/public/browser/web_contents_delegate.h" #include "content/public/common/page_transition_types.h" #include "content/public/common/page_zoom.h" #include "ui/base/ui_base_types.h" #include "ui/gfx/rect.h" class BrowserSyncedWindowDelegate; class BrowserTabRestoreServiceDelegate; class BrowserWindow; class Extension; class ExtensionWindowController; class FindBarController; class FullscreenController; class HtmlDialogUIDelegate; class InstantController; class InstantUnloadHandler; class PrefService; class Profile; class SkBitmap; class StatusBubble; class TabNavigation; class TabStripModel; struct WebApplicationInfo; namespace content { class NavigationController; class SessionStorageNamespace; } namespace gfx { class Point; } class Browser : public TabHandlerDelegate, public content::WebContentsDelegate, public CoreTabHelperDelegate, public SearchEngineTabHelperDelegate, public ConstrainedWindowTabHelperDelegate, public BlockedContentTabHelperDelegate, public BookmarkTabHelperDelegate, public ExtensionTabHelperDelegate, public content::PageNavigator, public CommandUpdater::CommandUpdaterDelegate, public content::NotificationObserver, public SelectFileDialog::Listener, public TabRestoreServiceObserver, public ProfileSyncServiceObserver, public InstantDelegate { public: // SessionService::WindowType mirrors these values. If you add to this // enum, look at SessionService::WindowType to see if it needs to be // updated. enum Type { // If you add a new type, consider updating the test // BrowserTest.StartMaximized. TYPE_TABBED = 1, TYPE_POPUP = 2, TYPE_PANEL = 3 }; // Possible elements of the Browser window. enum WindowFeature { FEATURE_NONE = 0, FEATURE_TITLEBAR = 1, FEATURE_TABSTRIP = 2, FEATURE_TOOLBAR = 4, FEATURE_LOCATIONBAR = 8, FEATURE_BOOKMARKBAR = 16, FEATURE_INFOBAR = 32, FEATURE_DOWNLOADSHELF = 64 }; // The context for a download blocked notification from // OkToCloseWithInProgressDownloads. enum DownloadClosePreventionType { // Browser close is not blocked by download state. DOWNLOAD_CLOSE_OK, // The browser is shutting down and there are active downloads // that would be cancelled. DOWNLOAD_CLOSE_BROWSER_SHUTDOWN, // There are active downloads associated with this incognito profile // that would be canceled. DOWNLOAD_CLOSE_LAST_WINDOW_IN_INCOGNITO_PROFILE, }; struct CreateParams { CreateParams(Type type, Profile* profile); // The browser type. Type type; // The associated profile. Profile* profile; // The application name that is also the name of the window to the shell. // This name should be set when: // 1) we launch an application via an application shortcut or extension API. // 2) we launch an undocked devtool window. std::string app_name; // The bounds of the window to open. gfx::Rect initial_bounds; ui::WindowShowState initial_show_state; bool is_session_restore; }; // Constructors, Creation, Showing ////////////////////////////////////////// // Creates a new browser of the given |type| and for the given |profile|. The // Browser has a NULL window after its construction, InitBrowserWindow must // be called after configuration for window() to be valid. // Avoid using this constructor directly if you can use one of the Create*() // methods below. This applies to almost all non-testing code. Browser(Type type, Profile* profile); virtual ~Browser(); // Creates a normal tabbed browser with the specified profile. The Browser's // window is created by this function call. static Browser* Create(Profile* profile); // Like Create, but creates a browser of the specified parameters. static Browser* CreateWithParams(const CreateParams& params); // Like Create, but creates a browser of the specified type. static Browser* CreateForType(Type type, Profile* profile); // Like Create, but creates a toolbar-less "app" window for the specified // app. |app_name| is required and is used to identify the window to the // shell. If |window_bounds| is set, it is used to determine the bounds of // the window to open. static Browser* CreateForApp(Type type, const std::string& app_name, const gfx::Rect& window_bounds, Profile* profile); // Like Create, but creates a tabstrip-less and toolbar-less // DevTools "app" window. static Browser* CreateForDevTools(Profile* profile); // Set overrides for the initial window bounds and maximized state. void set_override_bounds(const gfx::Rect& bounds) { override_bounds_ = bounds; } void set_show_state(ui::WindowShowState show_state) { show_state_ = show_state; } // Return true if the initial window bounds have been overridden. bool bounds_overridden() const { return !override_bounds_.IsEmpty(); } // Set indicator that this browser is being created via session restore. // This is used on the Mac (only) to determine animation style when the // browser window is shown. void set_is_session_restore(bool is_session_restore) { is_session_restore_ = is_session_restore; } bool is_session_restore() const { return is_session_restore_; } // Creates the Browser Window. Prefer to use the static helpers above where // possible. This does not show the window. You need to call window()->Show() // to show it. void InitBrowserWindow(); // Sets the BrowserWindow. This is intended for tests only. // Use CreateBrowserWindow outside of testing, or the static convenience // methods that create a BrowserWindow for you. void SetWindowForTesting(BrowserWindow* window); // Accessors //////////////////////////////////////////////////////////////// Type type() const { return type_; } const std::string& app_name() const { return app_name_; } Profile* profile() const { return profile_; } gfx::Rect override_bounds() const { return override_bounds_; } // Returns the InstantController or NULL if there is no InstantController for // this Browser. InstantController* instant() const { return instant_.get(); } // |window()| will return NULL if called before |CreateBrowserWindow()| // is done. BrowserWindow* window() const { return window_; } ToolbarModel* toolbar_model() { return &toolbar_model_; } const SessionID& session_id() const { return session_id_; } CommandUpdater* command_updater() { return &command_updater_; } bool block_command_execution() const { return block_command_execution_; } BrowserTabRestoreServiceDelegate* tab_restore_service_delegate() { return tab_restore_service_delegate_.get(); } BrowserSyncedWindowDelegate* synced_window_delegate() { return synced_window_delegate_.get(); } // Get the FindBarController for this browser, creating it if it does not // yet exist. FindBarController* GetFindBarController(); // Returns true if a FindBarController exists for this browser. bool HasFindBarController() const; // Returns the state of the bookmark bar. BookmarkBar::State bookmark_bar_state() const { return bookmark_bar_state_; } // Browser Creation Helpers ///////////////////////////////////////////////// // Opens a new window with the default blank tab. static void NewEmptyWindow(Profile* profile); // Opens a new window with the default blank tab. This bypasses metrics and // various internal bookkeeping; NewEmptyWindow (above) is preferred. static void OpenEmptyWindow(Profile* profile); // Opens a new window with the tabs from |profile|'s TabRestoreService. static void OpenWindowWithRestoredTabs(Profile* profile); // Opens the specified URL in a new browser window in an incognito session. // If there is already an existing active incognito session for the specified // |profile|, that session is re-used. static void OpenURLOffTheRecord(Profile* profile, const GURL& url); // Open |extension| in |container|, using |disposition| if container type is // TAB. Returns the WebContents* that was created or NULL. If non-empty, // |override_url| is used in place of the app launch url. static content::WebContents* OpenApplication( Profile* profile, const Extension* extension, extension_misc::LaunchContainer container, const GURL& override_url, WindowOpenDisposition disposition); #if defined(USE_AURA) // Opens |url| in a new application panel window for the specified url. static content::WebContents* OpenApplicationPanel( Profile* profile, const Extension* extension, const GURL& url); #endif // Opens a new application window for the specified url. If |as_panel| // is true, the application will be opened as a Browser::Type::APP_PANEL in // app panel window, otherwise it will be opened as as either // Browser::Type::APP a.k.a. "thin frame" (if |extension| is NULL) or // Browser::Type::EXTENSION_APP (if |extension| is non-NULL). // If |app_browser| is not NULL, it is set to the browser that hosts the // returned tab. static content::WebContents* OpenApplicationWindow( Profile* profile, const Extension* extension, extension_misc::LaunchContainer container, const GURL& url, Browser** app_browser); // Open |url| in an app shortcut window. If |update_shortcut| is true, // update the name, description, and favicon of the shortcut. // There are two kinds of app shortcuts: Shortcuts to a URL, // and shortcuts that open an installed application. This function // is used to open the former. To open the latter, use // Browser::OpenApplicationWindow(). static content::WebContents* OpenAppShortcutWindow(Profile* profile, const GURL& url, bool update_shortcut); // Open an application for |extension| using |disposition|. Returns NULL if // there are no appropriate existing browser windows for |profile|. If // non-empty, |override_url| is used in place of the app launch url. static content::WebContents* OpenApplicationTab( Profile* profile, const Extension* extension, const GURL& override_url, WindowOpenDisposition disposition); // Opens a new window and opens the bookmark manager. static void OpenBookmarkManagerWindow(Profile* profile); #if defined(OS_MACOSX) // Open a new window with history/downloads/help/options (needed on Mac when // there are no windows). static void OpenHistoryWindow(Profile* profile); static void OpenDownloadsWindow(Profile* profile); static void OpenHelpWindow(Profile* profile); static void OpenOptionsWindow(Profile* profile); static void OpenSyncSetupWindow(Profile* profile); static void OpenClearBrowsingDataDialogWindow(Profile* profile); static void OpenImportSettingsDialogWindow(Profile* profile); static void OpenInstantConfirmDialogWindow(Profile* profile); #endif // Opens a window with the extensions tab in it - needed by long-lived // extensions which may run with no windows open. static void OpenExtensionsWindow(Profile* profile); // State Storage and Retrieval for UI /////////////////////////////////////// // Save and restore the window position. std::string GetWindowPlacementKey() const; bool ShouldSaveWindowPlacement() const; void SaveWindowPlacement(const gfx::Rect& bounds, ui::WindowShowState show_state); gfx::Rect GetSavedWindowBounds() const; ui::WindowShowState GetSavedWindowShowState() const; // Gets the Favicon of the page in the selected tab. SkBitmap GetCurrentPageIcon() const; // Gets the title of the window based on the selected tab's title. string16 GetWindowTitleForCurrentTab() const; // Prepares a title string for display (removes embedded newlines, etc). static void FormatTitleForDisplay(string16* title); // OnBeforeUnload handling ////////////////////////////////////////////////// // Gives beforeunload handlers the chance to cancel the close. bool ShouldCloseWindow(); bool IsAttemptingToCloseBrowser() const { return is_attempting_to_close_browser_; } // Invoked when the window containing us is closing. Performs the necessary // cleanup. void OnWindowClosing(); // OnWindowActivationChanged handling /////////////////////////////////////// // Invoked when the window containing us is activated. void OnWindowActivated(); // In-progress download termination handling ///////////////////////////////// // Called when the user has decided whether to proceed or not with the browser // closure. |cancel_downloads| is true if the downloads should be canceled // and the browser closed, false if the browser should stay open and the // downloads running. void InProgressDownloadResponse(bool cancel_downloads); // Indicates whether or not this browser window can be closed, or // would be blocked by in-progress downloads. // If executing downloads would be cancelled by this window close, // then |*num_downloads_blocking| is updated with how many downloads // would be canceled if the close continued. DownloadClosePreventionType OkToCloseWithInProgressDownloads( int* num_downloads_blocking) const; // TabStripModel pass-thrus ///////////////////////////////////////////////// TabStripModel* tabstrip_model() const { // TODO(beng): remove this accessor. It violates google style. return tab_handler_->GetTabStripModel(); } int tab_count() const; int active_index() const; int GetIndexOfController( const content::NavigationController* controller) const; // TODO(dpapad): Rename to GetActiveTabContentsWrapper(). TabContentsWrapper* GetSelectedTabContentsWrapper() const; // A convenient version of the above which returns the TCW's WebContents. content::WebContents* GetSelectedWebContents() const; TabContentsWrapper* GetTabContentsWrapperAt(int index) const; // A convenient version of the above which returns the TCW's WebContents. content::WebContents* GetWebContentsAt(int index) const; void ActivateTabAt(int index, bool user_gesture); bool IsTabPinned(int index) const; bool IsTabDiscarded(int index) const; void CloseAllTabs(); // Tab adding/showing functions ///////////////////////////////////////////// // Returns true if the tab strip is editable (for extensions). bool IsTabStripEditable() const; // Returns the index to insert a tab at during session restore and startup. // |relative_index| gives the index of the url into the number of tabs that // are going to be opened. For example, if three urls are passed in on the // command line this is invoked three times with the values 0, 1 and 2. int GetIndexForInsertionDuringRestore(int relative_index); // Adds a selected tab with the specified URL and transition, returns the // created TabContents. TabContentsWrapper* AddSelectedTabWithURL( const GURL& url, content::PageTransition transition); // Add a new tab, given a TabContents. A TabContents appropriate to // display the last committed entry is created and returned. content::WebContents* AddTab(TabContentsWrapper* tab_contents, content::PageTransition type); // Add a tab with its session history restored from the SessionRestore // system. If select is true, the tab is selected. |tab_index| gives the index // to insert the tab at. |selected_navigation| is the index of the // TabNavigation in |navigations| to select. If |extension_app_id| is // non-empty the tab is an app tab and |extension_app_id| is the id of the // extension. If |pin| is true and |tab_index|/ is the last pinned tab, then // the newly created tab is pinned. If |from_last_session| is true, // |navigations| are from the previous session. content::WebContents* AddRestoredTab( const std::vector& navigations, int tab_index, int selected_navigation, const std::string& extension_app_id, bool select, bool pin, bool from_last_session, content::SessionStorageNamespace* storage_namespace); // Creates a new tab with the already-created WebContents 'new_contents'. // The window for the added contents will be reparented correctly when this // method returns. If |disposition| is NEW_POPUP, |pos| should hold the // initial position. void AddWebContents(content::WebContents* new_contents, WindowOpenDisposition disposition, const gfx::Rect& initial_pos, bool user_gesture); void CloseTabContents(content::WebContents* contents); // Shows a dialog with HTML content and returns it. |delegate| contains a // pointer to the delegate who knows how to display the dialog (which file // URL and JSON string input to use during initialization). |parent_window| // is the window that should be parent of the dialog, or NULL for the default. // |style| customizes this HTML dialog decoration and layout (X button, // throbber, default content padding). Except ChromeOS, other platforms // only have STYLE_GENERIC now. // TODO(bshe): Implementing styles not related to window decoration in other // platforms for consistency if necessary. gfx::NativeWindow BrowserShowHtmlDialog(HtmlDialogUIDelegate* delegate, gfx::NativeWindow parent_window, DialogStyle style); // Called when a popup select is about to be displayed. void BrowserRenderWidgetShowing(); // Notification that the bookmark bar has changed size. We need to resize the // content area and notify our InfoBarContainer. void BookmarkBarSizeChanged(bool is_animating); // Replaces the state of the currently selected tab with the session // history restored from the SessionRestore system. void ReplaceRestoredTab( const std::vector& navigations, int selected_navigation, bool from_last_session, const std::string& extension_app_id, content::SessionStorageNamespace* session_storage_namespace); // Navigate to an index in the tab history, opening a new tab depending on the // disposition. bool NavigateToIndexWithDisposition(int index, WindowOpenDisposition disp); // Show a given a URL. If a tab with the same URL (ignoring the ref) is // already visible in this browser, it becomes selected. Otherwise a new tab // is created. void ShowSingletonTab(const GURL& url); // Same as ShowSingletonTab, but does not ignore ref. void ShowSingletonTabRespectRef(const GURL& url); // As ShowSingletonTab, but if the current tab is the new tab page or // about:blank, then overwrite it with the passed contents. void ShowSingletonTabOverwritingNTP(const browser::NavigateParams& params); // Creates a NavigateParams struct for a singleton tab navigation. browser::NavigateParams GetSingletonTabNavigateParams(const GURL& url); // Invoked when the fullscreen state of the window changes. // BrowserWindow::EnterFullscreen invokes this after the window has become // fullscreen. void WindowFullscreenStateChanged(); // Assorted browser commands //////////////////////////////////////////////// // NOTE: Within each of the following sections, the IDs are ordered roughly by // how they appear in the GUI/menus (left to right, top to bottom, etc.). // Navigation commands bool CanGoBack() const; void GoBack(WindowOpenDisposition disposition); bool CanGoForward() const; void GoForward(WindowOpenDisposition disposition); void Reload(WindowOpenDisposition disposition); void ReloadIgnoringCache(WindowOpenDisposition disposition); // Shift-reload. void Home(WindowOpenDisposition disposition); void OpenCurrentURL(); void Stop(); // Window management commands void NewWindow(); void NewIncognitoWindow(); void CloseWindow(); void NewTab(); void CloseTab(); void SelectNextTab(); void SelectPreviousTab(); void OpenTabpose(); void MoveTabNext(); void MoveTabPrevious(); void SelectNumberedTab(int index); void SelectLastTab(); void DuplicateTab(); void WriteCurrentURLToClipboard(); void ConvertPopupToTabbedBrowser(); // In kiosk mode, the first toggle is valid, the rest is discarded. void ToggleFullscreenMode(); // See the description of // FullscreenController::ToggleFullscreenModeWithExtension. void ToggleFullscreenModeWithExtension(const GURL& extension_url); #if defined(OS_MACOSX) void TogglePresentationMode(); #endif void Exit(); #if defined(OS_CHROMEOS) void Search(); void ShowKeyboardOverlay(); #endif // Page-related commands void BookmarkCurrentPage(); void SavePage(); void ViewSelectedSource(); void ShowFindBar(); void ShowPageInfo(content::WebContents* web_contents, const GURL& url, const content::SSLStatus& ssl, bool show_history); // Returns true if the Browser supports the specified feature. The value of // this varies during the lifetime of the browser. For example, if the window // is fullscreen this may return a different value. If you only care about // whether or not it's possible for the browser to support a particular // feature use |CanSupportWindowFeature|. bool SupportsWindowFeature(WindowFeature feature) const; // Returns true if the Browser can support the specified feature. See comment // in |SupportsWindowFeature| for details on this. bool CanSupportWindowFeature(WindowFeature feature) const; // TODO(port): port these, and re-merge the two function declaration lists. // Page-related commands. void Print(); void AdvancedPrint(); void EmailPageLocation(); void ToggleEncodingAutoDetect(); void OverrideEncoding(int encoding_id); // Clipboard commands void Cut(); void Copy(); void Paste(); // Find-in-page void Find(); void FindNext(); void FindPrevious(); // Zoom void Zoom(content::PageZoom zoom); // Focus various bits of UI void FocusToolbar(); void FocusLocationBar(); // Also selects any existing text. void FocusSearch(); void FocusAppMenu(); void FocusBookmarksToolbar(); void FocusChromeOSStatus(); void FocusNextPane(); void FocusPreviousPane(); // Show various bits of UI void OpenFile(); void OpenCreateShortcutsDialog(); void ToggleDevToolsWindow(DevToolsToggleAction action); void OpenTaskManager(bool highlight_background_resources); void OpenFeedbackDialog(); void ToggleBookmarkBar(); void OpenBookmarkManager(); void OpenBookmarkManagerForNode(int64 node_id); void OpenBookmarkManagerEditNode(int64 node_id); void OpenBookmarkManagerAddNodeIn(int64 node_id); void ShowAppMenu(); void ShowAvatarMenu(); void ShowHistoryTab(); void ShowDownloadsTab(); void ShowExtensionsTab(); void ShowAboutConflictsTab(); void ShowBrokenPageTab(content::WebContents* contents); void ShowOptionsTab(const std::string& sub_page); // Shows the Content Settings page for a given content type. void ShowContentSettingsPage(ContentSettingsType content_type); void OpenClearBrowsingDataDialog(); void OpenOptionsDialog(); void OpenPasswordManager(); void OpenSyncMyBookmarksDialog(); void OpenImportSettingsDialog(); void OpenInstantConfirmDialog(); void OpenAboutChromeDialog(); void OpenUpdateChromeDialog(); void ShowHelpTab(); void OpenAutofillHelpTabAndActivate(); void OpenPrivacyDashboardTabAndActivate(); void OpenSearchEngineOptionsDialog(); #if defined(FILE_MANAGER_EXTENSION) void OpenFileManager(); #endif #if defined(OS_CHROMEOS) void LockScreen(); void Shutdown(); void OpenAdvancedOptionsDialog(); void OpenInternetOptionsDialog(); void OpenLanguageOptionsDialog(); void OpenSystemTabAndActivate(); void OpenMobilePlanTabAndActivate(); #endif #if defined(OS_CHROMEOS) && defined(USE_AURA) void OpenCrosh(); #endif void OpenPluginsTabAndActivate(); void ShowSyncSetup(); void ToggleSpeechInput(); virtual void UpdateDownloadShelfVisibility(bool visible); ///////////////////////////////////////////////////////////////////////////// // Sets the value of homepage related prefs to new values. Since we do not // want to change these values for existing users, we can not change the // default values under RegisterUserPrefs. Also if user already has an // existing profile we do not want to override those preferences so we only // set new values if they have not been set already. This method gets called // during First Run. static void SetNewHomePagePrefs(PrefService* prefs); static void RegisterPrefs(PrefService* prefs); static void RegisterUserPrefs(PrefService* prefs); // Helper function to run unload listeners on a WebContents. static bool RunUnloadEventsHelper(content::WebContents* contents); // Returns the Browser which contains the tab with the given // NavigationController, also filling in |index| (if valid) with the tab's // index in the tab strip. // Returns NULL if not found. // This call is O(N) in the number of tabs. static Browser* GetBrowserForController( const content::NavigationController* controller, int* index); // Retrieve the last active tabbed browser with a profile matching |profile|. static Browser* GetTabbedBrowser(Profile* profile, bool match_incognito); // Retrieve the last active tabbed browser with a profile matching |profile|. // Creates a new Browser if none are available. static Browser* GetOrCreateTabbedBrowser(Profile* profile); // Helper function to display the file selection dialog. static void RunFileChooserHelper( content::WebContents* tab, const content::FileChooserParams& params); // Helper function to enumerate a directory. static void EnumerateDirectoryHelper(content::WebContents* tab, int request_id, const FilePath& path); // Helper function to handle JS out of memory notifications static void JSOutOfMemoryHelper(content::WebContents* tab); // Helper function to register a protocol handler. static void RegisterProtocolHandlerHelper(content::WebContents* tab, const std::string& protocol, const GURL& url, const string16& title); // Helper function to register an intent handler. static void RegisterIntentHandlerHelper(content::WebContents* tab, const string16& action, const string16& type, const string16& href, const string16& title, const string16& disposition); // Helper function to handle find results. static void FindReplyHelper(content::WebContents* tab, int request_id, int number_of_matches, const gfx::Rect& selection_rect, int active_match_ordinal, bool final_update); // Helper function to handle crashed plugin notifications. static void CrashedPluginHelper(content::WebContents* tab, const FilePath& plugin_path); // Helper function to handle url update notifications. static void UpdateTargetURLHelper(content::WebContents* tab, int32 page_id, const GURL& url); // Calls ExecuteCommandWithDisposition with the given disposition. void ExecuteCommandWithDisposition(int id, WindowOpenDisposition); // Calls ExecuteCommandWithDisposition with the given event flags. void ExecuteCommand(int id, int event_flags); // Executes a command if it's enabled. // Returns true if the command is executed. bool ExecuteCommandIfEnabled(int id); // Returns true if |command_id| is a reserved command whose keyboard shortcuts // should not be sent to the renderer or |event| was triggered by a key that // we never want to send to the renderer. bool IsReservedCommandOrKey(int command_id, const NativeWebKeyboardEvent& event); // Sets if command execution shall be blocked. If |block| is true then // following calls to ExecuteCommand() or ExecuteCommandWithDisposition() // method will not execute the command, and the last blocked command will be // recorded for retrieval. void SetBlockCommandExecution(bool block); // Gets the last blocked command after calling SetBlockCommandExecution(true). // Returns the command id or -1 if there is no command blocked. The // disposition type of the command will be stored in |*disposition| if it's // not null. int GetLastBlockedCommand(WindowOpenDisposition* disposition); // Called by browser::Navigate() when a navigation has occurred in a tab in // this Browser. Updates the UI for the start of this navigation. void UpdateUIForNavigationInTab(TabContentsWrapper* contents, content::PageTransition transition, bool user_initiated); // Shows the cookies collected in the tab contents wrapper. void ShowCollectedCookiesDialog(TabContentsWrapper* wrapper); // Interface implementations //////////////////////////////////////////////// // Overridden from content::PageNavigator: virtual content::WebContents* OpenURL( const content::OpenURLParams& params) OVERRIDE; // Overridden from CommandUpdater::CommandUpdaterDelegate: virtual void ExecuteCommand(int id) OVERRIDE; // Overridden from TabRestoreServiceObserver: virtual void TabRestoreServiceChanged(TabRestoreService* service) OVERRIDE; virtual void TabRestoreServiceDestroyed(TabRestoreService* service) OVERRIDE; // Centralized method for creating a TabContents, configuring and installing // all its supporting objects and observers. static TabContentsWrapper* TabContentsFactory( Profile* profile, content::SiteInstance* site_instance, int routing_id, const content::WebContents* base_web_contents, content::SessionStorageNamespace* session_storage_namespace); // Overridden from TabHandlerDelegate: virtual Profile* GetProfile() const OVERRIDE; virtual Browser* AsBrowser() OVERRIDE; // Overridden from TabStripModelDelegate: virtual TabContentsWrapper* AddBlankTab(bool foreground); virtual TabContentsWrapper* AddBlankTabAt(int index, bool foreground); virtual Browser* CreateNewStripWithContents( TabContentsWrapper* detached_contents, const gfx::Rect& window_bounds, const DockInfo& dock_info, bool maximize); virtual int GetDragActions() const; // Construct a TabContents for a given URL, profile and transition type. // If instance is not null, its process will be used to render the tab. virtual TabContentsWrapper* CreateTabContentsForURL( const GURL& url, const content::Referrer& referrer, Profile* profile, content::PageTransition transition, bool defer_load, content::SiteInstance* instance) const; virtual bool CanDuplicateContentsAt(int index); virtual void DuplicateContentsAt(int index); virtual void CloseFrameAfterDragSession(); virtual void CreateHistoricalTab(TabContentsWrapper* contents); virtual bool RunUnloadListenerBeforeClosing(TabContentsWrapper* contents); virtual bool CanCloseContents(std::vector* indices); virtual bool CanBookmarkAllTabs() const; virtual void BookmarkAllTabs(); virtual bool CanCloseTab() const; virtual bool CanRestoreTab(); virtual void RestoreTab(); virtual bool LargeIconsPermitted() const; // Overridden from TabStripModelObserver: virtual void TabInsertedAt(TabContentsWrapper* contents, int index, bool foreground); virtual void TabClosingAt(TabStripModel* tab_strip_model, TabContentsWrapper* contents, int index); virtual void TabDetachedAt(TabContentsWrapper* contents, int index); virtual void TabDeactivated(TabContentsWrapper* contents); virtual void ActiveTabChanged(TabContentsWrapper* old_contents, TabContentsWrapper* new_contents, int index, bool user_gesture); virtual void TabMoved(TabContentsWrapper* contents, int from_index, int to_index); virtual void TabReplacedAt(TabStripModel* tab_strip_model, TabContentsWrapper* old_contents, TabContentsWrapper* new_contents, int index); virtual void TabPinnedStateChanged(TabContentsWrapper* contents, int index); virtual void TabStripEmpty(); // Fullscreen permission infobar callbacks. // TODO(koz): Remove this and have callers call FullscreenController directly. void OnAcceptFullscreenPermission(const GURL& url, FullscreenExitBubbleType bubble_type); void OnDenyFullscreenPermission(FullscreenExitBubbleType bubble_type); // Figure out if there are tabs that have beforeunload handlers. bool TabsNeedBeforeUnloadFired(); bool is_type_tabbed() const { return type_ == TYPE_TABBED; } bool is_type_popup() const { return type_ == TYPE_POPUP; } bool is_type_panel() const { return type_ == TYPE_PANEL; } bool is_app() const; bool is_devtools() const; // True when the current tab is in fullscreen mode, requested by // webkitRequestFullScreen. bool IsFullscreenForTab() const; // Called each time the browser window is shown. void OnWindowDidShow(); // Show the first run search engine bubble on the location bar. void ShowFirstRunBubble(); ExtensionWindowController* extension_window_controller() const { return extension_window_controller_.get(); } protected: // Wrapper for the factory method in BrowserWindow. This allows subclasses to // set their own window. virtual BrowserWindow* CreateBrowserWindow(); private: FRIEND_TEST_ALL_PREFIXES(AppModeTest, EnableAppModeTest); FRIEND_TEST_ALL_PREFIXES(BrowserTest, NoTabsInPopups); FRIEND_TEST_ALL_PREFIXES(BrowserTest, ConvertTabToAppShortcut); FRIEND_TEST_ALL_PREFIXES(BrowserTest, OpenAppWindowLikeNtp); FRIEND_TEST_ALL_PREFIXES(BrowserTest, AppIdSwitch); FRIEND_TEST_ALL_PREFIXES(BrowserTest, TestNewTabExitsFullscreen); FRIEND_TEST_ALL_PREFIXES(BrowserTest, TestTabExitsItselfFromFullscreen); FRIEND_TEST_ALL_PREFIXES(BrowserTest, TestFullscreenBubbleMouseLockState); FRIEND_TEST_ALL_PREFIXES(BrowserTest, TabEntersPresentationModeFromWindowed); FRIEND_TEST_ALL_PREFIXES(FullscreenExitBubbleControllerTest, DenyExitsFullscreen); FRIEND_TEST_ALL_PREFIXES(BrowserInitTest, OpenAppShortcutNoPref); FRIEND_TEST_ALL_PREFIXES(BrowserInitTest, OpenAppShortcutWindowPref); FRIEND_TEST_ALL_PREFIXES(BrowserInitTest, OpenAppShortcutTabPref); FRIEND_TEST_ALL_PREFIXES(BrowserInitTest, OpenAppShortcutPanel); // Used to describe why a tab is being detached. This is used by // TabDetachedAtImpl. enum DetachType { // Result of TabDetachedAt. DETACH_TYPE_DETACH, // Result of TabReplacedAt. DETACH_TYPE_REPLACE, // Result of the tab strip not having any significant tabs. DETACH_TYPE_EMPTY }; // Describes where the bookmark bar state change originated from. enum BookmarkBarStateChangeReason { // From the constructor. BOOKMARK_BAR_STATE_CHANGE_INIT, // Change is the result of the active tab changing. BOOKMARK_BAR_STATE_CHANGE_TAB_SWITCH, // Change is the result of the bookmark bar pref changing. BOOKMARK_BAR_STATE_CHANGE_PREF_CHANGE, // Change is the result of a state change in the active tab. BOOKMARK_BAR_STATE_CHANGE_TAB_STATE, // Change is the result of window toggling in/out of fullscreen mode. BOOKMARK_BAR_STATE_CHANGE_TOGGLE_FULLSCREEN, }; // Overridden from content::WebContentsDelegate: virtual content::WebContents* OpenURLFromTab( content::WebContents* source, const content::OpenURLParams& params) OVERRIDE; virtual void NavigationStateChanged(const content::WebContents* source, unsigned changed_flags) OVERRIDE; virtual void AddNewContents(content::WebContents* source, content::WebContents* new_contents, WindowOpenDisposition disposition, const gfx::Rect& initial_pos, bool user_gesture) OVERRIDE; virtual void ActivateContents(content::WebContents* contents) OVERRIDE; virtual void DeactivateContents(content::WebContents* contents) OVERRIDE; virtual void LoadingStateChanged(content::WebContents* source) OVERRIDE; virtual void CloseContents(content::WebContents* source) OVERRIDE; virtual void MoveContents(content::WebContents* source, const gfx::Rect& pos) OVERRIDE; virtual void DetachContents(content::WebContents* source) OVERRIDE; virtual bool IsPopupOrPanel( const content::WebContents* source) const OVERRIDE; virtual bool CanReloadContents(content::WebContents* source) const OVERRIDE; virtual void UpdateTargetURL(content::WebContents* source, int32 page_id, const GURL& url) OVERRIDE; virtual void ContentsMouseEvent(content::WebContents* source, const gfx::Point& location, bool motion) OVERRIDE; virtual void ContentsZoomChange(bool zoom_in) OVERRIDE; virtual void WebContentsFocused(content::WebContents* content) OVERRIDE; virtual bool TakeFocus(bool reverse) OVERRIDE; virtual bool IsApplication() const OVERRIDE; virtual void ConvertContentsToApplication( content::WebContents* source) OVERRIDE; virtual gfx::Rect GetRootWindowResizerRect() const OVERRIDE; virtual void BeforeUnloadFired(content::WebContents* source, bool proceed, bool* proceed_to_fire_unload) OVERRIDE; virtual void SetFocusToLocationBar(bool select_all) OVERRIDE; virtual void RenderWidgetShowing() OVERRIDE; virtual int GetExtraRenderViewHeight() const OVERRIDE; virtual void OnStartDownload(content::WebContents* source, content::DownloadItem* download) OVERRIDE; virtual void ViewSourceForTab(content::WebContents* source, const GURL& page_url) OVERRIDE; virtual void ViewSourceForFrame( content::WebContents* source, const GURL& frame_url, const std::string& frame_content_state) OVERRIDE; virtual bool PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event, bool* is_keyboard_shortcut) OVERRIDE; virtual void HandleKeyboardEvent( const NativeWebKeyboardEvent& event) OVERRIDE; virtual void ShowRepostFormWarningDialog( content::WebContents* source) OVERRIDE; virtual bool ShouldAddNavigationToHistory( const history::HistoryAddPageArgs& add_page_args, content::NavigationType navigation_type) OVERRIDE; virtual bool ShouldCreateWebContents( content::WebContents* web_contents, int route_id, WindowContainerType window_container_type, const string16& frame_name) OVERRIDE; virtual void WebContentsCreated(content::WebContents* source_contents, int64 source_frame_id, const GURL& target_url, content::WebContents* new_contents) OVERRIDE; virtual void ContentRestrictionsChanged( content::WebContents* source) OVERRIDE; virtual void RendererUnresponsive(content::WebContents* source) OVERRIDE; virtual void RendererResponsive(content::WebContents* source) OVERRIDE; virtual void WorkerCrashed(content::WebContents* source) OVERRIDE; virtual void DidNavigateMainFramePostCommit( content::WebContents* tab) OVERRIDE; virtual void DidNavigateToPendingEntry(content::WebContents* tab) OVERRIDE; virtual content::JavaScriptDialogCreator* GetJavaScriptDialogCreator() OVERRIDE; virtual void RunFileChooser( content::WebContents* tab, const content::FileChooserParams& params) OVERRIDE; virtual void EnumerateDirectory(content::WebContents* tab, int request_id, const FilePath& path) OVERRIDE; virtual void ToggleFullscreenModeForTab(content::WebContents* tab, bool enter_fullscreen) OVERRIDE; virtual bool IsFullscreenForTab( const content::WebContents* tab) const OVERRIDE; virtual void JSOutOfMemory(content::WebContents* tab) OVERRIDE; virtual void RegisterProtocolHandler(content::WebContents* tab, const std::string& protocol, const GURL& url, const string16& title) OVERRIDE; virtual void RegisterIntentHandler(content::WebContents* tab, const string16& action, const string16& type, const string16& href, const string16& title, const string16& disposition) OVERRIDE; virtual void WebIntentDispatch( content::WebContents* tab, content::WebIntentsDispatcher* intents_dispatcher) OVERRIDE; virtual void UpdatePreferredSize(content::WebContents* source, const gfx::Size& pref_size) OVERRIDE; virtual void ResizeDueToAutoResize(content::WebContents* source, const gfx::Size& new_size) OVERRIDE; virtual void FindReply(content::WebContents* tab, int request_id, int number_of_matches, const gfx::Rect& selection_rect, int active_match_ordinal, bool final_update) OVERRIDE; virtual void CrashedPlugin(content::WebContents* tab, const FilePath& plugin_path) OVERRIDE; virtual void RequestToLockMouse(content::WebContents* tab) OVERRIDE; virtual void LostMouseLock() OVERRIDE; // Overridden from CoreTabHelperDelegate: // Note that the caller is responsible for deleting |old_tab_contents|. virtual void SwapTabContents(TabContentsWrapper* old_tab_contents, TabContentsWrapper* new_tab_contents) OVERRIDE; // Overridden from SearchEngineTabHelperDelegate: virtual void ConfirmAddSearchProvider(const TemplateURL* template_url, Profile* profile) OVERRIDE; // Overridden from ConstrainedWindowTabHelperDelegate: virtual void SetTabContentBlocked(TabContentsWrapper* contents, bool blocked) OVERRIDE; // Overridden from BlockedContentTabHelperDelegate: virtual TabContentsWrapper* GetConstrainingContentsWrapper( TabContentsWrapper* source) OVERRIDE; // Overridden from BookmarkTabHelperDelegate: virtual void URLStarredChanged(TabContentsWrapper* source, bool starred) OVERRIDE; // Overridden from ExtensionTabHelperDelegate: virtual void OnDidGetApplicationInfo(TabContentsWrapper* source, int32 page_id) OVERRIDE; virtual void OnInstallApplication( TabContentsWrapper* source, const WebApplicationInfo& app_info) OVERRIDE; // Overridden from SelectFileDialog::Listener: virtual void FileSelected(const FilePath& path, int index, void* params) OVERRIDE; // Overridden from content::NotificationObserver: virtual void Observe(int type, const content::NotificationSource& source, const content::NotificationDetails& details) OVERRIDE; // Overridden from ProfileSyncServiceObserver: virtual void OnStateChanged() OVERRIDE; // Overriden from InstantDelegate: virtual void ShowInstant(TabContentsWrapper* preview_contents) OVERRIDE; virtual void HideInstant() OVERRIDE; virtual void CommitInstant(TabContentsWrapper* preview_contents) OVERRIDE; virtual void SetSuggestedText(const string16& text, InstantCompleteBehavior behavior) OVERRIDE; virtual gfx::Rect GetInstantBounds() OVERRIDE; // Command and state updating /////////////////////////////////////////////// // Returns true if the regular Chrome UI (not the fullscreen one and // not the single-tab one) is shown. Used for updating window command states // only. Consider using SupportsWindowFeature if you need the mentioned // functionality anywhere else. bool IsShowingMainUI(bool is_fullscreen); // Initialize state for all browser commands. void InitCommandState(); // Update commands whose state depends on incognito mode availability. void UpdateCommandsForIncognitoAvailability(); // Update commands whose state depends on the tab's state. void UpdateCommandsForTabState(); // Updates commands when the content's restrictions change. void UpdateCommandsForContentRestrictionState(); // Updates commands for enabling developer tools. void UpdateCommandsForDevTools(); // Updates commands for bookmark editing. void UpdateCommandsForBookmarkEditing(); // Updates commands that affect the bookmark bar. void UpdateCommandsForBookmarkBar(); // Set the preference that indicates that the home page has been changed. void MarkHomePageAsChanged(PrefService* pref_service); // Update commands whose state depends on whether the window is in fullscreen // mode. void UpdateCommandsForFullscreenMode(bool is_fullscreen); // Updates the printing command state. void UpdatePrintingState(int content_restrictions); // Updates the save-page-as command state. void UpdateSaveAsState(int content_restrictions); // Updates the open-file state (Mac Only). void UpdateOpenFileState(); // Ask the Reload/Stop button to change its icon, and update the Stop command // state. |is_loading| is true if the current TabContents is loading. // |force| is true if the button should change its icon immediately. void UpdateReloadStopState(bool is_loading, bool force); // UI update coalescing and handling //////////////////////////////////////// // Asks the toolbar (and as such the location bar) to update its state to // reflect the current tab's current URL, security state, etc. // If |should_restore_state| is true, we're switching (back?) to this tab and // should restore any previous location bar state (such as user editing) as // well. void UpdateToolbar(bool should_restore_state); // Does one or both of the following for each bit in |changed_flags|: // . If the update should be processed immediately, it is. // . If the update should processed asynchronously (to avoid lots of ui // updates), then scheduled_updates_ is updated for the |source| and update // pair and a task is scheduled (assuming it isn't running already) // that invokes ProcessPendingUIUpdates. void ScheduleUIUpdate(const content::WebContents* source, unsigned changed_flags); // Processes all pending updates to the UI that have been scheduled by // ScheduleUIUpdate in scheduled_updates_. void ProcessPendingUIUpdates(); // Removes all entries from scheduled_updates_ whose source is contents. void RemoveScheduledUpdatesFor(content::WebContents* contents); // Getters for UI /////////////////////////////////////////////////////////// // TODO(beng): remove, and provide AutomationProvider a better way to access // the LocationBarView's edit. friend class AutomationProvider; friend class BrowserProxy; friend class TestingAutomationProvider; // Returns the StatusBubble from the current toolbar. It is possible for // this to return NULL if called before the toolbar has initialized. // TODO(beng): remove this. StatusBubble* GetStatusBubble(); // Session restore functions //////////////////////////////////////////////// // Notifies the history database of the index for all tabs whose index is // >= index. void SyncHistoryWithTabs(int index); // OnBeforeUnload handling ////////////////////////////////////////////////// typedef std::set UnloadListenerSet; // Processes the next tab that needs it's beforeunload/unload event fired. void ProcessPendingTabs(); // Whether we've completed firing all the tabs' beforeunload/unload events. bool HasCompletedUnloadProcessing() const; // Clears all the state associated with processing tabs' beforeunload/unload // events since the user cancelled closing the window. void CancelWindowClose(); // Removes |tab| from the passed |set|. // Returns whether the tab was in the set in the first place. // TODO(beng): this method needs a better name! bool RemoveFromSet(UnloadListenerSet* set, content::WebContents* tab); // Cleans up state appropriately when we are trying to close the browser and // the tab has finished firing its unload handler. We also use this in the // cases where a tab crashes or hangs even if the beforeunload/unload haven't // successfully fired. If |process_now| is true |ProcessPendingTabs| is // invoked immediately, otherwise it is invoked after a delay (PostTask). // // Typically you'll want to pass in true for |process_now|. Passing in true // may result in deleting |tab|. If you know that shouldn't happen (because of // the state of the stack), pass in false. void ClearUnloadState(content::WebContents* tab, bool process_now); // In-progress download termination handling ///////////////////////////////// // Called when the window is closing to check if potential in-progress // downloads should prevent it from closing. // Returns true if the window can close, false otherwise. bool CanCloseWithInProgressDownloads(); // Assorted utility functions /////////////////////////////////////////////// // Sets the delegate of all the parts of the |TabContentsWrapper| that // are needed. void SetAsDelegate(TabContentsWrapper* tab, Browser* delegate); // Shows the Find Bar, optionally selecting the next entry that matches the // existing search string for that Tab. |forward_direction| controls the // search direction. void FindInPage(bool find_next, bool forward_direction); // Closes the frame. // TODO(beng): figure out if we need this now that the frame itself closes // after a return to the message loop. void CloseFrame(); void TabDetachedAtImpl(TabContentsWrapper* contents, int index, DetachType type); // Create a preference dictionary for the provided application name, in the // given user profile. This is done only once per application name / per // session / per user profile. static void RegisterAppPrefs(const std::string& app_name, Profile* profile); // Shared code between Reload() and ReloadIgnoringCache(). void ReloadInternal(WindowOpenDisposition disposition, bool ignore_cache); // Depending on the disposition, return the current tab or a clone of the // current tab. content::WebContents* GetOrCloneTabForDisposition( WindowOpenDisposition disposition); // Implementation of SupportsWindowFeature and CanSupportWindowFeature. If // |check_fullscreen| is true, the set of features reflect the actual state of // the browser, otherwise the set of features reflect the possible state of // the browser. bool SupportsWindowFeatureImpl(WindowFeature feature, bool check_fullscreen) const; // Determines if closing of browser can really be permitted after normal // sequence of downloads and unload handlers have given the go-ahead to close. // It is called from ShouldCloseWindow. It checks with // TabCloseableStateWatcher to confirm if browser can really be closed. // Appropriate action is taken by watcher as it sees fit. // If watcher denies closing of browser, CancelWindowClose is called to // cancel closing of window. bool IsClosingPermitted(); // Commits the current instant, returning true on success. This is intended // for use from OpenCurrentURL. bool OpenInstant(WindowOpenDisposition disposition); // If this browser should have instant one is created, otherwise does nothing. void CreateInstantIfNecessary(); // Opens view-source tab for given tab contents. void ViewSource(TabContentsWrapper* tab); // Opens view-source tab for any frame within given tab contents. void ViewSource(TabContentsWrapper* tab, const GURL& url, const std::string& content_state); // Retrieves the content restrictions for the currently selected tab. // Returns 0 if no tab selected, which is equivalent to no content // restrictions active. int GetContentRestrictionsForSelectedTab(); // Resets |bookmark_bar_state_| based on the active tab. Notifies the // BrowserWindow if necessary. void UpdateBookmarkBarState(BookmarkBarStateChangeReason reason); // Open the bookmark manager with a defined hash action. void OpenBookmarkManagerWithHash(const std::string& action, int64 node_id); // Creates a BackgroundContents if appropriate; return true if one was // created. bool MaybeCreateBackgroundContents(int route_id, content::SiteInstance* site, const GURL& opener_url, const string16& frame_name); // Data members ///////////////////////////////////////////////////////////// content::NotificationRegistrar registrar_; PrefChangeRegistrar profile_pref_registrar_; PrefChangeRegistrar local_pref_registrar_; // This Browser's type. const Type type_; // This Browser's profile. Profile* const profile_; // This Browser's window. BrowserWindow* window_; // This Browser's current TabHandler. scoped_ptr tab_handler_; // The CommandUpdater that manages the browser window commands. CommandUpdater command_updater_; // The application name that is also the name of the window to the shell. // This name should be set when: // 1) we launch an application via an application shortcut or extension API. // 2) we launch an undocked devtool window. std::string app_name_; // Unique identifier of this browser for session restore. This id is only // unique within the current session, and is not guaranteed to be unique // across sessions. const SessionID session_id_; // The model for the toolbar view. ToolbarModel toolbar_model_; // UI update coalescing and handling //////////////////////////////////////// typedef std::map UpdateMap; // Maps from TabContents to pending UI updates that need to be processed. // We don't update things like the URL or tab title right away to avoid // flickering and extra painting. // See ScheduleUIUpdate and ProcessPendingUIUpdates. UpdateMap scheduled_updates_; // The following factory is used for chrome update coalescing. base::WeakPtrFactory chrome_updater_factory_; // OnBeforeUnload handling ////////////////////////////////////////////////// // Tracks tabs that need there beforeunload event fired before we can // close the browser. Only gets populated when we try to close the browser. UnloadListenerSet tabs_needing_before_unload_fired_; // Tracks tabs that need there unload event fired before we can // close the browser. Only gets populated when we try to close the browser. UnloadListenerSet tabs_needing_unload_fired_; // Whether we are processing the beforeunload and unload events of each tab // in preparation for closing the browser. bool is_attempting_to_close_browser_; // In-progress download termination handling ///////////////////////////////// enum CancelDownloadConfirmationState { NOT_PROMPTED, // We have not asked the user. WAITING_FOR_RESPONSE, // We have asked the user and have not received a // reponse yet. RESPONSE_RECEIVED // The user was prompted and made a decision already. }; // State used to figure-out whether we should prompt the user for confirmation // when the browser is closed with in-progress downloads. CancelDownloadConfirmationState cancel_download_confirmation_state_; ///////////////////////////////////////////////////////////////////////////// // Override values for the bounds of the window and its maximized or minimized // state. // These are supplied by callers that don't want to use the default values. // The default values are typically loaded from local state (last session), // obtained from the last window of the same type, or obtained from the // shell shortcut's startup info. gfx::Rect override_bounds_; ui::WindowShowState show_state_; // Tracks when this browser is being created by session restore. bool is_session_restore_; // The following factory is used to close the frame at a later time. base::WeakPtrFactory weak_factory_; // The Find Bar. This may be NULL if there is no Find Bar, and if it is // non-NULL, it may or may not be visible. scoped_ptr find_bar_controller_; // Dialog box used for opening and saving files. scoped_refptr select_file_dialog_; // Keep track of the encoding auto detect pref. BooleanPrefMember encoding_auto_detect_; // Indicates if command execution is blocked. bool block_command_execution_; // Stores the last blocked command id when |block_command_execution_| is true. int last_blocked_command_id_; // Stores the disposition type of the last blocked command. WindowOpenDisposition last_blocked_command_disposition_; // Different types of action when web app info is available. // OnDidGetApplicationInfo uses this to dispatch calls. enum WebAppAction { NONE, // No action at all. CREATE_SHORTCUT, // Bring up create application shortcut dialog. UPDATE_SHORTCUT // Update icon for app shortcut. }; // Which deferred action to perform when OnDidGetApplicationInfo is notified // from a TabContents. Currently, only one pending action is allowed. WebAppAction pending_web_app_action_; // The profile's tab restore service. The service is owned by the profile, // and we install ourselves as an observer. TabRestoreService* tab_restore_service_; // Helper which implements the TabRestoreServiceDelegate interface. scoped_ptr tab_restore_service_delegate_; // Helper which implements the SyncedWindowDelegate interface. scoped_ptr synced_window_delegate_; scoped_ptr instant_; scoped_ptr instant_unload_handler_; BookmarkBar::State bookmark_bar_state_; scoped_refptr fullscreen_controller_; scoped_ptr extension_window_controller_; // True if the browser window has been shown at least once. bool window_has_shown_; DISALLOW_COPY_AND_ASSIGN(Browser); }; #endif // CHROME_BROWSER_UI_BROWSER_H_