Rename fullscreen_exit_bubble_* to exclusive_access_bubble_*

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 215 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;
   }
   SetMouseLockTab(web_contents);
-  FullscreenExitBubbleType bubble_type = GetFullscreenExitBubbleType();
+  ExclusiveAccessBubbleType bubble_type = GetExclusiveAccessBubbleType();
 
   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 (!IsPrivilegedFullscreenForTab() &&
-          fullscreen_bubble::ShowButtonsForType(bubble_type)) {
+          exclusive_access_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 {
@@ skipping 108 matching lines @@
 }
 
 void FullscreenController::ExitTabOrBrowserFullscreenToPreviousState() {
   if (IsWindowFullscreenForTabOrPending())
     ExitTabFullscreenOrMouseLockIfNecessary();
   else if (IsFullscreenForBrowser())
     ExitFullscreenModeInternal();
 }
 
 void FullscreenController::OnAcceptFullscreenPermission() {
-  FullscreenExitBubbleType bubble_type = GetFullscreenExitBubbleType();
+  ExclusiveAccessBubbleType bubble_type = GetExclusiveAccessBubbleType();
   bool mouse_lock = false;
   bool fullscreen = false;
-  fullscreen_bubble::PermissionRequestedByType(bubble_type, &fullscreen,
-                                               &mouse_lock);
+  exclusive_access_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());
@@ skipping 67 matching lines @@
 }
 
 GURL FullscreenController::GetFullscreenExitBubbleURL() const {
   if (fullscreened_tab_)
     return fullscreened_tab_->GetURL();
   if (mouse_lock_tab_)
     return mouse_lock_tab_->GetURL();
   return extension_caused_fullscreen_;
 }
 
-FullscreenExitBubbleType FullscreenController::GetFullscreenExitBubbleType()
+ExclusiveAccessBubbleType FullscreenController::GetExclusiveAccessBubbleType()
     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;
 #if !defined(OS_MACOSX)  // App mode (kiosk) is not available on Mac yet.
   app_mode = chrome::IsRunningInAppMode();
 #endif
 
   if (mouse_lock_state_ == MOUSELOCK_ACCEPTED_SILENTLY)
-    return FEB_TYPE_NONE;
+    return EXCLUSIVE_ACCESS_BUBBLE_TYPE_NONE;
 
   if (!fullscreened_tab_) {
     if (IsMouseLocked())
-      return FEB_TYPE_MOUSELOCK_EXIT_INSTRUCTION;
+      return EXCLUSIVE_ACCESS_BUBBLE_TYPE_MOUSELOCK_EXIT_INSTRUCTION;
     if (IsMouseLockRequested())
-      return FEB_TYPE_MOUSELOCK_BUTTONS;
+      return EXCLUSIVE_ACCESS_BUBBLE_TYPE_MOUSELOCK_BUTTONS;
     if (!extension_caused_fullscreen_.is_empty())
-      return FEB_TYPE_BROWSER_EXTENSION_FULLSCREEN_EXIT_INSTRUCTION;
+      return EXCLUSIVE_ACCESS_BUBBLE_TYPE_EXTENSION_FULLSCREEN_EXIT_INSTRUCTION;
     if (toggled_into_fullscreen_ && !app_mode)
-      return FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION;
-    return FEB_TYPE_NONE;
+      return EXCLUSIVE_ACCESS_BUBBLE_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION;
+    return EXCLUSIVE_ACCESS_BUBBLE_TYPE_NONE;
   }
 
   if (tab_fullscreen_accepted_) {
     if (IsPrivilegedFullscreenForTab())
-      return FEB_TYPE_NONE;
+      return EXCLUSIVE_ACCESS_BUBBLE_TYPE_NONE;
     if (IsMouseLocked())
-      return FEB_TYPE_FULLSCREEN_MOUSELOCK_EXIT_INSTRUCTION;
+      return EXCLUSIVE_ACCESS_BUBBLE_TYPE_FULLSCREEN_MOUSELOCK_EXIT_INSTRUCTION;
     if (IsMouseLockRequested())
-      return FEB_TYPE_MOUSELOCK_BUTTONS;
-    return FEB_TYPE_FULLSCREEN_EXIT_INSTRUCTION;
+      return EXCLUSIVE_ACCESS_BUBBLE_TYPE_MOUSELOCK_BUTTONS;
+    return EXCLUSIVE_ACCESS_BUBBLE_TYPE_FULLSCREEN_EXIT_INSTRUCTION;
   }
 
   if (IsMouseLockRequested())
-    return FEB_TYPE_FULLSCREEN_MOUSELOCK_BUTTONS;
-  return FEB_TYPE_FULLSCREEN_BUTTONS;
+    return EXCLUSIVE_ACCESS_BUBBLE_TYPE_FULLSCREEN_MOUSELOCK_BUTTONS;
+  return EXCLUSIVE_ACCESS_BUBBLE_TYPE_FULLSCREEN_BUTTONS;
 }
 
 void FullscreenController::UpdateNotificationRegistrations() {
   if (fullscreened_tab_ && mouse_lock_tab_)
     DCHECK(fullscreened_tab_ == mouse_lock_tab_);
 
   WebContents* tab = fullscreened_tab_ ? fullscreened_tab_ : mouse_lock_tab_;
 
   if (tab && registrar_.IsEmpty()) {
     registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
@@ skipping 105 matching lines @@
   } 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.
 
-  window_->EnterFullscreen(url,
-                           GetFullscreenExitBubbleType(),
+  window_->EnterFullscreen(url, GetExclusiveAccessBubbleType(),
                            option == BROWSER_WITH_TOOLBAR);
 
   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.
 }
 
@@ skipping 23 matching lines @@
 
 void FullscreenController::ExitTabFullscreenOrMouseLockIfNecessary() {
   if (IsWindowFullscreenForTabOrPending())
     ToggleFullscreenModeForTab(fullscreened_tab_, false);
   else
     NotifyTabOfExitIfNecessary();
 }
 
 void FullscreenController::UpdateFullscreenExitBubbleContent() {
   GURL url = GetFullscreenExitBubbleURL();
-  FullscreenExitBubbleType bubble_type = GetFullscreenExitBubbleType();
+  ExclusiveAccessBubbleType bubble_type = GetExclusiveAccessBubbleType();
 
   // If bubble displays buttons, unlock mouse to allow pressing them.
-  if (fullscreen_bubble::ShowButtonsForType(bubble_type) && IsMouseLocked())
+  if (exclusive_access_bubble::ShowButtonsForType(bubble_type) &&
+      IsMouseLocked())
     UnlockMouse();
 
   window_->UpdateFullscreenExitBubbleContent(url, bubble_type);
 }
 
 ContentSetting
 FullscreenController::GetFullscreenSetting(const GURL& url) const {
   if (IsPrivilegedFullscreenForTab() || url.SchemeIsFile())
     return CONTENT_SETTING_ALLOW;
 
@@ skipping 62 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();
 }