Tabs being screen-captured will fullscreen within their tab contents area.

chrome/browser/ui/fullscreen/fullscreen_controller_state_test.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_state_test.h"
 
 #include <memory.h>
 
 #include <iomanip>
 #include <iostream>
 
 #include "chrome/browser/fullscreen.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/fullscreen/fullscreen_controller.h"
 #include "chrome/browser/ui/fullscreen/fullscreen_controller_test.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #endif
 
 namespace {
 
 bool SupportsMacSystemFullscreen() {
 #if defined(OS_MACOSX)
   return chrome::mac::SupportsSystemFullscreen();
 #else
   return false;
 #endif
 }
 
 }  // namespace
 
 FullscreenControllerStateTest::FullscreenControllerStateTest()
     : state_(STATE_NORMAL),
       last_notification_received_state_(STATE_NORMAL) {
   // Human specified state machine data.
   // For each state, for each event, define the resulting state.
   State transition_table_data[][NUM_EVENTS] = {

[scheib, 2014/02/12 01:41:16]

I think it prudent to add states and expected outcomes for tab capture being
enabled and the various sub states. Fullscreen was complex, got worse, and
that's why we built up this exhaustive test suite. This change is adding a
additional complexity, but only two one-off tests.

Please also run the FullscreenControllerStateInteractiveTest locally enabling
the disabled tests from fullscreen_controller_state_interactive_browsertest.cc
if you haven't already.

[miu, 2014/02/12 08:25:19]

Regarding the additional complexity to FullscreenController: The way to think
about this CL is that I'm just adding a small amount of logic to
FullscreenController that sits on the side.  This new logic pretty much coexists
alongside the existing logic, and doesn't alter nor interfere with its behavior.
 The two sets of logic are pretty much orthogonal.

Regarding this test code: I originally started down the route you suggest, but
quickly found out it wouldn't work: All the test infrastructure here assumes
only one tab can be fullscreened at a time.  And, that makes sense, since all
the state transitions here only apply to the control logic that will manipulate
the browser window fullscreen state.

Overall, IMHO, the tests I've added do show that the screen-captured-tab
fullscreen toggles coexist harmoniously with the normal fullscreen toggles, and
that neither can interfere with each other.
Done, all passing once I fixed one of the tests.

[scheib, 2014/02/12 18:01:36]

The controller unfortunately has several 'orthogonal' bits of logic now... mouse
lock, metro snap, (somewhat more integral mac with-chrome fullscreen), and in
tab & while capturing FS. ;) It adds up, and it's hard to be confident when
making changes to the FSC that there isn't some subtle connection.

I understand the lack of suitability for the infrastructure, so off we go
without trying to bake this in. I think your additional tests should help.

REQUEST: Please add a DCHECK (somewhere?) to notify a developer if we break the
assumption that we won't start a capture session in an already fullscreened tab.

     { // STATE_NORMAL:
       STATE_TO_BROWSER_FULLSCREEN_NO_CHROME,  // Event TOGGLE_FULLSCREEN
       STATE_TO_BROWSER_FULLSCREEN_WITH_CHROME,// Event TOGGLE_FULLSCREEN_CHROME
       STATE_TO_TAB_FULLSCREEN,                // Event TAB_FULLSCREEN_TRUE
       STATE_NORMAL,                           // Event TAB_FULLSCREEN_FALSE
       STATE_METRO_SNAP,                       // Event METRO_SNAP_TRUE
       STATE_NORMAL,                           // Event METRO_SNAP_FALSE
       STATE_NORMAL,                           // Event BUBBLE_EXIT_LINK
       STATE_NORMAL,                           // Event BUBBLE_ALLOW
       STATE_NORMAL,                           // Event BUBBLE_DENY
@@ skipping 324 matching lines @@
 #if defined(OS_MACOSX)
       if (chrome::mac::SupportsSystemFullscreen()) {
         GetFullscreenController()->ToggleFullscreenWithChrome();
         break;
       }
 #endif
       NOTREACHED() << GetAndClearDebugLog();
       break;
 
     case TAB_FULLSCREEN_TRUE:
-      GetFullscreenController()->ToggleFullscreenModeForTab(
-           GetBrowser()->tab_strip_model()->GetActiveWebContents(), true);
+    case TAB_FULLSCREEN_FALSE: {
+      content::WebContents* const active_tab =
+          GetBrowser()->tab_strip_model()->GetActiveWebContents();
+      GetFullscreenController()->
+          ToggleFullscreenModeForTab(active_tab, event == TAB_FULLSCREEN_TRUE);
+      // Activating/Deactivating tab fullscreen on a captured tab should not
+      // evoke a state change in the browser window.
+      if (active_tab->GetCapturerCount() > 0)
+        state_ = source_state;
       break;
-
-    case TAB_FULLSCREEN_FALSE:
-      GetFullscreenController()->ToggleFullscreenModeForTab(
-           GetBrowser()->tab_strip_model()->GetActiveWebContents(), false);
-      break;
+    }
 
     case METRO_SNAP_TRUE:
 #if defined(OS_WIN)
       GetFullscreenController()->SetMetroSnapMode(true);
 #else
       NOTREACHED() << GetAndClearDebugLog();
 #endif
       break;
 
     case METRO_SNAP_FALSE:
@@ skipping 406 matching lines @@
         << std::right << std::setw(2)
         << info.distance
         << " }, // "
         << GetStateString(state2) << "\n";
     }
     output << "},\n";
   }
   output << "};";
   return output.str();
 }