Revert 179554 - suspected to break browser_tests on Mac 10.6

chrome/browser/ui/fullscreen/fullscreen_controller.cc

 // Copyright (c) 2012 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/fullscreen/fullscreen_controller.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
@@ skipping 39 matching lines @@
 
 FullscreenController::~FullscreenController() {
 }
 
 bool FullscreenController::IsFullscreenForBrowser() const {
   return window_->IsFullscreen() && !tab_caused_fullscreen_;
 }
 
 void FullscreenController::ToggleFullscreenMode() {
   extension_caused_fullscreen_ = GURL();
-  ToggleFullscreenModeInternal(BROWSER);
+  ToggleFullscreenModeInternal(false);
 }
 
 bool FullscreenController::IsFullscreenForTabOrPending() const {
   return fullscreened_tab_ != NULL;
 }
 
 bool FullscreenController::IsFullscreenForTabOrPending(
     const WebContents* web_contents) const {
   if (web_contents != fullscreened_tab_)
     return false;
@@ skipping 14 matching lines @@
   if (IsInMetroSnapMode())
     return;
 #endif
 
   bool in_browser_or_tab_fullscreen_mode = window_->IsFullscreen();
 
   if (enter_fullscreen) {
     SetFullscreenedTab(web_contents);
     if (!in_browser_or_tab_fullscreen_mode) {
       tab_caused_fullscreen_ = true;
-      ToggleFullscreenModeInternal(TAB);
+#if defined(OS_MACOSX)
+      TogglePresentationModeInternal(true);
+#else
+      ToggleFullscreenModeInternal(true);
+#endif
     } else {
       // We need to update the fullscreen exit bubble, e.g., going from browser
       // fullscreen to tab fullscreen will need to show different content.
       const GURL& url = web_contents->GetURL();
       if (!tab_fullscreen_accepted_) {
         tab_fullscreen_accepted_ =
             GetFullscreenSetting(url) == CONTENT_SETTING_ALLOW;
       }
       UpdateFullscreenExitBubbleContent();
 
       // This is only a change between Browser and Tab fullscreen. We generate
       // a fullscreen notification now because there is no window change.
       PostFullscreenChangeNotification(true);
     }
   } else {
     if (in_browser_or_tab_fullscreen_mode) {
       if (tab_caused_fullscreen_) {
-        ToggleFullscreenModeInternal(TAB);
+#if defined(OS_MACOSX)
+        TogglePresentationModeInternal(true);
+#else
+        ToggleFullscreenModeInternal(true);
+#endif
       } else {
         // If currently there is a tab in "tab fullscreen" mode and fullscreen
         // was not caused by it (i.e., previously it was in "browser fullscreen"
         // mode), we need to switch back to "browser fullscreen" mode. In this
         // case, all we have to do is notifying the tab that it has exited "tab
         // fullscreen" mode.
         NotifyTabOfExitIfNecessary();
 
         // This is only a change between Browser and Tab fullscreen. We generate
         // a fullscreen notification now because there is no window change.
         PostFullscreenChangeNotification(true);
       }
     }
   }
 }
 
 void FullscreenController::ToggleFullscreenModeWithExtension(
     const GURL& extension_url) {
   // |extension_caused_fullscreen_| will be reset if this causes fullscreen to
   // exit.
   extension_caused_fullscreen_ = extension_url;
-  ToggleFullscreenModeInternal(BROWSER);
+  ToggleFullscreenModeInternal(false);
 }
 
 bool FullscreenController::IsInMetroSnapMode() {
 #if defined(OS_WIN)
   return window_->IsInMetroSnapMode();
 #else
   return false;
 #endif
 }
 
 #if defined(OS_WIN)
 void FullscreenController::SetMetroSnapMode(bool enable) {
   reentrant_window_state_change_call_check_ = false;
 
   toggled_into_fullscreen_ = false;
   window_->SetMetroSnapMode(enable);
 
   // FullscreenController unit tests for metro snap assume that on Windows calls
   // to WindowFullscreenStateChanged are reentrant. If that assumption is
   // invalidated, the tests must be updated to maintain coverage.
   CHECK(reentrant_window_state_change_call_check_);
 }
 #endif  // defined(OS_WIN)
 
 #if defined(OS_MACOSX)
