TabContentsWrapper -> TabContents, part 48.

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 19 matching lines @@
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/speech/extension_api/tts_extension_api.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/ui/app_modal_dialogs/app_modal_dialog_queue.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_list.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_menu_model.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/accessibility/invert_bubble_view.h"
 #include "chrome/browser/ui/views/avatar_menu_bubble_view.h"
 #include "chrome/browser/ui/views/avatar_menu_button.h"
 #include "chrome/browser/ui/views/bookmarks/bookmark_bar_view.h"
 #include "chrome/browser/ui/views/browser_dialogs.h"
 #include "chrome/browser/ui/views/download/download_in_progress_dialog_view.h"
 #include "chrome/browser/ui/views/download/download_shelf_view.h"
@@ skipping 147 matching lines @@
 void BookmarkExtensionBackground::Paint(gfx::Canvas* canvas,
                                         views::View* view) const {
   ui::ThemeProvider* tp = host_view_->GetThemeProvider();
   int toolbar_overlap = host_view_->GetToolbarOverlap();
   // The client edge is drawn below the toolbar bounds.
   if (toolbar_overlap)
     toolbar_overlap += views::NonClientFrameView::kClientEdgeThickness;
   if (host_view_->IsDetached()) {
     // Draw the background to match the new tab page.
     int height = 0;
-    WebContents* contents = browser_->GetSelectedWebContents();
+    WebContents* contents = browser_->GetActiveWebContents();
     if (contents && contents->GetView())
       height = contents->GetView()->GetContainerSize().height();
     NtpBackgroundUtil::PaintBackgroundDetachedMode(
         host_view_->GetThemeProvider(), canvas,
         gfx::Rect(0, toolbar_overlap, host_view_->width(),
                   host_view_->height() - toolbar_overlap), height);
 
     // As 'hidden' according to the animation is the full in-tab state,
     // we invert the value - when current_state is at '0', we expect the
     // bar to be docked.
@@ skipping 282 matching lines @@
     if (active_browser && (browser_ != active_browser)) {
       active_browser->window()->FlashFrame(true);
       active_browser->window()->Activate();
     }
     AppModalDialogQueue::GetInstance()->ActivateModalDialog();
     return true;
   }
   return false;
 }
 
-WebContents* BrowserView::GetSelectedWebContents() const {
-  return browser_->GetSelectedWebContents();
+WebContents* BrowserView::GetActiveWebContents() const {
+  return browser_->GetActiveWebContents();
 }
 
-TabContentsWrapper* BrowserView::GetSelectedTabContentsWrapper() const {
-  return browser_->GetSelectedTabContentsWrapper();
+TabContents* BrowserView::GetActiveTabContents() const {
+  return browser_->GetActiveTabContents();
 }
 
 gfx::ImageSkia BrowserView::GetOTRAvatarIcon() const {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   const gfx::ImageSkia* otr_avatar =
       rb.GetNativeImageNamed(IDR_OTR_ICON).ToImageSkia();
   return *otr_avatar;
 }
 
 bool BrowserView::IsPositionInWindowCaption(const gfx::Point& point) {
@@ skipping 99 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(browser_->GetSelectedTabContentsWrapper());
+  UpdateUIForContents(browser_->GetActiveTabContents());
   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.
   {
     const LocationIconView* location_icon_view =
         toolbar_->location_bar()->location_icon_view();
     // The +1 in the next line creates a 1-px gap between icon and arrow tip.
@@ skipping 25 matching lines @@
   if (ShouldShowWindowIcon() && !loading_animation_timer_.IsRunning())
     frame_->UpdateWindowIcon();
 }
 
 void BrowserView::BookmarkBarStateChanged(
     BookmarkBar::AnimateChangeType change_type) {
   if (bookmark_bar_view_.get()) {
     bookmark_bar_view_->SetBookmarkBarState(
         browser_->bookmark_bar_state(), change_type);
   }
-  if (MaybeShowBookmarkBar(browser_->GetSelectedTabContentsWrapper()))
+  if (MaybeShowBookmarkBar(browser_->GetActiveTabContents()))
     Layout();
 }
 
 void BrowserView::UpdateDevTools() {
-  UpdateDevToolsForContents(GetSelectedTabContentsWrapper());
+  UpdateDevToolsForContents(GetActiveTabContents());
   Layout();
 }
 
 
 void BrowserView::SetDevToolsDockSide(DevToolsDockSide side) {
   if (devtools_dock_side_ == side)
     return;
 
   if (devtools_container_->visible()) {
     HideDevToolsContainer();
@@ skipping 112 matching lines @@
     } else {
       ProcessFullscreen(true, GURL(),
                         FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION);
     }
   } else {
     ProcessFullscreen(false, GURL(), FEB_TYPE_NONE);
   }
 }
 
 void BrowserView::RestoreFocus() {
-  WebContents* selected_web_contents = GetSelectedWebContents();
+  WebContents* selected_web_contents = GetActiveWebContents();
   if (selected_web_contents)
     selected_web_contents->GetView()->RestoreFocus();
 }
 
 void BrowserView::SetWindowSwitcherButton(views::Button* button) {
   if (window_switcher_button_)
     RemoveChildView(window_switcher_button_);
   window_switcher_button_ = button;
   AddChildView(button);
 }
@@ skipping 22 matching lines @@
     DCHECK(focus_manager);
     focus_manager->ClearFocus();
   }
 }
 
 void BrowserView::UpdateReloadStopState(bool is_loading, bool force) {
   toolbar_->reload_button()->ChangeMode(
       is_loading ? ReloadButton::MODE_STOP : ReloadButton::MODE_RELOAD, force);
 }
 
