Tab modes added to fullscreen controller unittests.

BUG=146666


Review URL: https://chromiumcodereview.appspot.com/11088040

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@162806 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 384 insertions, 41 deletions

diff --git a/chrome/browser/ui/fullscreen/fullscreen_controller_unittest.cc b/chrome/browser/ui/fullscreen/fullscreen_controller_unittest.cc
index d70bb04..b296122 100644
--- a/chrome/browser/ui/fullscreen/fullscreen_controller_unittest.cc
+++ b/chrome/browser/ui/fullscreen/fullscreen_controller_unittest.cc
@@ -4,6 +4,8 @@
 
 #include <memory.h>
 
+#include <iomanip>
+#include <iostream>
 #include <sstream>
 
 #include "build/build_config.h"
@@ -12,6 +14,7 @@
 #include "chrome/browser/ui/fullscreen/fullscreen_controller.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/url_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // A BrowserWindow used for testing FullscreenController. ----------------------
@@ -24,7 +27,7 @@ class FullscreenControllerTestWindow : public TestBrowserWindow {
     // No TO_ state for METRO_SNAP, the windows implementation is synchronous.
     METRO_SNAP,
     TO_NORMAL,
-    TO_FULLSCREEN
+    TO_FULLSCREEN,
   };
 
   FullscreenControllerTestWindow();
