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

chrome/browser/cocoa/tab_strip_controller.mm

 // 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.
 
 #import "chrome/browser/cocoa/tab_strip_controller.h"
 
 #import <QuartzCore/QuartzCore.h>
 
 #include <limits>
 #include <string>
@@ skipping 19 matching lines @@
 #import "chrome/browser/cocoa/tab_view.h"
 #import "chrome/browser/cocoa/throbber_view.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/sidebar/sidebar_container.h"
 #include "chrome/browser/sidebar/sidebar_manager.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.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/ui/browser_navigator.h"
 #include "grit/app_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "skia/ext/skia_utils_mac.h"
 #import "third_party/GTM/AppKit/GTMNSAnimation+Duration.h"
 
 NSString* const kTabStripNumberOfTabsChanged = @"kTabStripNumberOfTabsChanged";
 
@@ skipping 319 matching lines @@
     // Set accessibility descriptions. http://openradar.appspot.com/7496255
     NSString* description = l10n_util::GetNSStringWithFixup(IDS_ACCNAME_NEWTAB);
     [[newTabButton_ cell]
         accessibilitySetOverrideValue:description
                          forAttribute:NSAccessibilityDescriptionAttribute];
 
     // Controller may have been (re-)created by switching layout modes, which
     // means the tab model is already fully formed with tabs. Need to walk the
     // list and create the UI for each.
     const int existingTabCount = tabStripModel_->count();
