chrome/browser/ui/fullscreen/fullscreen_controller.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/fullscreen/fullscreen_controller.h"
   6
   7 #include "base/bind.h"
   8 #include "base/command_line.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "chrome/browser/app_mode/app_mode_utils.h"
  11 #include "chrome/browser/chrome_notification_types.h"
  12 #include "chrome/browser/content_settings/host_content_settings_map.h"
  13 #include "chrome/browser/download/download_shelf.h"
  14 #include "chrome/browser/fullscreen.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "chrome/browser/ui/browser.h"
  17 #include "chrome/browser/ui/browser_window.h"
  18 #include "chrome/browser/ui/status_bubble.h"
  19 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  20 #include "chrome/common/chrome_switches.h"
  21 #include "content/public/browser/navigation_details.h"
  22 #include "content/public/browser/navigation_entry.h"
  23 #include "content/public/browser/notification_service.h"
  24 #include "content/public/browser/render_view_host.h"
  25 #include "content/public/browser/render_widget_host_view.h"
  26 #include "content/public/browser/user_metrics.h"
  27 #include "content/public/browser/web_contents.h"
  28 #include "extensions/common/extension.h"
  29
  30 #if defined(OS_MACOSX)
  31 #include "base/mac/mac_util.h"
  32 #else
  33 #include "base/prefs/pref_service.h"
  34 #include "chrome/common/pref_names.h"
  35 #endif
  36
  37 using base::UserMetricsAction;
  38 using content::RenderViewHost;
  39 using content::WebContents;
  40
  41 FullscreenController::FullscreenController(Browser* browser)
  42     : browser_(browser),
  43       window_(browser->window()),
  44       profile_(browser->profile()),
  45       fullscreened_tab_(NULL),
  46       state_prior_to_tab_fullscreen_(STATE_INVALID),
  47       tab_fullscreen_accepted_(false),
  48       toggled_into_fullscreen_(false),
  49       mouse_lock_tab_(NULL),
  50       mouse_lock_state_(MOUSELOCK_NOT_REQUESTED),
  51       reentrant_window_state_change_call_check_(false),
  52       is_privileged_fullscreen_for_testing_(false),
  53       ptr_factory_(this) {
  54   DCHECK(window_);
  55   DCHECK(profile_);
  56 }
  57
  58 FullscreenController::~FullscreenController() {
  59 }
  60
  61 bool FullscreenController::IsFullscreenForBrowser() const {
  62   return window_->IsFullscreen() && !IsFullscreenCausedByTab();
  63 }
  64
  65 void FullscreenController::ToggleFullscreenMode() {
  66   extension_caused_fullscreen_ = GURL();
  67   ToggleFullscreenModeInternal(BROWSER);
  68 }
  69
  70 bool FullscreenController::IsFullscreenForTabOrPending() const {
  71   return fullscreened_tab_ != NULL;
  72 }
  73
  74 bool FullscreenController::IsFullscreenForTabOrPending(
  75     const WebContents* web_contents) const {
  76   if (web_contents != fullscreened_tab_)
  77     return false;
  78   DCHECK(web_contents == browser_->tab_strip_model()->GetActiveWebContents());
  79   return true;
  80 }
  81
  82 bool FullscreenController::IsFullscreenCausedByTab() const {
  83   return state_prior_to_tab_fullscreen_ == STATE_NORMAL;
  84 }
  85
  86 void FullscreenController::ToggleFullscreenModeForTab(WebContents* web_contents,
  87                                                       bool enter_fullscreen) {
  88   if (fullscreened_tab_) {
  89     if (web_contents != fullscreened_tab_)
  90       return;
  91   } else if (
  92       web_contents != browser_->tab_strip_model()->GetActiveWebContents()) {
  93     return;
  94   }
  95   if (IsFullscreenForTabOrPending() == enter_fullscreen)
  96     return;
  97
  98 #if defined(OS_WIN)
  99   // For now, avoid breaking when initiating full screen tab mode while in
 100   // a metro snap.
 101   // TODO(robertshield): Find a way to reconcile tab-initiated fullscreen
 102   //                     modes with metro snap.
 103   if (IsInMetroSnapMode())
 104     return;
 105 #endif
 106
 107   bool in_browser_or_tab_fullscreen_mode = window_->IsFullscreen();
 108   bool window_is_fullscreen_with_chrome = false;
 109 #if defined(OS_MACOSX)
 110   window_is_fullscreen_with_chrome = window_->IsFullscreenWithChrome();
 111 #endif
 112
 113   if (enter_fullscreen) {
 114     SetFullscreenedTab(web_contents);
 115     if (!in_browser_or_tab_fullscreen_mode) {
 116       state_prior_to_tab_fullscreen_ = STATE_NORMAL;
 117       ToggleFullscreenModeInternal(TAB);
 118     } else if (window_is_fullscreen_with_chrome) {
 119 #if defined(OS_MACOSX)
 120       state_prior_to_tab_fullscreen_ = STATE_BROWSER_FULLSCREEN_WITH_CHROME;
 121       EnterFullscreenModeInternal(TAB);
 122 #else
 123       NOTREACHED();
 124 #endif
 125     } else {
 126       state_prior_to_tab_fullscreen_ = STATE_BROWSER_FULLSCREEN_NO_CHROME;
 127
 128       // We need to update the fullscreen exit bubble, e.g., going from browser
 129       // fullscreen to tab fullscreen will need to show different content.
 130       const GURL& url = web_contents->GetURL();
 131       if (!tab_fullscreen_accepted_) {
 132         tab_fullscreen_accepted_ =
 133             GetFullscreenSetting(url) == CONTENT_SETTING_ALLOW;
 134       }
 135       UpdateFullscreenExitBubbleContent();
 136
 137       // This is only a change between Browser and Tab fullscreen. We generate
 138       // a fullscreen notification now because there is no window change.
 139       PostFullscreenChangeNotification(true);
 140     }
 141   } else {
 142     if (in_browser_or_tab_fullscreen_mode) {
 143       if (IsFullscreenCausedByTab()) {
 144         ToggleFullscreenModeInternal(TAB);
 145       } else {
 146 #if defined(OS_MACOSX)
 147         if (state_prior_to_tab_fullscreen_ ==
 148             STATE_BROWSER_FULLSCREEN_WITH_CHROME) {
 149           EnterFullscreenModeInternal(BROWSER_WITH_CHROME);
 150         } else {
 151           // Clear the bubble URL, which forces the Mac UI to redraw.
 152           UpdateFullscreenExitBubbleContent();
 153         }
 154 #endif
 155         // If currently there is a tab in "tab fullscreen" mode and fullscreen
 156         // was not caused by it (i.e., previously it was in "browser fullscreen"
 157         // mode), we need to switch back to "browser fullscreen" mode. In this
 158         // case, all we have to do is notifying the tab that it has exited "tab
 159         // fullscreen" mode.
 160         NotifyTabOfExitIfNecessary();
 161
 162         // This is only a change between Browser and Tab fullscreen. We generate
 163         // a fullscreen notification now because there is no window change.
 164         PostFullscreenChangeNotification(true);
 165       }
 166     }
 167   }
 168 }
 169
 170 void FullscreenController::ToggleFullscreenModeWithExtension(
 171     const GURL& extension_url) {
 172   // |extension_caused_fullscreen_| will be reset if this causes fullscreen to
 173   // exit.
 174   extension_caused_fullscreen_ = extension_url;
 175   ToggleFullscreenModeInternal(BROWSER);
 176 }
 177
 178 bool FullscreenController::IsInMetroSnapMode() {
 179 #if defined(OS_WIN)
 180   return window_->IsInMetroSnapMode();
 181 #else
 182   return false;
 183 #endif
 184 }
 185
 186 #if defined(OS_WIN)
 187 void FullscreenController::SetMetroSnapMode(bool enable) {
 188   reentrant_window_state_change_call_check_ = false;
 189
 190   toggled_into_fullscreen_ = false;
 191   window_->SetMetroSnapMode(enable);
 192
 193   // FullscreenController unit tests for metro snap assume that on Windows calls
 194   // to WindowFullscreenStateChanged are reentrant. If that assumption is
 195   // invalidated, the tests must be updated to maintain coverage.
 196   CHECK(reentrant_window_state_change_call_check_);
 197 }
 198 #endif  // defined(OS_WIN)
 199
 200 #if defined(OS_MACOSX)
 201 void FullscreenController::ToggleFullscreenWithChrome() {
 202   // This method cannot be called if simplified fullscreen is enabled.
 203   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 204   DCHECK(!command_line->HasSwitch(switches::kEnableSimplifiedFullscreen));
 205   ToggleFullscreenModeInternal(BROWSER_WITH_CHROME);
 206 }
 207 #endif
 208
 209 bool FullscreenController::IsMouseLockRequested() const {
 210   return mouse_lock_state_ == MOUSELOCK_REQUESTED;
 211 }
 212
 213 bool FullscreenController::IsMouseLocked() const {
 214   return mouse_lock_state_ == MOUSELOCK_ACCEPTED ||
 215          mouse_lock_state_ == MOUSELOCK_ACCEPTED_SILENTLY;
 216 }
 217
 218 void FullscreenController::RequestToLockMouse(WebContents* web_contents,
 219                                               bool user_gesture,
 220                                               bool last_unlocked_by_target) {
 221   DCHECK(!IsMouseLocked());
 222   NotifyMouseLockChange();
 223
 224   // Must have a user gesture to prevent misbehaving sites from constantly
 225   // re-locking the mouse. Exceptions are when the page has unlocked
 226   // (i.e. not the user), or if we're in tab fullscreen (user gesture required
 227   // for that)
 228   if (!last_unlocked_by_target && !user_gesture &&
 229       !IsFullscreenForTabOrPending(web_contents)) {
 230     web_contents->GotResponseToLockMouseRequest(false);
 231     return;
 232   }
 233   SetMouseLockTab(web_contents);
 234   FullscreenExitBubbleType bubble_type = GetFullscreenExitBubbleType();
 235
 236   switch (GetMouseLockSetting(web_contents->GetURL())) {
 237     case CONTENT_SETTING_ALLOW:
 238       // If bubble already displaying buttons we must not lock the mouse yet,
 239       // or it would prevent pressing those buttons. Instead, merge the request.
 240       if (!IsPrivilegedFullscreenForTab() &&
 241           fullscreen_bubble::ShowButtonsForType(bubble_type)) {
 242         mouse_lock_state_ = MOUSELOCK_REQUESTED;
 243       } else {
 244         // Lock mouse.
 245         if (web_contents->GotResponseToLockMouseRequest(true)) {
 246           if (last_unlocked_by_target) {
 247             mouse_lock_state_ = MOUSELOCK_ACCEPTED_SILENTLY;
 248           } else {
 249             mouse_lock_state_ = MOUSELOCK_ACCEPTED;
 250           }
 251         } else {
 252           SetMouseLockTab(NULL);
 253           mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
 254         }
 255       }
 256       break;
 257     case CONTENT_SETTING_BLOCK:
 258       web_contents->GotResponseToLockMouseRequest(false);
 259       SetMouseLockTab(NULL);
 260       mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
 261       break;
 262     case CONTENT_SETTING_ASK:
 263       mouse_lock_state_ = MOUSELOCK_REQUESTED;
 264       break;
 265     default:
 266       NOTREACHED();
 267   }
 268   UpdateFullscreenExitBubbleContent();
 269 }
 270
 271 void FullscreenController::OnTabDeactivated(WebContents* web_contents) {
 272   if (web_contents == fullscreened_tab_ || web_contents == mouse_lock_tab_)
 273     ExitTabFullscreenOrMouseLockIfNecessary();
 274 }
 275
 276 void FullscreenController::OnTabClosing(WebContents* web_contents) {
 277   if (web_contents == fullscreened_tab_ || web_contents == mouse_lock_tab_) {
 278     ExitTabFullscreenOrMouseLockIfNecessary();
 279     // The call to exit fullscreen may result in asynchronous notification of
 280     // fullscreen state change (e.g., on Linux). We don't want to rely on it
 281     // to call NotifyTabOfExitIfNecessary(), because at that point
 282     // |fullscreened_tab_| may not be valid. Instead, we call it here to clean
 283     // up tab fullscreen related state.
 284     NotifyTabOfExitIfNecessary();
 285   }
 286 }
 287
 288 void FullscreenController::WindowFullscreenStateChanged() {
 289   reentrant_window_state_change_call_check_ = true;
 290
 291   bool exiting_fullscreen = !window_->IsFullscreen();
 292
 293   PostFullscreenChangeNotification(!exiting_fullscreen);
 294   if (exiting_fullscreen) {
 295     toggled_into_fullscreen_ = false;
 296     extension_caused_fullscreen_ = GURL();
 297     NotifyTabOfExitIfNecessary();
 298   }
 299   if (exiting_fullscreen) {
 300     window_->GetDownloadShelf()->Unhide();
 301   } else {
 302     window_->GetDownloadShelf()->Hide();
 303     if (window_->GetStatusBubble())
 304       window_->GetStatusBubble()->Hide();
 305   }
 306 }
 307
 308 bool FullscreenController::HandleUserPressedEscape() {
 309   if (IsFullscreenForTabOrPending() ||
 310       IsMouseLocked() || IsMouseLockRequested()) {
 311     ExitTabFullscreenOrMouseLockIfNecessary();
 312     return true;
 313   }
 314
 315   return false;
 316 }
 317
 318 void FullscreenController::ExitTabOrBrowserFullscreenToPreviousState() {
 319   if (IsFullscreenForTabOrPending())
 320     ExitTabFullscreenOrMouseLockIfNecessary();
 321   else if (IsFullscreenForBrowser())
 322     ExitFullscreenModeInternal();
 323 }
 324
 325 void FullscreenController::OnAcceptFullscreenPermission() {
 326   FullscreenExitBubbleType bubble_type = GetFullscreenExitBubbleType();
 327   bool mouse_lock = false;
 328   bool fullscreen = false;
 329   fullscreen_bubble::PermissionRequestedByType(bubble_type, &fullscreen,
 330                                                &mouse_lock);
 331   DCHECK(!(fullscreen && tab_fullscreen_accepted_));
 332   DCHECK(!(mouse_lock && IsMouseLocked()));
 333
 334   HostContentSettingsMap* settings_map = profile_->GetHostContentSettingsMap();
 335
 336   GURL url = GetFullscreenExitBubbleURL();
 337   ContentSettingsPattern pattern = ContentSettingsPattern::FromURL(url);
 338
 339   if (mouse_lock && !IsMouseLocked()) {
 340     DCHECK(IsMouseLockRequested());
 341     // TODO(markusheintz): We should allow patterns for all possible URLs here.
 342     if (pattern.IsValid()) {
 343       settings_map->SetContentSetting(
 344           pattern, ContentSettingsPattern::Wildcard(),
 345           CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string(),
 346           CONTENT_SETTING_ALLOW);
 347     }
 348
 349     if (mouse_lock_tab_ &&
 350         mouse_lock_tab_->GotResponseToLockMouseRequest(true)) {
 351       mouse_lock_state_ = MOUSELOCK_ACCEPTED;
 352     } else {
 353       mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
 354       SetMouseLockTab(NULL);
 355     }
 356     NotifyMouseLockChange();
 357   }
 358
 359   if (fullscreen && !tab_fullscreen_accepted_) {
 360     DCHECK(fullscreened_tab_);
 361     if (pattern.IsValid()) {
 362       settings_map->SetContentSetting(
 363           pattern, ContentSettingsPattern::Wildcard(),
 364           CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string(),
 365           CONTENT_SETTING_ALLOW);
 366     }
 367     tab_fullscreen_accepted_ = true;
 368   }
 369   UpdateFullscreenExitBubbleContent();
 370 }
 371
 372 void FullscreenController::OnDenyFullscreenPermission() {
 373   if (!fullscreened_tab_ && !mouse_lock_tab_)
 374     return;
 375
 376   if (IsMouseLockRequested()) {
 377     mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
 378     if (mouse_lock_tab_)
 379       mouse_lock_tab_->GotResponseToLockMouseRequest(false);
 380     SetMouseLockTab(NULL);
 381     NotifyMouseLockChange();
 382
 383     // UpdateFullscreenExitBubbleContent() must be called, but to avoid
 384     // duplicate calls we do so only if not adjusting the fullscreen state
 385     // below, which also calls UpdateFullscreenExitBubbleContent().
 386     if (!IsFullscreenForTabOrPending())
 387       UpdateFullscreenExitBubbleContent();
 388   }
 389
 390   if (IsFullscreenForTabOrPending())
 391     ExitTabFullscreenOrMouseLockIfNecessary();
 392 }
 393
 394 void FullscreenController::LostMouseLock() {
 395   mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
 396   SetMouseLockTab(NULL);
 397   NotifyMouseLockChange();
 398   UpdateFullscreenExitBubbleContent();
 399 }
 400
 401 void FullscreenController::Observe(int type,
 402     const content::NotificationSource& source,
 403     const content::NotificationDetails& details) {
 404   switch (type) {
 405     case content::NOTIFICATION_NAV_ENTRY_COMMITTED:
 406       if (content::Details<content::LoadCommittedDetails>(details)->
 407               is_navigation_to_different_page()) {
 408         ExitTabFullscreenOrMouseLockIfNecessary();
 409       }
 410       break;
 411
 412     default:
 413       NOTREACHED() << "Got a notification we didn't register for.";
 414   }
 415 }
 416
 417 GURL FullscreenController::GetFullscreenExitBubbleURL() const {
 418   if (fullscreened_tab_)
 419     return fullscreened_tab_->GetURL();
 420   else if (mouse_lock_tab_)
 421     return mouse_lock_tab_->GetURL();
 422   else if (!extension_caused_fullscreen_.is_empty())
 423     return extension_caused_fullscreen_;
 424   else
 425     return GURL();
 426 }
 427
 428 FullscreenExitBubbleType FullscreenController::GetFullscreenExitBubbleType()
 429     const {
 430   // In kiosk and exclusive app mode we always want to be fullscreen and do not
 431   // want to show exit instructions for browser mode fullscreen.
 432   bool app_mode = false;
 433 #if !defined(OS_MACOSX)  // App mode (kiosk) is not available on Mac yet.
 434   app_mode = chrome::IsRunningInAppMode();
 435 #endif
 436
 437   if (mouse_lock_state_ == MOUSELOCK_ACCEPTED_SILENTLY) {
 438     return FEB_TYPE_NONE;
 439   }
 440
 441   if (fullscreened_tab_) {
 442     if (tab_fullscreen_accepted_) {
 443       if (IsPrivilegedFullscreenForTab()) {
 444         return FEB_TYPE_NONE;
 445       } else if (IsMouseLocked()) {
 446         return FEB_TYPE_FULLSCREEN_MOUSELOCK_EXIT_INSTRUCTION;
 447       } else if (IsMouseLockRequested()) {
 448         return FEB_TYPE_MOUSELOCK_BUTTONS;
 449       } else {
 450         return FEB_TYPE_FULLSCREEN_EXIT_INSTRUCTION;
 451       }
 452     } else {  // Full screen not yet accepted.
 453       if (IsMouseLockRequested()) {
 454         return FEB_TYPE_FULLSCREEN_MOUSELOCK_BUTTONS;
 455       } else {
 456         return FEB_TYPE_FULLSCREEN_BUTTONS;
 457       }
 458     }
 459   } else {  // Not tab full screen.
 460     if (IsMouseLocked()) {
 461       return FEB_TYPE_MOUSELOCK_EXIT_INSTRUCTION;
 462     } else if (IsMouseLockRequested()) {
 463       return FEB_TYPE_MOUSELOCK_BUTTONS;
 464     } else {
 465       if (!extension_caused_fullscreen_.is_empty()) {
 466         return FEB_TYPE_BROWSER_EXTENSION_FULLSCREEN_EXIT_INSTRUCTION;
 467       } else if (toggled_into_fullscreen_ && !app_mode) {
 468         return FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION;
 469       } else {
 470         return FEB_TYPE_NONE;
 471       }
 472     }
 473   }
 474   NOTREACHED();
 475   return FEB_TYPE_NONE;
 476 }
 477
 478 void FullscreenController::UpdateNotificationRegistrations() {
 479   if (fullscreened_tab_ && mouse_lock_tab_)
 480     DCHECK(fullscreened_tab_ == mouse_lock_tab_);
 481
 482   WebContents* tab = fullscreened_tab_ ? fullscreened_tab_ : mouse_lock_tab_;
 483
 484   if (tab && registrar_.IsEmpty()) {
 485     registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
 486         content::Source<content::NavigationController>(&tab->GetController()));
 487   } else if (!tab && !registrar_.IsEmpty()) {
 488     registrar_.RemoveAll();
 489   }
 490 }
 491
 492 void FullscreenController::PostFullscreenChangeNotification(
 493     bool is_fullscreen) {
 494   base::MessageLoop::current()->PostTask(
 495       FROM_HERE,
 496       base::Bind(&FullscreenController::NotifyFullscreenChange,
 497                  ptr_factory_.GetWeakPtr(),
 498                  is_fullscreen));
 499 }
 500
 501 void FullscreenController::NotifyFullscreenChange(bool is_fullscreen) {
 502   content::NotificationService::current()->Notify(
 503       chrome::NOTIFICATION_FULLSCREEN_CHANGED,
 504       content::Source<FullscreenController>(this),
 505       content::Details<bool>(&is_fullscreen));
 506 }
 507
 508 void FullscreenController::NotifyTabOfExitIfNecessary() {
 509   if (fullscreened_tab_) {
 510     RenderViewHost* rvh = fullscreened_tab_->GetRenderViewHost();
 511     SetFullscreenedTab(NULL);
 512     state_prior_to_tab_fullscreen_ = STATE_INVALID;
 513     tab_fullscreen_accepted_ = false;
 514     if (rvh)
 515       rvh->ExitFullscreen();
 516   }
 517
 518   if (mouse_lock_tab_) {
 519     if (IsMouseLockRequested()) {
 520       mouse_lock_tab_->GotResponseToLockMouseRequest(false);
 521       NotifyMouseLockChange();
 522     } else {
 523       UnlockMouse();
 524     }
 525     SetMouseLockTab(NULL);
 526     mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
 527   }
 528
 529   UpdateFullscreenExitBubbleContent();
 530 }
 531
 532 void FullscreenController::NotifyMouseLockChange() {
 533   content::NotificationService::current()->Notify(
 534       chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
 535       content::Source<FullscreenController>(this),
 536       content::NotificationService::NoDetails());
 537 }
 538
 539 void FullscreenController::ToggleFullscreenModeInternal(
 540     FullscreenInternalOption option) {
 541 #if defined(OS_WIN)
 542   // When in Metro snap mode, toggling in and out of fullscreen is prevented.
 543   if (IsInMetroSnapMode())
 544     return;
 545 #endif
 546
 547   bool enter_fullscreen = !window_->IsFullscreen();
 548 #if defined(OS_MACOSX)
 549   // When a Mac user requests a toggle they may be toggling between
 550   // FullscreenWithoutChrome and FullscreenWithChrome.
 551   if (!IsFullscreenForTabOrPending()) {
 552     if (option == BROWSER_WITH_CHROME)
 553       enter_fullscreen |= window_->IsFullscreenWithoutChrome();
 554     else
 555       enter_fullscreen |= window_->IsFullscreenWithChrome();
 556   }
 557 #endif
 558
 559   // In kiosk mode, we always want to be fullscreen. When the browser first
 560   // starts we're not yet fullscreen, so let the initial toggle go through.
 561   if (chrome::IsRunningInAppMode() && window_->IsFullscreen())
 562     return;
 563
 564 #if !defined(OS_MACOSX)
 565   // Do not enter fullscreen mode if disallowed by pref. This prevents the user
 566   // from manually entering fullscreen mode and also disables kiosk mode on
 567   // desktop platforms.
 568   if (enter_fullscreen &&
 569       !profile_->GetPrefs()->GetBoolean(prefs::kFullscreenAllowed)) {
 570     return;
 571   }
 572 #endif
 573
 574   if (enter_fullscreen)
 575     EnterFullscreenModeInternal(option);
 576   else
 577     ExitFullscreenModeInternal();
 578 }
 579
 580 void FullscreenController::EnterFullscreenModeInternal(
 581     FullscreenInternalOption option) {
 582   toggled_into_fullscreen_ = true;
 583   GURL url;
 584   if (option == TAB) {
 585     url = browser_->tab_strip_model()->GetActiveWebContents()->GetURL();
 586     tab_fullscreen_accepted_ =
 587         GetFullscreenSetting(url) == CONTENT_SETTING_ALLOW;
 588   } else {
 589     if (!extension_caused_fullscreen_.is_empty())
 590       url = extension_caused_fullscreen_;
 591   }
 592
 593   if (option == BROWSER)
 594     content::RecordAction(UserMetricsAction("ToggleFullscreen"));
 595   // TODO(scheib): Record metrics for WITH_CHROME, without counting transitions
 596   // from tab fullscreen out to browser with chrome.
 597
 598 #if defined(OS_MACOSX)
 599   if (option == BROWSER_WITH_CHROME) {
 600     CHECK(chrome::mac::SupportsSystemFullscreen());
 601     window_->EnterFullscreenWithChrome();
 602   } else {
 603 #else
 604   {
 605 #endif
 606     window_->EnterFullscreen(url, GetFullscreenExitBubbleType());
 607   }
 608
 609   UpdateFullscreenExitBubbleContent();
 610
 611   // Once the window has become fullscreen it'll call back to
 612   // WindowFullscreenStateChanged(). We don't do this immediately as
 613   // BrowserWindow::EnterFullscreen() asks for bookmark_bar_state_, so we let
 614   // the BrowserWindow invoke WindowFullscreenStateChanged when appropriate.
 615 }
 616
 617 void FullscreenController::ExitFullscreenModeInternal() {
 618   toggled_into_fullscreen_ = false;
 619 #if defined(OS_MACOSX)
 620   // Mac windows report a state change instantly, and so we must also clear
 621   // state_prior_to_tab_fullscreen_ to match them else other logic using
 622   // state_prior_to_tab_fullscreen_ will be incorrect.
 623   NotifyTabOfExitIfNecessary();
 624 #endif
 625   window_->ExitFullscreen();
 626   extension_caused_fullscreen_ = GURL();
 627
 628   UpdateFullscreenExitBubbleContent();
 629 }
 630
 631 void FullscreenController::SetFullscreenedTab(WebContents* tab) {
 632   fullscreened_tab_ = tab;
 633   UpdateNotificationRegistrations();
 634 }
 635
 636 void FullscreenController::SetMouseLockTab(WebContents* tab) {
 637   mouse_lock_tab_ = tab;
 638   UpdateNotificationRegistrations();
 639 }
 640
 641 void FullscreenController::ExitTabFullscreenOrMouseLockIfNecessary() {
 642   if (IsFullscreenForTabOrPending())
 643     ToggleFullscreenModeForTab(fullscreened_tab_, false);
 644   else
 645     NotifyTabOfExitIfNecessary();
 646 }
 647
 648 void FullscreenController::UpdateFullscreenExitBubbleContent() {
 649   GURL url = GetFullscreenExitBubbleURL();
 650   FullscreenExitBubbleType bubble_type = GetFullscreenExitBubbleType();
 651
 652   // If bubble displays buttons, unlock mouse to allow pressing them.
 653   if (fullscreen_bubble::ShowButtonsForType(bubble_type) && IsMouseLocked())
 654     UnlockMouse();
 655
 656   window_->UpdateFullscreenExitBubbleContent(url, bubble_type);
 657 }
 658
 659 ContentSetting
 660 FullscreenController::GetFullscreenSetting(const GURL& url) const {
 661   if (IsPrivilegedFullscreenForTab() || url.SchemeIsFile())
 662     return CONTENT_SETTING_ALLOW;
 663
 664   return profile_->GetHostContentSettingsMap()->GetContentSetting(url, url,
 665       CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string());
 666 }
 667
 668 ContentSetting
 669 FullscreenController::GetMouseLockSetting(const GURL& url) const {
 670   if (IsPrivilegedFullscreenForTab() || url.SchemeIsFile())
 671     return CONTENT_SETTING_ALLOW;
 672
 673   HostContentSettingsMap* settings_map = profile_->GetHostContentSettingsMap();
 674   return settings_map->GetContentSetting(url, url,
 675       CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string());
 676 }
 677
 678 bool FullscreenController::IsPrivilegedFullscreenForTab() const {
 679   const bool embedded_widget_present =
 680       fullscreened_tab_ &&
 681       fullscreened_tab_->GetFullscreenRenderWidgetHostView() &&
 682       implicit_cast<const content::WebContentsDelegate*>(browser_)->
 683           EmbedsFullscreenWidget();
 684   return embedded_widget_present || is_privileged_fullscreen_for_testing_;
 685 }
 686
 687 void FullscreenController::SetPrivilegedFullscreenForTesting(
 688     bool is_privileged) {
 689   is_privileged_fullscreen_for_testing_ = is_privileged;
 690 }
 691
 692 void FullscreenController::UnlockMouse() {
 693   if (!mouse_lock_tab_)
 694     return;
 695   content::RenderWidgetHostView* mouse_lock_view =
 696       (fullscreened_tab_ == mouse_lock_tab_ && IsPrivilegedFullscreenForTab()) ?
 697       mouse_lock_tab_->GetFullscreenRenderWidgetHostView() : NULL;
 698   if (!mouse_lock_view) {
 699     RenderViewHost* const rvh = mouse_lock_tab_->GetRenderViewHost();
 700     if (rvh)
 701       mouse_lock_view = rvh->GetView();
 702   }
 703   if (mouse_lock_view)
 704     mouse_lock_view->UnlockMouse();
 705 }