@@ -33,12 +36,20 @@ class FullscreenControllerTestWindow : public TestBrowserWindow {
   // BrowserWindow Interface:
   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;
+#endif
 
   static const char* GetWindowStateString(WindowState state);
   WindowState state() const { return state_; }
@@ -53,6 +64,7 @@ class FullscreenControllerTestWindow : public TestBrowserWindow {
 
  private:
   WindowState state_;
+  bool mac_presentation_mode_;
   Browser* browser_;
 
   // Causes reentrant calls to be made by calling
@@ -63,11 +75,17 @@ class FullscreenControllerTestWindow : public TestBrowserWindow {
 
 FullscreenControllerTestWindow::FullscreenControllerTestWindow()
     : state_(NORMAL),
-      browser_(NULL) {
+      mac_presentation_mode_(false),
+      browser_(NULL),
+      reentrant_(false) {
 }
 
 void FullscreenControllerTestWindow::EnterFullscreen(
     const GURL& url, FullscreenExitBubbleType type) {
+  EnterFullscreen();
+}
+
+void FullscreenControllerTestWindow::EnterFullscreen() {
   if (!IsFullscreen()) {
     state_ = TO_FULLSCREEN;
     ChangeWindowFullscreenStateIfReentrant();
@@ -77,6 +95,7 @@ void FullscreenControllerTestWindow::EnterFullscreen(
 void FullscreenControllerTestWindow::ExitFullscreen() {
   if (IsFullscreen()) {
     state_ = TO_NORMAL;
+    mac_presentation_mode_ = false;
     ChangeWindowFullscreenStateIfReentrant();
   }
 }
@@ -101,6 +120,26 @@ bool FullscreenControllerTestWindow::IsInMetroSnapMode() const {
 }
 #endif
 
+#if defined(OS_MACOSX)
+void FullscreenControllerTestWindow::EnterPresentationMode(
+    const GURL& url,
+    FullscreenExitBubbleType bubble_type) {
+  mac_presentation_mode_ = true;
+  EnterFullscreen();
+}
+
+void FullscreenControllerTestWindow::ExitPresentationMode() {
+  if (InPresentationMode()) {
+    mac_presentation_mode_ = false;
+    ExitFullscreen();
+  }
+}
+
+bool FullscreenControllerTestWindow::InPresentationMode() {
+  return mac_presentation_mode_;
+}
+#endif
+
 // static
 const char* FullscreenControllerTestWindow::GetWindowStateString(
     WindowState state) {
@@ -165,17 +204,26 @@ class FullscreenControllerUnitTest : public BrowserWithTestWindowTest {
     // No TO_ state for Metro, as the windows implementation is only reentrant.
     STATE_METRO_SNAP,
 #endif
+    // HTML5 tab-initiated fullscreen.
+    STATE_TAB_FULLSCREEN,
+    // Both tab and browser fullscreen.
+    STATE_TAB_BROWSER_FULLSCREEN,
     // TO_ states are asynchronous states waiting for window state change
     // before transitioning to their named state.
     STATE_TO_NORMAL,
     STATE_TO_BROWSER_FULLSCREEN_NO_CHROME,
+    STATE_TO_TAB_FULLSCREEN,
     NUM_STATES,
-    STATE_INVALID
+    STATE_INVALID,
   };
 
   enum Event {
     // FullscreenController::ToggleFullscreenMode()
     TOGGLE_FULLSCREEN,
+    // FullscreenController::ToggleFullscreenModeForTab(, true)
+    TAB_FULLSCREEN_TRUE,
+    // FullscreenController::ToggleFullscreenModeForTab(, false)
+    TAB_FULLSCREEN_FALSE,
 #if defined(OS_WIN)
     // FullscreenController::SetMetroSnapMode(true)
     METRO_SNAP_TRUE,
@@ -185,9 +233,12 @@ class FullscreenControllerUnitTest : public BrowserWithTestWindowTest {
     // FullscreenController::ChangeWindowFullscreenState()
     WINDOW_CHANGE,
     NUM_EVENTS,
-    EVENT_INVALID
+    EVENT_INVALID,
   };
 
+  static const int MAX_STATE_NAME_LENGTH = 37;
+  static const int MAX_EVENT_NAME_LENGTH = 20;
+
   virtual void SetUp() OVERRIDE;
 
   static const char* GetStateString(State state);
@@ -225,6 +276,11 @@ class FullscreenControllerUnitTest : public BrowserWithTestWindowTest {
 
   std::string GetAndClearDebugLog();
 
+  // Avoids currently broken cases in the fullscreen controller.
+  bool ShouldSkipStateAndEventPair(State state, Event event);
+  // Skips reentrant situations and calls ShouldSkipStateAndEventPair.
+  bool ShouldSkipTest(State state, Event event, bool reentrant);
+
   // Runs one test of transitioning to a state and invoking an event.
   void TestStateAndEvent(State state, Event event, bool reentrant);
 
@@ -252,9 +308,11 @@ void FullscreenControllerUnitTest::SetUp() {
 
   // Human specified state machine data.
   // For each state, for each event, define the resulting state.
-  State transition_table_data[NUM_STATES][NUM_EVENTS] = {
+  State transition_table_data[][NUM_EVENTS] = {
     { // STATE_NORMAL:
       STATE_TO_BROWSER_FULLSCREEN_NO_CHROME,  // Event TOGGLE_FULLSCREEN
+      STATE_TO_TAB_FULLSCREEN,                // Event TAB_FULLSCREEN_TRUE
+      STATE_NORMAL,                           // Event TAB_FULLSCREEN_FALSE
 #if defined(OS_WIN)
       STATE_METRO_SNAP,                       // Event METRO_SNAP_TRUE
       STATE_NORMAL,                           // Event METRO_SNAP_FALSE
@@ -263,6 +321,8 @@ void FullscreenControllerUnitTest::SetUp() {
     },
     { // STATE_BROWSER_FULLSCREEN_NO_CHROME:
       STATE_TO_NORMAL,                        // Event TOGGLE_FULLSCREEN
+      STATE_TAB_BROWSER_FULLSCREEN,           // Event TAB_FULLSCREEN_TRUE
+      STATE_BROWSER_FULLSCREEN_NO_CHROME,     // Event TAB_FULLSCREEN_FALSE
 #if defined(OS_WIN)
       STATE_METRO_SNAP,                       // Event METRO_SNAP_TRUE
       STATE_BROWSER_FULLSCREEN_NO_CHROME,     // Event METRO_SNAP_FALSE
@@ -272,13 +332,43 @@ void FullscreenControllerUnitTest::SetUp() {
 #if defined(OS_WIN)
     { // STATE_METRO_SNAP:
       STATE_METRO_SNAP,                       // Event TOGGLE_FULLSCREEN
+      STATE_METRO_SNAP,                       // Event TAB_FULLSCREEN_TRUE
+      STATE_METRO_SNAP,                       // Event TAB_FULLSCREEN_FALSE
       STATE_METRO_SNAP,                       // Event METRO_SNAP_TRUE
       STATE_NORMAL,                           // Event METRO_SNAP_FALSE
       STATE_METRO_SNAP,                       // Event WINDOW_CHANGE
     },
 #endif
+    { // STATE_TAB_FULLSCREEN:
+      STATE_TO_NORMAL,                        // Event TOGGLE_FULLSCREEN
+      STATE_TAB_FULLSCREEN,                   // Event TAB_FULLSCREEN_TRUE
+      STATE_TO_NORMAL,                        // Event TAB_FULLSCREEN_FALSE
+#if defined(OS_WIN)
+      STATE_METRO_SNAP,                       // Event METRO_SNAP_TRUE
+      STATE_TAB_FULLSCREEN,                   // Event METRO_SNAP_FALSE
+#endif
+      STATE_TAB_FULLSCREEN,                   // Event WINDOW_CHANGE
+    },
+    { // STATE_TAB_BROWSER_FULLSCREEN:
+      STATE_TO_NORMAL,                        // Event TOGGLE_FULLSCREEN
+      STATE_TAB_BROWSER_FULLSCREEN,           // Event TAB_FULLSCREEN_TRUE
+#if defined(OS_MACOSX)
+      // TODO(scheib) Mac exits browser mode too http://crbug.com/155642
+      STATE_TO_NORMAL,                        // Event TAB_FULLSCREEN_FALSE
+#else
+      STATE_BROWSER_FULLSCREEN_NO_CHROME,     // Event TAB_FULLSCREEN_FALSE
+#endif
+#if defined(OS_WIN)
+      STATE_METRO_SNAP,                       // Event METRO_SNAP_TRUE
+      STATE_TAB_BROWSER_FULLSCREEN,           // Event METRO_SNAP_FALSE
+#endif
+      STATE_TAB_BROWSER_FULLSCREEN,           // Event WINDOW_CHANGE
+    },
     // STATE_TO_NORMAL:
     { STATE_TO_NORMAL,                        // Event TOGGLE_FULLSCREEN
+      // TODO(scheib) Should be a route back to TAB. http://crbug.com/154196
+      STATE_TO_NORMAL,                        // Event TAB_FULLSCREEN_TRUE
+      STATE_TO_NORMAL,                        // Event TAB_FULLSCREEN_FALSE
 #if defined(OS_WIN)
       STATE_METRO_SNAP,                       // Event METRO_SNAP_TRUE
       STATE_TO_NORMAL,                        // Event METRO_SNAP_FALSE
@@ -287,12 +377,27 @@ void FullscreenControllerUnitTest::SetUp() {
     },
     // STATE_TO_BROWSER_FULLSCREEN_NO_CHROME:
     { STATE_TO_BROWSER_FULLSCREEN_NO_CHROME,  // Event TOGGLE_FULLSCREEN
+      // TODO(scheib) Should be a route to TAB_BROWSER http://crbug.com/154196
+      STATE_TO_BROWSER_FULLSCREEN_NO_CHROME,  // Event TAB_FULLSCREEN_TRUE
+      STATE_TO_BROWSER_FULLSCREEN_NO_CHROME,  // Event TAB_FULLSCREEN_FALSE
 #if defined(OS_WIN)
       STATE_METRO_SNAP,                       // Event METRO_SNAP_TRUE
       STATE_TO_BROWSER_FULLSCREEN_NO_CHROME,  // Event METRO_SNAP_FALSE
 #endif
       STATE_BROWSER_FULLSCREEN_NO_CHROME,     // Event WINDOW_CHANGE
     },
+    // STATE_TO_TAB_FULLSCREEN:
+    { // TODO(scheib) Should be a route to TAB_BROWSER http://crbug.com/154196
+      STATE_TO_TAB_FULLSCREEN,                // Event TOGGLE_FULLSCREEN
+      STATE_TO_TAB_FULLSCREEN,                // Event TAB_FULLSCREEN_TRUE
+      // TODO(scheib) Should be a route back to NORMAL. http://crbug.com/154196
+      STATE_TO_BROWSER_FULLSCREEN_NO_CHROME,  // Event TAB_FULLSCREEN_FALSE
+#if defined(OS_WIN)
+      STATE_METRO_SNAP,                       // Event METRO_SNAP_TRUE
+      STATE_TO_TAB_FULLSCREEN,                // Event METRO_SNAP_FALSE
+#endif
+      STATE_TAB_FULLSCREEN,                   // Event WINDOW_CHANGE
+    },
   };
   ASSERT_EQ(sizeof(transition_table_data), sizeof(transition_table_));
   memcpy(transition_table_, transition_table_data,
@@ -329,10 +434,16 @@ const char* FullscreenControllerUnitTest::GetStateString(State state) {
     case STATE_METRO_SNAP:
       return "STATE_METRO_SNAP";
 #endif
+    case STATE_TAB_FULLSCREEN:
+      return "STATE_TAB_FULLSCREEN";
+    case STATE_TAB_BROWSER_FULLSCREEN:
+      return "STATE_TAB_BROWSER_FULLSCREEN";
     case STATE_TO_NORMAL:
       return "STATE_TO_NORMAL";
     case STATE_TO_BROWSER_FULLSCREEN_NO_CHROME:
       return "STATE_TO_BROWSER_FULLSCREEN_NO_CHROME";
+    case STATE_TO_TAB_FULLSCREEN:
+      return "STATE_TO_TAB_FULLSCREEN";
     case STATE_INVALID:
       return "STATE_INVALID";
     default:
@@ -346,6 +457,10 @@ const char* FullscreenControllerUnitTest::GetEventString(Event event) {
   switch (event) {
     case TOGGLE_FULLSCREEN:
       return "TOGGLE_FULLSCREEN";
+    case TAB_FULLSCREEN_TRUE:
+      return "TAB_FULLSCREEN_TRUE";
+    case TAB_FULLSCREEN_FALSE:
+      return "TAB_FULLSCREEN_FALSE";
 #if defined(OS_WIN)
     case METRO_SNAP_TRUE:
       return "METRO_SNAP_TRUE";
@@ -404,9 +519,11 @@ bool FullscreenControllerUnitTest::InvokeEvent(Event event) {
   if (window_->reentrant())
     next_state = transition_table_[next_state][WINDOW_CHANGE];
 
-  debugging_log_ << "  Transitioning state " << GetStateString(source_state)
-      << " -> " << GetStateString(next_state) << " with event "
-      << GetEventString(event) << std::endl;
+  debugging_log_ << "  InvokeEvent(" << std::left
+      << std::setw(MAX_EVENT_NAME_LENGTH) << GetEventString(event)
+      << ") to "
+      << std::setw(MAX_STATE_NAME_LENGTH) << GetStateString(next_state)
+      << " ";
 
   state_ = next_state;
 
@@ -414,6 +531,14 @@ bool FullscreenControllerUnitTest::InvokeEvent(Event event) {
     case TOGGLE_FULLSCREEN:
       fullscreen_controller_->ToggleFullscreenMode();
       break;
+    case TAB_FULLSCREEN_TRUE:
+      fullscreen_controller_->ToggleFullscreenModeForTab(
+           chrome::GetActiveWebContents(browser()), true);
+      break;
+    case TAB_FULLSCREEN_FALSE:
+      fullscreen_controller_->ToggleFullscreenModeForTab(
+           chrome::GetActiveWebContents(browser()), false);
+      break;
 #if defined(OS_WIN)
     case METRO_SNAP_TRUE:
       fullscreen_controller_->SetMetroSnapMode(true);
@@ -431,12 +556,12 @@ bool FullscreenControllerUnitTest::InvokeEvent(Event event) {
       return false;
   }
 
-  VerifyWindowState();
-
-  debugging_log_ << "   Window state now "
+  debugging_log_ << "Window state now "
       << FullscreenControllerTestWindow::GetWindowStateString(window_->state())
       << std::endl;
 
+  VerifyWindowState();
+
   return true;
 }
 
@@ -445,39 +570,122 @@ void FullscreenControllerUnitTest::VerifyWindowState() {
     case STATE_NORMAL:
       EXPECT_EQ(FullscreenControllerTestWindow::NORMAL,
                 window_->state()) << GetAndClearDebugLog();
-      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForBrowser());
-      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForTabOrPending());
-      EXPECT_FALSE(fullscreen_controller_->IsInMetroSnapMode());
+#if defined(OS_MACOSX)
+      EXPECT_FALSE(window_->InPresentationMode())
+          << GetAndClearDebugLog();
+#endif
+      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForBrowser())
+          << GetAndClearDebugLog();
+      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForTabOrPending())
+          << GetAndClearDebugLog();
+      EXPECT_FALSE(fullscreen_controller_->IsInMetroSnapMode())
+          << GetAndClearDebugLog();
       break;
     case STATE_BROWSER_FULLSCREEN_NO_CHROME:
       EXPECT_EQ(FullscreenControllerTestWindow::FULLSCREEN,
                 window_->state()) << GetAndClearDebugLog();
-      EXPECT_TRUE(fullscreen_controller_->IsFullscreenForBrowser());
-      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForTabOrPending());
-      EXPECT_FALSE(fullscreen_controller_->IsInMetroSnapMode());
+#if defined(OS_MACOSX)
+      EXPECT_FALSE(window_->InPresentationMode())
+          << GetAndClearDebugLog();
+#endif
+      EXPECT_TRUE(fullscreen_controller_->IsFullscreenForBrowser())
+          << GetAndClearDebugLog();
+      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForTabOrPending())
+          << GetAndClearDebugLog();
+      EXPECT_FALSE(fullscreen_controller_->IsInMetroSnapMode())
+          << GetAndClearDebugLog();
       break;
 #if defined(OS_WIN)
     case STATE_METRO_SNAP:
       EXPECT_EQ(FullscreenControllerTestWindow::METRO_SNAP,
                 window_->state()) << GetAndClearDebugLog();
-      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForBrowser());
-      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForTabOrPending());
-      EXPECT_TRUE(fullscreen_controller_->IsInMetroSnapMode());
+      // No expectation for InPresentationMode.
+      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForBrowser())
+          << GetAndClearDebugLog();
+      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForTabOrPending())
+          << GetAndClearDebugLog();
+      EXPECT_TRUE(fullscreen_controller_->IsInMetroSnapMode())
+          << GetAndClearDebugLog();
       break;
 #endif
+    case STATE_TAB_FULLSCREEN:
+      EXPECT_EQ(FullscreenControllerTestWindow::FULLSCREEN,
+                window_->state()) << GetAndClearDebugLog();
+#if defined(OS_MACOSX)
+      EXPECT_TRUE(window_->InPresentationMode())
+          << GetAndClearDebugLog();
+#endif
+      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForBrowser())
+          << GetAndClearDebugLog();
+      EXPECT_TRUE(fullscreen_controller_->IsFullscreenForTabOrPending())
+          << GetAndClearDebugLog();
+      EXPECT_FALSE(fullscreen_controller_->IsInMetroSnapMode())
+          << GetAndClearDebugLog();
+      break;
+    case STATE_TAB_BROWSER_FULLSCREEN:
+      EXPECT_EQ(FullscreenControllerTestWindow::FULLSCREEN,
+                window_->state()) << GetAndClearDebugLog();
+#if defined(OS_MACOSX)
+      EXPECT_TRUE(window_->InPresentationMode())
+          << GetAndClearDebugLog();
+#endif
+#if defined(OS_MACOSX)
+      // TODO(scheib) Mac is reporting incorrect IsFullscreenForBrowser().
+      // e.g. in FullscreenControllerUnitTest.
+      //     STATE_BROWSER_FULLSCREEN_NO_CHROME_TAB_FULLSCREEN_TRUE
+      // At the end of ToggleFullscreenModeForTab
+      // tab_caused_fullscreen_ has incorrectly been set to true even
+      // though controller was already in browser fullscreen.
+      // http://crbug.com/155650
+      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForBrowser())
+          << GetAndClearDebugLog();
+#else
+      EXPECT_TRUE(fullscreen_controller_->IsFullscreenForBrowser())
+          << GetAndClearDebugLog();
+#endif
+      EXPECT_TRUE(fullscreen_controller_->IsFullscreenForTabOrPending())
+          << GetAndClearDebugLog();
+      EXPECT_FALSE(fullscreen_controller_->IsInMetroSnapMode())
+          << GetAndClearDebugLog();
+      break;
     case STATE_TO_NORMAL:
       EXPECT_EQ(FullscreenControllerTestWindow::TO_NORMAL,
                 window_->state()) << GetAndClearDebugLog();
+#if defined(OS_MACOSX)
+      EXPECT_FALSE(window_->InPresentationMode())
+          << GetAndClearDebugLog();
+#endif
       // No expectation for IsFullscreenForBrowser.
       // No expectation for IsFullscreenForTabOrPending.
-      EXPECT_FALSE(fullscreen_controller_->IsInMetroSnapMode());
+      EXPECT_FALSE(fullscreen_controller_->IsInMetroSnapMode())
+          << GetAndClearDebugLog();
       break;
     case STATE_TO_BROWSER_FULLSCREEN_NO_CHROME:
       EXPECT_EQ(FullscreenControllerTestWindow::TO_FULLSCREEN,
                 window_->state()) << GetAndClearDebugLog();
-      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForBrowser());
-      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForTabOrPending());
-      EXPECT_FALSE(fullscreen_controller_->IsInMetroSnapMode());
+#if defined(OS_MACOSX)
+      EXPECT_FALSE(window_->InPresentationMode())
+          << GetAndClearDebugLog();
+#endif
+      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForBrowser())
+          << GetAndClearDebugLog();
+      // No expectation for IsFullscreenForTabOrPending.
+      EXPECT_FALSE(fullscreen_controller_->IsInMetroSnapMode())
+          << GetAndClearDebugLog();
+      break;
+    case STATE_TO_TAB_FULLSCREEN:
+      EXPECT_EQ(FullscreenControllerTestWindow::TO_FULLSCREEN,
+                window_->state()) << GetAndClearDebugLog();
+#if defined(OS_MACOSX)
+      EXPECT_TRUE(window_->InPresentationMode())
+          << GetAndClearDebugLog();
+#endif
+      EXPECT_FALSE(fullscreen_controller_->IsFullscreenForBrowser())
+          << GetAndClearDebugLog();
+      EXPECT_TRUE(fullscreen_controller_->IsFullscreenForTabOrPending())
+          << GetAndClearDebugLog();
+      EXPECT_FALSE(fullscreen_controller_->IsInMetroSnapMode())
+          << GetAndClearDebugLog();
       break;
     default:
       NOTREACHED() << GetAndClearDebugLog();
@@ -495,15 +703,19 @@ FullscreenControllerUnitTest::StateTransitionInfo
     StateTransitionInfo result;
 
     // Consider all states reachable via each event from the source state.
-    for (int event = 0; event < NUM_EVENTS; event++) {
+    for (int event_int = 0; event_int < NUM_EVENTS; event_int++) {
+      Event event = static_cast<Event>(event_int);
       State next_state_candidate = transition_table_[source][event];
 
+      if (ShouldSkipStateAndEventPair(source, event))
+        continue;
+
       // Recurse.
       StateTransitionInfo candidate = NextTransitionInShortestPath(
           next_state_candidate, destination, search_limit - 1);
 
       if (candidate.distance + 1 < result.distance) {
-        result.event = static_cast<Event>(event);
+        result.event = event;
         result.state = next_state_candidate;
         result.distance = candidate.distance + 1;
       }
@@ -523,15 +735,29 @@ std::string FullscreenControllerUnitTest::GetAndClearDebugLog() {
   return output_log;
 }
 
-void FullscreenControllerUnitTest::TestStateAndEvent(State state,
-                                                     Event event,
-                                                     bool reentrant) {
+bool FullscreenControllerUnitTest::ShouldSkipStateAndEventPair(State state,
+                                                               Event event) {
+  // TODO(scheib) Toggling Tab fullscreen while pending Tab or
+  // Browser fullscreen is broken currently http://crbug.com/154196
+  if ((state == STATE_TO_BROWSER_FULLSCREEN_NO_CHROME ||
+       state == STATE_TO_TAB_FULLSCREEN) &&
+      (event == TAB_FULLSCREEN_TRUE || event == TAB_FULLSCREEN_FALSE))
+    return true;
+  if (state == STATE_TO_NORMAL && event == TAB_FULLSCREEN_TRUE)
+    return true;
+
+  return false;
+}
+
+bool FullscreenControllerUnitTest::ShouldSkipTest(State state,
+                                                  Event event,
+                                                  bool reentrant) {
 #if defined(OS_WIN)
   // FullscreenController verifies that WindowFullscreenStateChanged is
   // always reentrant on Windows. It will fail if we mock asynchronous calls.
   if (!reentrant) {
-    debugging_log_ << "Skipping non-reentrant test on Windows.\n";
-    return;
+    debugging_log_ << "\nSkipping non-reentrant test on Windows.\n";
+    return true;
   }
 #endif
 
@@ -540,21 +766,31 @@ void FullscreenControllerUnitTest::TestStateAndEvent(State state,
   // reentrant window change call. Skip states that will be instantly
   // exited by the reentrant call.
   if (reentrant && (transition_table_[state][WINDOW_CHANGE] != state)) {
-    debugging_log_ << "Skipping reentrant test for transitory source state "
+    debugging_log_ << "\nSkipping reentrant test for transitory source state "
         << GetStateString(state) << ".\n";
-    return;
+    return true;
   }
 
+  return ShouldSkipStateAndEventPair(state, event);
+}
+
+void FullscreenControllerUnitTest::TestStateAndEvent(State state,
+                                                     Event event,
+                                                     bool reentrant) {
+  if (ShouldSkipTest(state, event, reentrant))
+    return;
+
   debugging_log_ << "\nTest transition from state "
-      << GetStateString(state) << " via event " << GetEventString(event)
+      << GetStateString(state)
       << (reentrant ? " with reentrant calls.\n" : ".\n");
   window_->set_reentrant(reentrant);
 
-  debugging_log_ << " First, transition to " << GetStateString(state) << "\n";
+  debugging_log_ << " First,                           from "
+      << GetStateString(state_) << "\n";
   ASSERT_NO_FATAL_FAILURE(TransitionToState(state))
       << GetAndClearDebugLog();
 
-  debugging_log_ << " Then, invoke " << GetEventString(event) << "\n";
+  debugging_log_ << " Then,\n";
   ASSERT_TRUE(InvokeEvent(event)) << GetAndClearDebugLog();
 }
 
@@ -563,6 +799,7 @@ void FullscreenControllerUnitTest::TestStateAndEvent(State state,
 
 #define TEST_EVENT_INNER(state, event, reentrant, reentrant_id) \
     TEST_F(FullscreenControllerUnitTest, state##_##event##reentrant_id) { \
+      AddTab(browser(), GURL(chrome::kAboutBlankURL)); \
       ASSERT_NO_FATAL_FAILURE(TestStateAndEvent(state, event, reentrant)) \
           << GetAndClearDebugLog(); \
     }
@@ -573,7 +810,11 @@ void FullscreenControllerUnitTest::TestStateAndEvent(State state,
     TEST_EVENT_INNER(state, event, false, ); \
     TEST_EVENT_INNER(state, event, true, _Reentrant);
 
+// 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);
@@ -581,6 +822,8 @@ TEST_EVENT(STATE_NORMAL, METRO_SNAP_FALSE);
 TEST_EVENT(STATE_NORMAL, WINDOW_CHANGE);
 
 TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, TOGGLE_FULLSCREEN);
+TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, TAB_FULLSCREEN_TRUE);
+TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, TAB_FULLSCREEN_FALSE);
 #if defined(OS_WIN)
 TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, METRO_SNAP_TRUE);
 TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, METRO_SNAP_FALSE);
@@ -589,12 +832,34 @@ TEST_EVENT(STATE_BROWSER_FULLSCREEN_NO_CHROME, WINDOW_CHANGE);
 
 #if defined(OS_WIN)
 TEST_EVENT(STATE_METRO_SNAP, TOGGLE_FULLSCREEN);
+TEST_EVENT(STATE_METRO_SNAP, TAB_FULLSCREEN_TRUE);
+TEST_EVENT(STATE_METRO_SNAP, TAB_FULLSCREEN_FALSE);
 TEST_EVENT(STATE_METRO_SNAP, METRO_SNAP_TRUE);
 TEST_EVENT(STATE_METRO_SNAP, METRO_SNAP_FALSE);
 TEST_EVENT(STATE_METRO_SNAP, WINDOW_CHANGE);
 #endif
 
+TEST_EVENT(STATE_TAB_FULLSCREEN, TOGGLE_FULLSCREEN);
+TEST_EVENT(STATE_TAB_FULLSCREEN, TAB_FULLSCREEN_TRUE);
+TEST_EVENT(STATE_TAB_FULLSCREEN, TAB_FULLSCREEN_FALSE);
+#if defined(OS_WIN)
+TEST_EVENT(STATE_TAB_FULLSCREEN, METRO_SNAP_TRUE);
+TEST_EVENT(STATE_TAB_FULLSCREEN, METRO_SNAP_FALSE);
+#endif
+TEST_EVENT(STATE_TAB_FULLSCREEN, WINDOW_CHANGE);
+
+TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, TOGGLE_FULLSCREEN);
+TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, TAB_FULLSCREEN_TRUE);
+TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, TAB_FULLSCREEN_FALSE);
+#if defined(OS_WIN)
+TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, METRO_SNAP_TRUE);
+TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, METRO_SNAP_FALSE);
+#endif
+TEST_EVENT(STATE_TAB_BROWSER_FULLSCREEN, WINDOW_CHANGE);
+
 TEST_EVENT(STATE_TO_NORMAL, TOGGLE_FULLSCREEN);
+TEST_EVENT(STATE_TO_NORMAL, TAB_FULLSCREEN_TRUE);
+TEST_EVENT(STATE_TO_NORMAL, TAB_FULLSCREEN_FALSE);
 #if defined(OS_WIN)
 TEST_EVENT(STATE_TO_NORMAL, METRO_SNAP_TRUE);
 TEST_EVENT(STATE_TO_NORMAL, METRO_SNAP_FALSE);
@@ -602,22 +867,100 @@ TEST_EVENT(STATE_TO_NORMAL, METRO_SNAP_FALSE);
 TEST_EVENT(STATE_TO_NORMAL, WINDOW_CHANGE);
 
 TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, TOGGLE_FULLSCREEN);
+TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, TAB_FULLSCREEN_TRUE);
+TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, TAB_FULLSCREEN_FALSE);
 #if defined(OS_WIN)
 TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, METRO_SNAP_TRUE);
 TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, METRO_SNAP_FALSE);
 #endif
 TEST_EVENT(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME, WINDOW_CHANGE);
 