-void BrowserView::UpdateToolbar(TabContentsWrapper* contents,
+void BrowserView::UpdateToolbar(TabContents* contents,
                                 bool should_restore_state) {
   toolbar_->Update(contents->web_contents(), should_restore_state);
 }
 
 void BrowserView::FocusToolbar() {
   // Start the traversal within the main toolbar. SetPaneFocus stores
   // the current focused view before changing focus.
   toolbar_->SetPaneFocus(NULL);
 }
 
@@ skipping 232 matching lines @@
     download_shelf_->set_owned_by_client();
   }
   return download_shelf_.get();
 }
 
 void BrowserView::ConfirmBrowserCloseWithPendingDownloads() {
   DownloadInProgressDialogView::Show(browser_.get(), GetNativeWindow());
 }
 
 void BrowserView::ShowCreateWebAppShortcutsDialog(
-    TabContentsWrapper* tab_contents) {
+    TabContents* tab_contents) {
   browser::ShowCreateWebAppShortcutsDialog(GetNativeWindow(), tab_contents);
 }
 
 void BrowserView::ShowCreateChromeAppShortcutsDialog(
     Profile* profile,
     const extensions::Extension* app) {
   browser::ShowCreateChromeAppShortcutsDialog(GetNativeWindow(), profile, app);
 }
 
 void BrowserView::UserChangedTheme() {
@@ skipping 11 matching lines @@
 
 void BrowserView::ShowPageInfo(Profile* profile,
                                const GURL& url,
                                const SSLStatus& ssl,
                                bool show_history) {
   browser::ShowPageInfoBubble(GetLocationBarView()->location_icon_view(),
                               profile, url, ssl, show_history, browser_.get());
 }
 
 void BrowserView::ShowWebsiteSettings(Profile* profile,
-                                      TabContentsWrapper* tab_contents_wrapper,
+                                      TabContents* tab_contents,
                                       const GURL& url,
                                       const content::SSLStatus& ssl,
                                       bool show_history) {
   WebsiteSettingsPopupView::ShowPopup(
       GetLocationBarView()->location_icon_view(), profile,
-      tab_contents_wrapper, url, ssl);
+      tab_contents, url, ssl);
 }
 
 void BrowserView::ShowAppMenu() {
   toolbar_->app_menu()->Activate();
 }
 
 bool BrowserView::PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event,
                                          bool* is_keyboard_shortcut) {
   *is_keyboard_shortcut = false;
 
@@ skipping 94 matching lines @@
 void BrowserView::Copy() {
   ui_controls::SendKeyPress(GetNativeWindow(), ui::VKEY_C,
                             true, false, false, false);
 }
 
 void BrowserView::Paste() {
   ui_controls::SendKeyPress(GetNativeWindow(), ui::VKEY_V,
                             true, false, false, false);
 }
 
-void BrowserView::ShowInstant(TabContentsWrapper* preview) {
+void BrowserView::ShowInstant(TabContents* preview) {
   if (!preview_container_) {
     preview_container_ = new views::WebView(browser_->profile());
     preview_container_->set_id(VIEW_ID_TAB_CONTAINER);
   }
   contents_->SetPreview(preview_container_, preview->web_contents());
   preview_container_->SetWebContents(preview->web_contents());
 }
 
 void BrowserView::HideInstant() {
   if (!preview_container_)
@@ skipping 43 matching lines @@
   return contents_container_;
 }
 
 ToolbarView* BrowserView::GetToolbarView() const {
   return toolbar_;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, TabStripModelObserver implementation:
 
-void BrowserView::TabDetachedAt(TabContentsWrapper* contents, int index) {
+void BrowserView::TabDetachedAt(TabContents* contents, int index) {
   // We use index here rather than comparing |contents| because by this time
   // the model has already removed |contents| from its list, so
-  // browser_->GetSelectedWebContents() will return NULL or something else.
+  // browser_->GetActiveWebContents() will return NULL or something else.
   if (index == browser_->active_index()) {
     // We need to reset the current tab contents to NULL before it gets
     // freed. This is because the focus manager performs some operations
     // on the selected WebContents when it is removed.
     contents_container_->SetWebContents(NULL);
     infobar_container_->ChangeTabContents(NULL);
     UpdateDevToolsForContents(NULL);
   }
 }
 
-void BrowserView::TabDeactivated(TabContentsWrapper* contents) {
+void BrowserView::TabDeactivated(TabContents* 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->in_destructor())
     contents->web_contents()->GetView()->StoreFocus();
 }
 
-void BrowserView::ActiveTabChanged(TabContentsWrapper* old_contents,
-                                   TabContentsWrapper* new_contents,
+void BrowserView::ActiveTabChanged(TabContents* old_contents,
+                                   TabContents* new_contents,
                                    int index,
                                    bool user_gesture) {
   ProcessTabSelected(new_contents);
 }
 
 void BrowserView::TabReplacedAt(TabStripModel* tab_strip_model,
-                                TabContentsWrapper* old_contents,
-                                TabContentsWrapper* new_contents,
+                                TabContents* old_contents,
+                                TabContents* new_contents,
                                 int index) {
   if (index != browser_->tab_strip_model()->active_index())
     return;
 
   if (contents_->preview_web_contents() == new_contents->web_contents()) {
     // If 'preview' is becoming active, swap the 'active' and 'preview' and
     // delete what was the active.
     contents_->MakePreviewContentsActiveContents();
     views::WebView* old_container = contents_container_;
     contents_container_ = preview_container_;
@@ skipping 60 matching lines @@
   // For Ash only, app host windows do not show an icon, crbug.com/119411.
   // Child windows (e.g. extension panels, popups) do show an icon.
   if (browser_->is_app() && browser_->app_type() == Browser::APP_TYPE_HOST)
     return false;
 #endif
   return browser_->SupportsWindowFeature(Browser::FEATURE_TITLEBAR);
 }
 
 gfx::ImageSkia BrowserView::GetWindowAppIcon() {
   if (browser_->is_app()) {
-    TabContentsWrapper* contents = browser_->GetSelectedTabContentsWrapper();
+    TabContents* contents = browser_->GetActiveTabContents();
     if (contents && contents->extension_tab_helper()->GetExtensionAppIcon())
       return *contents->extension_tab_helper()->GetExtensionAppIcon();
   }
 
   return GetWindowIcon();
 }
 
 gfx::ImageSkia BrowserView::GetWindowIcon() {
   if (browser_->is_app())
     return browser_->GetCurrentPageIcon();
@@ skipping 124 matching lines @@
     launcher_item_controller_->BrowserActivationStateChanged();
 #endif
 
   if (active) {
     BrowserList::SetLastActive(browser_.get());
     browser_->OnWindowActivated();
   }
 }
 
 void BrowserView::OnWindowBeginUserBoundsChange() {
-  WebContents* web_contents = GetSelectedWebContents();
+  WebContents* web_contents = GetActiveWebContents();
   if (!web_contents)
     return;
   web_contents->GetRenderViewHost()->NotifyMoveOrResizeStarted();
 }
 
 void BrowserView::OnWidgetMove() {
   if (!initialized_) {
     // Creating the widget can trigger a move. Ignore it until we've initialized
     // things.
     return;
@@ skipping 276 matching lines @@
   last_animation_time_ = now;
   if (browser_->is_type_tabbed()) {
     // Loading animations are shown in the tab for tabbed windows.  We check the
     // browser type instead of calling IsTabStripVisible() because the latter
     // will return false for fullscreen windows, but we still need to update
     // their animations (so that when they come out of fullscreen mode they'll
     // be correct).
     tabstrip_->UpdateLoadingAnimations();
   } else if (ShouldShowWindowIcon()) {
     // ... or in the window icon area for popups and app windows.
-    WebContents* web_contents = browser_->GetSelectedWebContents();
-    // GetSelectedWebContents can return NULL for example under Purify when
+    WebContents* web_contents = browser_->GetActiveWebContents();
+    // GetActiveWebContents can return NULL for example under Purify when
     // the animations are running slowly and this function is called on a timer
     // through LoadingAnimationCallback.
     frame_->UpdateThrobber(web_contents && web_contents->IsLoading());
   }
 }
 
 // BrowserView, private --------------------------------------------------------
 
 BrowserViewLayout* BrowserView::GetBrowserViewLayout() const {
   return static_cast<BrowserViewLayout*>(GetLayoutManager());
 }
 
 void BrowserView::LayoutStatusBubble() {
   // In restored mode, the client area has a client edge between it and the
   // frame.
   int overlap = StatusBubbleViews::kShadowThickness;
   // The extra pixels defined by kClientEdgeThickness is only drawn in frame
   // content border on windows for non-aura build.
 #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(TabContentsWrapper* contents) {
+bool BrowserView::MaybeShowBookmarkBar(TabContents* 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()));
       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);
     }
     bookmark_bar_view_->SetPageNavigator(contents->web_contents());
     new_bookmark_bar_view = bookmark_bar_view_.get();
   }
   return UpdateChildViewAndLayout(new_bookmark_bar_view, &active_bookmark_bar_);
 }
 
-bool BrowserView::MaybeShowInfoBar(TabContentsWrapper* contents) {
+bool BrowserView::MaybeShowInfoBar(TabContents* 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(TabContentsWrapper* wrapper) {
+void BrowserView::UpdateDevToolsForContents(TabContents* tab_contents) {
   WebContents* devtools_contents = NULL;
-  if (wrapper) {
-    TabContentsWrapper* devtools_contents_wrapper =
-        DevToolsWindow::GetDevToolsContents(wrapper->web_contents());
-    if (devtools_contents_wrapper)
-      devtools_contents = devtools_contents_wrapper->web_contents();
+  if (tab_contents) {
+    TabContentsWrapper* devtools_tab_contents =
+        DevToolsWindow::GetDevToolsContents(tab_contents->web_contents());
+    if (devtools_tab_contents)
+      devtools_contents = devtools_tab_contents->web_contents();
   }
 
   bool should_show = devtools_contents && !devtools_container_->visible();
   bool should_hide = !devtools_contents && devtools_container_->visible();
 
   devtools_container_->SetWebContents(devtools_contents);
 
   if (should_show)
     ShowDevToolsContainer();
   else if (should_hide)
@@ skipping 50 matching lines @@
       contents_size - contents_split_->divider_offset());
 
   // Restore focus to the last focused view when hiding devtools window.
   devtools_focus_tracker_->FocusLastFocusedExternalView();
 
   devtools_container_->SetVisible(false);
   contents_split_->InvalidateLayout();
   Layout();
 }
 
-void BrowserView::UpdateUIForContents(TabContentsWrapper* contents) {
+void BrowserView::UpdateUIForContents(TabContents* 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 272 matching lines @@
       else if (key_code == ui::VKEY_K)
         content::RecordAction(UserMetricsAction("Accel_FocusSearch_K"));
       break;
     default:
       // Do nothing.
       break;
   }
 #endif
 }
 
-void BrowserView::ProcessTabSelected(TabContentsWrapper* new_contents) {
+void BrowserView::ProcessTabSelected(TabContents* new_contents) {
   // 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.
   DCHECK(new_contents);
   bool change_tab_contents =
       contents_container_->web_contents() != new_contents->web_contents();
 
   // Update various elements that are interested in knowing the current
   // WebContents.
@@ skipping 90 matching lines @@
 void BrowserView::ShowPasswordGenerationBubble(
     const gfx::Rect& rect,
     autofill::PasswordGenerator* password_generator,
     const webkit::forms::PasswordForm& form) {
   // Create a rect in the content bounds that the bubble will point to.
   gfx::Point origin(rect.origin());
   views::View::ConvertPointToScreen(GetTabContentsContainerView(), &origin);
   gfx::Rect bounds(origin, rect.size());
 
   // Create the bubble.
-  WebContents* web_contents = GetSelectedWebContents();
-  TabContentsWrapper* wrapper = GetSelectedTabContentsWrapper();
-  if (!web_contents || !wrapper)
+  TabContents* tab_contents = GetActiveTabContents();
+  if (!tab_contents)
     return;
 
   PasswordGenerationBubbleView* bubble =
-      new PasswordGenerationBubbleView(bounds,
-                                       form,
-                                       this,
-                                       web_contents->GetRenderViewHost(),
-                                       password_generator,
-                                       browser_.get(),
-                                       wrapper->password_manager());
+      new PasswordGenerationBubbleView(
+          bounds,
+          form,
+          this,
+          tab_contents->web_contents()->GetRenderViewHost(),
+          password_generator,
+          browser_.get(),
+          tab_contents->password_manager());
 
   views::BubbleDelegateView::CreateBubble(bubble);
   bubble->SetAlignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
   bubble->Show();
 }