-void FullscreenController::ToggleFullscreenWithChrome() {
-  ToggleFullscreenModeInternal(BROWSER_WITH_CHROME);
+void FullscreenController::TogglePresentationMode() {
+  TogglePresentationModeInternal(false);
 }
 #endif
 
 bool FullscreenController::IsMouseLockRequested() const {
   return mouse_lock_state_ == MOUSELOCK_REQUESTED;
 }
 
 bool FullscreenController::IsMouseLocked() const {
   return mouse_lock_state_ == MOUSELOCK_ACCEPTED ||
          mouse_lock_state_ == MOUSELOCK_ACCEPTED_SILENTLY;
@@ skipping 86 matching lines @@
   if (IsFullscreenForTabOrPending() ||
       IsMouseLocked() || IsMouseLockRequested()) {
     ExitTabFullscreenOrMouseLockIfNecessary();
     return true;
   }
 
   return false;
 }
 
 void FullscreenController::ExitTabOrBrowserFullscreenToPreviousState() {
-  if (IsFullscreenForTabOrPending())
+  if (IsFullscreenForTabOrPending()) {
     ExitTabFullscreenOrMouseLockIfNecessary();
-  else if (IsFullscreenForBrowser())
-    ExitFullscreenModeInternal();
+  } else if (IsFullscreenForBrowser()) {
+#if defined(OS_MACOSX)
+    TogglePresentationMode();
+#else
+    ToggleFullscreenMode();
+#endif
+  }
 }
 
 void FullscreenController::OnAcceptFullscreenPermission() {
   FullscreenExitBubbleType bubble_type = GetFullscreenExitBubbleType();
   bool mouse_lock = false;
   bool fullscreen = false;
   fullscreen_bubble::PermissionRequestedByType(bubble_type, &fullscreen,
                                                &mouse_lock);
   DCHECK(!(fullscreen && tab_fullscreen_accepted_));
   DCHECK(!(mouse_lock && IsMouseLocked()));
@@ skipping 194 matching lines @@
 }
 
 void FullscreenController::NotifyMouseLockChange() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
       content::Source<FullscreenController>(this),
       content::NotificationService::NoDetails());
 }
 
 // TODO(koz): Change |for_tab| to an enum.
