Add FullscreenController::ToggleFullscreenModeWithExtension

chrome/browser/ui/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_controller.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/extension.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 
 using content::UserMetricsAction;
 using content::WebContents;
 
 FullscreenController::FullscreenController(BrowserWindow* window,
                                            Profile* profile,
@@ skipping 75 matching lines @@
   in_browser_or_tab_fullscreen_mode = window_->InPresentationMode();
 #else
   in_browser_or_tab_fullscreen_mode = window_->IsFullscreen();
 #endif
 
   if (enter_fullscreen) {
     fullscreened_tab_ = TabContentsWrapper::GetCurrentWrapperForContents(tab);
     if (!in_browser_or_tab_fullscreen_mode) {
       tab_caused_fullscreen_ = true;
 #if defined(OS_MACOSX)
-      TogglePresentationMode(true);
+      TogglePresentationModeInternal(true);
 #else
-      ToggleFullscreenMode(true);
+      ToggleFullscreenModeInternal(true, NULL);

[yzshen1, 2012/02/08 18:05:27]

I think the following scenario doesn't work correctly:
1) an extension triggers fullscreen (Show: "some extension triggered full
screen.")
2) enter tab full screen (Show: "some website is now full screen.")
3) exit tab full screen (Note: at this point, it should show the same text as
step 1, instead of the text for user-triggered fullscreen.)

You need to remember whether an extension triggers the fullscreen, and show the
correct text. (With that information, you don't need to pass in a parameter to
GetFullscreenExitBubbleType.)

This page describes the state transition of the fullscreen exit bubble:
http://www.chromium.org/developers/design-documents/mouse-lock

[hashimoto, 2012/02/09 09:10:18]

Thank you for finding this.
Fixed by adding |extension_caused_fullscreen_|.

BTW, I found a bug where entering and exiting tab-fullscreen mode inside
browser-fullscreen mode does not work well. (filed in http://crbug.com/113349)
Is this a known bug?

 #endif
     } else {
       // 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 = tab->GetURL();
       if (!tab_fullscreen_accepted_) {
         tab_fullscreen_accepted_ =
             GetFullscreenSetting(url) == CONTENT_SETTING_ALLOW;
       }
       UpdateFullscreenExitBubbleContent();
     }
   } else {
     if (in_browser_or_tab_fullscreen_mode) {
       if (tab_caused_fullscreen_) {
 #if defined(OS_MACOSX)
-        TogglePresentationMode(true);
+        TogglePresentationModeInternal(true);
 #else
-        ToggleFullscreenMode(true);
+        ToggleFullscreenModeInternal(true, NULL);
 #endif
       } else {
         // 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.
         NotifyTabOfFullscreenExitIfNecessary();
       }
     }
   }
 }
 
 #if defined(OS_MACOSX)
