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(
-      const GURL& url,
-      FullscreenExitBubbleType bubble_type) OVERRIDE;
-  virtual void ExitPresentationMode() OVERRIDE;
-  virtual bool InPresentationMode() OVERRIDE;
+  virtual void EnterFullscreenWithChrome() 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(
-    const GURL& url,
-    FullscreenExitBubbleType bubble_type) {
-  mac_presentation_mode_ = true;
+void FullscreenControllerTestWindow::EnterFullscreenWithChrome() {
   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 149 matching lines @@
   window_->set_reentrant(reentrant);
   FullscreenControllerStateTest::TestStateAndEvent(state, event, reentrant);
 }
 
 Browser* FullscreenControllerStateUnitTest::GetBrowser() {
   return BrowserWithTestWindowTest::browser();
 }
 
 // Tests -----------------------------------------------------------------------
 
+#define TEST_EVENT_INNER(state, event, reentrant, reentrant_id) \
+    TEST_F(FullscreenControllerStateUnitTest, \
+           state##__##event##reentrant_id) { \
+      AddTab(browser(), GURL(chrome::kAboutBlankURL)); \
+      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:
 
-#define TEST_EVENT_INNER(state, event, reentrant, reentrant_id) \
-    TEST_F(FullscreenControllerStateUnitTest, \
-           state##__##event##reentrant_id) { \
-      AddTab(browser(), GURL(chrome::kAboutBlankURL)); \
-      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);
-
 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);
 TEST_EVENT(STATE_NORMAL, BUBBLE_ALLOW);
 TEST_EVENT(STATE_NORMAL, BUBBLE_DENY);
@@ skipping 110 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
 }