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 79 matching lines @@
     return true;
   }
   return IsFullscreenForCapturedTab(web_contents);
 }
 
 bool FullscreenController::IsFullscreenCausedByTab() const {
   return state_prior_to_tab_fullscreen_ == STATE_NORMAL;
 }
 
 void FullscreenController::ToggleFullscreenModeForTab(WebContents* web_contents,
+                                                      const GURL& origin,
                                                       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 (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
 
   bool in_browser_or_tab_fullscreen_mode = window_->IsFullscreen();
 
   if (enter_fullscreen) {
-    SetFullscreenedTab(web_contents);
+    SetFullscreenedTab(web_contents, origin);
     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;
       }
 
-      // 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;
+            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);
     }
   } else {
     if (in_browser_or_tab_fullscreen_mode) {
       if (IsFullscreenCausedByTab()) {
@@ skipping 289 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 57 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);
+    SetFullscreenedTab(nullptr, GURL());
     state_prior_to_tab_fullscreen_ = STATE_INVALID;
     tab_fullscreen_accepted_ = false;
     if (rvh)
       rvh->ExitFullscreen();
   }
 
   if (mouse_lock_tab_) {
     if (IsMouseLockRequested()) {
       mouse_lock_tab_->GotResponseToLockMouseRequest(false);
       NotifyMouseLockChange();
@@ skipping 56 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);
+    ToggleFullscreenModeForTab(fullscreened_tab_, GURL(), false);
   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());
+  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();
+}