Remove TabContents from TabStripModelObserver::ActiveTabChanged.

chrome/browser/ui/views/frame/browser_view.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/views/frame/browser_view.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 677 matching lines @@
     frame_->UpdateWindowIcon();
 }
 
 void BrowserView::BookmarkBarStateChanged(
     BookmarkBar::AnimateChangeType change_type) {
   if (bookmark_bar_view_.get()) {
     bookmark_bar_view_->SetBookmarkBarState(
         browser_->bookmark_bar_state(), change_type,
         browser_->search_model()->mode());
   }
-  if (MaybeShowBookmarkBar(GetActiveTabContents()))
+  if (MaybeShowBookmarkBar(GetActiveWebContents()))
     Layout();
 }
 
 void BrowserView::UpdateDevTools() {
-  UpdateDevToolsForContents(GetActiveTabContents());
+  UpdateDevToolsForContents(GetActiveWebContents());
   Layout();
 }
 
 
 void BrowserView::UpdateLoadingAnimations(bool should_animate) {
   if (should_animate) {
     if (!loading_animation_timer_.IsRunning()) {
       // Loads are happening, and the timer isn't running, so start it.
       last_animation_time_ = base::TimeTicks::Now();
       loading_animation_timer_.Start(FROM_HERE,
@@ skipping 134 matching lines @@
   // early-return in this case because we need to layout again so the infobar
   // container's bounds are set correctly.
   static CallState call_state = NORMAL;
 
   // A reentrant call can (and should) use the fast resize path unless both it
   // and the normal call are both non-animating.
   bool use_fast_resize =
       is_animating || (call_state == REENTRANT_FORCE_FAST_RESIZE);
   if (use_fast_resize)
     contents_container_->SetFastResize(true);
-  UpdateUIForContents(GetActiveTabContents());
+  UpdateUIForContents(GetActiveWebContents());
   if (use_fast_resize)
     contents_container_->SetFastResize(false);
 
   // Inform the InfoBarContainer that the distance to the location icon may have
   // changed.  We have to do this after the block above so that the toolbars are
   // laid out correctly for calculating the maximum arrow height below.
   {
     int top_arrow_height = 0;
     // Hide the arrows on the Instant Extended NTP.
     if (!chrome::search::IsInstantExtendedAPIEnabled(browser()->profile()) ||
@@ skipping 547 matching lines @@
 }
 
 void BrowserView::TabDeactivated(WebContents* contents) {
   // We do not store the focus when closing the tab to work-around bug 4633.
   // Some reports seem to show that the focus manager and/or focused view can
   // be garbage at that point, it is not clear why.
   if (!contents->IsBeingDestroyed())
     contents->GetView()->StoreFocus();
 }
 
-void BrowserView::ActiveTabChanged(TabContents* old_contents,
-                                   TabContents* new_contents,
+void BrowserView::ActiveTabChanged(content::WebContents* old_contents,
+                                   content::WebContents* new_contents,
                                    int index,
                                    bool user_gesture) {
   DCHECK(new_contents);
 
   // See if the Instant preview is being activated (committed).
-  if (contents_->preview_web_contents() == new_contents->web_contents()) {
+  if (contents_->preview_web_contents() == new_contents) {
     contents_->MakePreviewContentsActiveContents();
     views::WebView* old_container = contents_container_;
     contents_container_ = preview_controller_->release_preview_container();
     old_container->SetWebContents(NULL);
     delete old_container;
   }
 
   // If |contents_container_| already has the correct WebContents, we can save
   // some work.  This also prevents extra events from being reported by the
   // Visibility API under Windows, as ChangeWebContents will briefly hide
   // the WebContents window.
   bool change_tab_contents =
-      contents_container_->web_contents() != new_contents->web_contents();
+      contents_container_->web_contents() != new_contents;
 
   // Update various elements that are interested in knowing the current
   // WebContents.
 
   // When we toggle the NTP floating bookmarks bar and/or the info bar,
   // we don't want any WebContents to be attached, so that we
   // avoid an unnecessary resize and re-layout of a WebContents.
   if (change_tab_contents)
     contents_container_->SetWebContents(NULL);
   InfoBarTabHelper* new_infobar_tab_helper =
-      InfoBarTabHelper::FromWebContents(new_contents->web_contents());
+      InfoBarTabHelper::FromWebContents(new_contents);
   infobar_container_->ChangeTabContents(new_infobar_tab_helper);
   if (bookmark_bar_view_.get()) {
     bookmark_bar_view_->SetBookmarkBarState(
         browser_->bookmark_bar_state(),
         BookmarkBar::DONT_ANIMATE_STATE_CHANGE,
         browser_->search_model()->mode());
   }
   UpdateUIForContents(new_contents);
 
   // Layout for DevTools _before_ setting the main WebContents to avoid
   // toggling the size of the main WebContents.
   UpdateDevToolsForContents(new_contents);
 
   if (change_tab_contents) {
-    contents_container_->SetWebContents(new_contents->web_contents());
+    contents_container_->SetWebContents(new_contents);
 #if defined(USE_AURA)
     // Put the Instant preview back on top in case it is showing custom new tab
     // page content.
     if (contents_->preview_web_contents()) {
       ui::Layer* preview_layer =
           contents_->preview_web_contents()->GetNativeView()->layer();
       preview_layer->parent()->StackAtTop(preview_layer);
     }
 #endif
   }
 
   if (!browser_->tab_strip_model()->closing_all() && GetWidget()->IsActive() &&
       GetWidget()->IsVisible()) {
     // We only restore focus if our window is visible, to avoid invoking blur
     // handlers when we are eventually shown.
-    new_contents->web_contents()->GetView()->RestoreFocus();
+    new_contents->GetView()->RestoreFocus();
   }
 
   // Update all the UI bits.
   UpdateTitleBar();
 
   MaybeStackBookmarkBarAtTop();
 
   // No need to update Toolbar because it's already updated in
   // browser.cc.
 }
@@ skipping 562 matching lines @@
 #if !defined(USE_ASH)
   overlap +=
       IsMaximized() ? 0 : views::NonClientFrameView::kClientEdgeThickness;
 #endif
   int height = status_bubble_->GetPreferredSize().height();
   int contents_height = status_bubble_->base_view()->bounds().height();
   gfx::Point origin(-overlap, contents_height - height + overlap);
   status_bubble_->SetBounds(origin.x(), origin.y(), width() / 3, height);
 }
 
-bool BrowserView::MaybeShowBookmarkBar(TabContents* contents) {
+bool BrowserView::MaybeShowBookmarkBar(WebContents* contents) {
   views::View* new_bookmark_bar_view = NULL;
   if (browser_->SupportsWindowFeature(Browser::FEATURE_BOOKMARKBAR) &&
       contents) {
     if (!bookmark_bar_view_.get()) {
       bookmark_bar_view_.reset(new BookmarkBarView(browser_.get(), this));
       bookmark_bar_view_->set_owned_by_client();
       bookmark_bar_view_->set_background(
           new BookmarkExtensionBackground(this, bookmark_bar_view_.get(),
                                           browser_.get()));
       bookmark_bar_view_->SetBookmarkBarState(
           browser_->bookmark_bar_state(),
           BookmarkBar::DONT_ANIMATE_STATE_CHANGE,
           browser_->search_model()->mode());
     }
-    bookmark_bar_view_->SetPageNavigator(contents->web_contents());
+    bookmark_bar_view_->SetPageNavigator(contents);
     new_bookmark_bar_view = bookmark_bar_view_.get();
   }
   return UpdateChildViewAndLayout(new_bookmark_bar_view, &active_bookmark_bar_);
 }
 
-bool BrowserView::MaybeShowInfoBar(TabContents* contents) {
+bool BrowserView::MaybeShowInfoBar(WebContents* contents) {
   // TODO(beng): Remove this function once the interface between
   //             InfoBarContainer, DownloadShelfView and WebContents and this
   //             view is sorted out.
   return true;
 }
 
-void BrowserView::UpdateDevToolsForContents(TabContents* tab_contents) {
-  DevToolsWindow* new_devtools_window = tab_contents ?
-      DevToolsWindow::GetDockedInstanceForInspectedTab(
-          tab_contents->web_contents()) : NULL;
+void BrowserView::UpdateDevToolsForContents(WebContents* web_contents) {
+  DevToolsWindow* new_devtools_window = web_contents ?
+      DevToolsWindow::GetDockedInstanceForInspectedTab(web_contents) : NULL;
   // Fast return in case of the same window having same orientation.
   if (devtools_window_ == new_devtools_window) {
     if (!new_devtools_window ||
         (new_devtools_window->dock_side() == devtools_dock_side_)) {
       return;
     }
   }
 
   // Replace tab contents.
   if (devtools_window_ != new_devtools_window) {
@@ skipping 63 matching lines @@
     int split_offset = contents_split_->width() -
         devtools_window_->GetWidth(contents_split_->width());
     contents_split_->set_divider_offset(split_offset);
   } else {
     int split_offset = contents_split_->height() -
         devtools_window_->GetHeight(contents_split_->height());
     contents_split_->set_divider_offset(split_offset);
   }
 }
 
-void BrowserView::UpdateUIForContents(TabContents* contents) {
+void BrowserView::UpdateUIForContents(WebContents* contents) {
   bool needs_layout = MaybeShowBookmarkBar(contents);
   needs_layout |= MaybeShowInfoBar(contents);
   if (needs_layout)
     Layout();
 }
 
 bool BrowserView::UpdateChildViewAndLayout(views::View* new_view,
                                            views::View** old_view) {
   DCHECK(old_view);
   if (*old_view == new_view) {
@@ skipping 389 matching lines @@
     modal_browser->window()->Activate();
   }
 
   AppModalDialogQueue::GetInstance()->ActivateModalDialog();
 }
 
 void BrowserView::MaybeStackBookmarkBarAtTop() {
   if (bookmark_bar_view_.get())
     bookmark_bar_view_->MaybeStackAtTop();
 }