-    const TabContents* selection = tabStripModel_->GetSelectedTabContents();
+    const TabContentsWrapper* selection =
+        tabStripModel_->GetSelectedTabContents();
     for (int i = 0; i < existingTabCount; ++i) {
-      TabContents* currentContents = tabStripModel_->GetTabContentsAt(i);
+      TabContentsWrapper* currentContents = tabStripModel_->GetTabContentsAt(i);
       [self insertTabWithContents:currentContents
                           atIndex:i
                      inForeground:NO];
       if (selection == currentContents) {
         // Must manually force a selection since the model won't send
         // selection messages in this scenario.
         [self selectTabWithContents:currentContents
                    previousContents:NULL
                             atIndex:i
                         userGesture:NO];
@@ skipping 75 matching lines @@
   }
 
   // New content is in place, delegate should adjust itself accordingly.
   [delegate_ onSelectTabWithContents:[controller tabContents]];
 
   // It also restores content autoresizing properties.
   [controller ensureContentsVisible];
 
   // Make sure the new tabs's sheets are visible (necessary when a background
   // tab opened a sheet while it was in the background and now becomes active).
-  TabContents* newTab = tabStripModel_->GetTabContentsAt(modelIndex);
+  TabContentsWrapper* newTab = tabStripModel_->GetTabContentsAt(modelIndex);
   DCHECK(newTab);
   if (newTab) {
     TabContents::ConstrainedWindowList::iterator it, end;
-    end = newTab->constrained_window_end();
+    end = newTab->tab_contents()->constrained_window_end();
     NSWindowController* controller = [[newView window] windowController];
     DCHECK([controller isKindOfClass:[BrowserWindowController class]]);
 
-    for (it = newTab->constrained_window_begin(); it != end; ++it) {
+    for (it = newTab->tab_contents()->constrained_window_begin();
+         it != end;
+         ++it) {
       ConstrainedWindow* constrainedWindow = *it;
       static_cast<ConstrainedWindowMac*>(constrainedWindow)->Realize(
           static_cast<BrowserWindowController*>(controller));
     }
   }
 
   // Tell per-tab sheet manager about currently selected tab.
   if (sheetController_.get()) {
     [sheetController_ setActiveView:newView];
   }
@@ skipping 124 matching lines @@
 - (void)closeTab:(id)sender {
   DCHECK([sender isKindOfClass:[TabView class]]);
   if ([hoveredTab_ isEqual:sender]) {
     hoveredTab_ = nil;
   }
 
   NSInteger index = [self modelIndexForTabView:sender];
   if (!tabStripModel_->ContainsIndex(index))
     return;
 
-  TabContents* contents = tabStripModel_->GetTabContentsAt(index);
+  TabContentsWrapper* contents = tabStripModel_->GetTabContentsAt(index);
   if (contents)
     UserMetrics::RecordAction(UserMetricsAction("CloseTab_Mouse"),
-                              contents->profile());
+                              contents->tab_contents()->profile());
   const NSInteger numberOfOpenTabs = [self numberOfOpenTabs];
   if (numberOfOpenTabs > 1) {
     bool isClosingLastTab = index == numberOfOpenTabs - 1;
     if (!isClosingLastTab) {
       // Limit the width available for laying out tabs so that tabs are not
       // resized until a later time (when the mouse leaves the tab strip).
       // However, if the tab being closed is a pinned tab, break out of
       // rapid-closure mode since the mouse is almost guaranteed not to be over
       // the closebox of the adjacent tab (due to the difference in widths).
       // TODO(pinkerton): re-visit when handling tab overflow.
@@ skipping 309 matching lines @@
   if (contents)
     titleString = base::SysUTF16ToNSString(contents->GetTitle());
   if (![titleString length]) {
     titleString = l10n_util::GetNSString(IDS_BROWSER_WINDOW_MAC_TAB_UNTITLED);
   }
   [tab setTitle:titleString];
 }
 
 // Called when a notification is received from the model to insert a new tab
 // at |modelIndex|.
-- (void)insertTabWithContents:(TabContents*)contents
+- (void)insertTabWithContents:(TabContentsWrapper*)contents
                       atIndex:(NSInteger)modelIndex
                  inForeground:(bool)inForeground {
   DCHECK(contents);
   DCHECK(modelIndex == TabStripModel::kNoTab ||
          tabStripModel_->ContainsIndex(modelIndex));
 
   // Take closing tabs into account.
   NSInteger index = [self indexFromModelIndex:modelIndex];
 
   // Make a new tab. Load the contents of this tab from the nib and associate
   // the new controller with |contents| so it can be looked up later.
   scoped_nsobject<TabContentsController> contentsController(
-      [[TabContentsController alloc] initWithContents:contents delegate:self]);
+      [[TabContentsController alloc] initWithContents:contents->tab_contents()
+                                             delegate:self]);
   [tabContentsArray_ insertObject:contentsController atIndex:index];
 
   // Make a new tab and add it to the strip. Keep track of its controller.
   TabController* newController = [self newTab];
   [newController setMini:tabStripModel_->IsMiniTab(modelIndex)];
   [newController setPinned:tabStripModel_->IsTabPinned(modelIndex)];
   [newController setApp:tabStripModel_->IsAppTab(modelIndex)];
   [tabArray_ insertObject:newController atIndex:index];
   NSView* newView = [newController view];
 
   // Set the originating frame to just below the strip so that it animates
   // upwards as it's being initially layed out. Oddly, this works while doing
   // something similar in |-layoutTabs| confuses the window server.
   [newView setFrame:NSOffsetRect([newView frame],
                                  0, -[[self class] defaultTabHeight])];
 
-  [self setTabTitle:newController withContents:contents];
+  [self setTabTitle:newController withContents:contents->tab_contents()];
 
   // If a tab is being inserted, we can again use the entire tab strip width
   // for layout.
   availableResizeWidth_ = kUseFullAvailableWidth;
 
   // We don't need to call |-layoutTabs| if the tab will be in the foreground
   // because it will get called when the new tab is selected by the tab model.
   // Whenever |-layoutTabs| is called, it'll also add the new subview.
   if (!inForeground) {
     [self layoutTabs];
   }
 
   // During normal loading, we won't yet have a favicon and we'll get
   // subsequent state change notifications to show the throbber, but when we're
   // dragging a tab out into a new window, we have to put the tab's favicon
   // into the right state up front as we won't be told to do it from anywhere
   // else.
-  [self updateFavIconForContents:contents atIndex:modelIndex];
+  [self updateFavIconForContents:contents->tab_contents() atIndex:modelIndex];
 
   // Send a broadcast that the number of tabs have changed.
   [[NSNotificationCenter defaultCenter]
       postNotificationName:kTabStripNumberOfTabsChanged
                     object:self];
 }
 
 // Called when a notification is received from the model to select a particular
 // tab. Swaps in the toolbar and content area associated with |newContents|.
-- (void)selectTabWithContents:(TabContents*)newContents
-             previousContents:(TabContents*)oldContents
+- (void)selectTabWithContents:(TabContentsWrapper*)newContents
+             previousContents:(TabContentsWrapper*)oldContents
                       atIndex:(NSInteger)modelIndex
                   userGesture:(bool)wasUserGesture {
   // Take closing tabs into account.
   NSInteger index = [self indexFromModelIndex:modelIndex];
 
   if (oldContents) {
     int oldModelIndex =
         browser_->GetIndexOfController(&(oldContents->controller()));
     if (oldModelIndex != -1) {  // When closing a tab, the old tab may be gone.
       NSInteger oldIndex = [self indexFromModelIndex:oldModelIndex];
       TabContentsController* oldController =
           [tabContentsArray_ objectAtIndex:oldIndex];
       [oldController willBecomeUnselectedTab];
       oldContents->view()->StoreFocus();
-      oldContents->WasHidden();
+      oldContents->tab_contents()->WasHidden();
     }
   }
 
   // De-select all other tabs and select the new tab.
   int i = 0;
   for (TabController* current in tabArray_.get()) {
     [current setSelected:(i == index) ? YES : NO];
     ++i;
   }
 
   // Tell the new tab contents it is about to become the selected tab. Here it
   // can do things like make sure the toolbar is up to date.
   TabContentsController* newController =
       [tabContentsArray_ objectAtIndex:index];
   [newController willBecomeSelectedTab];
 
   // Relayout for new tabs and to let the selected tab grow to be larger in
   // size than surrounding tabs if the user has many. This also raises the
   // selected tab to the top.
   [self layoutTabs];
 
   // Swap in the contents for the new tab.
   [self swapInTabAtIndex:modelIndex];
 
   if (newContents) {
-    newContents->DidBecomeSelected();
+    newContents->tab_contents()->DidBecomeSelected();
     newContents->view()->RestoreFocus();
 
-    if (newContents->find_ui_active())
+    if (newContents->tab_contents()->find_ui_active())
       browser_->GetFindBarController()->find_bar()->SetFocusAndSelection();
   }
 }
 
-- (void)tabReplacedWithContents:(TabContents*)newContents
-               previousContents:(TabContents*)oldContents
+- (void)tabReplacedWithContents:(TabContentsWrapper*)newContents
+               previousContents:(TabContentsWrapper*)oldContents
                         atIndex:(NSInteger)modelIndex {
   NSInteger index = [self indexFromModelIndex:modelIndex];
   TabContentsController* oldController =
       [tabContentsArray_ objectAtIndex:index];
-  DCHECK_EQ(oldContents, [oldController tabContents]);
+  DCHECK_EQ(oldContents->tab_contents(), [oldController tabContents]);
 
   // Simply create a new TabContentsController for |newContents| and place it
   // into the array, replacing |oldContents|.  A TabSelectedAt notification will
   // follow, at which point we will install the new view.
   scoped_nsobject<TabContentsController> newController(
+<<<<<<< .mine
+      [[TabContentsController alloc]
+          initWithContents:newContents->tab_contents()]);
+=======
       [[TabContentsController alloc] initWithContents:newContents
                                              delegate:self]);
+>>>>>>> .r66339
 
   // Bye bye, |oldController|.
   [tabContentsArray_ replaceObjectAtIndex:index withObject:newController];
 
-  [delegate_ onReplaceTabWithContents:newContents];
+  [delegate_ onReplaceTabWithContents:newContents->tab_contents()];
 }
 
 // Remove all knowledge about this tab and its associated controller, and remove
 // the view from the strip.
 - (void)removeTab:(TabController*)controller {
   NSUInteger index = [tabArray_ indexOfObject:controller];
 
   // Release the tab contents controller so those views get destroyed. This
   // will remove all the tab content Cocoa views from the hierarchy. A
   // subsequent "select tab" notification will follow from the model. To
@@ skipping 64 matching lines @@
   NSRect newFrame = [tabView frame];
   newFrame = NSOffsetRect(newFrame, 0, -newFrame.size.height);
   ScopedNSAnimationContextGroup animationGroup(true);
   animationGroup.SetCurrentContextDuration(kAnimationDuration);
   [[tabView animator] setFrame:newFrame];
 }
 
 // Called when a notification is received from the model that the given tab
 // has gone away. Start an animation then force a layout to put everything
 // in motion.
-- (void)tabDetachedWithContents:(TabContents*)contents
+- (void)tabDetachedWithContents:(TabContentsWrapper*)contents
                         atIndex:(NSInteger)modelIndex {
   // Take closing tabs into account.
   NSInteger index = [self indexFromModelIndex:modelIndex];
 
   TabController* tab = [tabArray_ objectAtIndex:index];
   if (tabStripModel_->count() > 0) {
     [self startClosingTabWithAnimation:tab];
     [self layoutTabs];
   } else {
     [self removeTab:tab];
   }
 
   // Send a broadcast that the number of tabs have changed.
   [[NSNotificationCenter defaultCenter]
       postNotificationName:kTabStripNumberOfTabsChanged
                     object:self];
 
-  [delegate_ onTabDetachedWithContents:contents];
+  [delegate_ onTabDetachedWithContents:contents->tab_contents()];
 }
 
 // A helper routine for creating an NSImageView to hold the fav icon or app icon
 // for |contents|.
 - (NSImageView*)iconImageViewForContents:(TabContents*)contents {
   BOOL isApp = contents->is_app();
   NSImage* image = nil;
   if (isApp) {
     SkBitmap* icon = contents->GetExtensionAppIcon();
     if (icon)
@@ skipping 79 matching lines @@
       }
     }
 
     [tabController setIconView:iconView];
   }
 }
 
 // Called when a notification is received from the model that the given tab
 // has been updated. |loading| will be YES when we only want to update the
 // throbber state, not anything else about the (partially) loading tab.
