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

chrome/browser/tabs/default_tab_handler.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 "base/metrics/nacl_histogram.h"
 #include "chrome/browser/tabs/default_tab_handler.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser.h"
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 16 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // DefaultTabHandler, TabHandler implementation:
 
 TabStripModel* DefaultTabHandler::GetTabStripModel() const {
   return model_.get();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DefaultTabHandler, TabStripModelDelegate implementation:
 
-TabContents* DefaultTabHandler::AddBlankTab(bool foreground) {
+TabContentsWrapper* DefaultTabHandler::AddBlankTab(bool foreground) {
   UmaNaclHistogramEnumeration(NEW_TAB_NACL_BASELINE);
   return delegate_->AsBrowser()->AddBlankTab(foreground);
 }
 
-TabContents* DefaultTabHandler::AddBlankTabAt(int index, bool foreground) {
+TabContentsWrapper* DefaultTabHandler::AddBlankTabAt(int index,
+                                                     bool foreground) {
   return delegate_->AsBrowser()->AddBlankTabAt(index, foreground);
 }
 
 Browser* DefaultTabHandler::CreateNewStripWithContents(
-    TabContents* detached_contents,
+    TabContentsWrapper* detached_contents,
     const gfx::Rect& window_bounds,
     const DockInfo& dock_info,
     bool maximize) {
   return delegate_->AsBrowser()->CreateNewStripWithContents(detached_contents,
                                                             window_bounds,
                                                             dock_info,
                                                             maximize);
 }
 
 void DefaultTabHandler::ContinueDraggingDetachedTab(
-    TabContents* contents,
+    TabContentsWrapper* contents,
     const gfx::Rect& window_bounds,
     const gfx::Rect& tab_bounds) {
   delegate_->AsBrowser()->ContinueDraggingDetachedTab(contents,
                                                       window_bounds,
                                                       tab_bounds);
 }
 
 int DefaultTabHandler::GetDragActions() const {
   return delegate_->AsBrowser()->GetDragActions();
 }
 
-TabContents* DefaultTabHandler::CreateTabContentsForURL(
+TabContentsWrapper* DefaultTabHandler::CreateTabContentsForURL(
     const GURL& url,
     const GURL& referrer,
     Profile* profile,
     PageTransition::Type transition,
     bool defer_load,
     SiteInstance* instance) const {
   return delegate_->AsBrowser()->CreateTabContentsForURL(url,
                                                          referrer,
                                                          profile,
                                                          transition,
                                                          defer_load,
                                                          instance);
 }
 
 bool DefaultTabHandler::CanDuplicateContentsAt(int index) {
   return delegate_->AsBrowser()->CanDuplicateContentsAt(index);
 }
 
 void DefaultTabHandler::DuplicateContentsAt(int index) {
   delegate_->AsBrowser()->DuplicateContentsAt(index);
 }
 
 void DefaultTabHandler::CloseFrameAfterDragSession() {
   delegate_->AsBrowser()->CloseFrameAfterDragSession();
 }
 
-void DefaultTabHandler::CreateHistoricalTab(TabContents* contents) {
+void DefaultTabHandler::CreateHistoricalTab(TabContentsWrapper* contents) {
   delegate_->AsBrowser()->CreateHistoricalTab(contents);
 }
 
-bool DefaultTabHandler::RunUnloadListenerBeforeClosing(TabContents* contents) {
+bool DefaultTabHandler::RunUnloadListenerBeforeClosing(
+    TabContentsWrapper* contents) {
   return delegate_->AsBrowser()->RunUnloadListenerBeforeClosing(contents);
 }
 
 bool DefaultTabHandler::CanCloseContentsAt(int index) {
   return delegate_->AsBrowser()->CanCloseContentsAt(index);
 }
 
 bool DefaultTabHandler::CanBookmarkAllTabs() const {
   return delegate_->AsBrowser()->CanBookmarkAllTabs();
 }
@@ skipping 22 matching lines @@
   return delegate_->AsBrowser()->LargeIconsPermitted();
 }
 
 bool DefaultTabHandler::UseVerticalTabs() const {
   return delegate_->AsBrowser()->UseVerticalTabs();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DefaultTabHandler, TabStripModelObserver implementation:
 
-void DefaultTabHandler::TabInsertedAt(TabContents* contents,
+void DefaultTabHandler::TabInsertedAt(TabContentsWrapper* contents,
                                       int index,
                                       bool foreground) {
   delegate_->AsBrowser()->TabInsertedAt(contents, index, foreground);
 }
 
 void DefaultTabHandler::TabClosingAt(TabStripModel* tab_strip_model,
-                                     TabContents* contents,
+                                     TabContentsWrapper* contents,
                                      int index) {
   delegate_->AsBrowser()->TabClosingAt(tab_strip_model, contents, index);
 }
 
-void DefaultTabHandler::TabDetachedAt(TabContents* contents, int index) {
+void DefaultTabHandler::TabDetachedAt(TabContentsWrapper* contents, int index) {
   delegate_->AsBrowser()->TabDetachedAt(contents, index);
 }
 
-void DefaultTabHandler::TabDeselectedAt(TabContents* contents, int index) {
+void DefaultTabHandler::TabDeselectedAt(TabContentsWrapper* contents,
+                                        int index) {
   delegate_->AsBrowser()->TabDeselectedAt(contents, index);
 }
 
-void DefaultTabHandler::TabSelectedAt(TabContents* old_contents,
-                                      TabContents* new_contents,
+void DefaultTabHandler::TabSelectedAt(TabContentsWrapper* old_contents,
+                                      TabContentsWrapper* new_contents,
                                       int index,
                                       bool user_gesture) {
   delegate_->AsBrowser()->TabSelectedAt(old_contents,
                                         new_contents,
                                         index,
                                         user_gesture);
 }
 
-void DefaultTabHandler::TabMoved(TabContents* contents,
+void DefaultTabHandler::TabMoved(TabContentsWrapper* contents,
                                  int from_index,
                                  int to_index) {
   delegate_->AsBrowser()->TabMoved(contents, from_index, to_index);
 }
 
-void DefaultTabHandler::TabReplacedAt(TabContents* old_contents,
-                                      TabContents* new_contents,
+void DefaultTabHandler::TabReplacedAt(TabContentsWrapper* old_contents,
+                                      TabContentsWrapper* new_contents,
                                       int index) {
   delegate_->AsBrowser()->TabReplacedAt(old_contents, new_contents, index);
 }
 
-void DefaultTabHandler::TabPinnedStateChanged(TabContents* contents,
+void DefaultTabHandler::TabPinnedStateChanged(TabContentsWrapper* contents,
                                               int index) {
   delegate_->AsBrowser()->TabPinnedStateChanged(contents, index);
 }
 
 void DefaultTabHandler::TabStripEmpty() {
   delegate_->AsBrowser()->TabStripEmpty();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabHandler, public:
 
 // static
 TabHandler* TabHandler::CreateTabHandler(TabHandlerDelegate* delegate) {
   return new DefaultTabHandler(delegate);
 }