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

chrome/browser/ui/fullscreen/fullscreen_controller.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_FULLSCREEN_FULLSCREEN_CONTROLLER_H_
 #define CHROME_BROWSER_UI_FULLSCREEN_FULLSCREEN_CONTROLLER_H_
 
+#include <vector>
+
 #include "base/basictypes.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/ui/fullscreen/fullscreen_exit_bubble_type.h"
 #include "chrome/common/content_settings.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 class Browser;
 class BrowserWindow;
 class GURL;
 class Profile;
 
 namespace content {
 class WebContents;
 }
 
 // There are two different kinds of fullscreen mode - "tab fullscreen" and
 // "browser fullscreen". "Tab fullscreen" refers to a renderer-initiated
 // fullscreen mode (eg: from a Flash plugin or via the JS fullscreen API),
 // whereas "browser fullscreen" refers to the user putting the browser itself
 // into fullscreen mode from the UI. The difference is that tab fullscreen has
 // implications for how the contents of the tab render (eg: a video element may
 // grow to consume the whole tab), whereas browser fullscreen mode doesn't.
 // Therefore if a user forces an exit from tab fullscreen, we need to notify the
 // tab so it can stop rendering in its fullscreen mode.
 //
 // For Flash, FullscreenController will auto-accept all permission requests for
 // fullscreen and/or mouse lock, since the assumption is that the plugin handles
 // this for us.
+//
+// Special behavior for screen-captured tabs: When embedded fullscreen widgets

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

Consider anchoring/naming this note with e.g. 
"""
EmbeddedFullscreen Note: 
Special behavior ...
"""

And then referencing elsewhere with "See 'EmbeddedFullscreen Note'"

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

Done.