-- (void)tabChangedWithContents:(TabContents*)contents
+- (void)tabChangedWithContents:(TabContentsWrapper*)contents
                        atIndex:(NSInteger)modelIndex
                     changeType:(TabStripModelObserver::TabChangeType)change {
   // Take closing tabs into account.
   NSInteger index = [self indexFromModelIndex:modelIndex];
 
   if (modelIndex == tabStripModel_->selected_index())
     [delegate_ onSelectedTabChange:change];
 
   if (change == TabStripModelObserver::TITLE_NOT_LOADING) {
     // TODO(sky): make this work.
     // We'll receive another notification of the change asynchronously.
     return;
   }
 
   TabController* tabController = [tabArray_ objectAtIndex:index];
 
   if (change != TabStripModelObserver::LOADING_ONLY)
-    [self setTabTitle:tabController withContents:contents];
+    [self setTabTitle:tabController withContents:contents->tab_contents()];
 
-  [self updateFavIconForContents:contents atIndex:modelIndex];
+  [self updateFavIconForContents:contents->tab_contents() atIndex:modelIndex];
 
   TabContentsController* updatedController =
       [tabContentsArray_ objectAtIndex:index];
-  [updatedController tabDidChange:contents];
+  [updatedController tabDidChange:contents->tab_contents()];
 }
 
 // Called when a tab is moved (usually by drag&drop). Keep our parallel arrays
 // in sync with the tab strip model. It can also be pinned/unpinned
 // simultaneously, so we need to take care of that.
