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

chrome/browser/ui/views/tabs/dragged_tab_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/dragged_tab_controller.h"
 
 #include <math.h>
 #include <set>
 
 #include "app/animation.h"
@@ skipping 456 matching lines @@
   // Ignored.
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // DraggedTabController, NotificationObserver implementation:
 
 void DraggedTabController::Observe(NotificationType type,
                                    const NotificationSource& source,
                                    const NotificationDetails& details) {
   DCHECK(type == NotificationType::TAB_CONTENTS_DESTROYED);
-  DCHECK(Source<TabContents>(source).ptr() == dragged_contents_);
+  DCHECK(Source<TabContents>(source).ptr() ==
+         dragged_contents_->tab_contents());
   EndDragImpl(TAB_DESTROYED);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // DraggedTabController, MessageLoop::Observer implementation:
 
 #if defined(OS_WIN)
 void DraggedTabController::WillProcessMessage(const MSG& msg) {
 }
 
@@ skipping 81 matching lines @@
       }
     }
   } else if (dock_info_.type() != DockInfo::NONE &&
              !dock_controllers_.empty()) {
     // Current dock position is the same as last, update the controller's
     // in_enable_area state as it may have changed.
     dock_controllers_.back()->UpdateInEnabledArea(dock_info_.in_enable_area());
   }
 }
 
-void DraggedTabController::SetDraggedContents(TabContents* new_contents) {
+void DraggedTabController::SetDraggedContents(
+    TabContentsWrapper* new_contents) {
   if (dragged_contents_) {
     registrar_.Remove(this,
                       NotificationType::TAB_CONTENTS_DESTROYED,
-                      Source<TabContents>(dragged_contents_));
+                      Source<TabContents>(dragged_contents_->tab_contents()));
     if (original_delegate_)
       dragged_contents_->set_delegate(original_delegate_);
   }
   original_delegate_ = NULL;
   dragged_contents_ = new_contents;
   if (dragged_contents_) {
     registrar_.Add(this,
                    NotificationType::TAB_CONTENTS_DESTROYED,
-                   Source<TabContents>(dragged_contents_));
+                   Source<TabContents>(dragged_contents_->tab_contents()));
 
     // We need to be the delegate so we receive messages about stuff,
     // otherwise our dragged_contents() may be replaced and subsequently
     // collected/destroyed while the drag is in process, leading to
     // nasty crashes.
     original_delegate_ = dragged_contents_->delegate();
     dragged_contents_->set_delegate(this);
   }
 }
 
@@ skipping 222 matching lines @@
   if (!tab) {
     // There is no Tab in |attached_tabstrip| that corresponds to the dragged
     // TabContents. We must now create one.
 
     // Remove ourselves as the delegate now that the dragged TabContents is
     // being inserted back into a Browser.
     dragged_contents_->set_delegate(NULL);
     original_delegate_ = NULL;
 
     // Return the TabContents' to normalcy.
-    dragged_contents_->set_capturing_contents(false);
+    dragged_contents_->tab_contents()->set_capturing_contents(false);
 
     // Inserting counts as a move. We don't want the tabs to jitter when the
     // user moves the tab immediately after attaching it.
     last_move_screen_loc_ = MajorAxisValue(screen_point, attached_tabstrip);
 
     // Figure out where to insert the tab based on the bounds of the dragged
     // representation and the ideal bounds of the other Tabs already in the
     // strip. ("ideal bounds" are stable even if the Tabs' actual bounds are
     // changing due to animation).
     gfx::Rect bounds = GetDraggedViewTabStripBounds(screen_point);
@@ skipping 18 matching lines @@
                                          static_cast<int>(tab->width())));
   }
 
   // Move the corresponding window to the front.
   attached_tabstrip_->GetWindow()->Activate();
 }
 
 void DraggedTabController::Detach() {
   // Prevent the TabContents' HWND from being hidden by any of the model
   // operations performed during the drag.
-  dragged_contents_->set_capturing_contents(true);
+  dragged_contents_->tab_contents()->set_capturing_contents(true);
 
   // Update the Model.
   TabRendererData tab_data = attached_tab_->data();
   TabStripModel* attached_model = GetModel(attached_tabstrip_);
   int index = attached_model->GetIndexOfTabContents(dragged_contents_);
   DCHECK(index != -1);
   // Hide the tab so that the user doesn't see it animate closed.
   attached_tab_->SetVisible(false);
   int attached_tab_width = attached_tab_->width();
   attached_model->DetachTabContentsAt(index);
   // Detaching may end up deleting the tab, drop references to it.
   attached_tab_ = NULL;
 
   // If we've removed the last Tab from the TabStrip, hide the frame now.
   if (attached_model->empty())
     HideFrame();
 
   // Set up the photo booth to start capturing the contents of the dragged
   // TabContents.
   if (!photobooth_.get()) {
-    photobooth_.reset(
-        NativeViewPhotobooth::Create(dragged_contents_->GetNativeView()));
+    photobooth_.reset(NativeViewPhotobooth::Create(
+        dragged_contents_->tab_contents()->GetNativeView()));
   }
 
   // Create the dragged view.
   EnsureDraggedView(tab_data);
   view_->SetTabWidthAndUpdate(attached_tab_width, photobooth_.get());
 
   // Detaching resets the delegate, but we still want to be the delegate.
   dragged_contents_->set_delegate(this);
 
   attached_tabstrip_ = NULL;
@@ skipping 313 matching lines @@
                             pinned_);
     new_browser->window()->Show();
   }
 
   CleanUpHiddenFrame();
 }
 
 void DraggedTabController::EnsureDraggedView(const TabRendererData& data) {
   if (!view_.get()) {
     gfx::Rect tab_bounds;
-    dragged_contents_->GetContainerBounds(&tab_bounds);
+    dragged_contents_->tab_contents()->GetContainerBounds(&tab_bounds);
     BaseTab* renderer = source_tabstrip_->CreateTabForDragging();
     renderer->SetData(data);
     // DraggedTabView takes ownership of renderer.
     view_.reset(new DraggedTabView(renderer, mouse_offset_,
                                    tab_bounds.size(),
                                    Tab::GetMinimumSelectedSize()));
   }
 }
 
 gfx::Point DraggedTabController::GetCursorScreenPoint() const {
@@ skipping 91 matching lines @@
 #else
     NOTIMPLEMENTED();
 #endif
   }
 }
 
 TabStripModel* DraggedTabController::GetModel(BaseTabStrip* tabstrip) const {
   return static_cast<BrowserTabStripController*>(tabstrip->controller())->
       model();
 }