Remove unneeded TabContents::FromWebContents.

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.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_tabstrip.h"
 #include "chrome/browser/ui/browser_window.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/navigation_details.h"
 #include "content/public/browser/navigation_entry.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"
@@ skipping 29 matching lines @@
   extension_caused_fullscreen_ = GURL();
   ToggleFullscreenModeInternal(false);
 }
 
 bool FullscreenController::IsFullscreenForTabOrPending() const {
   return fullscreened_tab_ != NULL;
 }
 
 bool FullscreenController::IsFullscreenForTabOrPending(
     const WebContents* web_contents) const {
-  const TabContents* tab_contents =
-      TabContents::FromWebContents(web_contents);
-  if (!tab_contents || (tab_contents != fullscreened_tab_))
+  if (web_contents != fullscreened_tab_)
     return false;
   DCHECK(web_contents == chrome::GetActiveWebContents(browser_));
   return true;
 }
 
 void FullscreenController::ToggleFullscreenModeForTab(WebContents* web_contents,
                                                       bool enter_fullscreen) {
   if (web_contents != chrome::GetActiveWebContents(browser_))
     return;
 
 #if defined(OS_WIN)
   // For now, avoid breaking when initiating full screen tab mode while in
   // a metro snap.
   // TODO(robertshield): Find a way to reconcile tab-initiated fullscreen
   //                     modes with metro snap.
   if (IsInMetroSnapMode())
     return;
 #endif
 
   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) {
-    SetFullscreenedTab(TabContents::FromWebContents(web_contents));
+    SetFullscreenedTab(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.
@@ skipping 85 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(TabContents::FromWebContents(web_contents));
+  SetMouseLockTab(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.
@@ skipping 17 matching lines @@
     case CONTENT_SETTING_ASK:
       mouse_lock_state_ = MOUSELOCK_REQUESTED;
       break;
     default:
       NOTREACHED();
   }
   UpdateFullscreenExitBubbleContent();
 }
 
 void FullscreenController::OnTabDeactivated(WebContents* web_contents) {
-  const TabContents* contents = TabContents::FromWebContents(web_contents);
-  if (contents &&
-      (contents == fullscreened_tab_ || contents == mouse_lock_tab_)) {
+  if (web_contents == fullscreened_tab_ || web_contents == mouse_lock_tab_)
     ExitTabFullscreenOrMouseLockIfNecessary();
-  }
 }
 
 void FullscreenController::OnTabClosing(WebContents* web_contents) {
-  const TabContents* contents = TabContents::FromWebContents(web_contents);
-  if (contents &&
-      (contents == fullscreened_tab_ || contents == mouse_lock_tab_)) {
+  if (web_contents == fullscreened_tab_ || web_contents == mouse_lock_tab_) {
     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();
   }
 }
 
@@ skipping 42 matching lines @@
     DCHECK(IsMouseLockRequested());
     // TODO(markusheintz): We should allow patterns for all possible URLs here.
     if (pattern.IsValid()) {
       settings_map->SetContentSetting(
           pattern, ContentSettingsPattern::Wildcard(),
           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_tab_->GotResponseToLockMouseRequest(true)) {
       mouse_lock_state_ = MOUSELOCK_ACCEPTED;
     } else {
       mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
       SetMouseLockTab(NULL);
     }
     NotifyMouseLockChange();
   }
 
   if (fullscreen && !tab_fullscreen_accepted_) {
     DCHECK(fullscreened_tab_);
@@ skipping 14 matching lines @@
   bool fullscreen = false;
   fullscreen_bubble::PermissionRequestedByType(bubble_type, &fullscreen,
                                                &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);
+    if (mouse_lock_tab_)
+      mouse_lock_tab_->GotResponseToLockMouseRequest(false);
     SetMouseLockTab(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();
   }
 
@@ skipping 69 matching lines @@
     }
   }
   NOTREACHED();
   return FEB_TYPE_NONE;
 }
 
 void FullscreenController::UpdateNotificationRegistrations() {
   if (fullscreened_tab_ && mouse_lock_tab_)
     DCHECK(fullscreened_tab_ == mouse_lock_tab_);
 
-  TabContents* tab = fullscreened_tab_ ? 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,
-        content::Source<content::NavigationController>(
-            &tab->web_contents()->GetController()));
+        content::Source<content::NavigationController>(&tab->GetController()));
   } else if (!tab && !registrar_.IsEmpty()) {
     registrar_.RemoveAll();
   }
 }
 
 void FullscreenController::PostFullscreenChangeNotification(
     bool is_fullscreen) {
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&FullscreenController::NotifyFullscreenChange,
           ptr_factory_.GetWeakPtr(), is_fullscreen));
 }
 
 void FullscreenController::NotifyFullscreenChange(bool is_fullscreen) {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_FULLSCREEN_CHANGED,
       content::Source<FullscreenController>(this),
       content::Details<bool>(&is_fullscreen));
 }
 
 void FullscreenController::NotifyTabOfExitIfNecessary() {
   if (fullscreened_tab_) {
-    RenderViewHost* rvh =
-        fullscreened_tab_->web_contents()->GetRenderViewHost();
+    RenderViewHost* rvh = fullscreened_tab_->GetRenderViewHost();
     SetFullscreenedTab(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);
+      mouse_lock_tab_->GotResponseToLockMouseRequest(false);
       NotifyMouseLockChange();
-    } else if (web_contents->GetRenderViewHost() &&
-               web_contents->GetRenderViewHost()->GetView()) {
-      web_contents->GetRenderViewHost()->GetView()->UnlockMouse();
+    } else if (mouse_lock_tab_->GetRenderViewHost() &&
+               mouse_lock_tab_->GetRenderViewHost()->GetView()) {
+      mouse_lock_tab_->GetRenderViewHost()->GetView()->UnlockMouse();
     }
     SetMouseLockTab(NULL);
     mouse_lock_state_ = MOUSELOCK_NOT_REQUESTED;
   }
 
   UpdateFullscreenExitBubbleContent();
 }
 
 void FullscreenController::NotifyMouseLockChange() {
   content::NotificationService::current()->Notify(
@@ skipping 60 matching lines @@
     window_->EnterPresentationMode(url, GetFullscreenExitBubbleType());
   else
     window_->ExitFullscreen();
   UpdateFullscreenExitBubbleContent();
 
   // WindowFullscreenStateChanged will be called by BrowserWindowController
   // when the transition completes.
 }
 #endif
 
-void FullscreenController::SetFullscreenedTab(TabContents* tab) {
+void FullscreenController::SetFullscreenedTab(WebContents* tab) {
   fullscreened_tab_ = tab;
   UpdateNotificationRegistrations();
 }
 
-void FullscreenController::SetMouseLockTab(TabContents* tab) {
+void FullscreenController::SetMouseLockTab(WebContents* tab) {
   mouse_lock_tab_ = tab;
   UpdateNotificationRegistrations();
 }
 
 void FullscreenController::ExitTabFullscreenOrMouseLockIfNecessary() {
   if (tab_caused_fullscreen_)
     ToggleFullscreenMode();
   else
     NotifyTabOfExitIfNecessary();
 }
 
 void FullscreenController::UpdateFullscreenExitBubbleContent() {
   GURL url;
   if (fullscreened_tab_)
-    url = fullscreened_tab_->web_contents()->GetURL();
+    url = fullscreened_tab_->GetURL();
   else if (mouse_lock_tab_)
-    url = mouse_lock_tab_->web_contents()->GetURL();
+    url = mouse_lock_tab_->GetURL();
   else if (!extension_caused_fullscreen_.is_empty())
     url = extension_caused_fullscreen_;
 
   FullscreenExitBubbleType bubble_type = GetFullscreenExitBubbleType();
 
   // If bubble displays buttons, unlock mouse to allow pressing them.
   if (fullscreen_bubble::ShowButtonsForType(bubble_type) &&
       IsMouseLocked() &&
-      mouse_lock_tab_->web_contents()) {
-    WebContents* web_contents = mouse_lock_tab_->web_contents();
-    if (web_contents && web_contents->GetRenderViewHost() &&
-        web_contents->GetRenderViewHost()->GetView())
-      web_contents->GetRenderViewHost()->GetView()->UnlockMouse();
+      mouse_lock_tab_ &&
+      mouse_lock_tab_->GetRenderViewHost() &&
+      mouse_lock_tab_->GetRenderViewHost()->GetView()) {
+    mouse_lock_tab_->GetRenderViewHost()->GetView()->UnlockMouse();
   }
 
   window_->UpdateFullscreenExitBubbleContent(url, bubble_type);
 }
 
 ContentSetting
-    FullscreenController::GetFullscreenSetting(const GURL& url) const {
+FullscreenController::GetFullscreenSetting(const GURL& url) const {
   if (url.SchemeIsFile())
     return CONTENT_SETTING_ALLOW;
 
   return profile_->GetHostContentSettingsMap()->GetContentSetting(url, url,
       CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string());
 }
 
 ContentSetting
-    FullscreenController::GetMouseLockSetting(const GURL& url) const {
+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());
 }