-- (void)tabMovedWithContents:(TabContents*)contents
+- (void)tabMovedWithContents:(TabContentsWrapper*)contents
                    fromIndex:(NSInteger)modelFrom
                      toIndex:(NSInteger)modelTo {
   // Take closing tabs into account.
   NSInteger from = [self indexFromModelIndex:modelFrom];
   NSInteger to = [self indexFromModelIndex:modelTo];
 
   scoped_nsobject<TabContentsController> movedTabContentsController(
       [[tabContentsArray_ objectAtIndex:from] retain]);
   [tabContentsArray_ removeObjectAtIndex:from];
   [tabContentsArray_ insertObject:movedTabContentsController.get()
                           atIndex:to];
   scoped_nsobject<TabController> movedTabController(
       [[tabArray_ objectAtIndex:from] retain]);
   DCHECK([movedTabController isKindOfClass:[TabController class]]);
   [tabArray_ removeObjectAtIndex:from];
   [tabArray_ insertObject:movedTabController.get() atIndex:to];
 
   // The tab moved, which means that the mini-tab state may have changed.
   if (tabStripModel_->IsMiniTab(modelTo) != [movedTabController mini])
     [self tabMiniStateChangedWithContents:contents atIndex:modelTo];
 
   [self layoutTabs];
 }
 
 // Called when a tab is pinned or unpinned without moving.
