Split out fullscreen logic from Browser into FullscreenController.

chrome/browser/ui/browser.h

 // Copyright (c) 2011 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 <map>
 #include <set>
@@ skipping 37 matching lines @@
 #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 FindBarController;
+class FullscreenController;
 class InstantController;
 class InstantUnloadHandler;
 class PrefService;
 class Profile;
 class SessionStorageNamespace;
 class SkBitmap;
 class StatusBubble;
 class TabNavigation;
 class TabStripModel;
 struct WebApplicationInfo;
@@ skipping 419 matching lines @@
   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();
 
-  // Sends a notification that the fullscreen state has changed.
-  void NotifyFullscreenChange();
-
   // 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);
@@ skipping 316 matching lines @@
                         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.
   void OnAcceptFullscreenPermission(const GURL& url,

[yzshen1, 2011/11/04 01:56:32]

You could make fullscreen exit bubble directly notify fullscreen controller.

[koz (OOO until 15th September), 2011/11/06 23:30:20]

Would you mind if I do that in a follow up change? I'd like to keep Browser's
public interface intact in this change to make it clear that this is a straight
lifting of functions out of it into FullscreenController. I've added a TODO.

[yzshen1, 2011/11/08 00:55:41]

Okay.

On 2011/11/06 23:30:20, koz wrote:

                                     FullscreenExitBubbleType bubble_type);
   void OnDenyFullscreenPermission(FullscreenExitBubbleType bubble_type);
-  ContentSetting GetFullscreenSetting(const GURL& url);
-  ContentSetting GetMouseLockSetting(const GURL& url);
 
   // 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 is_fullscreen_for_tab() const { return fullscreened_tab_ != NULL; }
+  bool IsFullscreenForTab() const;
 
   // Called each time the browser window is shown.
   void OnWindowDidShow();
 
  protected:
   // Wrapper for the factory method in BrowserWindow. This allows subclasses to
   // set their own window.
   virtual BrowserWindow* CreateBrowserWindow();
 
  private:
@@ skipping 37 matching lines @@
     // 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,
   };
 
-  enum MouseLockState {
-    MOUSELOCK_NOT_REQUESTED,
-    // The page requests to lock the mouse and the user hasn't responded to the
-    // request.
-    MOUSELOCK_REQUESTED,
-    // Mouse lock has been allowed by the user.
-    MOUSELOCK_ACCEPTED
-  };
-
   // Overridden from TabContentsDelegate:
   // Deprecated. Please use two-argument variant.
   // TODO(adriansc): Remove this method once refactoring changed all call sites.
   virtual TabContents* OpenURLFromTab(
       TabContents* source,
       const GURL& url,
       const GURL& referrer,
       WindowOpenDisposition disposition,
       content::PageTransition transition) OVERRIDE;
   virtual TabContents* OpenURLFromTab(TabContents* source,
@@ skipping 222 matching lines @@
   // 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);
 
-  // Tab fullscreen functions /////////////////////////////////////////////////
-
-  // There are two different kinds of fullscreen mode - "tab fullscreen" and
-  // "browser fullscreen". "Tab fullscreen" refers to when a tab enters
-  // fullscreen mode via the JS fullscreen API, and "browser fullscreen"
-  // refers to the user putting the browser itself into fullscreen mode from
-  // the UI. The difference is that tab fullscreen has implications for how
-  // the contents of the tab render (eg: a video element may grow to consume
-  // the whole tab), whereas browser fullscreen mode doesn't. Therefore if a
-  // user forces an exit from fullscreen, we need to notify the tab so it can
-  // stop rendering in its fullscreen mode.
-
-  // Make the current tab exit fullscreen mode if it is in it.
-  void ExitTabbedFullscreenModeIfNecessary();
-
-  // Notifies the tab that it has been forced out of fullscreen mode if
-  // necessary.
-  void NotifyTabOfFullscreenExitIfNecessary();
-
   // OnBeforeUnload handling //////////////////////////////////////////////////
 
   typedef std::set<TabContents*> 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;
 
@@ skipping 99 matching lines @@
   void OpenBookmarkManagerWithHash(const std::string& action, int64 node_id);
 
   // Make the current tab exit fullscreen mode. If the browser was fullscreen
   // because of that (as opposed to the user clicking the fullscreen button)
   // then take the browser out of fullscreen mode as well.
   void ExitTabbedFullscreenMode();
 
   // Notifies the tab that it has been forced out of fullscreen mode.
   void NotifyTabOfFullscreenExit();
 
-  // Determines what should be shown in the fullscreen exit bubble.
-  FullscreenExitBubbleType GetFullscreenExitBubbleType() const;
-
-  // Updates the content of the fullscreen exit bubble.
-  void UpdateFullscreenExitBubbleContent();
-
   // Data members /////////////////////////////////////////////////////////////
 
   content::NotificationRegistrar registrar_;
 
   PrefChangeRegistrar profile_pref_registrar_;
 
   PrefChangeRegistrar local_pref_registrar_;
 
   // This Browser's type.
   const Type type_;
@@ skipping 120 matching lines @@
   scoped_ptr<BrowserTabRestoreServiceDelegate> tab_restore_service_delegate_;
 
   // Helper which implements the SyncedWindowDelegate interface.
   scoped_ptr<BrowserSyncedWindowDelegate> synced_window_delegate_;
 
   scoped_ptr<InstantController> instant_;
   scoped_ptr<InstantUnloadHandler> instant_unload_handler_;
 
   BookmarkBar::State bookmark_bar_state_;
 
-  // If there is currently a tab in fullscreen mode (entered via
-  // webkitRequestFullScreen), this is its wrapper.
-  TabContentsWrapper* fullscreened_tab_;
-
-  // True if the current tab entered fullscreen mode via webkitRequestFullScreen
-  bool tab_caused_fullscreen_;
-  // True if tab fullscreen has been allowed, either by settings or by user
-  // clicking the allow button on the fullscreen infobar.
-  bool tab_fullscreen_accepted_;
-
-  MouseLockState mouse_lock_state_;
-
   // True if the browser window has been shown at least once.
   bool window_has_shown_;
 
+  FullscreenController* fullscreen_controller_;

[Peter Kasting, 2011/11/03 18:24:56]

Nit: I'd put this above |window_has_shown_|

[tfarina, 2011/11/04 01:09:31]

Aren't we leaking this? Could you use scoped_ptr?

[koz (OOO until 15th September), 2011/11/06 23:30:20]

Done.

[koz (OOO until 15th September), 2011/11/06 23:30:20]

Done.

+
   DISALLOW_COPY_AND_ASSIGN(Browser);
 };
 
 #endif  // CHROME_BROWSER_UI_BROWSER_H_