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

chrome/browser/ui/fullscreen/fullscreen_controller.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.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/fullscreen.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/status_bubble.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_view.h"
 #include "extensions/common/extension.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #else
 #include "base/prefs/pref_service.h"
 #include "chrome/common/pref_names.h"
 #endif
 
 using base::UserMetricsAction;
@@ skipping 28 matching lines @@
   extension_caused_fullscreen_ = GURL();
   ToggleFullscreenModeInternal(BROWSER);
 }
 
 bool FullscreenController::IsFullscreenForTabOrPending() const {
   return fullscreened_tab_ != NULL;
 }
 
 bool FullscreenController::IsFullscreenForTabOrPending(
     const WebContents* web_contents) const {
-  if (web_contents != fullscreened_tab_)
-    return false;
-  DCHECK(web_contents == browser_->tab_strip_model()->GetActiveWebContents());
-  return true;
+  return web_contents == fullscreened_tab_ ||

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

Why drop the DCHECK when !IsCapturedFullscreenTab?

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

Good point.  I rearranged this to put it back.

+      IsCapturedFullscreenTab(web_contents);
 }
 
 bool FullscreenController::IsFullscreenCausedByTab() const {
   return state_prior_to_tab_fullscreen_ == STATE_NORMAL;
 }
 
 void FullscreenController::ToggleFullscreenModeForTab(WebContents* web_contents,
                                                       bool enter_fullscreen) {
+  if (MaybeToggleAsFullscreenWithinTab(web_contents, enter_fullscreen)) {
+    // During tab capture of embedded fullscreen views, browser window
+    // fullscreen state is unchanged, so return now.
+    return;
+  }
   if (fullscreened_tab_) {
     if (web_contents != fullscreened_tab_)
       return;
   } else if (
       web_contents != browser_->tab_strip_model()->GetActiveWebContents()) {
     return;
   }
   if (IsFullscreenForTabOrPending() == enter_fullscreen)
     return;
 
@@ skipping 113 matching lines @@
 }
 
 bool FullscreenController::IsMouseLocked() const {
   return mouse_lock_state_ == MOUSELOCK_ACCEPTED ||
          mouse_lock_state_ == MOUSELOCK_ACCEPTED_SILENTLY;
 }
 
 void FullscreenController::RequestToLockMouse(WebContents* web_contents,
                                               bool user_gesture,
                                               bool last_unlocked_by_target) {
+  if (IsCapturedFullscreenTab(web_contents)) {

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

Won't this break the use case of casting play of fullscreen pointer lock
content? Such as http://media.tojicode.com/q3bsp/
At least file an issue to support pointer locked fullscreen casting. 

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

Resolved.  I took this code out and mouse lock works perfectly during tab
capture.  ;-)

Originally, I was thinking mouse lock only happens in fullscreen mode, but I now
see mouse lock can happen without fullscreen.

+    web_contents->GotResponseToLockMouseRequest(false);
+    return;
+  }
+
   DCHECK(!IsMouseLocked());
   NotifyMouseLockChange();
 
   // Must have a user gesture to prevent misbehaving sites from constantly
   // re-locking the mouse. Exceptions are when the page has unlocked
   // (i.e. not the user), or if we're in tab fullscreen (user gesture required
   // for that)
   if (!last_unlocked_by_target && !user_gesture &&
       !IsFullscreenForTabOrPending(web_contents)) {
     web_contents->GotResponseToLockMouseRequest(false);
@@ skipping 35 matching lines @@
       NOTREACHED();
   }
   UpdateFullscreenExitBubbleContent();
 }
 
 void FullscreenController::OnTabDeactivated(WebContents* web_contents) {
   if (web_contents == fullscreened_tab_ || web_contents == mouse_lock_tab_)
     ExitTabFullscreenOrMouseLockIfNecessary();
 }
 
