Refactor BrowserWindow fullscreen and presentation on Mac to be consistent with other platforms.

chrome/browser/ui/fullscreen/fullscreen_controller_state_unittest.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 "build/build_config.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/fullscreen/fullscreen_controller.h"
 #include "chrome/browser/ui/fullscreen/fullscreen_controller_state_test.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
@@ skipping 33 matching lines @@
   virtual void EnterFullscreen(const GURL& url,
                                FullscreenExitBubbleType type) OVERRIDE;
   virtual void EnterFullscreen();
   virtual void ExitFullscreen() OVERRIDE;
   virtual bool IsFullscreen() const OVERRIDE;
 #if defined(OS_WIN)
   virtual void SetMetroSnapMode(bool enable) OVERRIDE;
   virtual bool IsInMetroSnapMode() const OVERRIDE;
 #endif
 #if defined(OS_MACOSX)
-  virtual void EnterPresentationMode(
+  virtual void EnterFullscreenWithChrome(
       const GURL& url,
       FullscreenExitBubbleType bubble_type) OVERRIDE;
-  virtual void ExitPresentationMode() OVERRIDE;
-  virtual bool InPresentationMode() OVERRIDE;
+  virtual bool IsFullscreenWithChrome() OVERRIDE;
+  virtual bool IsFullscreenWithoutChrome() OVERRIDE;
 #endif
 
   static const char* GetWindowStateString(WindowState state);
   WindowState state() const { return state_; }
   void set_browser(Browser* browser) { browser_ = browser; }
   void set_reentrant(bool value) { reentrant_ = value; }
   bool reentrant() const { return reentrant_; }
 
   // Simulates the window changing state.
   void ChangeWindowFullscreenState();
   // Calls ChangeWindowFullscreenState() if |reentrant_| is true.
   void ChangeWindowFullscreenStateIfReentrant();
 
  private:
   WindowState state_;
-  bool mac_presentation_mode_;
+  bool mac_with_chrome_mode_;
   Browser* browser_;
 
   // Causes reentrant calls to be made by calling
   // browser_->WindowFullscreenStateChanged() from the BrowserWindow
   // interface methods.
   bool reentrant_;
 };
 
 FullscreenControllerTestWindow::FullscreenControllerTestWindow()
     : state_(NORMAL),
-      mac_presentation_mode_(false),
+      mac_with_chrome_mode_(false),
       browser_(NULL),
       reentrant_(false) {
 }
 
 void FullscreenControllerTestWindow::EnterFullscreen(
     const GURL& url, FullscreenExitBubbleType type) {
   EnterFullscreen();
 }
 
 void FullscreenControllerTestWindow::EnterFullscreen() {
+  mac_with_chrome_mode_ = false;
   if (!IsFullscreen()) {
     state_ = TO_FULLSCREEN;
     ChangeWindowFullscreenStateIfReentrant();
   }
 }
 
 void FullscreenControllerTestWindow::ExitFullscreen() {
   if (IsFullscreen()) {
     state_ = TO_NORMAL;
-    mac_presentation_mode_ = false;
+    mac_with_chrome_mode_ = false;
     ChangeWindowFullscreenStateIfReentrant();
   }
 }
 
 bool FullscreenControllerTestWindow::IsFullscreen() const {
 #if defined(OS_MACOSX)
   return state_ == FULLSCREEN || state_ == TO_FULLSCREEN;
 #else
   return state_ == FULLSCREEN || state_ == TO_NORMAL;
 #endif
 }
 
 #if defined(OS_WIN)
 void FullscreenControllerTestWindow::SetMetroSnapMode(bool enable) {
   if (enable != IsInMetroSnapMode()) {
     if (enable)
       state_ = METRO_SNAP;
     else
       state_ = NORMAL;
   }
   ChangeWindowFullscreenStateIfReentrant();
 }
 
 bool FullscreenControllerTestWindow::IsInMetroSnapMode() const {
   return state_ == METRO_SNAP;
 }
 #endif
 
 #if defined(OS_MACOSX)
