Make pink's TabContentsWrapper change compile on Windows....

chrome/browser/ui/views/frame/browser_view.cc

 // Copyright (c) 2010 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/views/frame/browser_view.h"
 
 #if defined(OS_LINUX)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 19 matching lines @@
 #include "chrome/browser/ntp_background_util.h"
 #include "chrome/browser/page_info_window.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/sidebar/sidebar_container.h"
 #include "chrome/browser/sidebar/sidebar_manager.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
+#include "chrome/browser/tab_contents_wrapper.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/themes/browser_theme_provider.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/view_ids.h"
 #include "chrome/browser/views/accessible_view_helper.h"
 #include "chrome/browser/views/bookmark_bar_view.h"
 #include "chrome/browser/views/browser_dialogs.h"
 #include "chrome/browser/views/default_search_view.h"
 #include "chrome/browser/views/download_shelf_view.h"
 #include "chrome/browser/views/frame/browser_view_layout.h"
@@ skipping 613 matching lines @@
 
 void BrowserView::ActivationChanged(bool activated) {
   if (activated)
     BrowserList::SetLastActive(browser_.get());
 }
 
 TabContents* BrowserView::GetSelectedTabContents() const {
   return browser_->GetSelectedTabContents();
 }
 
+TabContentsWrapper* BrowserView::GetSelectedTabContentsWrapper() const {
+  return browser_->GetSelectedTabContentsWrapper();
+}
+
 SkBitmap BrowserView::GetOTRAvatarIcon() {
   static SkBitmap* otr_avatar_ = new SkBitmap();
 
   if (otr_avatar_->isNull()) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     *otr_avatar_ = *rb.GetBitmapNamed(IDR_OTR_ICON);
   }
   return *otr_avatar_;
 }
 
