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 1220 matching lines @@
 }
 
 void Browser::CloseWindow() {
   UserMetrics::RecordAction(UserMetricsAction("CloseWindow"));
   window_->Close();
 }
 
 void Browser::NewTab() {
   UserMetrics::RecordAction(UserMetricsAction("NewTab"));
 
+  ExitTabbedFullscreenMode();
+
   if (is_type_tabbed()) {
     AddBlankTab(true);
     GetSelectedTabContentsWrapper()->view()->RestoreFocus();
   } else {
     Browser* b = GetOrCreateTabbedBrowser(profile_);
     b->AddBlankTab(true);
     b->window()->Show();
     // The call to AddBlankTab above did not set the focus to the tab as its
     // window was not active, so we have to do it explicitly.
     // See http://crbug.com/6380.
     b->GetSelectedTabContentsWrapper()->view()->RestoreFocus();
   }
 }
 
 void Browser::CloseTab() {
   UserMetrics::RecordAction(UserMetricsAction("CloseTab_Accelerator"));
   if (CanCloseTab())
     tab_handler_->GetTabStripModel()->CloseSelectedTabs();
+  ExitTabbedFullscreenMode();
 }
 
 void Browser::SelectNextTab() {
   UserMetrics::RecordAction(UserMetricsAction("SelectNextTab"));
+  ExitTabbedFullscreenMode();
   tab_handler_->GetTabStripModel()->SelectNextTab();
 }
 
 void Browser::SelectPreviousTab() {
   UserMetrics::RecordAction(UserMetricsAction("SelectPrevTab"));
+  ExitTabbedFullscreenMode();

[Ben Goodger (Google), 2011/08/15 22:37:12]

For all of these... these aren't the only ways that tabs can be selected. It
seems it'd be safer to do this in the TabStripModelObserver.

[koz (OOO until 15th September), 2011/08/16 07:06:55]

Done.

   tab_handler_->GetTabStripModel()->SelectPreviousTab();
 }
 
 void Browser::OpenTabpose() {
 #if defined(OS_MACOSX)
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kEnableExposeForTabs)) {
     return;
   }
 
@@ skipping 60 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)
+    NotifyTabOfFullscreenExit();
+}
+
+void Browser::NotifyTabOfFullscreenExit() {
+  if (!notify_tab_of_fullscreen_exit_)

[Ben Goodger (Google), 2011/08/15 22:37:12]

Would be nice for the logic of this function to live in the TCW... I don't like
seeing browser-level code doing things like sending IPC messages.

[koz (OOO until 15th September), 2011/08/16 07:06:55]

Done.

+    return;
+  TabContentsWrapper* tab_contents = GetSelectedTabContentsWrapper();
+  RenderViewHost* host = tab_contents->render_view_host();
+  host->Send(new ViewMsg_ExitFullscreen(host->routing_id()));
+  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 1484 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();
+
+  if (activating_index != active_index) {
+    ExitTabbedFullscreenMode();
+  }
   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::ToggleFullscreenModeForRVH(TabContents* tab,
+    bool enter_fullscreen) {
+  if (tab != GetSelectedTabContents())
+    return;
+  if (enter_fullscreen) {

[Ben Goodger (Google), 2011/08/15 22:37:12]

These toggling functions make my brain hurt.

Given the logic... I think it'd be clearer if there were two functions...
EnterFullscreen and ExitFullscreen.

[Peter Kasting, 2011/08/15 22:42:54]

BTW Ben, that's how things originally were, and I asked for this change, because
it reduced a lot of API surface and redundancy.

[Peter Kasting, 2011/08/15 22:42:54]

Nit: Shorter:

  notify_tab_of_fullscreen_exit_ = enter_fullscreen;
  if (enter_fullscreen && !window_->IsFullscreen())
    tab_caused_fullscreen_ = true;
  if (tab_caused_fullscreen_)
    ToggleFullscreenMode();

Given sufficient comments about what's going on, this hopefully obviates the
need for Ben's revert-to-two-functions suggestion.

[koz (OOO until 15th September), 2011/08/16 07:06:55]

This is shorter, but I feel it is less semantic. Maybe if I add an Enter/Exit
function, but leave the public interface as the single Toggle function, it'd be
the best of both worlds? I'll implement that and upload it, let me know what you
think.

+    notify_tab_of_fullscreen_exit_ = true;
+    if (!window_->IsFullscreen()) {
+      tab_caused_fullscreen_ = true;
+      ToggleFullscreenMode();
+    }
+  } else {
+    notify_tab_of_fullscreen_exit_ = false;
+    if (tab_caused_fullscreen_)
+      ToggleFullscreenMode();
+  }
+}
+
+void Browser::ExitTabbedFullscreenMode() {
+  if (tab_caused_fullscreen_)
+    ToggleFullscreenMode();
+  else
+    NotifyTabOfFullscreenExit();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // 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();
 }