-void FullscreenControllerTestWindow::EnterPresentationMode(
+void FullscreenControllerTestWindow::EnterFullscreenWithChrome(
     const GURL& url,
     FullscreenExitBubbleType bubble_type) {
-  mac_presentation_mode_ = true;
   EnterFullscreen();
+  mac_with_chrome_mode_ = true;
 }
 
-void FullscreenControllerTestWindow::ExitPresentationMode() {
-  if (InPresentationMode()) {
-    mac_presentation_mode_ = false;
-    ExitFullscreen();
-  }
+bool FullscreenControllerTestWindow::IsFullscreenWithChrome() {
+  return IsFullscreen() && mac_with_chrome_mode_;
 }
 
-bool FullscreenControllerTestWindow::InPresentationMode() {
-  return mac_presentation_mode_;
+bool FullscreenControllerTestWindow::IsFullscreenWithoutChrome() {
+  return IsFullscreen() && !mac_with_chrome_mode_;
 }
 #endif
 
 // static
 const char* FullscreenControllerTestWindow::GetWindowStateString(
     WindowState state) {
   switch (state) {
     case NORMAL:
       return "NORMAL";
     case FULLSCREEN:
@@ skipping 163 matching lines @@
       ASSERT_NO_FATAL_FAILURE(TestStateAndEvent(state, event, reentrant)) \
           << GetAndClearDebugLog(); \
     }
     // Progress of tests can be examined by inserting the following line:
     // LOG(INFO) << GetAndClearDebugLog(); }
 
 #define TEST_EVENT(state, event) \
     TEST_EVENT_INNER(state, event, false, ); \
     TEST_EVENT_INNER(state, event, true, _Reentrant);
 
+// Soak tests:
+
+// Tests all states with all permutations of multiple events to detect lingering
+// state issues that would bleed over to other states.
+// I.E. for each state test all combinations of events E1, E2, E3.
+//
+// This produces coverage for event sequences that may happen normally but
+// would not be exposed by traversing to each state via TransitionToState().
+// TransitionToState() always takes the same path even when multiple paths
+// exist.
+TEST_F(FullscreenControllerStateUnitTest, TransitionsForEachState) {
+  // A tab is needed for tab fullscreen.
+  AddTab(browser(), GURL(chrome::kAboutBlankURL));
+  TestTransitionsForEachState();
+  // Progress of test can be examined via LOG(INFO) << GetAndClearDebugLog();
+}
+
+
 // Individual tests for each pair of state and event:
 
 TEST_EVENT(STATE_NORMAL, TOGGLE_FULLSCREEN);
 TEST_EVENT(STATE_NORMAL, TAB_FULLSCREEN_TRUE);
 TEST_EVENT(STATE_NORMAL, TAB_FULLSCREEN_FALSE);
 #if defined(OS_WIN)
 TEST_EVENT(STATE_NORMAL, METRO_SNAP_TRUE);
 TEST_EVENT(STATE_NORMAL, METRO_SNAP_FALSE);
 #endif
 TEST_EVENT(STATE_NORMAL, BUBBLE_EXIT_LINK);
@@ skipping 111 matching lines @@
   ASSERT_NO_FATAL_FAILURE(
       TransitionToState(STATE_TO_TAB_FULLSCREEN))
       << GetAndClearDebugLog();
 
   ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_TRUE)) << GetAndClearDebugLog();
   ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_FALSE)) << GetAndClearDebugLog();
   ASSERT_TRUE(InvokeEvent(WINDOW_CHANGE)) << GetAndClearDebugLog();
 #endif
 }
 
-// Soak tests:
-
-// Tests all states with all permutations of multiple events to detect lingering
-// state issues that would bleed over to other states.
-// I.E. for each state test all combinations of events E1, E2, E3.
-//
-// This produces coverage for event sequences that may happen normally but
-// would not be exposed by traversing to each state via TransitionToState().
-// TransitionToState() always takes the same path even when multiple paths
-// exist.
-TEST_F(FullscreenControllerStateUnitTest, TransitionsForEachState) {
-  // A tab is needed for tab fullscreen.
-  AddTab(browser(), GURL(chrome::kAboutBlankURL));
-  TestTransitionsForEachState();
-  // Progress of test can be examined via LOG(INFO) << GetAndClearDebugLog();
-}
-