// Copyright (c) 2006-2008 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_BROWSER_H_ #define CHROME_BROWSER_BROWSER_H_ #include "chrome/browser/controller.h" #include "chrome/browser/shell_dialogs.h" #include "chrome/browser/browser_window.h" #include "chrome/browser/session_id.h" #include "chrome/browser/tab_contents.h" #include "chrome/browser/tab_contents_delegate.h" #include "chrome/browser/tabs/tab_strip_model.h" #include "chrome/browser/toolbar_model.h" #include "chrome/common/notification_service.h" #include "chrome/common/pref_member.h" class BrowserIdleTimer; class BrowserWindow; class DebuggerWindow; class GoButton; class LocationBarView; class PrefService; class Profile; class StatusBubble; struct TabNavigation; class WebApp; class Browser : public TabStripModelDelegate, public TabStripModelObserver, public TabContentsDelegate, public CommandHandler, public NotificationObserver, public SelectFileDialog::Listener { public: enum Type { TYPE_NORMAL = 0, TYPE_POPUP = 1, TYPE_APP = 2 }; // 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, CreateBrowserWindow must // be called after configuration for window() to be valid. Browser(Type type, Profile* profile); ~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 tabstrip-less popup window. static Browser* CreateForPopup(Profile* profile); // Like Create, but creates a tabstrip-less and toolbar-less "app" window for // the specified app. static Browser* CreateForApp(const std::wstring& app_name, 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_override_maximized(bool maximized) { override_maximized_ = maximized; } // 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 CreateBrowserWindow(); // Accessors //////////////////////////////////////////////////////////////// Type type() const { return type_; } Profile* profile() const { return profile_; } BrowserWindow* window() const { return window_; } ToolbarModel* toolbar_model() { return &toolbar_model_; } const SessionID& session_id() const { return session_id_; } CommandController* controller() { return &controller_; } // Browser Creation Helpers ///////////////////////////////////////////////// // Opens a new window with the default blank tab. static void OpenEmptyWindow(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); // Opens the a new application window for the specified WebApp. static void OpenWebApplication(Profile* profile, WebApp* app); // Command API ////////////////////////////////////////////////////////////// // Please fix the incestuous nest that is */controller.h and eliminate the // need for this retarded hack. bool SupportsCommand(int id) const; bool IsCommandEnabled(int id) const; // State Storage and Retrieval for UI /////////////////////////////////////// // Save and restore the window position. std::wstring GetWindowPlacementKey() const; bool ShouldSaveWindowPlacement() const; void SaveWindowPlacement(const gfx::Rect& bounds, bool maximized); gfx::Rect GetSavedWindowBounds() const; bool GetSavedMaximizedState() const; // Gets the FavIcon of the page in the selected tab. SkBitmap GetCurrentPageIcon() const; // Gets the title of the page in the selected tab. std::wstring GetCurrentPageTitle() const; // Returns true if the current page is loading. bool IsCurrentPageLoading() const; // Prepares a title string for display (removes embedded newlines, etc). static void FormatTitleForDisplay(std::wstring* title); // OnBeforeUnload handling ////////////////////////////////////////////////// // Gives beforeunload handlers the chance to cancel the close. bool ShouldCloseWindow(); // Invoked when the window containing us is closing. Performs the necessary // cleanup. void OnWindowClosing(); // TabStripModel pass-thrus ///////////////////////////////////////////////// TabStripModel* tabstrip_model() const { return const_cast(&tabstrip_model_); } int tab_count() const { return tabstrip_model_.count(); } int selected_index() const { return tabstrip_model_.selected_index(); } int GetIndexOfController(const NavigationController* controller) const { return tabstrip_model_.GetIndexOfController(controller); } TabContents* GetTabContentsAt(int index) const { return tabstrip_model_.GetTabContentsAt(index); } TabContents* GetSelectedTabContents() const { return tabstrip_model_.GetSelectedTabContents(); } void SelectTabContentsAt(int index, bool user_gesture) { tabstrip_model_.SelectTabContentsAt(index, user_gesture); } TabContents* AddBlankTab(bool foreground) { return tabstrip_model_.AddBlankTab(foreground); } void CloseAllTabs() { tabstrip_model_.CloseAllTabs(); } // Tab adding/showing functions ///////////////////////////////////////////// // Add a new tab with the specified URL. If instance is not null, its process // will be used to render the tab. TabContents* AddTabWithURL( const GURL& url, const GURL& referrer, PageTransition::Type transition, bool foreground, SiteInstance* instance); // Add a new application tab for the specified URL. If lazy is true, the tab // won't be selected. Further, the initial web page load will only take place // when the tab is first selected. TabContents* AddWebApplicationTab(Profile* profile, WebApp* web_app, bool lazy); // Add a new tab, given a NavigationController. A TabContents appropriate to // display the last committed entry is created and returned. TabContents* AddTabWithNavigationController(NavigationController* ctrl, PageTransition::Type type); // Add a tab with its session history restored from the SessionRestore // system. If select is true, the tab is selected. Returns the created // NavigationController. |tab_index| gives the index to insert the tab at. // |selected_navigation| is the index of the TabNavigation in |navigations| // to select. NavigationController* AddRestoredTab( const std::vector& navigations, int tab_index, int selected_navigation, bool select); // 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); // Show a native UI tab given a URL. If a tab with the same URL is already // visible in this browser, it becomes selected. Otherwise a new tab is // created. void ShowNativeUITab(const GURL& url); // Assorted browser commands //////////////////////////////////////////////// // Navigation commands void GoBack(); void GoForward(); void Reload(); void Stop(); void Home(); void Go(); void OpenCurrentURL(); // Window management commands void NewTab(); void CloseTab(); void CloseApp(); void NewWindow(); void NewIncognitoWindow(); void CloseWindow(); void SelectNextTab(); void SelectPreviousTab(); void SelectNumberedTab(int index); void SelectLastTab(); void DuplicateTab(); void RestoreTab(); void ConvertPopupToTabbedBrowser(); void Exit(); // Clipboard commands void Cut(); void Copy(); void CopyCurrentPageURL(); void Paste(); // Opens the FindInPage window for the currently open tab. void Find(); void FindNext(); void FindPrevious(); // Zoom void ZoomIn(); void ZoomOut(); void ZoomReset(); // Sets focus to various bits of UI. void FocusLocationBar(); void FocusSearch(); void FocusToolbar(); // Page-related commands. void BookmarkCurrentPage(); void ViewSource(); void ClosePopups(); void Print(); void SavePage(); void ToggleEncodingAutoDetect(); void OverrideEncoding(int encoding_id); // Show various bits of UI. void OpenKeywordEditor(); void OpenClearBrowsingDataDialog(); void OpenImportSettingsDialog(); void OpenBugReportDialog(); void OpenDebuggerWindow(); void OpenJavaScriptConsole(); void OpenCreateShortcutsDialog(); void OpenPasswordManager(); void OpenAboutChromeDialog(); void OpenFile(); void OpenTaskManager(); void OpenOptionsDialog(); void OpenHelpTab(); void ShowHistoryTab(); void ShowDownloadsTab(); void OpenBookmarksManager(); void ToggleBookmarksBar(); ///////////////////////////////////////////////////////////////////////////// static void RegisterPrefs(PrefService* prefs); static void RegisterUserPrefs(PrefService* prefs); // 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 NavigationController* controller, int* index); // Interface implementations //////////////////////////////////////////////// // Overridden from CommandHandler: virtual bool GetContextualLabel(int id, std::wstring* out) const { return false; } virtual void ExecuteCommand(int id); // Overridden from TabStripModelDelegate: virtual GURL GetBlankTabURL() const; virtual void CreateNewStripWithContents(TabContents* detached_contents, const gfx::Rect& window_bounds, const DockInfo& dock_info); 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 TabContents* CreateTabContentsForURL( const GURL& url, const GURL& referrer, Profile* profile, PageTransition::Type transition, bool defer_load, SiteInstance* instance) const; virtual bool CanDuplicateContentsAt(int index); virtual void DuplicateContentsAt(int index); virtual void CloseFrameAfterDragSession(); // Overridden from TabStripModelObserver: virtual void TabInsertedAt(TabContents* contents, int index, bool foreground); virtual void TabClosingAt(TabContents* contents, int index); virtual void TabDetachedAt(TabContents* contents, int index); virtual void TabSelectedAt(TabContents* old_contents, TabContents* new_contents, int index, bool user_gesture); virtual void TabMoved(TabContents* contents, int from_index, int to_index); virtual void TabStripEmpty(); // Overridden from TabContentsDelegate: virtual void OpenURLFromTab(TabContents* source, const GURL& url, const GURL& referrer, WindowOpenDisposition disposition, PageTransition::Type transition); virtual void NavigationStateChanged(const TabContents* source, unsigned changed_flags); virtual void ReplaceContents(TabContents* source, TabContents* new_contents); virtual void AddNewContents(TabContents* source, TabContents* new_contents, WindowOpenDisposition disposition, const gfx::Rect& initial_pos, bool user_gesture); virtual void ActivateContents(TabContents* contents); virtual void LoadingStateChanged(TabContents* source); virtual void CloseContents(TabContents* source); virtual void MoveContents(TabContents* source, const gfx::Rect& pos); virtual bool IsPopup(TabContents* source); virtual void ToolbarSizeChanged(TabContents* source, bool is_animating); virtual void URLStarredChanged(TabContents* source, bool starred); virtual void ContentsMouseEvent(TabContents* source, UINT message); virtual void UpdateTargetURL(TabContents* source, const GURL& url); virtual void ContentsZoomChange(bool zoom_in); virtual bool IsApplication() const; virtual void ConvertContentsToApplication(TabContents* source); virtual void ContentsStateChanged(TabContents* source); virtual bool ShouldDisplayURLField(); virtual void BeforeUnloadFired(TabContents* source, bool proceed, bool* proceed_to_fire_unload); virtual void ShowHtmlDialog(HtmlDialogContentsDelegate* delegate, void* parent_window); // Overridden from SelectFileDialog::Listener: virtual void FileSelected(const std::wstring& path, void* params); // Overridden from NotificationObserver: virtual void Observe(NotificationType type, const NotificationSource& source, const NotificationDetails& details); private: // Command and state updating /////////////////////////////////////////////// // Initialize state for all browser commands. void InitCommandState(); // Update commands that drive the NavigationController to reflect changes in // the NavigationController's state (Back, Forward, etc). void UpdateNavigationCommands(); // Change the "starred" button display to starred/unstarred. // TODO(evanm): migrate this to the commands framework. void SetStarredButtonToggled(bool starred); // 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); // Adds an update to the update queue and schedules an update if necessary. // These are subsequently processed by ProcessPendingUIUpdates. // |changed_flags| is a bitfield of TabContents::INVALIDATE_* values. void ScheduleUIUpdate(const TabContents* source, unsigned changed_flags); // Processes all pending updates to the UI that have been queued by // ScheduleUIUpdate in scheduled_updates_. void ProcessPendingUIUpdates(); // Removes all entries from scheduled_updates_ whose source is contents. void RemoveScheduledUpdatesFor(TabContents* contents); // Getters for UI /////////////////////////////////////////////////////////// // TODO(beng): remove, and provide AutomationProvider a better way to access // the LocationBarView's edit. friend class AutomationProvider; // Getters for the location bar and go button. LocationBarView* GetLocationBarView() const; GoButton* GetGoButton(); // 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); // Called from AddRestoredTab and ReplaceRestoredTab to build a // NavigationController from an incoming vector of TabNavigations. // Caller takes ownership of the returned NavigationController. NavigationController* BuildRestoredNavigationController( const std::vector& navigations, int selected_navigation); // OnBeforeUnload handling ////////////////////////////////////////////////// typedef std::vector UnloadListenerVector; // 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(); // Clears all the state associated with processing tabs' beforeunload/unload // events since the user cancelled closing the window. void CancelWindowClose(); // Removes the tab from the associated vector. Returns whether the tab // was in the vector in the first place. // TODO(beng): this method needs a better name! bool RemoveFromVector(UnloadListenerVector* vector, TabContents* tab); // Cleans up state appropriately when we are trying to close the browser and // the tab has finished firing it's unload handler. We also use this in the // cases where a tab crashes or hangs even if the beforeunload/unload haven't // successfully fired. void ClearUnloadState(TabContents* tab); // Assorted utility functions /////////////////////////////////////////////// // Retrieve the last active tabbed browser with the same profile as the // receiving Browser. Creates a new Browser if none are available. Browser* GetOrCreateTabbedBrowser(); // Creates a new popup window with its own Browser object with the // incoming sizing information. |initial_pos|'s origin() is the // window origin, and its size() is the size of the content area. void BuildPopupWindow(TabContents* source, TabContents* new_contents, const gfx::Rect& initial_pos); // Returns what the user's home page is, or the new tab page if the home page // has not been set. GURL GetHomePage(); // Advance the find selection by one. Direction is either forward or // backwards depending on parameter passed in. void AdvanceFindSelection(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(); // Compute a deterministic name based on the URL. We use this pseudo name // as a key to store window location per application URLs. static std::wstring ComputeApplicationNameFromURL(const GURL& url); // Create a preference dictionary for the provided application name. This is // done only once per application name / per session. static void RegisterAppPrefs(const std::wstring& app_name); // Data members ///////////////////////////////////////////////////////////// // This Browser's type. Type type_; // This Browser's profile. Profile* profile_; // This Browser's window. BrowserWindow* window_; // This Browser's TabStripModel. TabStripModel tabstrip_model_; // The Controller that updates all browser commands. CommandController controller_; // An optional application name which is used to retrieve and save window // positions. std::wstring 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. SessionID session_id_; // TODO(beng): should be combined with ToolbarModel now that this is the only // implementation. class BrowserToolbarModel : public ToolbarModel { public: explicit BrowserToolbarModel(Browser* browser) : browser_(browser) { } virtual ~BrowserToolbarModel() { } // ToolbarModel implementation. virtual NavigationController* GetNavigationController() { // This |current_tab| can be NULL during the initialization of the // toolbar during window creation (i.e. before any tabs have been added // to the window). TabContents* current_tab = browser_->GetSelectedTabContents(); return current_tab ? current_tab->controller() : NULL; } private: Browser* browser_; DISALLOW_EVIL_CONSTRUCTORS(BrowserToolbarModel); }; // The model for the toolbar view. BrowserToolbarModel toolbar_model_; // UI update coalescing and handling //////////////////////////////////////// // Tracks invalidates to the UI, see the declaration in the .cc file. struct UIUpdate; typedef std::vector UpdateVector; // Lists all UI updates that are pending. We don't update things like the // URL or tab title right away to avoid flickering and extra painting. // See ScheduleUIUpdate and ProcessPendingUIUpdates. UpdateVector scheduled_updates_; // The following factory is used for chrome update coalescing. ScopedRunnableMethodFactory 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. UnloadListenerVector 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. UnloadListenerVector 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_; ///////////////////////////////////////////////////////////////////////////// // Override values for the bounds of the window and its maximized 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_; bool override_maximized_; // The following factory is used to close the frame at a later time. ScopedRunnableMethodFactory method_factory_; // Debugger Window, created lazily scoped_refptr debugger_window_; // Dialog box used for opening and saving files. scoped_refptr select_file_dialog_; // The browser idle task helps cleanup unused memory resources when idle. scoped_ptr idle_task_; // Keep track of the encoding auto detect pref. BooleanPrefMember encoding_auto_detect_; DISALLOW_COPY_AND_ASSIGN(Browser); }; #endif // CHROME_BROWSER_BROWSER_H_