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 <set>
+
 #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.
+//
+// FullscreenWithinTab Note:
+// When the browser is configured as such, all fullscreen widgets are displayed
+// within the tab contents area, and FullscreenController will expand the
+// browser window so that the tab contents area fills the entire
+// screen. However, special behavior applies when a tab is being
+// screen-captured. First, the browser window will not be fullscreened. 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. Second, FullscreenController will auto-resize fullscreen widgets to
+// that of the capture video resolution when they are hidden (e.g., when a user
+// has switched to another tab). This is both a performance and quality
+// improvement since scaling and letterboxing steps can be skipped in the
+// capture pipeline.
 
 // 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 and its
+  // browser window is/will be fullscreen. 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. See 'FullscreenWithinTab Note'.
   bool IsFullscreenForTabOrPending() const;
   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);
 
@@ skipping 24 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 fullscreen-within-tab has been enabled for the
+  // |browser_|. See 'FullscreenWithinTab Note'.
+  bool IsFullscreenWithinTabPossible() const;
+  // Returns true if |web_contents| was toggled into/out of fullscreen mode as a
+  // screen-captured tab. See 'FullscreenWithinTab Note'.
+  bool MaybeToggleFullscreenForCapturedTab(content::WebContents* web_contents,
+                                           bool enter_fullscreen);
+  // Returns true if |web_contents| is in fullscreen mode as a screen-captured
+  // tab. See 'FullscreenWithinTab Note'.
+  bool IsFullscreenForCapturedTab(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. See 'FullscreenWithinTab
+  // Note'.
+  std::set<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_