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

chrome/browser/ui/views/tabs/browser_tab_strip_controller.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/tabs/browser_tab_strip_controller.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
+#include "chrome/browser/tab_contents_wrapper.h"
 #include "chrome/browser/tab_menu_model.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/views/tabs/base_tab_strip.h"
 #include "chrome/browser/views/tabs/tab_renderer_data.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/url_constants.h"
 #include "views/controls/menu/menu_2.h"
 #include "views/widget/widget.h"
@@ skipping 169 matching lines @@
   return model_->ContainsIndex(model_index) && model_->IsTabPinned(model_index);
 }
 
 bool BrowserTabStripController::IsTabCloseable(int model_index) const {
   return !model_->ContainsIndex(model_index) ||
       model_->delegate()->CanCloseTab();
 }
 
 bool BrowserTabStripController::IsNewTabPage(int model_index) const {
   return model_->ContainsIndex(model_index) &&
-      model_->GetTabContentsAt(model_index)->GetURL() ==
+      model_->GetTabContentsAt(model_index)->tab_contents()->GetURL() ==
       GURL(chrome::kChromeUINewTabURL);
 }
 
 void BrowserTabStripController::SelectTab(int model_index) {
   model_->SelectTabContentsAt(model_index, true);
 }
 
 void BrowserTabStripController::CloseTab(int model_index) {
   tabstrip_->PrepareForCloseAt(model_index);
   model_->CloseTabContentsAt(model_index,
                              TabStripModel::CLOSE_USER_GESTURE |
                              TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
 }
 
 void BrowserTabStripController::ShowContextMenu(BaseTab* tab,
                                                 const gfx::Point& p) {
   context_menu_contents_.reset(new TabContextMenuContents(tab, this));
   context_menu_contents_->RunMenuAt(p);
 }
 
 void BrowserTabStripController::UpdateLoadingAnimations() {
   // Don't use the model count here as it's possible for this to be invoked
   // before we've applied an update from the model (Browser::TabInsertedAt may
   // be processed before us and invokes this).
   for (int tab_index = 0, tab_count = tabstrip_->tab_count();
        tab_index < tab_count; ++tab_index) {
     BaseTab* tab = tabstrip_->base_tab_at_tab_index(tab_index);
     int model_index = tabstrip_->GetModelIndexOfBaseTab(tab);
     if (model_->ContainsIndex(model_index)) {
-      TabContents* contents = model_->GetTabContentsAt(model_index);
-      tab->UpdateLoadingAnimation(TabContentsNetworkState(contents));
+      TabContentsWrapper* contents = model_->GetTabContentsAt(model_index);
+      tab->UpdateLoadingAnimation(
+          TabContentsNetworkState(contents->tab_contents()));
     }
   }
 }
 
 int BrowserTabStripController::HasAvailableDragActions() const {
   return model_->delegate()->GetDragActions();
 }
 
 void BrowserTabStripController::PerformDrop(bool drop_before,
                                             int index,
                                             const GURL& url) {
   if (drop_before) {
     UserMetrics::RecordAction(UserMetricsAction("Tab_DropURLBetweenTabs"),
                               model_->profile());
 
     // Insert a new tab.
-    TabContents* contents = model_->delegate()->CreateTabContentsForURL(
+    TabContentsWrapper* contents = model_->delegate()->CreateTabContentsForURL(
         url, GURL(), model_->profile(), PageTransition::TYPED, false, NULL);
     model_->AddTabContents(contents, index, PageTransition::GENERATED,
                            TabStripModel::ADD_SELECTED);
   } else {
     UserMetrics::RecordAction(UserMetricsAction("Tab_DropURLOnTab"),
                               model_->profile());
 
     model_->GetTabContentsAt(index)->controller().LoadURL(
         url, GURL(), PageTransition::GENERATED);
     model_->SelectTabContentsAt(index, true);
   }
 }
 
 bool BrowserTabStripController::IsCompatibleWith(BaseTabStrip* other) const {
   Profile* other_profile =
       static_cast<BrowserTabStripController*>(other->controller())->profile();
   return other_profile == profile();
 }
 
 void BrowserTabStripController::CreateNewTab() {
   UserMetrics::RecordAction(UserMetricsAction("NewTab_Button"),
                             model_->profile());
 
   model_->delegate()->AddBlankTab(true);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserTabStripController, TabStripModelObserver implementation:
 
-void BrowserTabStripController::TabInsertedAt(TabContents* contents,
+void BrowserTabStripController::TabInsertedAt(TabContentsWrapper* contents,
                                               int model_index,
                                               bool foreground) {
   DCHECK(contents);
   DCHECK(model_index == TabStripModel::kNoTab ||
          model_->ContainsIndex(model_index));
   // This tab may be attached to another browser window, we should notify
   // renderer.
   contents->render_view_host()->UpdateBrowserWindowId(
       contents->controller().window_id().id());
 
   TabRendererData data;
-  SetTabRendererDataFromModel(contents, model_index, &data);
+  SetTabRendererDataFromModel(contents->tab_contents(), model_index, &data);
   tabstrip_->AddTabAt(model_index, foreground, data);
 }
 
-void BrowserTabStripController::TabDetachedAt(TabContents* contents,
+void BrowserTabStripController::TabDetachedAt(TabContentsWrapper* contents,
                                               int model_index) {
   tabstrip_->RemoveTabAt(model_index);
 }
 
-void BrowserTabStripController::TabSelectedAt(TabContents* old_contents,
-                                              TabContents* contents,
+void BrowserTabStripController::TabSelectedAt(TabContentsWrapper* old_contents,
+                                              TabContentsWrapper* contents,
                                               int model_index,
                                               bool user_gesture) {
   tabstrip_->SelectTabAt(model_->GetIndexOfTabContents(old_contents),
                          model_index);
 }
 
-void BrowserTabStripController::TabMoved(TabContents* contents,
+void BrowserTabStripController::TabMoved(TabContentsWrapper* contents,
                                          int from_model_index,
                                          int to_model_index) {
   // Update the data first as the pinned state may have changed.
   TabRendererData data;
-  SetTabRendererDataFromModel(contents, to_model_index, &data);
+  SetTabRendererDataFromModel(contents->tab_contents(), to_model_index, &data);
   tabstrip_->SetTabData(from_model_index, data);
 
   tabstrip_->MoveTab(from_model_index, to_model_index);
 }
 
-void BrowserTabStripController::TabChangedAt(TabContents* contents,
+void BrowserTabStripController::TabChangedAt(TabContentsWrapper* contents,
                                              int model_index,
                                              TabChangeType change_type) {
   if (change_type == TITLE_NOT_LOADING) {
     tabstrip_->TabTitleChangedNotLoading(model_index);
     // We'll receive another notification of the change asynchronously.
     return;
   }
 
   SetTabDataAt(contents, model_index);
 }
 
-void BrowserTabStripController::TabReplacedAt(TabContents* old_contents,
-                                              TabContents* new_contents,
+void BrowserTabStripController::TabReplacedAt(TabContentsWrapper* old_contents,
+                                              TabContentsWrapper* new_contents,
                                               int model_index) {
   SetTabDataAt(new_contents, model_index);
 }
 
-void BrowserTabStripController::TabPinnedStateChanged(TabContents* contents,
-                                                      int model_index) {
+void BrowserTabStripController::TabPinnedStateChanged(
+    TabContentsWrapper* contents,
+    int model_index) {
   // Currently none of the renderers render pinned state differently.
 }
 
 void BrowserTabStripController::TabMiniStateChanged(
-    TabContents* contents,
+    TabContentsWrapper* contents,
     int model_index) {
   SetTabDataAt(contents, model_index);
 }
 
-void BrowserTabStripController::TabBlockedStateChanged(TabContents* contents,
-                                                       int model_index) {
+void BrowserTabStripController::TabBlockedStateChanged(
+    TabContentsWrapper* contents,
+    int model_index) {
   SetTabDataAt(contents, model_index);
 }
 
-void BrowserTabStripController::SetTabDataAt(TabContents* contents,
-                                             int model_index) {
+void BrowserTabStripController::SetTabDataAt(
+    TabContentsWrapper* contents,
+    int model_index) {
   TabRendererData data;
-  SetTabRendererDataFromModel(contents, model_index, &data);
+  SetTabRendererDataFromModel(contents->tab_contents(), model_index, &data);
   tabstrip_->SetTabData(model_index, data);
 }
 
 void BrowserTabStripController::SetTabRendererDataFromModel(
     TabContents* contents,
     int model_index,
     TabRendererData* data) {
   SkBitmap* app_icon = NULL;
 
   // Extension App icons are slightly larger than favicons, so only allow
@@ skipping 51 matching lines @@
   DCHECK(type.value == NotificationType::TAB_CLOSEABLE_STATE_CHANGED);
   // Note that this notification may be fired during a model mutation and
   // possibly before the tabstrip has processed the change.
   // Here, we just re-layout each existing tab to reflect the change in its
   // closeable state, and then schedule paint for entire tabstrip.
   for (int i = 0; i < tabstrip_->tab_count(); ++i) {
     tabstrip_->base_tab_at_tab_index(i)->Layout();
   }
   tabstrip_->SchedulePaint();
 }