-// A single test that traverses all state and event pairs to detect lingering
+TEST_EVENT(STATE_TO_TAB_FULLSCREEN, TOGGLE_FULLSCREEN);
+TEST_EVENT(STATE_TO_TAB_FULLSCREEN, TAB_FULLSCREEN_TRUE);
+TEST_EVENT(STATE_TO_TAB_FULLSCREEN, TAB_FULLSCREEN_FALSE);
+#if defined(OS_WIN)
+TEST_EVENT(STATE_TO_TAB_FULLSCREEN, METRO_SNAP_TRUE);
+TEST_EVENT(STATE_TO_TAB_FULLSCREEN, METRO_SNAP_FALSE);
+#endif
+TEST_EVENT(STATE_TO_TAB_FULLSCREEN, WINDOW_CHANGE);
+
+// Specific one-off tests for known issues:
+
+// TODO(scheib) Toggling Tab fullscreen while pending Tab or
+// Browser fullscreen is broken currently http://crbug.com/154196
+TEST_F(FullscreenControllerUnitTest, DISABLED_ToggleTabWhenPendingBrowser) {
+#if !defined(OS_WIN)  // Only possible without reentrancy
+  AddTab(browser(), GURL(chrome::kAboutBlankURL));
+  ASSERT_NO_FATAL_FAILURE(
+      TransitionToState(STATE_TO_BROWSER_FULLSCREEN_NO_CHROME))
+      << GetAndClearDebugLog();
+
+  ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_TRUE)) << GetAndClearDebugLog();
+  ASSERT_TRUE(InvokeEvent(TAB_FULLSCREEN_FALSE)) << GetAndClearDebugLog();
+  ASSERT_TRUE(InvokeEvent(WINDOW_CHANGE)) << GetAndClearDebugLog();
+#endif
+}
+
+// TODO(scheib) Toggling Tab fullscreen while pending Tab or
+// Browser fullscreen is broken currently http://crbug.com/154196
+TEST_F(FullscreenControllerUnitTest, DISABLED_ToggleTabWhenPendingTab) {
+#if !defined(OS_WIN)  // Only possible without reentrancy
+  AddTab(browser(), GURL(chrome::kAboutBlankURL));
+  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(FullscreenControllerUnitTest, TransitionsForEachState) {
+  // A tab is needed for tab fullscreen.
+  AddTab(browser(), GURL(chrome::kAboutBlankURL));
   for (int reentrant = 0; reentrant <= 1; reentrant++) {
     for (int source_int = 0; source_int < NUM_STATES; source_int++) {
-      for (int event_int = 0; event_int < NUM_EVENTS; event_int++) {
+      for (int event1_int = 0; event1_int < NUM_EVENTS; event1_int++) {
         State state = static_cast<State>(source_int);
-        Event event = static_cast<Event>(event_int);
-        ASSERT_NO_FATAL_FAILURE(TestStateAndEvent(state, event, !!reentrant))
-            << GetAndClearDebugLog();
+        Event event1 = static_cast<Event>(event1_int);
+
+        // Early out if skipping all tests for this state, reduces log noise.
+        if (ShouldSkipTest(state, event1, !!reentrant))
+          continue;
+
+        for (int event2_int = 0; event2_int < NUM_EVENTS; event2_int++) {
+          for (int event3_int = 0; event3_int < NUM_EVENTS; event3_int++) {
+            Event event2 = static_cast<Event>(event2_int);
+            Event event3 = static_cast<Event>(event3_int);
+
+            // Test each state and each event.
+            ASSERT_NO_FATAL_FAILURE(TestStateAndEvent(state,
+                                                      event1,
+                                                      !!reentrant))
+                << GetAndClearDebugLog();
+
+            // Then, add an additional event to the sequence.
+            if (ShouldSkipStateAndEventPair(state_, event2))
+              continue;
+            ASSERT_TRUE(InvokeEvent(event2)) << GetAndClearDebugLog();
+
+            // Then, add an additional event to the sequence.
+            if (ShouldSkipStateAndEventPair(state_, event3))
+              continue;
+            ASSERT_TRUE(InvokeEvent(event3)) << GetAndClearDebugLog();
+          }
+        }
       }
     }
   }