Home | History | Annotate | Download | only in fullscreen 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "build/build_config.h"
      6 #include "chrome/browser/ui/browser.h"
      7 #include "chrome/browser/ui/browser_tabstrip.h"
      8 #include "chrome/browser/ui/fullscreen/fullscreen_controller.h"
      9 #include "chrome/browser/ui/fullscreen/fullscreen_controller_state_test.h"
     10 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     11 #include "chrome/test/base/browser_with_test_window_test.h"
     12 #include "content/public/browser/web_contents.h"
     13 #include "content/public/common/url_constants.h"
     14 #include "testing/gtest/include/gtest/gtest.h"
     15 
     16 // The FullscreenControllerStateUnitTest unit test suite exhastively tests
     17 // the FullscreenController through all permutations of events. The behavior
     18 // of the BrowserWindow is mocked via FullscreenControllerTestWindow.
     19 
     20 
     21 // FullscreenControllerTestWindow ----------------------------------------------
     22 
     23 // A BrowserWindow used for testing FullscreenController. The behavior of this
     24 // mock is verfied manually by running FullscreenControllerStateInteractiveTest.
     25 class FullscreenControllerTestWindow : public TestBrowserWindow {
     26  public:
     27   // Simulate the window state with an enumeration.
     28   enum WindowState {
     29     NORMAL,
     30     FULLSCREEN,
     31     // No TO_ state for METRO_SNAP, the windows implementation is synchronous.
     32     METRO_SNAP,
     33     TO_NORMAL,
     34     TO_FULLSCREEN,
     35   };
     36 
     37   FullscreenControllerTestWindow();
     38   virtual ~FullscreenControllerTestWindow() {}
     39 
     40   // BrowserWindow Interface:
     41   virtual void EnterFullscreen(const GURL& url,
     42                                FullscreenExitBubbleType type) OVERRIDE;
     43   virtual void ExitFullscreen() OVERRIDE;
     44   virtual bool ShouldHideUIForFullscreen() const OVERRIDE;
     45   virtual bool IsFullscreen() const OVERRIDE;
     46 #if defined(OS_WIN)
     47   virtual void SetMetroSnapMode(bool enable) OVERRIDE;
     48   virtual bool IsInMetroSnapMode() const OVERRIDE;
     49 #endif
     50 #if defined(OS_MACOSX)
     51   virtual void EnterFullscreenWithChrome() OVERRIDE;
     52   virtual bool IsFullscreenWithChrome() OVERRIDE;
     53   virtual bool IsFullscreenWithoutChrome() OVERRIDE;
     54 #endif
     55 
     56   static const char* GetWindowStateString(WindowState state);
     57   WindowState state() const { return state_; }
     58   void set_browser(Browser* browser) { browser_ = browser; }
     59 
     60   // Simulates the window changing state.
     61   void ChangeWindowFullscreenState();
     62 
     63  private:
     64   // Enters fullscreen with |new_mac_with_chrome_mode|.
     65   void EnterFullscreen(bool new_mac_with_chrome_mode);
     66 
     67   // Returns true if ChangeWindowFullscreenState() should be called as a result
     68   // of updating the current fullscreen state to the passed in state.
     69   bool IsTransitionReentrant(bool new_fullscreen,
     70                              bool new_mac_with_chrome_mode);
     71 
     72   WindowState state_;
     73   bool mac_with_chrome_mode_;
     74   Browser* browser_;
     75 };
     76 
     77 FullscreenControllerTestWindow::FullscreenControllerTestWindow()
     78     : state_(NORMAL),
     79       mac_with_chrome_mode_(false),
     80       browser_(NULL) {
     81 }
     82 
     83 void FullscreenControllerTestWindow::EnterFullscreen(
     84     const GURL& url, FullscreenExitBubbleType type) {
     85   EnterFullscreen(false);
     86 }
     87 
     88 void FullscreenControllerTestWindow::ExitFullscreen() {
     89   if (IsFullscreen()) {
     90     state_ = TO_NORMAL;
     91     mac_with_chrome_mode_ = false;
     92 
     93     if (IsTransitionReentrant(false, false))
     94       ChangeWindowFullscreenState();
     95   }
     96 }
     97 
     98 bool FullscreenControllerTestWindow::ShouldHideUIForFullscreen() const {
     99   return IsFullscreen();
    100 }
    101 
    102 bool FullscreenControllerTestWindow::IsFullscreen() const {
    103 #if defined(OS_MACOSX)
    104   return state_ == FULLSCREEN || state_ == TO_FULLSCREEN;
    105 #else
    106   return state_ == FULLSCREEN || state_ == TO_NORMAL;
    107 #endif
    108 }
    109 
    110 #if defined(OS_WIN)
    111 void FullscreenControllerTestWindow::SetMetroSnapMode(bool enable) {
    112   if (enable != IsInMetroSnapMode())
    113     state_ = enable ? METRO_SNAP : NORMAL;
    114 
    115   if (FullscreenControllerStateTest::IsWindowFullscreenStateChangedReentrant())
    116     ChangeWindowFullscreenState();
    117 }
    118 
    119 bool FullscreenControllerTestWindow::IsInMetroSnapMode() const {
    120   return state_ == METRO_SNAP;
    121 }
    122 #endif
    123 
    124 #if defined(OS_MACOSX)
    125 void FullscreenControllerTestWindow::EnterFullscreenWithChrome() {
    126   EnterFullscreen(true);
    127 }
    128 
    129 bool FullscreenControllerTestWindow::IsFullscreenWithChrome() {
    130   return IsFullscreen() && mac_with_chrome_mode_;
    131 }
    132 
    133 bool FullscreenControllerTestWindow::IsFullscreenWithoutChrome() {
    134   return IsFullscreen() && !mac_with_chrome_mode_;
    135 }
    136 #endif
    137 
    138 // static
    139 const char* FullscreenControllerTestWindow::GetWindowStateString(
    140     WindowState state) {
    141   switch (state) {
    142     ENUM_TO_STRING(NORMAL);
    143     ENUM_TO_STRING(FULLSCREEN);
    144     ENUM_TO_STRING(METRO_SNAP);
    145     ENUM_TO_STRING(TO_FULLSCREEN);
    146     ENUM_TO_STRING(TO_NORMAL);
    147     default:
    148       NOTREACHED() << "No string for state " << state;
    149       return "WindowState-Unknown";
    150   }
    151 }
    152 
    153 void FullscreenControllerTestWindow::ChangeWindowFullscreenState() {
    154   // Most states result in "no operation" intentionally. The tests
    155   // assume that all possible states and event pairs can be tested, even
    156   // though window managers will not generate all of these.
    157   if (state_ == TO_FULLSCREEN)
    158       state_ = FULLSCREEN;
    159   else if (state_ == TO_NORMAL)
    160       state_ = NORMAL;
    161 
    162   // Emit a change event from every state to ensure the Fullscreen Controller
    163   // handles it in all circumstances.
    164   browser_->WindowFullscreenStateChanged();
    165 }
    166 
    167 void FullscreenControllerTestWindow::EnterFullscreen(
    168     bool new_mac_with_chrome_mode) {
    169   bool reentrant = IsTransitionReentrant(true, new_mac_with_chrome_mode);
    170 
    171   mac_with_chrome_mode_ = new_mac_with_chrome_mode;
    172   if (!IsFullscreen())
    173     state_ = TO_FULLSCREEN;
    174 
    175   if (reentrant)
    176     ChangeWindowFullscreenState();
    177 }
    178 
    179 bool FullscreenControllerTestWindow::IsTransitionReentrant(
    180     bool new_fullscreen,
    181     bool new_mac_with_chrome_mode) {
    182 #if defined(OS_MACOSX)
    183   bool mac_with_chrome_mode_changed = new_mac_with_chrome_mode ?
    184       IsFullscreenWithoutChrome() : IsFullscreenWithChrome();
    185 #else
    186   bool mac_with_chrome_mode_changed = false;
    187 #endif
    188   bool fullscreen_changed = (new_fullscreen != IsFullscreen());
    189 
    190   if (!fullscreen_changed && !mac_with_chrome_mode_changed)
    191     return false;
    192 
    193   if (FullscreenControllerStateTest::IsWindowFullscreenStateChangedReentrant())
    194     return true;
    195 
    196   // BrowserWindowCocoa::EnterFullscreen() and
    197   // BrowserWindowCocoa::EnterFullscreenWithChrome() are reentrant when
    198   // switching between fullscreen with chrome and fullscreen without chrome.
    199   return state_ == FULLSCREEN &&
    200       !fullscreen_changed &&
    201       mac_with_chrome_mode_changed;
    202 }
    203 
    204 
    205 // FullscreenControllerStateUnitTest -------------------------------------------
    206 
    207 // Unit test fixture testing Fullscreen Controller through its states. Most of
    208 // the test logic comes from FullscreenControllerStateTest.
    209 class FullscreenControllerStateUnitTest : public BrowserWithTestWindowTest,
    210                                           public FullscreenControllerStateTest {
    211  public:
    212   FullscreenControllerStateUnitTest();
    213 
    214   // FullscreenControllerStateTest:
    215   virtual void SetUp() OVERRIDE;
    216   virtual BrowserWindow* CreateBrowserWindow() OVERRIDE;
    217   virtual void ChangeWindowFullscreenState() OVERRIDE;
    218   virtual const char* GetWindowStateString() OVERRIDE;
    219   virtual void VerifyWindowState() OVERRIDE;
    220 
    221  protected:
    222   // FullscreenControllerStateTest:
    223   virtual bool ShouldSkipStateAndEventPair(State state, Event event) OVERRIDE;
    224   virtual Browser* GetBrowser() OVERRIDE;
    225   FullscreenControllerTestWindow* window_;
    226 };
    227 
    228 FullscreenControllerStateUnitTest::FullscreenControllerStateUnitTest ()
    229     : window_(NULL) {
    230 }
    231 
    232 void FullscreenControllerStateUnitTest::SetUp() {
    233   BrowserWithTestWindowTest::SetUp();
    234   window_->set_browser(browser());
    235 }
    236 
    237 BrowserWindow* FullscreenControllerStateUnitTest::CreateBrowserWindow() {
    238   window_ = new FullscreenControllerTestWindow();
    239   return window_;  // BrowserWithTestWindowTest takes ownership.
    240 }
    241 
    242 void FullscreenControllerStateUnitTest::ChangeWindowFullscreenState() {
    243   window_->ChangeWindowFullscreenState();
    244 }
    245 
    246 const char* FullscreenControllerStateUnitTest::GetWindowStateString() {
    247   return FullscreenControllerTestWindow::GetWindowStateString(window_->state());
    248 }
    249 
    250 void FullscreenControllerStateUnitTest::VerifyWindowState() {
    251   switch (state()) {
    252     case STATE_NORMAL:
    253       EXPECT_EQ(FullscreenControllerTestWindow::NORMAL,
    254                 window_->state()) << GetAndClearDebugLog();
    255       break;
    256 
    257     case STATE_BROWSER_FULLSCREEN_NO_CHROME:
    258     case STATE_BROWSER_FULLSCREEN_WITH_CHROME:
    259     case STATE_TAB_FULLSCREEN:
    260     case STATE_TAB_BROWSER_FULLSCREEN:
    261     case STATE_TAB_BROWSER_FULLSCREEN_CHROME:
    262       EXPECT_EQ(FullscreenControllerTestWindow::FULLSCREEN,
    263                 window_->state()) << GetAndClearDebugLog();
    264       break;
    265 
    266 #if defined(OS_WIN)
    267     case STATE_METRO_SNAP:
    268       EXPECT_EQ(FullscreenControllerTestWindow::METRO_SNAP,
    269                 window_->state()) << GetAndClearDebugLog();
    270       break;
    271 #endif
    272 
    273     case STATE_TO_NORMAL:
    274       EXPECT_EQ(FullscreenControllerTestWindow::TO_NORMAL,
    275                 window_->state()) << GetAndClearDebugLog();
    276       break;
    277 
    278     case STATE_TO_BROWSER_FULLSCREEN_NO_CHROME:
    279     case STATE_TO_BROWSER_FULLSCREEN_WITH_CHROME:
    280     case STATE_TO_TAB_FULLSCREEN:
    281       EXPECT_EQ(FullscreenControllerTestWindow::TO_FULLSCREEN,
    282                 window_->state()) << GetAndClearDebugLog();
    283       break;
    284 
    285     default:
    286       NOTREACHED() << GetAndClearDebugLog();
    287   }
    288 
    289   FullscreenControllerStateTest::VerifyWindowState();
    290 }
    291 
    292 bool FullscreenControllerStateUnitTest::ShouldSkipStateAndEventPair(
    293     State state, Event event) {
    294 #if defined(OS_MACOSX)
    295   // TODO(scheib) Toggle, Window Event, Toggle, Toggle on Mac as exposed by
    296   // test *.STATE_TO_NORMAL__TOGGLE_FULLSCREEN runs interactively and exits to
    297   // Normal. This doesn't appear to be the desired result, and would add
    298   // too much complexity to mimic in our simple FullscreenControllerTestWindow.
    299   // http://crbug.com/156968
    300   if ((state == STATE_TO_NORMAL ||
    301        state == STATE_TO_BROWSER_FULLSCREEN_NO_CHROME ||
    302        state == STATE_TO_TAB_FULLSCREEN) &&
    303       event == TOGGLE_FULLSCREEN)
    304     return true;
    305 #endif
    306 
    307   return FullscreenControllerStateTest::ShouldSkipStateAndEventPair(state,
    308                                                                     event);
    309 }
    310 
    311 Browser* FullscreenControllerStateUnitTest::GetBrowser() {
    312   return BrowserWithTestWindowTest::browser();
    313 }
    314 
    315 
    316 // Soak tests ------------------------------------------------------------------
    317 
    318 // Tests all states with all permutations of multiple events to detect lingering
    319 // state issues that would bleed over to other states.
    320 // I.E. for each state test all combinations of events E1, E2, E3.
    321 //
    322 // This produces coverage for event sequences that may happen normally but
    323 // would not be exposed by traversing to each state via TransitionToState().
    324 // TransitionToState() always takes the same path even when multiple paths
    325 // exist.
    326 TEST_F(FullscreenControllerStateUnitTest, TransitionsForEachState) {
    327   // A tab is needed for tab fullscreen.
    328   AddTab(browser(), GURL(content::kAboutBlankURL));
    329   TestTransitionsForEachState();
    330   // Progress of test can be examined via LOG(INFO) << GetAndClearDebugLog();
    331 }
    332 
    333 
    334 // Individual tests for each pair of state and event ---------------------------
    335 
    336 #define TEST_EVENT(state, event) \
    337     TEST_F(FullscreenControllerStateUnitTest, state##__##event) { \
    338       AddTab(browser(), GURL(content::kAboutBlankURL)); \
    339       ASSERT_NO_FATAL_FAILURE(TestStateAndEvent(state, event)) \
    340           << GetAndClearDebugLog(); \
    341     }
    342     // Progress of tests can be examined by inserting the following line:
    343     // LOG(INFO) << GetAndClearDebugLog(); }
    344 
    345 #include "chrome/browser/ui/fullscreen/fullscreen_controller_state_tests.h"
    346 
    347 
    348 // Specific one-off tests for known issues -------------------------------------
    349 
    350 // TODO(scheib) Toggling Tab fullscreen while pending Tab or
    351 // Browser fullscreen is broken currently http://crbug.com/154196
    352 TEST_F(FullscreenControllerStateUnitTest,
    353        DISABLED_ToggleTabWhenPendingBrowser) {
    354   // Only possible without reentrancy.
    355   if (FullscreenControllerStateTest::IsWindowFullscreenStateChangedReentrant())
    356     return;
    357   AddTab(browser(), GURL(content::kAboutBlankURL));
    358   ASSERT_NO_FATAL_FAILURE(
    359       TransitionToState(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME))
    360       << GetAndClearDebugLog();
    361 
    362   ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_TRUE)) << GetAndClearDebugLog();
    363   ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_FALSE)) << GetAndClearDebugLog();
    364   ASSERT_TRUE(InvokeEvent(WINDOW_CHANGE)) << GetAndClearDebugLog();
    365 }
    366 
    367 // TODO(scheib) Toggling Tab fullscreen while pending Tab or
    368 // Browser fullscreen is broken currently http://crbug.com/154196
    369 TEST_F(FullscreenControllerStateUnitTest, DISABLED_ToggleTabWhenPendingTab) {
    370   // Only possible without reentrancy.
    371   if (FullscreenControllerStateTest::IsWindowFullscreenStateChangedReentrant())
    372     return;
    373   AddTab(browser(), GURL(content::kAboutBlankURL));
    374   ASSERT_NO_FATAL_FAILURE(
    375       TransitionToState(STATE_TO_TAB_FULLSCREEN))
    376       << GetAndClearDebugLog();
    377 
    378   ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_TRUE)) << GetAndClearDebugLog();
    379   ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_FALSE)) << GetAndClearDebugLog();
    380   ASSERT_TRUE(InvokeEvent(WINDOW_CHANGE)) << GetAndClearDebugLog();
    381 }
    382 
    383 // Debugging utility: Display the transition tables. Intentionally disabled
    384 TEST_F(FullscreenControllerStateUnitTest, DISABLED_DebugLogStateTables) {
    385   std::ostringstream output;
    386   output << "\n\nTransition Table:";
    387   output << GetTransitionTableAsString();
    388 
    389   output << "\n\nInitial transitions:";
    390   output << GetStateTransitionsAsString();
    391 
    392   // Calculate all transition pairs.
    393   for (int state1_int = 0; state1_int < NUM_STATES; ++state1_int) {
    394     State state1 = static_cast<State>(state1_int);
    395     for (int state2_int = 0; state2_int < NUM_STATES; ++state2_int) {
    396       State state2 = static_cast<State>(state2_int);
    397       if (ShouldSkipStateAndEventPair(state1, EVENT_INVALID) ||
    398           ShouldSkipStateAndEventPair(state2, EVENT_INVALID))
    399         continue;
    400       // Compute the transition
    401       if (NextTransitionInShortestPath(state1, state2, NUM_STATES).state ==
    402           STATE_INVALID) {
    403         LOG(ERROR) << "Should be skipping state transitions for: "
    404             << GetStateString(state1) << " " << GetStateString(state2);
    405       }
    406     }
    407   }
    408 
    409   output << "\n\nAll transitions:";
    410   output << GetStateTransitionsAsString();
    411   LOG(INFO) << output.str();
    412 }
    413 
    414 // Test that the fullscreen exit bubble is closed by
    415 // WindowFullscreenStateChanged() if fullscreen is exited via BrowserWindow.
    416 // This currently occurs when an extension exits fullscreen via changing the
    417 // browser bounds.
    418 TEST_F(FullscreenControllerStateUnitTest, ExitFullscreenViaBrowserWindow) {
    419   AddTab(browser(), GURL(content::kAboutBlankURL));
    420   ASSERT_TRUE(InvokeEvent(TOGGLE_FULLSCREEN));
    421   ASSERT_TRUE(InvokeEvent(WINDOW_CHANGE));
    422   ASSERT_TRUE(browser()->window()->IsFullscreen());
    423   // Exit fullscreen without going through fullscreen controller.
    424   browser()->window()->ExitFullscreen();
    425   ChangeWindowFullscreenState();
    426   EXPECT_EQ(FEB_TYPE_NONE,
    427             browser()->fullscreen_controller()->GetFullscreenExitBubbleType());
    428 }
    429 
    430 // Test that switching tabs takes the browser out of tab fullscreen.
    431 TEST_F(FullscreenControllerStateUnitTest, ExitTabFullscreenViaSwitchingTab) {
    432   AddTab(browser(), GURL(content::kAboutBlankURL));
    433   AddTab(browser(), GURL(content::kAboutBlankURL));
    434   ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_TRUE));
    435   ASSERT_TRUE(InvokeEvent(WINDOW_CHANGE));
    436   ASSERT_TRUE(browser()->window()->IsFullscreen());
    437 
    438   browser()->tab_strip_model()->SelectNextTab();
    439   ChangeWindowFullscreenState();
    440   EXPECT_FALSE(browser()->window()->IsFullscreen());
    441 }
    442 
    443 // Test that switching tabs via detaching the active tab (which is in tab
    444 // fullscreen) takes the browser out of tab fullscreen. This case can
    445 // occur if the user is in both tab fullscreen and immersive browser fullscreen.
    446 TEST_F(FullscreenControllerStateUnitTest, ExitTabFullscreenViaDetachingTab) {
    447   AddTab(browser(), GURL(content::kAboutBlankURL));
    448   AddTab(browser(), GURL(content::kAboutBlankURL));
    449   ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_TRUE));
    450   ASSERT_TRUE(InvokeEvent(WINDOW_CHANGE));
    451   ASSERT_TRUE(browser()->window()->IsFullscreen());
    452 
    453   scoped_ptr<content::WebContents> web_contents(
    454       browser()->tab_strip_model()->DetachWebContentsAt(0));
    455   ChangeWindowFullscreenState();
    456   EXPECT_FALSE(browser()->window()->IsFullscreen());
    457 }
    458 
    459 // Test that replacing the web contents for a tab which is in tab fullscreen
    460 // takes the browser out of tab fullscreen. This can occur if the user
    461 // navigates to a prerendered page from a page which is tab fullscreen.
    462 TEST_F(FullscreenControllerStateUnitTest, ExitTabFullscreenViaReplacingTab) {
    463   AddTab(browser(), GURL(content::kAboutBlankURL));
    464   ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_TRUE));
    465   ASSERT_TRUE(InvokeEvent(WINDOW_CHANGE));
    466   ASSERT_TRUE(browser()->window()->IsFullscreen());
    467 
    468   content::WebContents* new_web_contents = content::WebContents::Create(
    469       content::WebContents::CreateParams(profile()));
    470   scoped_ptr<content::WebContents> old_web_contents(
    471       browser()->tab_strip_model()->ReplaceWebContentsAt(
    472           0, new_web_contents));
    473   ChangeWindowFullscreenState();
    474   EXPECT_FALSE(browser()->window()->IsFullscreen());
    475 }
    476