browser.h revision 23730a6e56a168d1879203e4b3819bb36e3d8f1f 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef CHROME_BROWSER_UI_BROWSER_H_
6#define CHROME_BROWSER_UI_BROWSER_H_
7
8#include <map>
9#include <set>
10#include <string>
11#include <vector>
12
13#include "base/basictypes.h"
14#include "base/compiler_specific.h"
15#include "base/gtest_prod_util.h"
16#include "base/memory/scoped_ptr.h"
17#include "base/memory/weak_ptr.h"
18#include "base/prefs/pref_change_registrar.h"
19#include "base/prefs/pref_member.h"
20#include "base/strings/string16.h"
21#include "chrome/browser/devtools/devtools_toggle_action.h"
22#include "chrome/browser/sessions/session_id.h"
23#include "chrome/browser/ui/bookmarks/bookmark_bar.h"
24#include "chrome/browser/ui/bookmarks/bookmark_tab_helper_delegate.h"
25#include "chrome/browser/ui/browser_navigator.h"
26#include "chrome/browser/ui/chrome_web_modal_dialog_manager_delegate.h"
27#include "chrome/browser/ui/host_desktop.h"
28#include "chrome/browser/ui/search_engines/search_engine_tab_helper_delegate.h"
29#include "chrome/browser/ui/tab_contents/core_tab_helper_delegate.h"
30#include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
31#include "chrome/browser/ui/toolbar/toolbar_model.h"
32#include "chrome/browser/ui/zoom/zoom_observer.h"
33#include "chrome/common/content_settings.h"
34#include "chrome/common/content_settings_types.h"
35#include "chrome/common/extensions/extension_constants.h"
36#include "content/public/browser/notification_observer.h"
37#include "content/public/browser/notification_registrar.h"
38#include "content/public/browser/page_navigator.h"
39#include "content/public/browser/web_contents_delegate.h"
40#include "content/public/common/page_transition_types.h"
41#include "content/public/common/page_zoom.h"
42#include "ui/base/ui_base_types.h"
43#include "ui/base/window_open_disposition.h"
44#include "ui/gfx/rect.h"
45#include "ui/shell_dialogs/select_file_dialog.h"
46
47class BrowserContentSettingBubbleModelDelegate;
48class BrowserContentTranslateDriverObserver;
49class BrowserInstantController;
50class BrowserSyncedWindowDelegate;
51class BrowserToolbarModelDelegate;
52class BrowserTabRestoreServiceDelegate;
53class BrowserWindow;
54class FindBarController;
55class FullscreenController;
56class PrefService;
57class Profile;
58class SearchDelegate;
59class SearchModel;
60class StatusBubble;
61class TabStripModel;
62class TabStripModelDelegate;
63struct WebApplicationInfo;
64
65namespace chrome {
66class BrowserCommandController;
67class FastUnloadController;
68class UnloadController;
69class ValidationMessageBubble;
70}
71
72namespace content {
73class NavigationController;
74class PageState;
75class SessionStorageNamespace;
76}
77
78namespace extensions {
79class Extension;
80class WindowController;
81}
82
83namespace gfx {
84class Image;
85class Point;
86}
87
88namespace ui {
89struct SelectedFileInfo;
90class WebDialogDelegate;
91}
92
93namespace web_modal {
94class WebContentsModalDialogHost;
95}
96
97class Browser : public TabStripModelObserver,
98                public content::WebContentsDelegate,
99                public CoreTabHelperDelegate,
100                public SearchEngineTabHelperDelegate,
101                public ChromeWebModalDialogManagerDelegate,
102                public BookmarkTabHelperDelegate,
103                public ZoomObserver,
104                public content::PageNavigator,
105                public content::NotificationObserver,
106                public ui::SelectFileDialog::Listener {
107 public:
108  // SessionService::WindowType mirrors these values.  If you add to this
109  // enum, look at SessionService::WindowType to see if it needs to be
110  // updated.
111  enum Type {
112    // If you add a new type, consider updating the test
113    // BrowserTest.StartMaximized.
114    TYPE_TABBED = 1,
115    TYPE_POPUP = 2
116  };
117
118  // Distinguishes between browsers that host an app (opened from
119  // ApplicationLauncher::OpenApplication), and child browsers created by an app
120  // from Browser::CreateForApp (e.g. by windows.open or the extension API).
121  enum AppType {
122    APP_TYPE_HOST = 1,
123    APP_TYPE_CHILD = 2
124  };
125
126  // Possible elements of the Browser window.
127  enum WindowFeature {
128    FEATURE_NONE = 0,
129    FEATURE_TITLEBAR = 1,
130    FEATURE_TABSTRIP = 2,
131    FEATURE_TOOLBAR = 4,
132    FEATURE_LOCATIONBAR = 8,
133    FEATURE_BOOKMARKBAR = 16,
134    FEATURE_INFOBAR = 32,
135    FEATURE_DOWNLOADSHELF = 64
136  };
137
138  // The context for a download blocked notification from
139  // OkToCloseWithInProgressDownloads.
140  enum DownloadClosePreventionType {
141    // Browser close is not blocked by download state.
142    DOWNLOAD_CLOSE_OK,
143
144    // The browser is shutting down and there are active downloads
145    // that would be cancelled.
146    DOWNLOAD_CLOSE_BROWSER_SHUTDOWN,
147
148    // There are active downloads associated with this incognito profile
149    // that would be canceled.
150    DOWNLOAD_CLOSE_LAST_WINDOW_IN_INCOGNITO_PROFILE,
151  };
152
153  struct CreateParams {
154    CreateParams(Profile* profile, chrome::HostDesktopType host_desktop_type);
155    CreateParams(Type type,
156                 Profile* profile,
157                 chrome::HostDesktopType host_desktop_type);
158
159    static CreateParams CreateForApp(Type type,
160                                     const std::string& app_name,
161                                     const gfx::Rect& window_bounds,
162                                     Profile* profile,
163                                     chrome::HostDesktopType host_desktop_type);
164
165    static CreateParams CreateForDevTools(
166        Profile* profile,
167        chrome::HostDesktopType host_desktop_type);
168
169    // The browser type.
170    Type type;
171
172    // The associated profile.
173    Profile* profile;
174
175    // The host desktop the browser is created on.
176    chrome::HostDesktopType host_desktop_type;
177
178    // The application name that is also the name of the window to the shell.
179    // This name should be set when:
180    // 1) we launch an application via an application shortcut or extension API.
181    // 2) we launch an undocked devtool window.
182    std::string app_name;
183
184    // Type of app (host or child). See description of AppType.
185    AppType app_type;
186
187    // The bounds of the window to open.
188    gfx::Rect initial_bounds;
189
190    ui::WindowShowState initial_show_state;
191
192    bool is_session_restore;
193
194    // Supply a custom BrowserWindow implementation, to be used instead of the
195    // default. Intended for testing.
196    BrowserWindow* window;
197  };
198
199  // Constructors, Creation, Showing //////////////////////////////////////////
200
201  explicit Browser(const CreateParams& params);
202  virtual ~Browser();
203
204  // Set overrides for the initial window bounds and maximized state.
205  void set_override_bounds(const gfx::Rect& bounds) {
206    override_bounds_ = bounds;
207  }
208  ui::WindowShowState initial_show_state() const { return initial_show_state_; }
209  void set_initial_show_state(ui::WindowShowState initial_show_state) {
210    initial_show_state_ = initial_show_state;
211  }
212  // Return true if the initial window bounds have been overridden.
213  bool bounds_overridden() const {
214    return !override_bounds_.IsEmpty();
215  }
216  // Set indicator that this browser is being created via session restore.
217  // This is used on the Mac (only) to determine animation style when the
218  // browser window is shown.
219  void set_is_session_restore(bool is_session_restore) {
220    is_session_restore_ = is_session_restore;
221  }
222  bool is_session_restore() const {
223    return is_session_restore_;
224  }
225  chrome::HostDesktopType host_desktop_type() const {
226    return host_desktop_type_;
227  }
228
229  // Accessors ////////////////////////////////////////////////////////////////
230
231  Type type() const { return type_; }
232  const std::string& app_name() const { return app_name_; }
233  AppType app_type() const { return app_type_; }
234  Profile* profile() const { return profile_; }
235  gfx::Rect override_bounds() const { return override_bounds_; }
236
237  // |window()| will return NULL if called before |CreateBrowserWindow()|
238  // is done.
239  BrowserWindow* window() const { return window_; }
240  ToolbarModel* toolbar_model() { return toolbar_model_.get(); }
241  const ToolbarModel* toolbar_model() const { return toolbar_model_.get(); }
242#if defined(UNIT_TEST)
243  void swap_toolbar_models(scoped_ptr<ToolbarModel>* toolbar_model) {
244    toolbar_model->swap(toolbar_model_);
245  }
246#endif
247  TabStripModel* tab_strip_model() const { return tab_strip_model_.get(); }
248  chrome::BrowserCommandController* command_controller() {
249    return command_controller_.get();
250  }
251  SearchModel* search_model() { return search_model_.get(); }
252  const SearchModel* search_model() const {
253      return search_model_.get();
254  }
255  SearchDelegate* search_delegate() {
256    return search_delegate_.get();
257  }
258  const SessionID& session_id() const { return session_id_; }
259  BrowserContentSettingBubbleModelDelegate*
260      content_setting_bubble_model_delegate() {
261    return content_setting_bubble_model_delegate_.get();
262  }
263  BrowserTabRestoreServiceDelegate* tab_restore_service_delegate() {
264    return tab_restore_service_delegate_.get();
265  }
266  BrowserSyncedWindowDelegate* synced_window_delegate() {
267    return synced_window_delegate_.get();
268  }
269  BrowserInstantController* instant_controller() {
270    return instant_controller_.get();
271  }
272
273  // Get the FindBarController for this browser, creating it if it does not
274  // yet exist.
275  FindBarController* GetFindBarController();
276
277  // Returns true if a FindBarController exists for this browser.
278  bool HasFindBarController() const;
279
280  // Returns the state of the bookmark bar.
281  BookmarkBar::State bookmark_bar_state() const { return bookmark_bar_state_; }
282
283  // State Storage and Retrieval for UI ///////////////////////////////////////
284
285  // Gets the Favicon of the page in the selected tab.
286  gfx::Image GetCurrentPageIcon() const;
287
288  // Gets the title of the window based on the selected tab's title.
289  base::string16 GetWindowTitleForCurrentTab() const;
290
291  // Prepares a title string for display (removes embedded newlines, etc).
292  static void FormatTitleForDisplay(base::string16* title);
293
294  // OnBeforeUnload handling //////////////////////////////////////////////////
295
296  // Gives beforeunload handlers the chance to cancel the close. Returns whether
297  // to proceed with the close. If called while the process begun by
298  // CallBeforeUnloadHandlers is in progress, returns false without taking
299  // action.
300  bool ShouldCloseWindow();
301
302  // Begins the process of confirming whether the associated browser can be
303  // closed. If there are no tabs with beforeunload handlers it will immediately
304  // return false. Otherwise, it starts prompting the user, returns true and
305  // will call |on_close_confirmed| with the result of the user's decision.
306  // After calling this function, if the window will not be closed, call
307  // ResetBeforeUnloadHandlers() to reset all beforeunload handlers; calling
308  // this function multiple times without an intervening call to
309  // ResetBeforeUnloadHandlers() will run only the beforeunload handlers
310  // registered since the previous call.
311  bool CallBeforeUnloadHandlers(
312      const base::Callback<void(bool)>& on_close_confirmed);
313
314  // Clears the results of any beforeunload confirmation dialogs triggered by a
315  // CallBeforeUnloadHandlers call.
316  void ResetBeforeUnloadHandlers();
317
318  // Figure out if there are tabs that have beforeunload handlers.
319  // It starts beforeunload/unload processing as a side-effect.
320  bool TabsNeedBeforeUnloadFired();
321
322  // Returns true if all tabs' beforeunload/unload events have fired.
323  bool HasCompletedUnloadProcessing() const;
324
325  bool IsAttemptingToCloseBrowser() const;
326
327  // Invoked when the window containing us is closing. Performs the necessary
328  // cleanup.
329  void OnWindowClosing();
330
331  // In-progress download termination handling /////////////////////////////////
332
333  // Called when the user has decided whether to proceed or not with the browser
334  // closure.  |cancel_downloads| is true if the downloads should be canceled
335  // and the browser closed, false if the browser should stay open and the
336  // downloads running.
337  void InProgressDownloadResponse(bool cancel_downloads);
338
339  // Indicates whether or not this browser window can be closed, or
340  // would be blocked by in-progress downloads.
341  // If executing downloads would be cancelled by this window close,
342  // then |*num_downloads_blocking| is updated with how many downloads
343  // would be canceled if the close continued.
344  DownloadClosePreventionType OkToCloseWithInProgressDownloads(
345      int* num_downloads_blocking) const;
346
347  // External state change handling ////////////////////////////////////////////
348
349  // Invoked when the fullscreen state of the window changes.
350  // BrowserWindow::EnterFullscreen invokes this after the window has become
351  // fullscreen.
352  void WindowFullscreenStateChanged();
353
354  // Invoked when visible SSL state (as defined by SSLStatus) changes.
355  void VisibleSSLStateChanged(content::WebContents* web_contents);
356
357  // Invoked when the |web_contents| no longer supports Instant. Refreshes the
358  // omnibox so it no longer shows search terms.
359  void OnWebContentsInstantSupportDisabled(
360      const content::WebContents* web_contents);
361
362  // Assorted browser commands ////////////////////////////////////////////////
363
364  // NOTE: Within each of the following sections, the IDs are ordered roughly by
365  // how they appear in the GUI/menus (left to right, top to bottom, etc.).
366
367  // See the description of
368  // FullscreenController::ToggleFullscreenModeWithExtension.
369  void ToggleFullscreenModeWithExtension(const GURL& extension_url);
370#if defined(OS_WIN)
371  // See the description of FullscreenController::ToggleMetroSnapMode.
372  void SetMetroSnapMode(bool enable);
373#endif
374
375  // Returns true if the Browser supports the specified feature. The value of
376  // this varies during the lifetime of the browser. For example, if the window
377  // is fullscreen this may return a different value. If you only care about
378  // whether or not it's possible for the browser to support a particular
379  // feature use |CanSupportWindowFeature|.
380  bool SupportsWindowFeature(WindowFeature feature) const;
381
382  // Returns true if the Browser can support the specified feature. See comment
383  // in |SupportsWindowFeature| for details on this.
384  bool CanSupportWindowFeature(WindowFeature feature) const;
385
386  // TODO(port): port these, and re-merge the two function declaration lists.
387  // Page-related commands.
388  void ToggleEncodingAutoDetect();
389  void OverrideEncoding(int encoding_id);
390
391  // Show various bits of UI
392  void OpenFile();
393
394  void UpdateDownloadShelfVisibility(bool visible);
395
396  /////////////////////////////////////////////////////////////////////////////
397
398  // Called by chrome::Navigate() when a navigation has occurred in a tab in
399  // this Browser. Updates the UI for the start of this navigation.
400  void UpdateUIForNavigationInTab(content::WebContents* contents,
401                                  content::PageTransition transition,
402                                  bool user_initiated);
403
404  // Interface implementations ////////////////////////////////////////////////
405
406  // Overridden from content::PageNavigator:
407  virtual content::WebContents* OpenURL(
408      const content::OpenURLParams& params) OVERRIDE;
409
410  // Overridden from TabStripModelObserver:
411  virtual void TabInsertedAt(content::WebContents* contents,
412                             int index,
413                             bool foreground) OVERRIDE;
414  virtual void TabClosingAt(TabStripModel* tab_strip_model,
415                            content::WebContents* contents,
416                            int index) OVERRIDE;
417  virtual void TabDetachedAt(content::WebContents* contents,
418                             int index) OVERRIDE;
419  virtual void TabDeactivated(content::WebContents* contents) OVERRIDE;
420  virtual void ActiveTabChanged(content::WebContents* old_contents,
421                                content::WebContents* new_contents,
422                                int index,
423                                int reason) OVERRIDE;
424  virtual void TabMoved(content::WebContents* contents,
425                        int from_index,
426                        int to_index) OVERRIDE;
427  virtual void TabReplacedAt(TabStripModel* tab_strip_model,
428                             content::WebContents* old_contents,
429                             content::WebContents* new_contents,
430                             int index) OVERRIDE;
431  virtual void TabPinnedStateChanged(content::WebContents* contents,
432                                     int index) OVERRIDE;
433  virtual void TabStripEmpty() OVERRIDE;
434
435  // Overridden from content::WebContentsDelegate:
436  virtual bool CanOverscrollContent() const OVERRIDE;
437  virtual bool PreHandleKeyboardEvent(
438      content::WebContents* source,
439      const content::NativeWebKeyboardEvent& event,
440      bool* is_keyboard_shortcut) OVERRIDE;
441  virtual void HandleKeyboardEvent(
442      content::WebContents* source,
443      const content::NativeWebKeyboardEvent& event) OVERRIDE;
444  virtual void OverscrollUpdate(int delta_y) OVERRIDE;
445  virtual void ShowValidationMessage(content::WebContents* web_contents,
446                                     const gfx::Rect& anchor_in_root_view,
447                                     const base::string16& main_text,
448                                     const base::string16& sub_text) OVERRIDE;
449  virtual void HideValidationMessage(
450      content::WebContents* web_contents) OVERRIDE;
451  virtual void MoveValidationMessage(
452      content::WebContents* web_contents,
453      const gfx::Rect& anchor_in_root_view) OVERRIDE;
454  virtual bool PreHandleGestureEvent(
455      content::WebContents* source,
456      const blink::WebGestureEvent& event) OVERRIDE;
457
458  bool is_type_tabbed() const { return type_ == TYPE_TABBED; }
459  bool is_type_popup() const { return type_ == TYPE_POPUP; }
460
461  bool is_app() const;
462  bool is_devtools() const;
463
464  // True when the mouse cursor is locked.
465  bool IsMouseLocked() const;
466
467  // Called each time the browser window is shown.
468  void OnWindowDidShow();
469
470  // Show the first run search engine bubble on the location bar.
471  void ShowFirstRunBubble();
472
473  // Show a download on the download shelf.
474  void ShowDownload(content::DownloadItem* download);
475
476  FullscreenController* fullscreen_controller() const {
477    return fullscreen_controller_.get();
478  }
479
480  extensions::WindowController* extension_window_controller() const {
481    return extension_window_controller_.get();
482  }
483
484 private:
485  friend class BrowserTest;
486  friend class FullscreenControllerInteractiveTest;
487  friend class FullscreenControllerTest;
488  FRIEND_TEST_ALL_PREFIXES(AppModeTest, EnableAppModeTest);
489  FRIEND_TEST_ALL_PREFIXES(BrowserCommandControllerTest,
490                           IsReservedCommandOrKeyIsApp);
491  FRIEND_TEST_ALL_PREFIXES(BrowserCommandControllerTest, AppFullScreen);
492  FRIEND_TEST_ALL_PREFIXES(BrowserTest, NoTabsInPopups);
493  FRIEND_TEST_ALL_PREFIXES(BrowserTest, ConvertTabToAppShortcut);
494  FRIEND_TEST_ALL_PREFIXES(BrowserTest, OpenAppWindowLikeNtp);
495  FRIEND_TEST_ALL_PREFIXES(BrowserTest, AppIdSwitch);
496  FRIEND_TEST_ALL_PREFIXES(FullscreenControllerTest,
497                           TabEntersPresentationModeFromWindowed);
498  FRIEND_TEST_ALL_PREFIXES(FullscreenExitBubbleControllerTest,
499                           DenyExitsFullscreen);
500  FRIEND_TEST_ALL_PREFIXES(StartupBrowserCreatorTest, OpenAppShortcutNoPref);
501  FRIEND_TEST_ALL_PREFIXES(StartupBrowserCreatorTest,
502                           OpenAppShortcutWindowPref);
503  FRIEND_TEST_ALL_PREFIXES(StartupBrowserCreatorTest, OpenAppShortcutTabPref);
504
505  class InterstitialObserver;
506
507  // Used to describe why a tab is being detached. This is used by
508  // TabDetachedAtImpl.
509  enum DetachType {
510    // Result of TabDetachedAt.
511    DETACH_TYPE_DETACH,
512
513    // Result of TabReplacedAt.
514    DETACH_TYPE_REPLACE,
515
516    // Result of the tab strip not having any significant tabs.
517    DETACH_TYPE_EMPTY
518  };
519
520  // Describes where the bookmark bar state change originated from.
521  enum BookmarkBarStateChangeReason {
522    // From the constructor.
523    BOOKMARK_BAR_STATE_CHANGE_INIT,
524
525    // Change is the result of the active tab changing.
526    BOOKMARK_BAR_STATE_CHANGE_TAB_SWITCH,
527
528    // Change is the result of the bookmark bar pref changing.
529    BOOKMARK_BAR_STATE_CHANGE_PREF_CHANGE,
530
531    // Change is the result of a state change in the active tab.
532    BOOKMARK_BAR_STATE_CHANGE_TAB_STATE,
533
534    // Change is the result of window toggling in/out of fullscreen mode.
535    BOOKMARK_BAR_STATE_CHANGE_TOGGLE_FULLSCREEN,
536  };
537
538  // Overridden from content::WebContentsDelegate:
539  virtual content::WebContents* OpenURLFromTab(
540      content::WebContents* source,
541      const content::OpenURLParams& params) OVERRIDE;
542  virtual void NavigationStateChanged(const content::WebContents* source,
543                                      unsigned changed_flags) OVERRIDE;
544  virtual void AddNewContents(content::WebContents* source,
545                              content::WebContents* new_contents,
546                              WindowOpenDisposition disposition,
547                              const gfx::Rect& initial_pos,
548                              bool user_gesture,
549                              bool* was_blocked) OVERRIDE;
550  virtual void ActivateContents(content::WebContents* contents) OVERRIDE;
551  virtual void DeactivateContents(content::WebContents* contents) OVERRIDE;
552  virtual void LoadingStateChanged(content::WebContents* source) OVERRIDE;
553  virtual void CloseContents(content::WebContents* source) OVERRIDE;
554  virtual void MoveContents(content::WebContents* source,
555                            const gfx::Rect& pos) OVERRIDE;
556  virtual bool IsPopupOrPanel(
557      const content::WebContents* source) const OVERRIDE;
558  virtual void UpdateTargetURL(content::WebContents* source, int32 page_id,
559                               const GURL& url) OVERRIDE;
560  virtual void ContentsMouseEvent(content::WebContents* source,
561                                  const gfx::Point& location,
562                                  bool motion) OVERRIDE;
563  virtual void ContentsZoomChange(bool zoom_in) OVERRIDE;
564  virtual void WebContentsFocused(content::WebContents* content) OVERRIDE;
565  virtual bool TakeFocus(content::WebContents* source, bool reverse) OVERRIDE;
566  virtual gfx::Rect GetRootWindowResizerRect() const OVERRIDE;
567  virtual void BeforeUnloadFired(content::WebContents* source,
568                                 bool proceed,
569                                 bool* proceed_to_fire_unload) OVERRIDE;
570  virtual bool ShouldFocusLocationBarByDefault(
571      content::WebContents* source) OVERRIDE;
572  virtual void SetFocusToLocationBar(bool select_all) OVERRIDE;
573  virtual int GetExtraRenderViewHeight() const OVERRIDE;
574  virtual void ViewSourceForTab(content::WebContents* source,
575                                const GURL& page_url) OVERRIDE;
576  virtual void ViewSourceForFrame(
577      content::WebContents* source,
578      const GURL& frame_url,
579      const content::PageState& frame_page_state) OVERRIDE;
580  virtual void ShowRepostFormWarningDialog(
581      content::WebContents* source) OVERRIDE;
582  virtual bool ShouldCreateWebContents(
583      content::WebContents* web_contents,
584      int route_id,
585      WindowContainerType window_container_type,
586      const base::string16& frame_name,
587      const GURL& target_url,
588      const std::string& partition_id,
589      content::SessionStorageNamespace* session_storage_namespace) OVERRIDE;
590  virtual void WebContentsCreated(content::WebContents* source_contents,
591                                  int64 source_frame_id,
592                                  const base::string16& frame_name,
593                                  const GURL& target_url,
594                                  content::WebContents* new_contents) OVERRIDE;
595  virtual void RendererUnresponsive(content::WebContents* source) OVERRIDE;
596  virtual void RendererResponsive(content::WebContents* source) OVERRIDE;
597  virtual void WorkerCrashed(content::WebContents* source) OVERRIDE;
598  virtual void DidNavigateMainFramePostCommit(
599      content::WebContents* web_contents) OVERRIDE;
600  virtual void DidNavigateToPendingEntry(
601      content::WebContents* web_contents) OVERRIDE;
602  virtual content::JavaScriptDialogManager*
603      GetJavaScriptDialogManager() OVERRIDE;
604  virtual content::ColorChooser* OpenColorChooser(
605      content::WebContents* web_contents,
606      SkColor color,
607      const std::vector<content::ColorSuggestion>& suggestions) OVERRIDE;
608  virtual void RunFileChooser(
609      content::WebContents* web_contents,
610      const content::FileChooserParams& params) OVERRIDE;
611  virtual void EnumerateDirectory(content::WebContents* web_contents,
612                                  int request_id,
613                                  const base::FilePath& path) OVERRIDE;
614  virtual bool EmbedsFullscreenWidget() const OVERRIDE;
615  virtual void ToggleFullscreenModeForTab(content::WebContents* web_contents,
616      bool enter_fullscreen) OVERRIDE;
617  virtual bool IsFullscreenForTabOrPending(
618      const content::WebContents* web_contents) const OVERRIDE;
619  virtual void RegisterProtocolHandler(content::WebContents* web_contents,
620                                       const std::string& protocol,
621                                       const GURL& url,
622                                       const base::string16& title,
623                                       bool user_gesture) OVERRIDE;
624  virtual void UpdatePreferredSize(content::WebContents* source,
625                                   const gfx::Size& pref_size) OVERRIDE;
626  virtual void ResizeDueToAutoResize(content::WebContents* source,
627                                     const gfx::Size& new_size) OVERRIDE;
628  virtual void FindReply(content::WebContents* web_contents,
629                         int request_id,
630                         int number_of_matches,
631                         const gfx::Rect& selection_rect,
632                         int active_match_ordinal,
633                         bool final_update) OVERRIDE;
634  virtual void RequestToLockMouse(content::WebContents* web_contents,
635                                  bool user_gesture,
636                                  bool last_unlocked_by_target) OVERRIDE;
637  virtual void LostMouseLock() OVERRIDE;
638  virtual void RequestMediaAccessPermission(
639      content::WebContents* web_contents,
640      const content::MediaStreamRequest& request,
641      const content::MediaResponseCallback& callback) OVERRIDE;
642  virtual bool RequestPpapiBrokerPermission(
643      content::WebContents* web_contents,
644      const GURL& url,
645      const base::FilePath& plugin_path,
646      const base::Callback<void(bool)>& callback) OVERRIDE;
647  virtual gfx::Size GetSizeForNewRenderView(
648      const content::WebContents* web_contents) const OVERRIDE;
649
650  // Overridden from CoreTabHelperDelegate:
651  // Note that the caller is responsible for deleting |old_contents|.
652  virtual void SwapTabContents(content::WebContents* old_contents,
653                               content::WebContents* new_contents,
654                               bool did_start_load,
655                               bool did_finish_load) OVERRIDE;
656  virtual bool CanReloadContents(
657      content::WebContents* web_contents) const OVERRIDE;
658  virtual bool CanSaveContents(
659      content::WebContents* web_contents) const OVERRIDE;
660
661  // Overridden from SearchEngineTabHelperDelegate:
662  virtual void ConfirmAddSearchProvider(TemplateURL* template_url,
663                                        Profile* profile) OVERRIDE;
664
665  // Overridden from WebContentsModalDialogManagerDelegate:
666  virtual void SetWebContentsBlocked(content::WebContents* web_contents,
667                                     bool blocked) OVERRIDE;
668  virtual web_modal::WebContentsModalDialogHost*
669      GetWebContentsModalDialogHost() OVERRIDE;
670
671  // Overridden from BookmarkTabHelperDelegate:
672  virtual void URLStarredChanged(content::WebContents* web_contents,
673                                 bool starred) OVERRIDE;
674
675  // Overridden from ZoomObserver:
676  virtual void OnZoomChanged(content::WebContents* source,
677                             bool can_show_bubble) OVERRIDE;
678
679  // Overridden from SelectFileDialog::Listener:
680  virtual void FileSelected(const base::FilePath& path,
681                            int index,
682                            void* params) OVERRIDE;
683  virtual void FileSelectedWithExtraInfo(
684      const ui::SelectedFileInfo& file_info,
685      int index,
686      void* params) OVERRIDE;
687
688  // Overridden from content::NotificationObserver:
689  virtual void Observe(int type,
690                       const content::NotificationSource& source,
691                       const content::NotificationDetails& details) OVERRIDE;
692
693  // Command and state updating ///////////////////////////////////////////////
694
695  // Handle changes to kDevTools preference.
696  void OnDevToolsDisabledChanged();
697
698  // UI update coalescing and handling ////////////////////////////////////////
699
700  // Asks the toolbar (and as such the location bar) to update its state to
701  // reflect the current tab's current URL, security state, etc.
702  // If |should_restore_state| is true, we're switching (back?) to this tab and
703  // should restore any previous location bar state (such as user editing) as
704  // well.
705  void UpdateToolbar(bool should_restore_state);
706
707  // Does one or both of the following for each bit in |changed_flags|:
708  // . If the update should be processed immediately, it is.
709  // . If the update should processed asynchronously (to avoid lots of ui
710  //   updates), then scheduled_updates_ is updated for the |source| and update
711  //   pair and a task is scheduled (assuming it isn't running already)
712  //   that invokes ProcessPendingUIUpdates.
713  void ScheduleUIUpdate(const content::WebContents* source,
714                        unsigned changed_flags);
715
716  // Processes all pending updates to the UI that have been scheduled by
717  // ScheduleUIUpdate in scheduled_updates_.
718  void ProcessPendingUIUpdates();
719
720  // Removes all entries from scheduled_updates_ whose source is contents.
721  void RemoveScheduledUpdatesFor(content::WebContents* contents);
722
723  // Getters for UI ///////////////////////////////////////////////////////////
724
725  // TODO(beng): remove, and provide AutomationProvider a better way to access
726  //             the LocationBarView's edit.
727  friend class AutomationProvider;
728  friend class BrowserProxy;
729  friend class TestingAutomationProvider;
730
731  // Returns the StatusBubble from the current toolbar. It is possible for
732  // this to return NULL if called before the toolbar has initialized.
733  // TODO(beng): remove this.
734  StatusBubble* GetStatusBubble();
735
736  // Session restore functions ////////////////////////////////////////////////
737
738  // Notifies the history database of the index for all tabs whose index is
739  // >= index.
740  void SyncHistoryWithTabs(int index);
741
742  // In-progress download termination handling /////////////////////////////////
743
744  // Called when the window is closing to check if potential in-progress
745  // downloads should prevent it from closing.
746  // Returns true if the window can close, false otherwise.
747  bool CanCloseWithInProgressDownloads();
748
749  // Assorted utility functions ///////////////////////////////////////////////
750
751  // Sets the specified browser as the delegate of the WebContents and all the
752  // associated tab helpers that are needed.
753  void SetAsDelegate(content::WebContents* web_contents, Browser* delegate);
754
755  // Shows the Find Bar, optionally selecting the next entry that matches the
756  // existing search string for that Tab. |forward_direction| controls the
757  // search direction.
758  void FindInPage(bool find_next, bool forward_direction);
759
760  // Closes the frame.
761  // TODO(beng): figure out if we need this now that the frame itself closes
762  //             after a return to the message loop.
763  void CloseFrame();
764
765  void TabDetachedAtImpl(content::WebContents* contents,
766                         int index,
767                         DetachType type);
768
769  // Shared code between Reload() and ReloadIgnoringCache().
770  void ReloadInternal(WindowOpenDisposition disposition, bool ignore_cache);
771
772  // Implementation of SupportsWindowFeature and CanSupportWindowFeature. If
773  // |check_fullscreen| is true, the set of features reflect the actual state of
774  // the browser, otherwise the set of features reflect the possible state of
775  // the browser.
776  bool SupportsWindowFeatureImpl(WindowFeature feature,
777                                 bool check_fullscreen) const;
778
779  // Resets |bookmark_bar_state_| based on the active tab. Notifies the
780  // BrowserWindow if necessary.
781  void UpdateBookmarkBarState(BookmarkBarStateChangeReason reason);
782
783  bool ShouldHideUIForFullscreen() const;
784
785  // Creates a BackgroundContents if appropriate; return true if one was
786  // created.
787  bool MaybeCreateBackgroundContents(
788      int route_id,
789      content::WebContents* opener_web_contents,
790      const base::string16& frame_name,
791      const GURL& target_url,
792      const std::string& partition_id,
793      content::SessionStorageNamespace* session_storage_namespace);
794
795  // Data members /////////////////////////////////////////////////////////////
796
797  std::vector<InterstitialObserver*> interstitial_observers_;
798
799  content::NotificationRegistrar registrar_;
800
801  PrefChangeRegistrar profile_pref_registrar_;
802
803  // This Browser's type.
804  const Type type_;
805
806  // This Browser's profile.
807  Profile* const profile_;
808
809  // This Browser's window.
810  BrowserWindow* window_;
811
812  scoped_ptr<TabStripModelDelegate> tab_strip_model_delegate_;
813  scoped_ptr<TabStripModel> tab_strip_model_;
814
815  // The application name that is also the name of the window to the shell.
816  // This name should be set when:
817  // 1) we launch an application via an application shortcut or extension API.
818  // 2) we launch an undocked devtool window.
819  std::string app_name_;
820
821  // Type of app (host or child). See description of AppType.
822  AppType app_type_;
823
824  // Unique identifier of this browser for session restore. This id is only
825  // unique within the current session, and is not guaranteed to be unique
826  // across sessions.
827  const SessionID session_id_;
828
829  // The model for the toolbar view.
830  scoped_ptr<ToolbarModel> toolbar_model_;
831
832  // The model for the "active" search state.  There are per-tab search models
833  // as well.  When a tab is active its model is kept in sync with this one.
834  // When a new tab is activated its model state is propagated to this active
835  // model.  This way, observers only have to attach to this single model for
836  // updates, and don't have to worry about active tab changes directly.
837  scoped_ptr<SearchModel> search_model_;
838
839  // UI update coalescing and handling ////////////////////////////////////////
840
841  typedef std::map<const content::WebContents*, int> UpdateMap;
842
843  // Maps from WebContents to pending UI updates that need to be processed.
844  // We don't update things like the URL or tab title right away to avoid
845  // flickering and extra painting.
846  // See ScheduleUIUpdate and ProcessPendingUIUpdates.
847  UpdateMap scheduled_updates_;
848
849  // In-progress download termination handling /////////////////////////////////
850
851  enum CancelDownloadConfirmationState {
852    NOT_PROMPTED,          // We have not asked the user.
853    WAITING_FOR_RESPONSE,  // We have asked the user and have not received a
854                           // reponse yet.
855    RESPONSE_RECEIVED      // The user was prompted and made a decision already.
856  };
857
858  // State used to figure-out whether we should prompt the user for confirmation
859  // when the browser is closed with in-progress downloads.
860  CancelDownloadConfirmationState cancel_download_confirmation_state_;
861
862  /////////////////////////////////////////////////////////////////////////////
863
864  // Override values for the bounds of the window and its maximized or minimized
865  // state.
866  // These are supplied by callers that don't want to use the default values.
867  // The default values are typically loaded from local state (last session),
868  // obtained from the last window of the same type, or obtained from the
869  // shell shortcut's startup info.
870  gfx::Rect override_bounds_;
871  ui::WindowShowState initial_show_state_;
872
873  // Tracks when this browser is being created by session restore.
874  bool is_session_restore_;
875
876  const chrome::HostDesktopType host_desktop_type_;
877
878  scoped_ptr<chrome::UnloadController> unload_controller_;
879  scoped_ptr<chrome::FastUnloadController> fast_unload_controller_;
880
881  // The Find Bar. This may be NULL if there is no Find Bar, and if it is
882  // non-NULL, it may or may not be visible.
883  scoped_ptr<FindBarController> find_bar_controller_;
884
885  // Dialog box used for opening and saving files.
886  scoped_refptr<ui::SelectFileDialog> select_file_dialog_;
887
888  // Keep track of the encoding auto detect pref.
889  BooleanPrefMember encoding_auto_detect_;
890
891  // Helper which implements the ContentSettingBubbleModel interface.
892  scoped_ptr<BrowserContentSettingBubbleModelDelegate>
893      content_setting_bubble_model_delegate_;
894
895  // Helper which implements the ToolbarModelDelegate interface.
896  scoped_ptr<BrowserToolbarModelDelegate> toolbar_model_delegate_;
897
898  // A delegate that handles the details of updating the "active"
899  // |search_model_| state with the tab's state.
900  scoped_ptr<SearchDelegate> search_delegate_;
901
902  // Helper which implements the TabRestoreServiceDelegate interface.
903  scoped_ptr<BrowserTabRestoreServiceDelegate> tab_restore_service_delegate_;
904
905  // Helper which implements the SyncedWindowDelegate interface.
906  scoped_ptr<BrowserSyncedWindowDelegate> synced_window_delegate_;
907
908  scoped_ptr<BrowserInstantController> instant_controller_;
909
910  BookmarkBar::State bookmark_bar_state_;
911
912  scoped_ptr<FullscreenController> fullscreen_controller_;
913
914  scoped_ptr<extensions::WindowController> extension_window_controller_;
915
916  scoped_ptr<chrome::BrowserCommandController> command_controller_;
917
918  // True if the browser window has been shown at least once.
919  bool window_has_shown_;
920
921  // The following factory is used for chrome update coalescing.
922  base::WeakPtrFactory<Browser> chrome_updater_factory_;
923
924  // The following factory is used to close the frame at a later time.
925  base::WeakPtrFactory<Browser> weak_factory_;
926
927  scoped_ptr<BrowserContentTranslateDriverObserver> translate_driver_observer_;
928
929  scoped_ptr<chrome::ValidationMessageBubble> validation_message_bubble_;
930
931  DISALLOW_COPY_AND_ASSIGN(Browser);
932};
933
934#endif  // CHROME_BROWSER_UI_BROWSER_H_
935