+void FullscreenController::OnTabDetachedFromView(WebContents* old_contents) {

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

So far I haven't noticed when we resize content back to the browser window size
when it is again activated. Perhaps comment here where that would happen?

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

Done.  (Reworked this into the comment a few lines down.)

+  if (!IsCapturedFullscreenTab(old_contents))
+    return;
+
+  // After detaching an embedded fullscreen view undergoing screen capture, set
+  // it to exactly the WebContents' preferred size.  This will allow it to be
+  // rendered and captured at the ideal resolution while the tab is being
+  // backgroundend by the user.
+  if (old_contents->GetCapturerCount() == 0 ||
+      old_contents->GetPreferredSize().IsEmpty()) {
+    // Do nothing if tab capture ended after toggling fullscreen, or a preferred
+    // size was never specified by the capturer.
+    return;
+  }
+  content::RenderWidgetHostView* const current_fs_view =
+      old_contents->GetFullscreenRenderWidgetHostView();
+  if (current_fs_view)
+    current_fs_view->SetSize(old_contents->GetPreferredSize());
+  old_contents->GetView()->SizeContents(old_contents->GetPreferredSize());
+}
+
 void FullscreenController::OnTabClosing(WebContents* web_contents) {
-  if (web_contents == fullscreened_tab_ || web_contents == mouse_lock_tab_) {
+  if (IsCapturedFullscreenTab(web_contents)) {
+    RenderViewHost* const rvh = web_contents->GetRenderViewHost();
+    if (rvh)
+      rvh->ExitFullscreen();
+  } else if (web_contents == fullscreened_tab_ ||
+             web_contents == mouse_lock_tab_) {
     ExitTabFullscreenOrMouseLockIfNecessary();
     // The call to exit fullscreen may result in asynchronous notification of
     // fullscreen state change (e.g., on Linux). We don't want to rely on it
     // to call NotifyTabOfExitIfNecessary(), because at that point
     // |fullscreened_tab_| may not be valid. Instead, we call it here to clean
     // up tab fullscreen related state.
     NotifyTabOfExitIfNecessary();
   }
 }
 
@@ skipping 11 matching lines @@
   if (exiting_fullscreen) {
     window_->GetDownloadShelf()->Unhide();
   } else {
     window_->GetDownloadShelf()->Hide();
     if (window_->GetStatusBubble())
       window_->GetStatusBubble()->Hide();
   }
 }
 
 bool FullscreenController::HandleUserPressedEscape() {
-  if (IsFullscreenForTabOrPending() ||
-      IsMouseLocked() || IsMouseLockRequested()) {
+  WebContents* const active_web_contents =
+      browser_->tab_strip_model()->GetActiveWebContents();
+  if (IsCapturedFullscreenTab(active_web_contents)) {
+    RenderViewHost* const rvh = active_web_contents->GetRenderViewHost();
+    if (rvh)
+      rvh->ExitFullscreen();
+    return true;
+  } else if (IsFullscreenForTabOrPending() ||
+             IsMouseLocked() || IsMouseLockRequested()) {
     ExitTabFullscreenOrMouseLockIfNecessary();
     return true;
   }
 
   return false;
 }
 
 void FullscreenController::ExitTabOrBrowserFullscreenToPreviousState() {
   if (IsFullscreenForTabOrPending())
     ExitTabFullscreenOrMouseLockIfNecessary();
@@ skipping 351 matching lines @@
 
   HostContentSettingsMap* settings_map = profile_->GetHostContentSettingsMap();
   return settings_map->GetContentSetting(url, url,
       CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string());
 }
 
 bool FullscreenController::IsPrivilegedFullscreenForTab() const {
   const bool embedded_widget_present =
       fullscreened_tab_ &&
       fullscreened_tab_->GetFullscreenRenderWidgetHostView() &&
-      implicit_cast<const content::WebContentsDelegate*>(browser_)->
-          EmbedsFullscreenWidget();
+      IsEmbeddedFullscreenEnabled();
   return embedded_widget_present || is_privileged_fullscreen_for_testing_;
 }
 
 void FullscreenController::SetPrivilegedFullscreenForTesting(
     bool is_privileged) {
   is_privileged_fullscreen_for_testing_ = is_privileged;
 }
 
+bool FullscreenController::IsEmbeddedFullscreenEnabled() const {
+  return implicit_cast<const content::WebContentsDelegate*>(browser_)->
+      EmbedsFullscreenWidget();
+}
+
+bool FullscreenController::MaybeToggleAsFullscreenWithinTab(
+    WebContents* web_contents, bool enter_fullscreen) {
+  if (!IsEmbeddedFullscreenEnabled())
+    return false;
+
+  if (enter_fullscreen) {
+    if (web_contents->GetCapturerCount() > 0) {
+      if (std::find(captured_tabs_.begin(), captured_tabs_.end(),

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

why not just std::set::insert()?

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

Done.

+                    web_contents) == captured_tabs_.end()) {
+        captured_tabs_.push_back(web_contents);
+      }
+      return true;
+    }
+  } else {
+    const std::vector<const WebContents*>::iterator it =
+        std::find(captured_tabs_.begin(), captured_tabs_.end(), web_contents);
+    if (it != captured_tabs_.end()) {

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

captured_tabs_.find(web_contents) != captured_tabs_.end()

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

Done.

+      captured_tabs_.erase(it);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool FullscreenController::IsCapturedFullscreenTab(
+    const WebContents* web_contents) const {
+  if (std::find(captured_tabs_.begin(), captured_tabs_.end(), web_contents) !=
+          captured_tabs_.end()) {
+    DCHECK(IsEmbeddedFullscreenEnabled());
+    DCHECK_NE(fullscreened_tab_, web_contents);
+    DCHECK_NE(mouse_lock_tab_, web_contents);

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

I removed this since it was wrong (i.e., mouse lock is valid on screen-captured
tabs).

+    return true;
+  }
+  return false;
+}
+
 void FullscreenController::UnlockMouse() {
   if (!mouse_lock_tab_)
     return;
   content::RenderWidgetHostView* mouse_lock_view =
       (fullscreened_tab_ == mouse_lock_tab_ && IsPrivilegedFullscreenForTab()) ?
       mouse_lock_tab_->GetFullscreenRenderWidgetHostView() : NULL;
   if (!mouse_lock_view) {
     RenderViewHost* const rvh = mouse_lock_tab_->GetRenderViewHost();
     if (rvh)
       mouse_lock_view = rvh->GetView();
   }
   if (mouse_lock_view)
     mouse_lock_view->UnlockMouse();
 }