@@ skipping 84 matching lines @@
   return this;
 }
 
 StatusBubble* BrowserView::GetStatusBubble() {
   return status_bubble_.get();
 }
 
 void BrowserView::SelectedTabToolbarSizeChanged(bool is_animating) {
   if (is_animating) {
     contents_container_->SetFastResize(true);
-    UpdateUIForContents(browser_->GetSelectedTabContents());
+    UpdateUIForContents(browser_->GetSelectedTabContentsWrapper());
     contents_container_->SetFastResize(false);
   } else {
-    UpdateUIForContents(browser_->GetSelectedTabContents());
+    UpdateUIForContents(browser_->GetSelectedTabContentsWrapper());
     // When transitioning from animating to not animating we need to make sure
     // the contents_container_ gets layed out. If we don't do this and the
     // bounds haven't changed contents_container_ won't get a Layout out and
     // we'll end up with a gray rect because the clip wasn't updated.
     contents_container_->InvalidateLayout();
     contents_split_->Layout();
   }
 }
 
 void BrowserView::UpdateTitleBar() {
   frame_->GetWindow()->UpdateWindowTitle();
   if (ShouldShowWindowIcon() && !loading_animation_timer_.IsRunning())
     frame_->GetWindow()->UpdateWindowIcon();
 }
 
 void BrowserView::ShelfVisibilityChanged() {
   Layout();
 }
 
 void BrowserView::UpdateDevTools() {
-  UpdateDevToolsForContents(GetSelectedTabContents());
+  UpdateDevToolsForContents(GetSelectedTabContentsWrapper());
   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.
       loading_animation_timer_.Start(
           TimeDelta::FromMilliseconds(kLoadingAnimationFrameTimeMs), this,
           &BrowserView::LoadingAnimationCallback);
@@ skipping 66 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(TabContents* contents,
+void BrowserView::UpdateToolbar(TabContentsWrapper* contents,
                                 bool should_restore_state) {
-  toolbar_->Update(contents, should_restore_state);
+  toolbar_->Update(contents->tab_contents(), should_restore_state);
 }
 
 void BrowserView::FocusToolbar() {
   // Start the traversal within the main toolbar, passing it the storage id
   // of the view where focus should be returned if the user exits the toolbar.
   SaveFocusedView();
   toolbar_->SetPaneFocus(last_focused_view_storage_id_, NULL);
 }
 
 void BrowserView::FocusBookmarksToolbar() {
@@ skipping 514 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, NotificationObserver implementation:
 
 void BrowserView::Observe(NotificationType type,
                           const NotificationSource& source,
                           const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::PREF_CHANGED:
       if (*Details<std::string>(details).ptr() == prefs::kShowBookmarkBar &&
-          MaybeShowBookmarkBar(browser_->GetSelectedTabContents())) {
+          MaybeShowBookmarkBar(browser_->GetSelectedTabContentsWrapper())) {
         Layout();
       }
       break;
 
     case NotificationType::SIDEBAR_CHANGED:
       if (Details<SidebarContainer>(details)->tab_contents() ==
           browser_->GetSelectedTabContents()) {
         UpdateSidebar();
       }
       break;
 
     default:
       NOTREACHED() << "Got a notification we didn't register for!";
       break;
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, TabStripModelObserver implementation:
 
-void BrowserView::TabDetachedAt(TabContents* contents, int index) {
+void BrowserView::TabDetachedAt(TabContentsWrapper* 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_->GetSelectedTabContents() will return NULL or something else.
   if (index == browser_->tabstrip_model()->selected_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 TabContents when it is removed.
     contents_container_->ChangeTabContents(NULL);
     infobar_container_->ChangeTabContents(NULL);
     UpdateSidebarForContents(NULL);
     UpdateDevToolsForContents(NULL);
   }
 }
 
-void BrowserView::TabDeselectedAt(TabContents* contents, int index) {
+void BrowserView::TabDeselectedAt(TabContentsWrapper* contents, int index) {
   // 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->is_being_destroyed())
+  if (!contents->tab_contents()->is_being_destroyed())
     contents->view()->StoreFocus();
 }
 
-void BrowserView::TabSelectedAt(TabContents* old_contents,
-                                TabContents* new_contents,
+void BrowserView::TabSelectedAt(TabContentsWrapper* old_contents,
+                                TabContentsWrapper* new_contents,
                                 int index,
                                 bool user_gesture) {
   DCHECK(old_contents != new_contents);
 
   ProcessTabSelected(new_contents, true);
 }
 
-void BrowserView::TabReplacedAt(TabContents* old_contents,
-                                TabContents* new_contents,
+void BrowserView::TabReplacedAt(TabContentsWrapper* old_contents,
+                                TabContentsWrapper* new_contents,
                                 int index) {
   if (index != browser_->tabstrip_model()->selected_index())
     return;
 
   // Swap the 'active' and 'preview' and delete what was the active.
   contents_->MakePreviewContentsActiveContents();
   TabContentsContainer* old_container = contents_container_;
   contents_container_ = preview_container_;
   old_container->ChangeTabContents(NULL);
   delete old_container;
@@ skipping 517 matching lines @@
       (IsMaximized() ? 0 : views::NonClientFrameView::kClientEdgeThickness);
   int x = -overlap;
   if (UseVerticalTabs() && IsTabStripVisible())
     x += tabstrip_->bounds().right();
   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(TabContentsWrapper* 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(contents->profile(),
                                                    browser_.get()));
       bookmark_bar_view_->set_parent_owned(false);
       bookmark_bar_view_->set_background(
           new BookmarkExtensionBackground(this, bookmark_bar_view_.get(),
                                           browser_.get()));
     } else {
       bookmark_bar_view_->SetProfile(contents->profile());
     }
-    bookmark_bar_view_->SetPageNavigator(contents);
+    bookmark_bar_view_->SetPageNavigator(contents->tab_contents());
     bookmark_bar_view_->
         SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_BOOKMARKS));
     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(TabContentsWrapper* contents) {
   // TODO(beng): Remove this function once the interface between
   //             InfoBarContainer, DownloadShelfView and TabContents and this
   //             view is sorted out.
   return true;
 }
 
 void BrowserView::UpdateSidebar() {
-  UpdateSidebarForContents(GetSelectedTabContents());
+  UpdateSidebarForContents(GetSelectedTabContentsWrapper());
   Layout();
 }
 
-void BrowserView::UpdateSidebarForContents(TabContents* tab_contents) {
+void BrowserView::UpdateSidebarForContents(TabContentsWrapper* tab_contents) {
   if (!sidebar_container_)
     return;  // Happens when sidebar is not allowed.
   if (!SidebarManager::GetInstance())
     return;  // Happens only in tests.
 
   TabContents* sidebar_contents = NULL;
   if (tab_contents) {
     SidebarContainer* client_host = SidebarManager::GetInstance()->
-        GetActiveSidebarContainerFor(tab_contents);
+        GetActiveSidebarContainerFor(tab_contents->tab_contents());
     if (client_host)
       sidebar_contents = client_host->sidebar_contents();
   }
 
   bool visible = NULL != sidebar_contents &&
                  browser_->SupportsWindowFeature(Browser::FEATURE_SIDEBAR);
 
   bool should_show = visible && !sidebar_container_->IsVisible();
   bool should_hide = !visible && sidebar_container_->IsVisible();
 
@@ skipping 26 matching lines @@
     // Store split offset when hiding sidebar only.
     g_browser_process->local_state()->SetInteger(
         prefs::kExtensionSidebarWidth,
         sidebar_split_->width() - sidebar_split_->divider_offset());
 
     sidebar_container_->SetVisible(false);
     sidebar_split_->Layout();
   }
 }
 
-void BrowserView::UpdateDevToolsForContents(TabContents* tab_contents) {
+void BrowserView::UpdateDevToolsForContents(TabContentsWrapper* wrapper) {
+  TabContents* tab_contents = wrapper ? wrapper->tab_contents() : NULL;
   TabContents* devtools_contents =
       DevToolsWindow::GetDevToolsContents(tab_contents);
 
   bool should_show = devtools_contents && !devtools_container_->IsVisible();
   bool should_hide = !devtools_contents && devtools_container_->IsVisible();
 
   devtools_container_->ChangeTabContents(devtools_contents);
 
   if (should_show) {
     if (!devtools_focus_tracker_.get()) {
@@ skipping 25 matching lines @@
         prefs::kDevToolsSplitLocation, 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_->Layout();
   }
 }
 
-void BrowserView::UpdateUIForContents(TabContents* contents) {
+void BrowserView::UpdateUIForContents(TabContentsWrapper* 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 289 matching lines @@
     ticker_.Start();
 
     pref_service->SetInteger(prefs::kPluginMessageResponseTimeout,
                              plugin_message_response_timeout);
     pref_service->SetInteger(prefs::kHungPluginDetectFrequency,
                              hung_plugin_detect_freq);
   }
 #endif
 }
 
-void BrowserView::ProcessTabSelected(TabContents* new_contents,
+void BrowserView::ProcessTabSelected(TabContentsWrapper* new_contents,
                                      bool change_tab_contents) {
   // Update various elements that are interested in knowing the current
   // TabContents.
 
   // When we toggle the NTP floating bookmarks bar and/or the info bar,
   // we don't want any TabContents to be attached, so that we
   // avoid an unnecessary resize and re-layout of a TabContents.
   if (change_tab_contents)
     contents_container_->ChangeTabContents(NULL);
-  infobar_container_->ChangeTabContents(new_contents);
+  infobar_container_->ChangeTabContents(new_contents->tab_contents());
   UpdateUIForContents(new_contents);
   if (change_tab_contents)
-    contents_container_->ChangeTabContents(new_contents);
+    contents_container_->ChangeTabContents(new_contents->tab_contents());
   UpdateSidebarForContents(new_contents);
 
   UpdateDevToolsForContents(new_contents);
   // TODO(beng): This should be called automatically by ChangeTabContents, but I
   //             am striving for parity now rather than cleanliness. This is
   //             required to make features like Duplicate Tab, Undo Close Tab,
   //             etc not result in sad tab.
-  new_contents->DidBecomeSelected();
+  new_contents->tab_contents()->DidBecomeSelected();
   if (BrowserList::GetLastActive() == browser_ &&
       !browser_->tabstrip_model()->closing_all() && GetWindow()->IsVisible()) {
     // We only restore focus if our window is visible, to avoid invoking blur
     // handlers when we are eventually shown.
     new_contents->view()->RestoreFocus();
   }
 
   // Update all the UI bits.
   UpdateTitleBar();
   UpdateToolbar(new_contents, true);
@@ skipping 12 matching lines @@
       SetAccessibleName(l10n_util::GetString(IDS_PRODUCT_NAME));
 
   return view;
 }
 #endif
 
 // static
 FindBar* BrowserWindow::CreateFindBar(Browser* browser) {
   return browser::CreateFindBar(static_cast<BrowserView*>(browser->window()));
 }