+// are enabled and the renderer toggles into fullscreen mode, the browser window
+// will not expand to enter fullscreen.  This allows the user to retain control
+// of their desktop to work in other browser tabs or applications while the
+// fullscreen view is displayed on a remote screen.  FullscreenController will
+// track which WebContentses have renderers in fullscreen mode, and use an
+// alternate set of heuristics to manage them.
 
 // This class implements fullscreen and mouselock behaviour.
 class FullscreenController : public content::NotificationObserver {
  public:
   explicit FullscreenController(Browser* browser);
   virtual ~FullscreenController();
 
   // Browser/User Fullscreen ///////////////////////////////////////////////////
 
   // Returns true if the window is currently fullscreen and was initially
   // transitioned to fullscreen by a browser (vs tab) mode transition.
   bool IsFullscreenForBrowser() const;
 
   void ToggleFullscreenMode();
 
   // Tab/HTML/Flash Fullscreen /////////////////////////////////////////////////
 
   // Returns true if fullscreen has been caused by a tab.
   // The window may still be transitioning, and window_->IsFullscreen()
   // may still return false.
+  //
+  // NOTE: The zero-argument version returns true iff a fullscreen tab will

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

For clarity (presuming I have it right): "iff a fullscreen tab and its browser
window is(or will be) fullscreen."

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

Done.

+  // result in the browser window expanding to fill the screen.  On the other
+  // hand, the one-argument version will return true while the renderer is/will
+  // be in fullscreen mode, but not necessarily the browser window.  The latter
+  // case accounts for the special behavior employed during screen capture of a

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

And then reference "See 'EmbeddedFullscreen Note'"

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

Done.

+  // WebContents where the fullscreen view remains within the browser tab.
   bool IsFullscreenForTabOrPending() const;

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

Consider renaming the method to differentiate the meaning between the two,
overloading is getting dicey here.

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

Agreed.  There are quite a few callers of it, so I'd prefer to follow this up in
a separate clean-up CL.  SGTY?

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

Yes.

   bool IsFullscreenForTabOrPending(
       const content::WebContents* web_contents) const;
   // True if fullscreen was entered because of tab fullscreen (was not
   // previously in browser fullscreen).
   bool IsFullscreenCausedByTab() const;
 
   void ToggleFullscreenModeForTab(content::WebContents* web_contents,
                                   bool enter_fullscreen);
 
   // Extension API implementation uses this method to toggle fullscreen mode.
@@ skipping 23 matching lines @@
 
   void RequestToLockMouse(content::WebContents* web_contents,
                           bool user_gesture,
                           bool last_unlocked_by_target);
 
   // Callbacks /////////////////////////////////////////////////////////////////
 
   // Called by Browser::TabDeactivated.
   void OnTabDeactivated(content::WebContents* web_contents);
 
+  // Called by Browser::ActiveTabChanged.
+  void OnTabDetachedFromView(content::WebContents* web_contents);
+
   // Called by Browser::TabClosingAt.
   void OnTabClosing(content::WebContents* web_contents);
 
   // Called by Browser::WindowFullscreenStateChanged.
   void WindowFullscreenStateChanged();
 
   // Called by Browser::PreHandleKeyboardEvent.
   bool HandleUserPressedEscape();
 
   // Called by platform FullscreenExitBubble.
@@ skipping 55 matching lines @@
 
   // Make the current tab exit fullscreen mode or mouse lock if it is in it.
   void ExitTabFullscreenOrMouseLockIfNecessary();
   void UpdateFullscreenExitBubbleContent();
 
   ContentSetting GetFullscreenSetting(const GURL& url) const;
   ContentSetting GetMouseLockSetting(const GURL& url) const;
 
   bool IsPrivilegedFullscreenForTab() const;
   void SetPrivilegedFullscreenForTesting(bool is_privileged);
+  // Returns true if embedded fullscreen features have been enabled for the
+  // |browser_|.

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

And then reference "See 'EmbeddedFullscreen Note'" for these.

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

Done.

+  bool IsEmbeddedFullscreenEnabled() const;

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

Use a consistent terminology, always 'EmbeddedFullscreen' or
'FullscreenWithinTab', or 'CapturedFullscreen' or ScreenCapture'... but pick
one.

Also, IsEmbeddedFullscreenEnabled and IsCapturedFullscreenTab are similar, and a
tad confusing.

Here's a proposal for these methods in order:
IsEmbeddedFullscreenPossible
MaybeToggleEmbeddedFullscreen
IsEmbeddedFullscreen

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

I see your point, and agree the naming was confusing.  Please take a look at how
I rewrote the 'FullscreenWithinTab Note' at the top of this file, since it
points out how there are two related pieces of functionality at play here
(http://crbug.com/290403 versus http://crbug.com/256870).  Both involve showing
fullscreen widgets within the tab contents area.  The special-case (introduced
by this CL) is when a tab is being screen-captured: We do not fullscreen the
browser window.

I've reworked the naming of the methods (and terminology in comments) to be
consistent and also clarify differences.  I decided to stop using the "embedded
fullscreen" terminology altogether since it is overused throughout Chromium code
and could be easily confused with unrelated NPAPI special-case foo in
src/content.

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

Thanks - I think it's clearer now - though still subtle that
'FullscreenWithinTab' is a super set of 'FullscreenForCapturedTab'. 

+  // Returns true if |web_contents| is/was being screen-captured and was
+  // toggled into/out of fullscreen-within-tab mode.
+  bool MaybeToggleAsFullscreenWithinTab(content::WebContents* web_contents,
+                                        bool enter_fullscreen);
+  // Returns true if |web_contents| has its fullscreen view embedded within a
+  // browser tab and is being screen captured.
+  bool IsCapturedFullscreenTab(const content::WebContents* web_contents) const;
   void UnlockMouse();
 
   Browser* const browser_;
   BrowserWindow* const window_;
   Profile* const profile_;
 
   // If there is currently a tab in fullscreen mode (entered via
   // webkitRequestFullScreen), this is its WebContents.
   // Assign using SetFullscreenedTab().
   content::WebContents* fullscreened_tab_;
@@ skipping 24 matching lines @@
   content::WebContents* mouse_lock_tab_;
 
   MouseLockState mouse_lock_state_;
 
   content::NotificationRegistrar registrar_;
 
   // Used to verify that calls we expect to reenter by calling
   // WindowFullscreenStateChanged do so.
   bool reentrant_window_state_change_call_check_;
 
+  // A WebContents pointer is in this set if it entered fullscreen mode during
+  // screen capture.  In other words, this tracks those WebContentses that are
+  // in fullscreen mode, but the browser window is not.  Note: Behavior only
+  // applies when IsEmbeddedFullscreenEnabled() returns true.
+  std::vector<const content::WebContents*> captured_tabs_;
+
   // Used in testing to confirm proper behavior for specific, privileged
   // fullscreen cases.
   bool is_privileged_fullscreen_for_testing_;
 
   base::WeakPtrFactory<FullscreenController> ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FullscreenController);
 };
 
 #endif  // CHROME_BROWSER_UI_FULLSCREEN_FULLSCREEN_CONTROLLER_H_