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

chrome/browser/gtk/tabs/tab_strip_gtk.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/gtk/tabs/tab_strip_gtk.h"
 
 #include <algorithm>
 
 #include "app/gtk_dnd_util.h"
 #include "app/resource_bundle.h"
 #include "app/slide_animation.h"
 #include "base/i18n/rtl.h"
 #include "base/string_util.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/gtk/browser_window_gtk.h"
 #include "chrome/browser/gtk/custom_button.h"
 #include "chrome/browser/gtk/gtk_theme_provider.h"
 #include "chrome/browser/gtk/gtk_util.h"
 #include "chrome/browser/gtk/tabs/dragged_tab_controller_gtk.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
+#include "chrome/browser/tab_contents_wrapper.h"
 #include "chrome/browser/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/themes/browser_theme_provider.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "gfx/gtk_util.h"
 #include "gfx/point.h"
 #include "grit/app_resources.h"
 #include "grit/theme_resources.h"
@@ skipping 773 matching lines @@
   bounds_ = bounds;
 }
 
 void TabStripGtk::UpdateLoadingAnimations() {
   for (int i = 0, index = 0; i < GetTabCount(); ++i, ++index) {
     TabGtk* current_tab = GetTabAt(i);
     if (current_tab->closing()) {
       --index;
     } else {
       TabRendererGtk::AnimationState state;
-      TabContents* contents = model_->GetTabContentsAt(index);
-      if (!contents || !contents->is_loading()) {
+      TabContentsWrapper* contents = model_->GetTabContentsAt(index);
+      if (!contents || !contents->tab_contents()->is_loading()) {
         state = TabGtk::ANIMATION_NONE;
-      } else if (contents->waiting_for_response()) {
+      } else if (contents->tab_contents()->waiting_for_response()) {
         state = TabGtk::ANIMATION_WAITING;
       } else {
         state = TabGtk::ANIMATION_LOADING;
       }
       if (current_tab->ValidateLoadingAnimation(state)) {
         // Queue the tab's icon area to be repainted.
         gfx::Rect favicon_bounds = current_tab->favicon_bounds();
         gtk_widget_queue_draw_area(tabstrip_.get(),
             favicon_bounds.x() + current_tab->x(),
             favicon_bounds.y() + current_tab->y(),
@@ skipping 88 matching lines @@
       }
     }
   }
 
   return NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabStripGtk, TabStripModelObserver implementation:
 
-void TabStripGtk::TabInsertedAt(TabContents* contents,
+void TabStripGtk::TabInsertedAt(TabContentsWrapper* contents,
                                 int index,
                                 bool foreground) {
   DCHECK(contents);
   DCHECK(index == TabStripModel::kNoTab || model_->ContainsIndex(index));
 
   StopAnimation();
 
   bool contains_tab = false;
   TabGtk* tab = NULL;
   // First see if this Tab is one that was dragged out of this TabStrip and is
   // now being dragged back in. In this case, the DraggedTabController actually
   // has the Tab already constructed and we can just insert it into our list
   // again.
   if (IsDragSessionActive()) {
-    tab = drag_controller_->GetDragSourceTabForContents(contents);
+    tab = drag_controller_->GetDragSourceTabForContents(
+        contents->tab_contents());
     if (tab) {
       // If the Tab was detached, it would have been animated closed but not
       // removed, so we need to reset this property.
       tab->set_closing(false);
       tab->ValidateLoadingAnimation(TabRendererGtk::ANIMATION_NONE);
       tab->SetVisible(true);
     }
 
     // See if we're already in the list. We don't want to add ourselves twice.
     std::vector<TabData>::const_iterator iter = tab_data_.begin();
     for (; iter != tab_data_.end() && !contains_tab; ++iter) {
       if (iter->tab == tab)
         contains_tab = true;
     }
   }
 
   if (!tab)
     tab = new TabGtk(this);
 
   // Only insert if we're not already in the list.
   if (!contains_tab) {
     TabData d = { tab, gfx::Rect() };
     tab_data_.insert(tab_data_.begin() + index, d);
-    tab->UpdateData(contents, model_->IsAppTab(index), false);
+    tab->UpdateData(contents->tab_contents(), model_->IsAppTab(index), false);
   }
   tab->set_mini(model_->IsMiniTab(index));
   tab->set_app(model_->IsAppTab(index));
   tab->SetBlocked(model_->IsTabBlocked(index));
 
   if (gtk_widget_get_parent(tab->widget()) != tabstrip_.get())
     gtk_fixed_put(GTK_FIXED(tabstrip_.get()), tab->widget(), 0, 0);
 
   // Don't animate the first tab; it looks weird.
   if (GetTabCount() > 1) {
     StartInsertTabAnimation(index);
     // We added the tab at 0x0, we need to force an animation step otherwise
     // if GTK paints before the animation event the tab is painted at 0x0
     // which is most likely not where it should be positioned.
     active_animation_->AnimationProgressed(NULL);
   } else {
     Layout();
   }
 }
 
-void TabStripGtk::TabDetachedAt(TabContents* contents, int index) {
+void TabStripGtk::TabDetachedAt(TabContentsWrapper* contents, int index) {
   GenerateIdealBounds();
-  StartRemoveTabAnimation(index, contents);
+  StartRemoveTabAnimation(index, contents->tab_contents());
   // Have to do this _after_ calling StartRemoveTabAnimation, so that any
   // previous remove is completed fully and index is valid in sync with the
   // model index.
   GetTabAt(index)->set_closing(true);
 }
 
-void TabStripGtk::TabSelectedAt(TabContents* old_contents,
-                                TabContents* new_contents,
+void TabStripGtk::TabSelectedAt(TabContentsWrapper* old_contents,
+                                TabContentsWrapper* new_contents,
                                 int index,
                                 bool user_gesture) {
   DCHECK(index >= 0 && index < static_cast<int>(GetTabCount()));
 
   // We have "tiny tabs" if the tabs are so tiny that the unselected ones are
   // a different size to the selected ones.
   bool tiny_tabs = current_unselected_width_ != current_selected_width_;
   if (!IsAnimating() && (!needs_resize_layout_ || tiny_tabs))
     Layout();
 
   GetTabAt(index)->SchedulePaint();
 
   int old_index = model_->GetIndexOfTabContents(old_contents);
   if (old_index >= 0) {
     GetTabAt(old_index)->SchedulePaint();
     GetTabAt(old_index)->StopMiniTabTitleAnimation();
   }
 }
 
-void TabStripGtk::TabMoved(TabContents* contents,
+void TabStripGtk::TabMoved(TabContentsWrapper* contents,
                            int from_index,
                            int to_index) {
   gfx::Rect start_bounds = GetIdealBounds(from_index);
   TabGtk* tab = GetTabAt(from_index);
   tab_data_.erase(tab_data_.begin() + from_index);
   TabData data = {tab, gfx::Rect()};
   tab->set_mini(model_->IsMiniTab(to_index));
   tab->SetBlocked(model_->IsTabBlocked(to_index));
   tab_data_.insert(tab_data_.begin() + to_index, data);
   GenerateIdealBounds();
   StartMoveTabAnimation(from_index, to_index);
 }
 
-void TabStripGtk::TabChangedAt(TabContents* contents, int index,
+void TabStripGtk::TabChangedAt(TabContentsWrapper* contents, int index,
                                TabChangeType change_type) {
   // Index is in terms of the model. Need to make sure we adjust that index in
   // case we have an animation going.
   TabGtk* tab = GetTabAtAdjustForAnimation(index);
   if (change_type == TITLE_NOT_LOADING) {
     if (tab->mini() && !tab->IsSelected())
       tab->StartMiniTabTitleAnimation();
     // We'll receive another notification of the change asynchronously.
     return;
   }
-  tab->UpdateData(contents,
+  tab->UpdateData(contents->tab_contents(),
                   model_->IsAppTab(index),
                   change_type == LOADING_ONLY);
   tab->UpdateFromModel();
 }
 
-void TabStripGtk::TabReplacedAt(TabContents* old_contents,
-                                TabContents* new_contents,
+void TabStripGtk::TabReplacedAt(TabContentsWrapper* old_contents,
+                                TabContentsWrapper* new_contents,
                                 int index) {
   TabChangedAt(new_contents, index, ALL);
 }
 
-void TabStripGtk::TabMiniStateChanged(TabContents* contents, int index) {
+void TabStripGtk::TabMiniStateChanged(TabContentsWrapper* contents, int index) {
   // Don't do anything if we've already picked up the change from TabMoved.
   if (GetTabAt(index)->mini() == model_->IsMiniTab(index))
     return;
 
   GetTabAt(index)->set_mini(model_->IsMiniTab(index));
   // Don't animate if the window isn't visible yet. The window won't be visible
   // when dragging a mini-tab to a new window.
   if (window_ && window_->window() &&
       GTK_WIDGET_VISIBLE(GTK_WIDGET(window_->window()))) {
     StartMiniTabAnimation(index);
   } else {
     Layout();
   }
 }
 
-void TabStripGtk::TabBlockedStateChanged(TabContents* contents, int index) {
+void TabStripGtk::TabBlockedStateChanged(TabContentsWrapper* contents,
+                                         int index) {
   GetTabAt(index)->SetBlocked(model_->IsTabBlocked(index));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabStripGtk, TabGtk::TabDelegate implementation:
 
 bool TabStripGtk::IsTabSelected(const TabGtk* tab) const {
   if (tab->closing())
     return false;
 
@@ skipping 887 matching lines @@
     case 1:
       model_->delegate()->AddBlankTab(true);
       break;
     case 2: {
       // On middle-click, try to parse the PRIMARY selection as a URL and load
       // it instead of creating a blank page.
       GURL url;
       if (!gtk_util::URLFromPrimarySelection(model_->profile(), &url))
         return;
 
+<<<<<<< .mine
+      TabContentsWrapper* contents =
+          model_->delegate()->CreateTabContentsForURL(
+              url,
+              GURL(),  // referrer
+              model_->profile(),
+              PageTransition::TYPED,
+              false,   // defer_load
+              NULL);   // instance
+      model_->AddTabContents(
+          contents,
+          -1,     // index
+          PageTransition::TYPED,
+          TabStripModel::ADD_SELECTED);
+=======
       Browser* browser = window_->browser();
       DCHECK(browser);
       browser->AddSelectedTabWithURL(url, PageTransition::TYPED);
+>>>>>>> .r66288
       break;
     }
     default:
       NOTREACHED() << "Got click on new tab button with unhandled mouse "
                    << "button " << mouse_button;
   }
 }
 
 void TabStripGtk::SetTabBounds(TabGtk* tab, const gfx::Rect& bounds) {
   gfx::Rect bds = bounds;
@@ skipping 35 matching lines @@
 
   // Let the middle mouse button initiate clicks as well.
   gtk_util::SetButtonTriggersNavigation(button->widget());
   g_signal_connect(button->widget(), "clicked",
                    G_CALLBACK(OnNewTabClickedThunk), this);
   GTK_WIDGET_UNSET_FLAGS(button->widget(), GTK_CAN_FOCUS);
   gtk_fixed_put(GTK_FIXED(tabstrip_.get()), button->widget(), 0, 0);
 
   return button;
 }