-void FullscreenController::TogglePresentationMode(bool for_tab) {
+void FullscreenController::TogglePresentationMode() {
+  TogglePresentationModeInternal(false);
+}
+
+void FullscreenController::TogglePresentationModeInternal(bool for_tab) {
   bool entering_fullscreen = !window_->InPresentationMode();
   GURL url;
   if (for_tab) {
     url = browser_->GetSelectedWebContents()->GetURL();
     tab_fullscreen_accepted_ = entering_fullscreen &&
         GetFullscreenSetting(url) == CONTENT_SETTING_ALLOW;
   }
   if (entering_fullscreen)
-    window_->EnterPresentationMode(url, GetFullscreenExitBubbleType());
+    window_->EnterPresentationMode(url, GetFullscreenExitBubbleType(NULL));
   else
     window_->ExitPresentationMode();
   WindowFullscreenStateChanged();
 }
 #endif
 
+void FullscreenController::ToggleFullscreenMode() {
+  ToggleFullscreenModeInternal(false, NULL);
+}
+
+void FullscreenController::ToggleFullscreenModeWithExtension(
+    const Extension& extension) {
+  ToggleFullscreenModeInternal(false, &extension);
+}
+
 // TODO(koz): Change |for_tab| to an enum.
-void FullscreenController::ToggleFullscreenMode(bool for_tab) {
+void FullscreenController::ToggleFullscreenModeInternal(
+    bool for_tab, const Extension* extension) {
   bool entering_fullscreen = !window_->IsFullscreen();
 
 #if !defined(OS_MACOSX)
   // In kiosk mode, we always want to be fullscreen. When the browser first
   // starts we're not yet fullscreen, so let the initial toggle go through.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode) &&
       window_->IsFullscreen())
     return;
 #endif
 
   GURL url;
   if (for_tab) {
     url = browser_->GetSelectedWebContents()->GetURL();
     tab_fullscreen_accepted_ = entering_fullscreen &&
         GetFullscreenSetting(url) == CONTENT_SETTING_ALLOW;
   } else {
+    if (extension)
+      url = extension->url();
     content::RecordAction(UserMetricsAction("ToggleFullscreen"));
   }
-  if (entering_fullscreen)
-    window_->EnterFullscreen(url, GetFullscreenExitBubbleType());
-  else
+  if (entering_fullscreen) {
+    window_->EnterFullscreen(url, GetFullscreenExitBubbleType(extension));
+  } else {
     window_->ExitFullscreen();
+  }
 
   // Once the window has become fullscreen it'll call back to
   // WindowFullscreenStateChanged(). We don't do this immediately as
   // BrowserWindow::EnterFullscreen() asks for bookmark_bar_state_, so we let
   // the BrowserWindow invoke WindowFullscreenStateChanged when appropriate.
 
   // TODO: convert mac to invoke WindowFullscreenStateChanged once it updates
   // the necessary state of the frame.
 #if defined(OS_MACOSX)
   WindowFullscreenStateChanged();
@@ skipping 109 matching lines @@
   fullscreened_tab_ = NULL;
   tab_caused_fullscreen_ = false;
   tab_fullscreen_accepted_ = false;
   mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
 
   UpdateFullscreenExitBubbleContent();
 }
 
 void FullscreenController::ExitTabbedFullscreenModeIfNecessary() {
   if (tab_caused_fullscreen_)
-    ToggleFullscreenMode(false);
+    ToggleFullscreenMode();
   else
     NotifyTabOfFullscreenExitIfNecessary();
 }
 
 void FullscreenController::UpdateFullscreenExitBubbleContent() {
   GURL url;
   if (fullscreened_tab_)
     url = fullscreened_tab_->web_contents()->GetURL();
 
   window_->UpdateFullscreenExitBubbleContent(url,
-                                             GetFullscreenExitBubbleType());
+                                             GetFullscreenExitBubbleType(NULL));
 }
 
 void FullscreenController::NotifyFullscreenChange() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_FULLSCREEN_CHANGED,
       content::Source<FullscreenController>(this),
       content::NotificationService::NoDetails());
 }
 
-FullscreenExitBubbleType
-    FullscreenController::GetFullscreenExitBubbleType() const {
+FullscreenExitBubbleType FullscreenController::GetFullscreenExitBubbleType(
+    const Extension* extension) const {
   if (!fullscreened_tab_) {
     DCHECK_EQ(MOUSELOCK_NOT_REQUESTED, mouse_lock_state_);
-    return FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION;
+    return extension ? FEB_TYPE_BROWSER_EXTENSION_FULLSCREEN_EXIT_INSTRUCTION :
+        FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION;
   }
   if (fullscreened_tab_ && !tab_fullscreen_accepted_) {
     DCHECK_NE(MOUSELOCK_ACCEPTED, mouse_lock_state_);
     return mouse_lock_state_ == MOUSELOCK_REQUESTED ?
         FEB_TYPE_FULLSCREEN_MOUSELOCK_BUTTONS : FEB_TYPE_FULLSCREEN_BUTTONS;
   }
   if (mouse_lock_state_ == MOUSELOCK_REQUESTED)
     return FEB_TYPE_MOUSELOCK_BUTTONS;
   return mouse_lock_state_ == MOUSELOCK_ACCEPTED ?
       FEB_TYPE_FULLSCREEN_MOUSELOCK_EXIT_INSTRUCTION :
@@ skipping 12 matching lines @@
 
 ContentSetting
     FullscreenController::GetMouseLockSetting(const GURL& url) const {
   if (url.SchemeIsFile())
     return CONTENT_SETTING_ALLOW;
 
   HostContentSettingsMap* settings_map = profile_->GetHostContentSettingsMap();
   return settings_map->GetContentSetting(url, url,
       CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string());
 }