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;
+  if (web_contents == fullscreened_tab_) {
+    DCHECK(web_contents == browser_->tab_strip_model()->GetActiveWebContents());
+    DCHECK(!IsFullscreenWithinTabPossible() ||
+           web_contents->GetCapturerCount() == 0);
+    return true;
+  }
+  return IsFullscreenForCapturedTab(web_contents);
 }
 
 bool FullscreenController::IsFullscreenCausedByTab() const {
   return state_prior_to_tab_fullscreen_ == STATE_NORMAL;
 }
 
 void FullscreenController::ToggleFullscreenModeForTab(WebContents* web_contents,
                                                       bool enter_fullscreen) {
+  if (MaybeToggleFullscreenForCapturedTab(web_contents, enter_fullscreen)) {
+    // During tab capture of fullscreen-within-tab views, the 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 168 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) {
+  if (!IsFullscreenForCapturedTab(old_contents))
+    return;
+
+  // A fullscreen-within-tab view undergoing screen capture has been detached
+  // and is no longer visible to the user. Set it to exactly the WebContents'
+  // preferred size. See 'FullscreenWithinTab Note'.
+  //
+  // When the user later selects the tab to show |old_contents| again, UI code
+  // elsewhere (e.g., views::WebView) will resize the view to fit within the
+  // browser window once again.
+  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 (IsFullscreenForCapturedTab(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 (IsFullscreenForCapturedTab(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();
+      IsFullscreenWithinTabPossible();
   return embedded_widget_present || is_privileged_fullscreen_for_testing_;
 }
 
 void FullscreenController::SetPrivilegedFullscreenForTesting(
     bool is_privileged) {
   is_privileged_fullscreen_for_testing_ = is_privileged;
 }
 
+bool FullscreenController::IsFullscreenWithinTabPossible() const {
+  return implicit_cast<const content::WebContentsDelegate*>(browser_)->
+      EmbedsFullscreenWidget();
+}
+
+bool FullscreenController::MaybeToggleFullscreenForCapturedTab(
+    WebContents* web_contents, bool enter_fullscreen) {
+  if (!IsFullscreenWithinTabPossible())
+    return false;
+
+  if (enter_fullscreen) {
+    if (web_contents->GetCapturerCount() > 0) {
+      captured_tabs_.insert(web_contents);
+      return true;
+    }
+  } else {
+    const std::set<const WebContents*>::iterator it =
+        captured_tabs_.find(web_contents);
+    if (it != captured_tabs_.end()) {
+      captured_tabs_.erase(it);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool FullscreenController::IsFullscreenForCapturedTab(
+    const WebContents* web_contents) const {
+  if (captured_tabs_.find(web_contents) != captured_tabs_.end()) {
+    DCHECK(IsFullscreenWithinTabPossible());
+    DCHECK_NE(fullscreened_tab_, web_contents);
+    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();
 }