Exit mouse lock or fullscreen on navigation and reload.

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"
@@ skipping 21 matching lines @@
                                            Profile* profile,
                                            Browser* browser)
   : window_(window),
     profile_(profile),
     browser_(browser),
     fullscreened_tab_(NULL),
     tab_caused_fullscreen_(false),
     tab_fullscreen_accepted_(false),
     toggled_into_fullscreen_(false),
     mouse_lock_tab_(NULL),
-    mouse_lock_state_(MOUSELOCK_NOT_REQUESTED),
-    cancel_fullscreen_on_navigate_mode_(false) {
+    mouse_lock_state_(MOUSELOCK_NOT_REQUESTED) {
 }
 
 void FullscreenController::Observe(int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_NAV_ENTRY_COMMITTED:
       if (content::Details<content::LoadCommittedDetails>(details)->
           is_navigation_to_different_page()) {
         ExitTabFullscreenOrMouseLockIfNecessary();
@@ skipping 55 matching lines @@
 
   // Must have a user gesture to prevent misbehaving sites from constantly
   // re-locking the mouse. Exceptions are when the page has unlocked
   // (i.e. not the user), or if we're in tab fullscreen (user gesture required
   // for that)
   if (!last_unlocked_by_target && !user_gesture &&
       !IsFullscreenForTabOrPending(web_contents)) {
     web_contents->GotResponseToLockMouseRequest(false);
     return;
   }
-  mouse_lock_tab_ = TabContents::FromWebContents(web_contents);
+  set_mouse_lock_tab(TabContents::FromWebContents(web_contents));
   FullscreenExitBubbleType bubble_type = GetFullscreenExitBubbleType();
 
   switch (GetMouseLockSetting(web_contents->GetURL())) {
     case CONTENT_SETTING_ALLOW:
       // If bubble already displaying buttons we must not lock the mouse yet,
       // or it would prevent pressing those buttons. Instead, merge the request.
       if (fullscreen_bubble::ShowButtonsForType(bubble_type)) {
         mouse_lock_state_ = MOUSELOCK_REQUESTED;
       } else {
         // Lock mouse.
         if (web_contents->GotResponseToLockMouseRequest(true)) {
           if (last_unlocked_by_target) {
             mouse_lock_state_ = MOUSELOCK_ACCEPTED_SILENTLY;
           } else {
             mouse_lock_state_ = MOUSELOCK_ACCEPTED;
           }
         } else {
-          mouse_lock_tab_ = NULL;
+          set_mouse_lock_tab(NULL);
           mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
         }
       }
       break;
     case CONTENT_SETTING_BLOCK:
       web_contents->GotResponseToLockMouseRequest(false);
-      mouse_lock_tab_ = NULL;
+      set_mouse_lock_tab(NULL);
       mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
       break;
     case CONTENT_SETTING_ASK:
       mouse_lock_state_ = MOUSELOCK_REQUESTED;
       break;
     default:
       NOTREACHED();
   }
   UpdateFullscreenExitBubbleContent();
 }
 
 void FullscreenController::ToggleFullscreenModeForTab(WebContents* web_contents,
                                                       bool enter_fullscreen) {
   if (web_contents != browser_->GetActiveWebContents())
     return;
 
   bool in_browser_or_tab_fullscreen_mode;
 #if defined(OS_MACOSX)
   in_browser_or_tab_fullscreen_mode = window_->InPresentationMode();
 #else
   in_browser_or_tab_fullscreen_mode = window_->IsFullscreen();
 #endif
 
   if (enter_fullscreen) {
-    fullscreened_tab_ = TabContents::FromWebContents(web_contents);
-    EnterCancelFullscreenOnNavigateMode();
+    set_fullscreened_tab(TabContents::FromWebContents(web_contents));
     if (!in_browser_or_tab_fullscreen_mode) {
       tab_caused_fullscreen_ = true;
 #if defined(OS_MACOSX)
       TogglePresentationModeInternal(true);
 #else
       ToggleFullscreenModeInternal(true);
 #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 = web_contents->GetURL();
       if (!tab_fullscreen_accepted_) {
         tab_fullscreen_accepted_ =
             GetFullscreenSetting(url) == CONTENT_SETTING_ALLOW;
       }
       UpdateFullscreenExitBubbleContent();
     }
   } else {
-    ExitCancelFullscreenOnNavigateMode();
     if (in_browser_or_tab_fullscreen_mode) {
       if (tab_caused_fullscreen_) {
 #if defined(OS_MACOSX)
         TogglePresentationModeInternal(true);
 #else
         ToggleFullscreenModeInternal(true);
 #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"
@@ skipping 26 matching lines @@
 void FullscreenController::ToggleFullscreenModeWithExtension(
     const GURL& extension_url) {
   // |extension_caused_fullscreen_| will be reset if this causes fullscreen to
   // exit.
   extension_caused_fullscreen_ = extension_url;
   ToggleFullscreenModeInternal(false);
 }
 
 void FullscreenController::LostMouseLock() {
   mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
-  mouse_lock_tab_ = NULL;
+  set_mouse_lock_tab(NULL);
   NotifyMouseLockChange();
   UpdateFullscreenExitBubbleContent();
 }
 
 void FullscreenController::OnTabClosing(WebContents* web_contents) {
   if (IsFullscreenForTabOrPending(web_contents)) {
     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
@@ skipping 30 matching lines @@
           CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string(),
           CONTENT_SETTING_ALLOW);
     }
 
     if (mouse_lock_tab_ &&
         mouse_lock_tab_->web_contents() &&
         mouse_lock_tab_->web_contents()->GotResponseToLockMouseRequest(true)) {
       mouse_lock_state_ = MOUSELOCK_ACCEPTED;
     } else {
       mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
-      mouse_lock_tab_ = NULL;
+      set_mouse_lock_tab(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(),
@@ skipping 12 matching lines @@
                                                &mouse_lock);
   DCHECK(fullscreened_tab_ || mouse_lock_tab_);
   DCHECK(!(fullscreen && tab_fullscreen_accepted_));
   DCHECK(!(mouse_lock && IsMouseLocked()));
 
   if (mouse_lock) {
     DCHECK(IsMouseLockRequested());
     mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
     if (mouse_lock_tab_ && mouse_lock_tab_->web_contents())
       mouse_lock_tab_->web_contents()->GotResponseToLockMouseRequest(false);
-    mouse_lock_tab_ = NULL;
+    set_mouse_lock_tab(NULL);
     NotifyMouseLockChange();
 
     // UpdateFullscreenExitBubbleContent() must be called, but to avoid
     // duplicate calls we do so only if not adjusting the fullscreen state
     // below, which also calls UpdateFullscreenExitBubbleContent().
     if (!fullscreen)
       UpdateFullscreenExitBubbleContent();
   }
 
   if (fullscreen)
@@ skipping 25 matching lines @@
     return true;
   }
 
   return false;
 }
 
 FullscreenController::~FullscreenController() {}
 
 void FullscreenController::NotifyTabOfExitIfNecessary() {
   if (fullscreened_tab_) {
-    ExitCancelFullscreenOnNavigateMode();
     RenderViewHost* rvh =
         fullscreened_tab_->web_contents()->GetRenderViewHost();
-    fullscreened_tab_ = NULL;
+    set_fullscreened_tab(NULL);
     tab_caused_fullscreen_ = false;
     tab_fullscreen_accepted_ = false;
     if (rvh)
       rvh->ExitFullscreen();
   }
 
   if (mouse_lock_tab_) {
     WebContents* web_contents = mouse_lock_tab_->web_contents();
     if (IsMouseLockRequested()) {
       web_contents->GotResponseToLockMouseRequest(false);
+      NotifyMouseLockChange();
     } else if (web_contents->GetRenderViewHost() &&
                web_contents->GetRenderViewHost()->GetView()) {
       web_contents->GetRenderViewHost()->GetView()->UnlockMouse();
     }
-    mouse_lock_tab_ = NULL;
+    set_mouse_lock_tab(NULL);
     mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
   }
 
   UpdateFullscreenExitBubbleContent();
 }
 
-void FullscreenController::EnterCancelFullscreenOnNavigateMode() {
-  if (cancel_fullscreen_on_navigate_mode_)
-    return;
-  cancel_fullscreen_on_navigate_mode_ = true;
-  registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
-      content::Source<content::NavigationController>(
-          &fullscreened_tab_->web_contents()->GetController()));
+void FullscreenController::UpdateNotificationRegistrations() {
+  if (fullscreened_tab_ && mouse_lock_tab_)
+    DCHECK(fullscreened_tab_ == mouse_lock_tab_);

[yzshen1, 2012/06/20 18:07:54]

nit: you could DCHECK(!(fullscreened_tab_ && mouse_lock_tab_) ||
fullscreened_tab_ == mouse_lock_tab_)

[scheib, 2012/06/20 20:38:24]

I considered, but felt this was easier to read.

[yzshen1, 2012/06/20 20:56:46]

A if-block containing only a DCHECK is a little bit unusual.
But I am fine if you would like to keep it.

On 2012/06/20 20:38:24, scheib wrote:

+
+  TabContents* tab = fullscreened_tab_ ? fullscreened_tab_ : mouse_lock_tab_;
+
+  if (tab && registrar_.IsEmpty()) {
+    registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+        content::Source<content::NavigationController>(
+            &tab->web_contents()->GetController()));
+  } else if (!tab && !registrar_.IsEmpty()) {
+    registrar_.RemoveAll();
+  }
 }
 
-void FullscreenController::ExitCancelFullscreenOnNavigateMode() {
-  if (!cancel_fullscreen_on_navigate_mode_)
-    return;
-  cancel_fullscreen_on_navigate_mode_ = false;
-  registrar_.RemoveAll();
-}
-
-
 void FullscreenController::ExitTabFullscreenOrMouseLockIfNecessary() {
   if (tab_caused_fullscreen_)
     ToggleFullscreenMode();
   else
     NotifyTabOfExitIfNecessary();
 }
 
 void FullscreenController::UpdateFullscreenExitBubbleContent() {
   GURL url;
   if (fullscreened_tab_)
@@ skipping 147 matching lines @@
     window_->ExitFullscreen();
     extension_caused_fullscreen_ = GURL();
   }
   UpdateFullscreenExitBubbleContent();
 
   // 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.
 }
+
+void FullscreenController::set_fullscreened_tab(TabContents* tab) {

[koz (OOO until 15th September), 2012/06/19 23:57:17]

nit: I think it's more in line with C++ style to have these methods be CamelCase
rather than unix_style because they aren't straight setters, but up to you.

[scheib, 2012/06/20 20:38:24]

Done.

+  fullscreened_tab_ = tab;
+  UpdateNotificationRegistrations();
+}
+
+void FullscreenController::set_mouse_lock_tab(TabContents* tab) {
+  mouse_lock_tab_ = tab;
+  UpdateNotificationRegistrations();
+}