Fullscreen: make fullscreen requests come from RenderFrame

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"
@@ skipping 78 matching lines @@
     DCHECK(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)) {
+void FullscreenController::EnterFullscreenModeForTab(WebContents* web_contents,
+                                                     const GURL& origin) {
+  DCHECK(web_contents);
+
+  if (MaybeToggleFullscreenForCapturedTab(web_contents, true)) {
     // 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_)
+
+  if (web_contents != browser_->tab_strip_model()->GetActiveWebContents() ||
+      IsWindowFullscreenForTabOrPending()) {
       return;
-  } else if (
-      web_contents != browser_->tab_strip_model()->GetActiveWebContents()) {
-    return;
   }
-  if (IsWindowFullscreenForTabOrPending() == enter_fullscreen)
-    return;
 
 #if defined(OS_WIN)
   // For now, avoid breaking when initiating full screen tab mode while in
+  // a metro snap.
+  // TODO(robertshield): Find a way to reconcile tab-initiated fullscreen
+  //                     modes with metro snap.
+  if (IsInMetroSnapMode())
+    return;
+#endif
+
+  SetFullscreenedTab(web_contents, origin);
+
+  if (!window_->IsFullscreen()) {
+    // Normal -> Tab Fullscreen.
+    state_prior_to_tab_fullscreen_ = STATE_NORMAL;
+    ToggleFullscreenModeInternal(TAB);
+    return;
+  }
+
+  if (window_->IsFullscreenWithToolbar()) {
+    // Browser Fullscreen with Toolbar -> Tab Fullscreen (no toolbar).
+    window_->UpdateFullscreenWithToolbar(false);
+    state_prior_to_tab_fullscreen_ = STATE_BROWSER_FULLSCREEN_WITH_TOOLBAR;
+  } else {
+    // Browser Fullscreen without Toolbar -> Tab Fullscreen.
+    state_prior_to_tab_fullscreen_ = STATE_BROWSER_FULLSCREEN_NO_TOOLBAR;
+  }
+
+  // We need to update the fullscreen exit bubble, e.g., going from browser
+  // fullscreen to tab fullscreen will need to show different content.
+  if (!tab_fullscreen_accepted_) {
+    tab_fullscreen_accepted_ =
+        GetFullscreenSetting() == CONTENT_SETTING_ALLOW;
+  }
+  UpdateFullscreenExitBubbleContent();
+
+  // This is only a change between Browser and Tab fullscreen. We generate
+  // a fullscreen notification now because there is no window change.
+  PostFullscreenChangeNotification(true);
+}
+
+void FullscreenController::ExitFullscreenModeForTab(WebContents* web_contents) {
+  if (MaybeToggleFullscreenForCapturedTab(web_contents, false)) {
+    // During tab capture of fullscreen-within-tab views, the browser window
+    // fullscreen state is unchanged, so return now.
+    return;
+  }
+
+  if (web_contents != fullscreened_tab_ ||
+      web_contents != browser_->tab_strip_model()->GetActiveWebContents() ||
+      !IsWindowFullscreenForTabOrPending()) {
+    return;
+  }
+
+#if defined(OS_WIN)
+  // For now, avoid breaking when initiating full screen tab mode while in
   // a metro snap.
   // TODO(robertshield): Find a way to reconcile tab-initiated fullscreen
   //                     modes with metro snap.
   if (IsInMetroSnapMode())
     return;
 #endif
 
-  bool in_browser_or_tab_fullscreen_mode = window_->IsFullscreen();
+  if (!window_->IsFullscreen())
+    return;
 
-  if (enter_fullscreen) {
-    SetFullscreenedTab(web_contents);
-    if (!in_browser_or_tab_fullscreen_mode) {
-      // Normal -> Tab Fullscreen.
-      state_prior_to_tab_fullscreen_ = STATE_NORMAL;
-      ToggleFullscreenModeInternal(TAB);
-    } else {
-      if (window_->IsFullscreenWithToolbar()) {
-        // Browser Fullscreen with Toolbar -> Tab Fullscreen (no toolbar).
-        window_->UpdateFullscreenWithToolbar(false);
-        state_prior_to_tab_fullscreen_ = STATE_BROWSER_FULLSCREEN_WITH_TOOLBAR;
-      } else {
-        // Browser Fullscreen without Toolbar -> Tab Fullscreen.
-        state_prior_to_tab_fullscreen_ = STATE_BROWSER_FULLSCREEN_NO_TOOLBAR;
-      }
+  if (IsFullscreenCausedByTab()) {
+    // Tab Fullscreen -> Normal.
+    ToggleFullscreenModeInternal(TAB);
+    return;
+  }
 
-      // We need to update the fullscreen exit bubble, e.g., going from browser
-      // fullscreen to tab fullscreen will need to show different content.
-      const GURL& url = web_contents->GetURL();
-      if (!tab_fullscreen_accepted_) {
-        tab_fullscreen_accepted_ =
-            GetFullscreenSetting(url) == CONTENT_SETTING_ALLOW;
-      }
-      UpdateFullscreenExitBubbleContent();
-
-      // This is only a change between Browser and Tab fullscreen. We generate
-      // a fullscreen notification now because there is no window change.
-      PostFullscreenChangeNotification(true);
-    }
-  } else {
-    if (in_browser_or_tab_fullscreen_mode) {
-      if (IsFullscreenCausedByTab()) {
-        // Tab Fullscreen -> Normal.
-        ToggleFullscreenModeInternal(TAB);
-      } else {
-        // Tab Fullscreen -> Browser Fullscreen (with or without toolbar).
-        if (state_prior_to_tab_fullscreen_ ==
-            STATE_BROWSER_FULLSCREEN_WITH_TOOLBAR) {
-          // Tab Fullscreen (no toolbar) -> Browser Fullscreen with Toolbar.
-          window_->UpdateFullscreenWithToolbar(true);
-        }
+  // Tab Fullscreen -> Browser Fullscreen (with or without toolbar).
+  if (state_prior_to_tab_fullscreen_ ==
+      STATE_BROWSER_FULLSCREEN_WITH_TOOLBAR) {
+    // Tab Fullscreen (no toolbar) -> Browser Fullscreen with Toolbar.
+    window_->UpdateFullscreenWithToolbar(true);
+  }
 
 #if defined(OS_MACOSX)
-        // Clear the bubble URL, which forces the Mac UI to redraw.
-        UpdateFullscreenExitBubbleContent();
+  // Clear the bubble URL, which forces the Mac UI to redraw.
+  UpdateFullscreenExitBubbleContent();
 #endif  // defined(OS_MACOSX)
 
-        // If currently there is a tab in "tab fullscreen" mode and fullscreen
-        // was not caused by it (i.e., previously it was in "browser fullscreen"
-        // mode), we need to switch back to "browser fullscreen" mode. In this
-        // case, all we have to do is notifying the tab that it has exited "tab
-        // fullscreen" mode.
-        NotifyTabOfExitIfNecessary();
+  // If currently there is a tab in "tab fullscreen" mode and fullscreen
+  // was not caused by it (i.e., previously it was in "browser fullscreen"
+  // mode), we need to switch back to "browser fullscreen" mode. In this
+  // case, all we have to do is notifying the tab that it has exited "tab
+  // fullscreen" mode.
+  NotifyTabOfExitIfNecessary();
 
-        // This is only a change between Browser and Tab fullscreen. We generate
-        // a fullscreen notification now because there is no window change.
-        PostFullscreenChangeNotification(true);
-      }
-    }
-  }
+  // This is only a change between Browser and Tab fullscreen. We generate
+  // a fullscreen notification now because there is no window change.
+  PostFullscreenChangeNotification(true);
 }
 
 bool FullscreenController::IsInMetroSnapMode() {
 #if defined(OS_WIN)
   return window_->IsInMetroSnapMode();
 #else
   return false;
 #endif
 }
 
@@ skipping 105 matching lines @@
 
   content::RenderWidgetHostView* const current_fs_view =
       old_contents->GetFullscreenRenderWidgetHostView();
   if (current_fs_view)
     current_fs_view->SetSize(old_contents->GetPreferredSize());
   ResizeWebContents(old_contents, old_contents->GetPreferredSize());
 }
 
 void FullscreenController::OnTabClosing(WebContents* web_contents) {
   if (IsFullscreenForCapturedTab(web_contents)) {
-    RenderViewHost* const rvh = web_contents->GetRenderViewHost();
-    if (rvh)
-      rvh->ExitFullscreen();
+    web_contents->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 16 matching lines @@
     window_->GetDownloadShelf()->Hide();
     if (window_->GetStatusBubble())
       window_->GetStatusBubble()->Hide();
   }
 }
 
 bool FullscreenController::HandleUserPressedEscape() {
   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();
+    active_web_contents->ExitFullscreen();
     return true;
   } else if (IsWindowFullscreenForTabOrPending() ||
              IsMouseLocked() || IsMouseLockRequested()) {
     ExitTabFullscreenOrMouseLockIfNecessary();
     return true;
   }
 
   return false;
 }
 
 void FullscreenController::ExitTabOrBrowserFullscreenToPreviousState() {
   if (IsWindowFullscreenForTabOrPending())
     ExitTabFullscreenOrMouseLockIfNecessary();
   else if (IsFullscreenForBrowser())
     ExitFullscreenModeInternal();
 }
 
 void FullscreenController::OnAcceptFullscreenPermission() {
   FullscreenExitBubbleType bubble_type = GetFullscreenExitBubbleType();
   bool mouse_lock = false;
   bool fullscreen = false;
   fullscreen_bubble::PermissionRequestedByType(bubble_type, &fullscreen,
                                                &mouse_lock);
   DCHECK(!(fullscreen && tab_fullscreen_accepted_));
   DCHECK(!(mouse_lock && IsMouseLocked()));
 
   HostContentSettingsMap* settings_map = profile_->GetHostContentSettingsMap();
 
-  GURL url = GetFullscreenExitBubbleURL();
-  ContentSettingsPattern pattern = ContentSettingsPattern::FromURL(url);
-
   if (mouse_lock && !IsMouseLocked()) {
     DCHECK(IsMouseLockRequested());
+
+    GURL url = GetFullscreenExitBubbleURL();
+    ContentSettingsPattern pattern = ContentSettingsPattern::FromURL(url);
+
     // TODO(markusheintz): We should allow patterns for all possible URLs here.
     if (pattern.IsValid()) {
       settings_map->SetContentSetting(
           pattern, ContentSettingsPattern::Wildcard(),
           CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string(),
           CONTENT_SETTING_ALLOW);
     }
 
     if (mouse_lock_tab_ &&
         mouse_lock_tab_->GotResponseToLockMouseRequest(true)) {
       mouse_lock_state_ = MOUSELOCK_ACCEPTED;
     } else {
       mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
       SetMouseLockTab(NULL);
     }
     NotifyMouseLockChange();
   }
 
   if (fullscreen && !tab_fullscreen_accepted_) {
     DCHECK(fullscreened_tab_);
-    if (pattern.IsValid()) {
-      settings_map->SetContentSetting(
-          pattern, ContentSettingsPattern::Wildcard(),
-          CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string(),
-          CONTENT_SETTING_ALLOW);
-    }
+    // We allow the requesting origin to use fullscreen when inside the
+    // embedding origin. That means that if the requesting origin is found
+    // embedded in another origin, it will not be considered as allowed to use
+    // fullscreen. However, if the permission is granted for a tuple with both
+    // origins being the same, the requesting origin will always be allowed to
+    // use fullscreen, regardless of the embedder.

[scheib, 2014/12/11 17:56:56]

This was still difficult for me to understand. Here's a shot at a rewrite:

Origins can enter fullscreen even when embedded in other origins. Permission is
tracked based on the combinations of requester and embedder. Thus, even if a
requesting origin has been previously approved for embedder A, it will not be
approved when embedded in a different origin B.

However, an exception is made when a requester and an embedder are the same
origin. If that combination is ALLOWED, then future requests from that origin
will succeed no matter what the embedder is. E.g. youtube.com is visited and
user selects ALLOW. Later user visits example.com which embeds youtube in an
iframe, which is then ALLOWed.


If other areas of the code base (PermissionContextBase) explain this behavior
well then add a reference.

+    settings_map->SetContentSetting(
+        ContentSettingsPattern::FromURLNoWildcard(GetRequestingOrigin()),
+        ContentSettingsPattern::FromURLNoWildcard(GetEmbeddingOrigin()),
+        CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string(),
+        CONTENT_SETTING_ALLOW);
     tab_fullscreen_accepted_ = true;
   }
   UpdateFullscreenExitBubbleContent();
 }
 
 void FullscreenController::OnDenyFullscreenPermission() {
   if (!fullscreened_tab_ && !mouse_lock_tab_)
     return;
 
   if (IsMouseLockRequested()) {
@@ skipping 25 matching lines @@
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(content::NOTIFICATION_NAV_ENTRY_COMMITTED, type);
   if (content::Details<content::LoadCommittedDetails>(details)->
       is_navigation_to_different_page())
     ExitTabFullscreenOrMouseLockIfNecessary();
 }
 
 GURL FullscreenController::GetFullscreenExitBubbleURL() const {
   if (fullscreened_tab_)
-    return fullscreened_tab_->GetURL();
+    return GetRequestingOrigin();
   if (mouse_lock_tab_)
     return mouse_lock_tab_->GetURL();
   return extension_caused_fullscreen_;
 }
 
 FullscreenExitBubbleType FullscreenController::GetFullscreenExitBubbleType()
     const {
   // In kiosk and exclusive app mode we always want to be fullscreen and do not
   // want to show exit instructions for browser mode fullscreen.
   bool app_mode = false;
@@ skipping 56 matching lines @@
 
 void FullscreenController::NotifyFullscreenChange(bool is_fullscreen) {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_FULLSCREEN_CHANGED,
       content::Source<FullscreenController>(this),
       content::Details<bool>(&is_fullscreen));
 }
 
 void FullscreenController::NotifyTabOfExitIfNecessary() {
   if (fullscreened_tab_) {
-    RenderViewHost* rvh = fullscreened_tab_->GetRenderViewHost();
-    SetFullscreenedTab(NULL);
+    WebContents* web_contents = fullscreened_tab_;
+    // This call will set |fullscreened_tab_| to nullptr.
+    SetFullscreenedTab(nullptr, GURL());
     state_prior_to_tab_fullscreen_ = STATE_INVALID;
     tab_fullscreen_accepted_ = false;
-    if (rvh)
-      rvh->ExitFullscreen();
+    web_contents->ExitFullscreen();
   }
 
   if (mouse_lock_tab_) {
     if (IsMouseLockRequested()) {
       mouse_lock_tab_->GotResponseToLockMouseRequest(false);
       NotifyMouseLockChange();
     } else {
       UnlockMouse();
     }
     SetMouseLockTab(NULL);
@@ skipping 52 matching lines @@
     EnterFullscreenModeInternal(option);
   else
     ExitFullscreenModeInternal();
 }
 
 void FullscreenController::EnterFullscreenModeInternal(
     FullscreenInternalOption option) {
   toggled_into_fullscreen_ = true;
   GURL url;
   if (option == TAB) {
-    url = browser_->tab_strip_model()->GetActiveWebContents()->GetURL();
+    url = GetRequestingOrigin();
     tab_fullscreen_accepted_ =
-        GetFullscreenSetting(url) == CONTENT_SETTING_ALLOW;
+        GetFullscreenSetting() == CONTENT_SETTING_ALLOW;
   } else {
     if (!extension_caused_fullscreen_.is_empty())
       url = extension_caused_fullscreen_;
   }
 
   if (option == BROWSER)
     content::RecordAction(UserMetricsAction("ToggleFullscreen"));
   // TODO(scheib): Record metrics for WITH_TOOLBAR, without counting transitions
   // from tab fullscreen out to browser with toolbar.
 
@@ skipping 16 matching lines @@
   // state_prior_to_tab_fullscreen_ to match them else other logic using
   // state_prior_to_tab_fullscreen_ will be incorrect.
   NotifyTabOfExitIfNecessary();
 #endif
   window_->ExitFullscreen();
   extension_caused_fullscreen_ = GURL();
 
   UpdateFullscreenExitBubbleContent();
 }
 
-void FullscreenController::SetFullscreenedTab(WebContents* tab) {
+void FullscreenController::SetFullscreenedTab(WebContents* tab,
+                                              const GURL& origin) {
   fullscreened_tab_ = tab;
+  fullscreened_origin_ = origin;
   UpdateNotificationRegistrations();
 }
 
 void FullscreenController::SetMouseLockTab(WebContents* tab) {
   mouse_lock_tab_ = tab;
   UpdateNotificationRegistrations();
 }
 
 void FullscreenController::ExitTabFullscreenOrMouseLockIfNecessary() {
   if (IsWindowFullscreenForTabOrPending())
-    ToggleFullscreenModeForTab(fullscreened_tab_, false);
+    ExitFullscreenModeForTab(fullscreened_tab_);
   else
     NotifyTabOfExitIfNecessary();
 }
 
 void FullscreenController::UpdateFullscreenExitBubbleContent() {
   GURL url = GetFullscreenExitBubbleURL();
   FullscreenExitBubbleType bubble_type = GetFullscreenExitBubbleType();
 
   // If bubble displays buttons, unlock mouse to allow pressing them.
   if (fullscreen_bubble::ShowButtonsForType(bubble_type) && IsMouseLocked())
     UnlockMouse();
 
   window_->UpdateFullscreenExitBubbleContent(url, bubble_type);
 }
 
 ContentSetting
-FullscreenController::GetFullscreenSetting(const GURL& url) const {
+FullscreenController::GetFullscreenSetting() const {
+  DCHECK(fullscreened_tab_);
+
+  GURL url = GetRequestingOrigin();
+
   if (IsPrivilegedFullscreenForTab() || url.SchemeIsFile())
     return CONTENT_SETTING_ALLOW;
 
-  return profile_->GetHostContentSettingsMap()->GetContentSetting(url, url,
-      CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string());
+  // See the comment above the call to |SetContentSetting()| for how the
+  // requesting and embedding origins interact with each other wrt permissions.
+  return profile_->GetHostContentSettingsMap()->GetContentSetting(
+      url,
+      GetEmbeddingOrigin(),
+      CONTENT_SETTINGS_TYPE_FULLSCREEN,
+      std::string());
 }
 
 ContentSetting
 FullscreenController::GetMouseLockSetting(const GURL& url) const {
   if (IsPrivilegedFullscreenForTab() || url.SchemeIsFile())
     return CONTENT_SETTING_ALLOW;
 
   HostContentSettingsMap* settings_map = profile_->GetHostContentSettingsMap();
   return settings_map->GetContentSetting(url, url,
       CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string());
@@ skipping 50 matching lines @@
       (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();
 }
+
+GURL FullscreenController::GetRequestingOrigin() const {
+  DCHECK(fullscreened_tab_);
+
+  if (!fullscreened_origin_.is_empty())
+    return fullscreened_origin_;
+
+  return fullscreened_tab_->GetLastCommittedURL();
+}
+
+GURL FullscreenController::GetEmbeddingOrigin() const {
+  DCHECK(fullscreened_tab_);
+
+  return fullscreened_tab_->GetLastCommittedURL();
+}