Fullscreen JS API implementation.

chrome/browser/ui/browser.cc

 // 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.
 
 #include "chrome/browser/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 232 matching lines @@
       cancel_download_confirmation_state_(NOT_PROMPTED),
       maximized_state_(MAXIMIZED_STATE_DEFAULT),
       method_factory_(this),
       block_command_execution_(false),
       last_blocked_command_id_(-1),
       last_blocked_command_disposition_(CURRENT_TAB),
       pending_web_app_action_(NONE),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           tab_restore_service_delegate_(
               new BrowserTabRestoreServiceDelegate(this))),
-      bookmark_bar_state_(BookmarkBar::HIDDEN) {
+      bookmark_bar_state_(BookmarkBar::HIDDEN),
+      notify_tab_of_fullscreen_exit_(false),
+      tab_caused_fullscreen_(false) {
   registrar_.Add(this, content::NOTIFICATION_SSL_VISIBLE_STATE_CHANGED,
                  NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
                  NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
                  NotificationService::AllSources());
@@ skipping 1327 matching lines @@
   UserMetrics::RecordAction(UserMetricsAction("ShowAsTab"));
   int tab_strip_index = tab_handler_->GetTabStripModel()->active_index();
   TabContentsWrapper* contents =
       tab_handler_->GetTabStripModel()->DetachTabContentsAt(tab_strip_index);
   Browser* browser = Browser::Create(profile_);
   browser->tabstrip_model()->AppendTabContents(contents, true);
   browser->window()->Show();
 }
 
 void Browser::ToggleFullscreenMode() {
+  bool entering_fullscreen = !window_->IsFullscreen();
+
 #if !defined(OS_MACOSX)
   // In kiosk mode, we always want to be fullscreen. When the browser first
   // starts we're not yet fullscreen, so let the initial toggle go through.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode) &&
       window_->IsFullscreen())
     return;
 #endif
 
   UserMetrics::RecordAction(UserMetricsAction("ToggleFullscreen"));
-  window_->SetFullscreen(!window_->IsFullscreen());
+  window_->SetFullscreen(entering_fullscreen);
 
   // Once the window has become fullscreen it'll call back to
   // WindowFullscreenStateChanged(). We don't do this immediately as
   // BrowserWindow::SetFullscreen() asks for bookmark_bar_state_, so we let the
   // BrowserWindow invoke WindowFullscreenStateChanged when appropriate.
 
   // TODO: convert mac to invoke WindowFullscreenStateChanged once it updates
   // the necessary state of the frame.
 #if defined(OS_MACOSX)
   WindowFullscreenStateChanged();
 #endif
+
+  if (!entering_fullscreen)
+    NotifyTabOfFullscreenExitIfNecessary();
+}
+
+void Browser::NotifyTabOfFullscreenExitIfNecessary() {
+  if (!notify_tab_of_fullscreen_exit_)
+    return;
+  GetSelectedTabContentsWrapper()->ExitFullscreenMode();
+  notify_tab_of_fullscreen_exit_ = false;
+  tab_caused_fullscreen_ = false;
 }
 
 #if defined(OS_CHROMEOS)
 void Browser::Search() {
   // If the NTP is showing, close it.
   const GURL& url = GetSelectedTabContents()->GetURL();
   if (url.SchemeIs(chrome::kChromeUIScheme) &&
       url.host() == chrome::kChromeUINewTabHost) {
     CloseTab();
     return;
@@ skipping 1247 matching lines @@
   registrar_.Add(this, content::NOTIFICATION_TAB_CONTENTS_DISCONNECTED,
                  Source<TabContents>(contents->tab_contents()));
 
   registrar_.Add(this, content::NOTIFICATION_INTERSTITIAL_ATTACHED,
                  Source<TabContents>(contents->tab_contents()));
 }
 
 void Browser::TabClosingAt(TabStripModel* tab_strip_model,
                            TabContentsWrapper* contents,
                            int index) {
+  if (contents == GetSelectedTabContentsWrapper())
+    ExitTabbedFullscreenModeIfNecessary();
   NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_CLOSING,
       Source<NavigationController>(&contents->controller()),
       NotificationService::NoDetails());
 
   // Sever the TabContents' connection back to us.
   SetAsDelegate(contents, NULL);
 }
 
 void Browser::TabDetachedAt(TabContentsWrapper* contents, int index) {
   TabDetachedAtImpl(contents, index, DETACH_TYPE_DETACH);
 }
 
 void Browser::TabDeactivated(TabContentsWrapper* contents) {
+  ExitTabbedFullscreenModeIfNecessary();
   if (instant())
     instant()->DestroyPreviewContents();
 
   // Save what the user's currently typing, so it can be restored when we
   // switch back to this tab.
   window_->GetLocationBar()->SaveStateToContents(contents->tab_contents());
 }
 
 void Browser::ActiveTabChanged(TabContentsWrapper* old_contents,
                                TabContentsWrapper* new_contents,
                                int index,
                                bool user_gesture) {
+  ExitTabbedFullscreenModeIfNecessary();
   // On some platforms we want to automatically reload tabs that are
   // killed when the user selects them.
   if (user_gesture && new_contents->tab_contents()->crashed_status() ==
         base::TERMINATION_STATUS_PROCESS_WAS_KILLED) {
     const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
     if (parsed_command_line.HasSwitch(switches::kReloadKilledTabs)) {
       Reload(CURRENT_TAB);
       return;
     }
   }
@@ skipping 191 matching lines @@
 
   if (source) {
     NotificationService::current()->Notify(
       content::NOTIFICATION_TAB_ADDED,
       Source<TabContentsDelegate>(source->delegate()),
       Details<TabContents>(source));
   }
 }
 
 void Browser::ActivateContents(TabContents* contents) {
+  int activating_index =
+      tab_handler_->GetTabStripModel()->GetWrapperIndex(contents);
+  int active_index = tab_handler_->GetTabStripModel()->active_index();

[Peter Kasting, 2011/08/16 18:04:43]

Nit: This variable seems unused?  In fact this whole function should just be
unchanged.

[koz (OOO until 15th September), 2011/08/17 03:47:05]

Done.

+
   tab_handler_->GetTabStripModel()->ActivateTabAt(
-      tab_handler_->GetTabStripModel()->GetWrapperIndex(contents), false);
+      activating_index, false);
   window_->Activate();
 }
 
 void Browser::DeactivateContents(TabContents* contents) {
   window_->Deactivate();
 }
 
 void Browser::LoadingStateChanged(TabContents* source) {
   window_->UpdateLoadingAnimations(
       tab_handler_->GetTabStripModel()->TabsAreLoading());
@@ skipping 332 matching lines @@
 
 void Browser::DidNavigateToPendingEntry(TabContents* tab) {
   if (tab == GetSelectedTabContents())
     UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
 }
 
 content::JavaScriptDialogCreator* Browser::GetJavaScriptDialogCreator() {
   return GetJavaScriptDialogCreatorInstance();
 }
 
+void Browser::ToggleFullscreenModeForTab(TabContents* tab,
+    bool enter_fullscreen) {
+  if (tab != GetSelectedTabContents())
+    return;
+  if (enter_fullscreen)
+    EnterFullscreenModeForTab(tab);

[Peter Kasting, 2011/08/16 18:04:43]

I don't think this is a win over your previous patch.  It's just more lines of
code, without much other benefit I can see.

[koz (OOO until 15th September), 2011/08/17 03:47:05]

I think this is clearer because each function is easy to digest in isolation.
Having them in the same scope means you need to swallow all that logic at once,
which is a little overwhelming.

That said, it's a minor point and I'm happy to defer. I've implemented your
suggestion from last patch here.

+  else
+    ExitFullscreenModeForTab(tab);
+}
+
+void Browser::EnterFullscreenModeForTab(TabContents* tab) {
+  notify_tab_of_fullscreen_exit_ = true;
+  if (!window_->IsFullscreen()) {
+    tab_caused_fullscreen_ = true;
+    ToggleFullscreenMode();
+  }
+}
+
+void Browser::ExitFullscreenModeForTab(TabContents* tab) {
+  notify_tab_of_fullscreen_exit_ = false;
+  if (tab_caused_fullscreen_)
+    ToggleFullscreenMode();
+}
+
+void Browser::ExitTabbedFullscreenModeIfNecessary() {
+  if (tab_caused_fullscreen_)
+    ToggleFullscreenMode();
+  else
+    NotifyTabOfFullscreenExitIfNecessary();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabContentsWrapperDelegate implementation:
 
 void Browser::OnDidGetApplicationInfo(TabContentsWrapper* source,
                                       int32 page_id) {
   if (GetSelectedTabContentsWrapper() != source)
     return;
 
   NavigationEntry* entry = source->controller().GetLastCommittedEntry();
   if (!entry || (entry->page_id() != page_id))
@@ skipping 1292 matching lines @@
   window_->BookmarkBarStateChanged(animate_type);
 }
 
 void Browser::ShowSyncSetup() {
   ProfileSyncService* service = profile()->GetProfileSyncService();
   if (service->HasSyncSetupCompleted())
     ShowOptionsTab(chrome::kSyncSetupSubPage);
   else
     profile()->GetProfileSyncService()->ShowLoginDialog();
 }