-- (void)tabMiniStateChangedWithContents:(TabContents*)contents
+- (void)tabMiniStateChangedWithContents:(TabContentsWrapper*)contents
                                 atIndex:(NSInteger)modelIndex {
   // Take closing tabs into account.
   NSInteger index = [self indexFromModelIndex:modelIndex];
 
   TabController* tabController = [tabArray_ objectAtIndex:index];
   DCHECK([tabController isKindOfClass:[TabController class]]);
 
   // Don't do anything if the change was already picked up by the move event.
   if (tabStripModel_->IsMiniTab(modelIndex) == [tabController mini])
     return;
 
   [tabController setMini:tabStripModel_->IsMiniTab(modelIndex)];
   [tabController setPinned:tabStripModel_->IsTabPinned(modelIndex)];
   [tabController setApp:tabStripModel_->IsAppTab(modelIndex)];
-  [self updateFavIconForContents:contents atIndex:modelIndex];
+  [self updateFavIconForContents:contents->tab_contents() atIndex:modelIndex];
   // If the tab is being restored and it's pinned, the mini state is set after
   // the tab has already been rendered, so re-layout the tabstrip. In all other
   // cases, the state is set before the tab is rendered so this isn't needed.
   [self layoutTabs];
 }
 
 - (void)setFrameOfSelectedTab:(NSRect)frame {
   NSView* view = [self selectedTabView];
   NSValue* identifier = [NSValue valueWithPointer:view];
   [targetFrames_ setObject:[NSValue valueWithRect:frame]
@@ skipping 53 matching lines @@
 
 // Drop a given TabContents at the location of the current placeholder. If there
 // is no placeholder, it will go at the end. Used when dragging from another
 // window when we don't have access to the TabContents as part of our strip.
 // |frame| is in the coordinate system of the tab strip view and represents
 // where the user dropped the new tab so it can be animated into its correct
 // location when the tab is added to the model. If the tab was pinned in its
 // previous window, setting |pinned| to YES will propagate that state to the
 // new window. Mini-tabs are either app or pinned tabs; the app state is stored
 // by the |contents|, but the |pinned| state is the caller's responsibility.
-- (void)dropTabContents:(TabContents*)contents
+- (void)dropTabContents:(TabContentsWrapper*)contents
               withFrame:(NSRect)frame
             asPinnedTab:(BOOL)pinned {
   int modelIndex = [self indexOfPlaceholder];
 
   // Mark that the new tab being created should start at |frame|. It will be
   // reset as soon as the tab has been positioned.
   droppedTabFrame_ = frame;
 
   // Insert it into this tab strip. We want it in the foreground and to not
   // inherit the current tab's group.
@@ skipping 260 matching lines @@
       params.disposition = disposition;
       params.tabstrip_index = index;
       params.tabstrip_add_types =
           TabStripModel::ADD_SELECTED | TabStripModel::ADD_FORCE_INDEX;
       browser::Navigate(&params);
       break;
     }
     case CURRENT_TAB:
       UserMetrics::RecordAction(UserMetricsAction("Tab_DropURLOnTab"),
                                 browser_->profile());
-      tabStripModel_->GetTabContentsAt(index)->OpenURL(url, GURL(), CURRENT_TAB,
-                                                       PageTransition::TYPED);
+      tabStripModel_->GetTabContentsAt(index)
+          ->tab_contents()->OpenURL(url, GURL(), CURRENT_TAB,
+                                    PageTransition::TYPED);
       tabStripModel_->SelectTabContentsAt(index, true);
       break;
     default:
       NOTIMPLEMENTED();
   }
 }
 
 // (URLDropTargetController protocol)
 - (void)indicateDropURLsInView:(NSView*)view at:(NSPoint)point {
   DCHECK_EQ(view, tabStripView_.get());
@@ skipping 128 matching lines @@
   NSInteger index = [self indexFromModelIndex:modelIndex];
   BrowserWindowController* controller =
       (BrowserWindowController*)[[switchView_ window] windowController];
   DCHECK(index >= 0);
   if (index >= 0) {
     [controller setTab:[self viewAtIndex:index] isDraggable:YES];
   }
 }
 
 @end