TabContentsWrapper -> TabContents, part 53.

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/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 
 using content::RenderViewHost;
@@ skipping 16 matching lines @@
 
 bool FullscreenController::IsFullscreenForBrowser() const {
   return window_->IsFullscreen() && !tab_caused_fullscreen_;
 }
 
 bool FullscreenController::IsFullscreenForTabOrPending() const {
   return fullscreened_tab_ != NULL;
 }
 
 bool FullscreenController::IsFullscreenForTabOrPending(
-    const WebContents* tab) const {
-  const TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(tab);
-  if (!wrapper || (wrapper != fullscreened_tab_))
+    const WebContents* web_contents) const {
+  const TabContents* tab_contents =
+      TabContents::FromWebContents(web_contents);
+  if (!tab_contents || (tab_contents != fullscreened_tab_))
     return false;
-  DCHECK(tab == browser_->GetSelectedWebContents());
+  DCHECK(web_contents == browser_->GetActiveWebContents());
   return true;
 }
 
 bool FullscreenController::IsMouseLockRequested() const {
   return mouse_lock_state_ == MOUSELOCK_REQUESTED;
 }
 
 bool FullscreenController::IsMouseLocked() const {
   return mouse_lock_state_ == MOUSELOCK_ACCEPTED ||
          mouse_lock_state_ == MOUSELOCK_ACCEPTED_SILENTLY;
 }
 
-void FullscreenController::RequestToLockMouse(WebContents* tab,
+void FullscreenController::RequestToLockMouse(WebContents* web_contents,
                                               bool user_gesture,
                                               bool last_unlocked_by_target) {
   DCHECK(!IsMouseLocked());
   NotifyMouseLockChange();
 
   // 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(tab)) {
-    tab->GotResponseToLockMouseRequest(false);
+      !IsFullscreenForTabOrPending(web_contents)) {
+    web_contents->GotResponseToLockMouseRequest(false);
     return;
   }
-  mouse_lock_tab_ = TabContentsWrapper::GetCurrentWrapperForContents(tab);
+  mouse_lock_tab_ = TabContents::FromWebContents(web_contents);
   FullscreenExitBubbleType bubble_type = GetFullscreenExitBubbleType();
 
-  switch (GetMouseLockSetting(tab->GetURL())) {
+  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 (tab->GotResponseToLockMouseRequest(true)) {
+        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;
           mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
         }
       }
       break;
     case CONTENT_SETTING_BLOCK:
-      tab->GotResponseToLockMouseRequest(false);
+      web_contents->GotResponseToLockMouseRequest(false);
       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* tab,
+void FullscreenController::ToggleFullscreenModeForTab(WebContents* web_contents,
                                                       bool enter_fullscreen) {
-  if (tab != browser_->GetSelectedWebContents())
+  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_ = TabContentsWrapper::GetCurrentWrapperForContents(tab);
+    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 = tab->GetURL();
+      const GURL& url = web_contents->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)
@@ skipping 44 matching lines @@
     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
     // |fullscreened_tab_| may not be valid. Instead, we call it here to clean
     // up tab fullscreen related state.
     NotifyTabOfExitIfNecessary();
   }
 }
 
-void FullscreenController::OnTabDeactivated(TabContentsWrapper* contents) {
+void FullscreenController::OnTabDeactivated(TabContents* contents) {
   if (contents == fullscreened_tab_)
     ExitTabFullscreenOrMouseLockIfNecessary();
 }
 
 void FullscreenController::OnAcceptFullscreenPermission(
     const GURL& url,
     FullscreenExitBubbleType bubble_type) {
   bool mouse_lock = false;
   bool fullscreen = false;
   fullscreen_bubble::PermissionRequestedByType(bubble_type, &fullscreen,
@@ skipping 234 matching lines @@
   HostContentSettingsMap* settings_map = profile_->GetHostContentSettingsMap();
   return settings_map->GetContentSetting(url, url,
       CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string());
 }
 
 #if defined(OS_MACOSX)
 void FullscreenController::TogglePresentationModeInternal(bool for_tab) {
   toggled_into_fullscreen_ = !window_->InPresentationMode();
   GURL url;
   if (for_tab) {
-    url = browser_->GetSelectedWebContents()->GetURL();
+    url = browser_->GetActiveWebContents()->GetURL();
     tab_fullscreen_accepted_ = toggled_into_fullscreen_ &&
         GetFullscreenSetting(url) == CONTENT_SETTING_ALLOW;
   }
   if (toggled_into_fullscreen_)
     window_->EnterPresentationMode(url, GetFullscreenExitBubbleType());
   else
     window_->ExitPresentationMode();
   UpdateFullscreenExitBubbleContent();
 
   // WindowFullscreenStateChanged will be called by BrowserWindowController
   // when the transition completes.
 }
 #endif
 
 // TODO(koz): Change |for_tab| to an enum.
 void FullscreenController::ToggleFullscreenModeInternal(bool for_tab) {
   toggled_into_fullscreen_ = !window_->IsFullscreen();
 
  // 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 !defined(OS_MACOSX)  // Kiosk mode not available on Mac.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode) &&
       window_->IsFullscreen())
     return;
 #endif
 
   GURL url;
   if (for_tab) {
-    url = browser_->GetSelectedWebContents()->GetURL();
+    url = browser_->GetActiveWebContents()->GetURL();
     tab_fullscreen_accepted_ = toggled_into_fullscreen_ &&
         GetFullscreenSetting(url) == CONTENT_SETTING_ALLOW;
   } else {
     if (!extension_caused_fullscreen_.is_empty())
       url = extension_caused_fullscreen_;
     content::RecordAction(UserMetricsAction("ToggleFullscreen"));
   }
   if (toggled_into_fullscreen_) {
     window_->EnterFullscreen(url, GetFullscreenExitBubbleType());
   } else {
     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.
 }