-void FullscreenController::ToggleFullscreenModeInternal(
-    FullscreenInternalOption option) {
+void FullscreenController::ToggleFullscreenModeInternal(bool for_tab) {
 #if defined(OS_WIN)
   // When in Metro snap mode, toggling in and out of fullscreen is prevented.
   if (IsInMetroSnapMode())
     return;
 #endif
 
-  bool enter_fullscreen = !window_->IsFullscreen();
+  toggled_into_fullscreen_ = !window_->IsFullscreen();
 #if defined(OS_MACOSX)
-  // When a Mac user requests a toggle they may be toggling between
-  // FullscreenWithoutChrome and FullscreenWithChrome.
-  if (!IsFullscreenForTabOrPending()) {
-    if (option == BROWSER_WITH_CHROME)
-      enter_fullscreen |= window_->IsFullscreenWithoutChrome();
-    else
-      enter_fullscreen |= window_->IsFullscreenWithChrome();
-  }
+  // When a Mac user requests a toggle they may be transitioning from
+  // FullscreenWithoutChrome to FullscreenWithChrome.
+  if (!IsFullscreenForTabOrPending())
+    toggled_into_fullscreen_ |= window_->IsFullscreenWithoutChrome();
 #endif
 
   // 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())
+      !toggled_into_fullscreen_)
     return;
 
-  if (enter_fullscreen)
-    EnterFullscreenModeInternal(option);
-  else
-    ExitFullscreenModeInternal();
-}
-
-void FullscreenController::EnterFullscreenModeInternal(
-    FullscreenInternalOption option) {
-  toggled_into_fullscreen_ = true;
   GURL url;
-  if (option == TAB) {
+  if (for_tab) {
     url = browser_->tab_strip_model()->GetActiveWebContents()->GetURL();
-    tab_fullscreen_accepted_ =
+    tab_fullscreen_accepted_ = toggled_into_fullscreen_ &&
         GetFullscreenSetting(url) == CONTENT_SETTING_ALLOW;
   } else {
     if (!extension_caused_fullscreen_.is_empty())
       url = extension_caused_fullscreen_;
     content::RecordAction(UserMetricsAction("ToggleFullscreen"));
   }
-
+  if (toggled_into_fullscreen_) {
 #if defined(OS_MACOSX)
-  if (option == BROWSER_WITH_CHROME) {
+    CHECK(!for_tab);  // EnterFullscreenWithChrome invalid for tab fullscreen.
     CHECK(base::mac::IsOSLionOrLater());
     window_->EnterFullscreenWithChrome();
+#else
+    window_->EnterFullscreen(url, GetFullscreenExitBubbleType());
+#endif
   } else {
-#else
-  {
+#if defined(OS_MACOSX)
+    // Mac windows report a state change instantly, and so we must also clear
+    // tab_caused_fullscreen_ to match them else other logic using
+    // tab_caused_fullscreen_ will be incorrect.
+    NotifyTabOfExitIfNecessary();
 #endif
-    window_->EnterFullscreen(url, GetFullscreenExitBubbleType());
+    window_->ExitFullscreen();
+    extension_caused_fullscreen_ = GURL();
   }
-
   UpdateFullscreenExitBubbleContent();
 
   // Once the window has become fullscreen it'll call back to
   // WindowFullscreenStateChanged(). We don't do this immediately as
   // BrowserWindow::EnterFullscreen() asks for bookmark_bar_state_, so we let
   // the BrowserWindow invoke WindowFullscreenStateChanged when appropriate.
 }
 
-void FullscreenController::ExitFullscreenModeInternal() {
-  toggled_into_fullscreen_ = false;
 #if defined(OS_MACOSX)
-  // Mac windows report a state change instantly, and so we must also clear
-  // tab_caused_fullscreen_ to match them else other logic using
-  // tab_caused_fullscreen_ will be incorrect.
-  NotifyTabOfExitIfNecessary();
+void FullscreenController::TogglePresentationModeInternal(bool for_tab) {
+  toggled_into_fullscreen_ = !window_->IsFullscreenWithoutChrome();
+  GURL url;
+  if (for_tab) {
+    url = browser_->tab_strip_model()->GetActiveWebContents()->GetURL();
+    tab_fullscreen_accepted_ = toggled_into_fullscreen_ &&
+        GetFullscreenSetting(url) == CONTENT_SETTING_ALLOW;
+  }
+  if (!window_->IsFullscreenWithoutChrome()) {
+    window_->EnterFullscreen(url, GetFullscreenExitBubbleType());
+  } else {
+    window_->ExitFullscreen();
+
+    // Mac windows report a state change instantly, and so we must also clear
+    // tab_caused_fullscreen_ to match them else other logic using
+    // tab_caused_fullscreen_ will be incorrect.
+    NotifyTabOfExitIfNecessary();
+  }
+  UpdateFullscreenExitBubbleContent();
+
+  // WindowFullscreenStateChanged will be called by BrowserWindowController
+  // when the transition completes.
+}
 #endif
-  window_->ExitFullscreen();
-  extension_caused_fullscreen_ = GURL();
-
-  UpdateFullscreenExitBubbleContent();
-}
 
 void FullscreenController::SetFullscreenedTab(WebContents* tab) {
   fullscreened_tab_ = tab;
   UpdateNotificationRegistrations();
 }
 
 void FullscreenController::SetMouseLockTab(WebContents* tab) {
   mouse_lock_tab_ = tab;
   UpdateNotificationRegistrations();
 }
 
 void FullscreenController::ExitTabFullscreenOrMouseLockIfNecessary() {
   if (tab_caused_fullscreen_)
-    ToggleFullscreenModeInternal(TAB);
+    ToggleFullscreenModeInternal(true);
   else
     NotifyTabOfExitIfNecessary();
 }
 
 void FullscreenController::UpdateFullscreenExitBubbleContent() {
   GURL url = GetFullscreenExitBubbleURL();
   FullscreenExitBubbleType bubble_type = GetFullscreenExitBubbleType();
 
   // If bubble displays buttons, unlock mouse to allow pressing them.
   if (fullscreen_bubble::ShowButtonsForType(bubble_type) &&
@@ skipping 18 matching lines @@
 
 ContentSetting
 FullscreenController::GetMouseLockSetting(const GURL& url) const {
   if (url.SchemeIsFile())
     return CONTENT_SETTING_ALLOW;
 
   HostContentSettingsMap* settings_map = profile_->GetHostContentSettingsMap();
   return settings_map->GetContentSetting(url, url,
       CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string());
 }