Remove TabContents from TabStripModelObserverBridge.

chrome/browser/ui/cocoa/tabs/tab_strip_controller.mm

 // Copyright (c) 2012 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/ui/cocoa/tabs/tab_strip_controller.h"
 
 #import <QuartzCore/QuartzCore.h>
 
 #include <cmath>
 #include <limits>
@@ skipping 132 matching lines @@
   bool animate_;
   DISALLOW_COPY_AND_ASSIGN(ScopedNSAnimationContextGroup);
 };
 
 }  // namespace
 
 @interface TabStripController (Private)
 - (void)addSubviewToPermanentList:(NSView*)aView;
 - (void)regenerateSubviewList;
 - (NSInteger)indexForContentsView:(NSView*)view;
-- (void)updateFaviconForContents:(TabContents*)contents
+- (NSImageView*)iconImageViewForContents:(content::WebContents*)contents;
+- (void)updateFaviconForContents:(content::WebContents*)contents
                          atIndex:(NSInteger)modelIndex;
 - (void)layoutTabsWithAnimation:(BOOL)animate
              regenerateSubviews:(BOOL)doUpdate;
 - (void)animationDidStopForController:(TabController*)controller
                              finished:(BOOL)finished;
 - (NSInteger)indexFromModelIndex:(NSInteger)index;
 - (void)clickNewTabButton:(id)sender;
 - (NSInteger)numberOfOpenTabs;
 - (NSInteger)numberOfOpenMiniTabs;
 - (NSInteger)numberOfOpenNonMiniTabs;
@@ skipping 289 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_->GetActiveTabContents();
+    const content::WebContents* selection =
+        tabStripModel_->GetActiveWebContents();
     for (int i = 0; i < existingTabCount; ++i) {
-      TabContents* currentContents = tabStripModel_->GetTabContentsAt(i);
+      content::WebContents* currentContents =
+          tabStripModel_->GetWebContentsAt(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 activateTabWithContents:currentContents
                      previousContents:NULL
                               atIndex:i
                           userGesture:NO];
@@ skipping 684 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:(content::WebContents*)contents
                       atIndex:(NSInteger)modelIndex
                  inForeground:(bool)inForeground {
   DCHECK(contents);
   DCHECK(modelIndex == TabStripModel::kNoTab ||
          tabStripModel_->ContainsIndex(modelIndex));
 
   // Cancel any pending tab transition.
   hoverTabSelector_->CancelTabTransition();
 
   // 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->web_contents()]);
+      [[TabContentsController alloc] initWithContents:contents]);
   [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)];
-  [newController setUrl:contents->web_contents()->GetURL()];
+  [newController setUrl:contents->GetURL()];
   [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->web_contents()];
+  [self setTabTitle:newController withContents: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];
 }
 
 // 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)activateTabWithContents:(TabContents*)newContents
-               previousContents:(TabContents*)oldContents
+- (void)activateTabWithContents:(content::WebContents*)newContents
+               previousContents:(content::WebContents*)oldContents
                         atIndex:(NSInteger)modelIndex
                     userGesture:(bool)wasUserGesture {
   // Take closing tabs into account.
   NSInteger activeIndex = [self indexFromModelIndex:modelIndex];
 
   if (oldContents) {
-    int oldModelIndex =
-        chrome::GetIndexOfTab(browser_, oldContents->web_contents());
+    int oldModelIndex = chrome::GetIndexOfTab(browser_, oldContents);
     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->web_contents()->GetView()->StoreFocus();
-      oldContents->web_contents()->WasHidden();
+      oldContents->GetView()->StoreFocus();
+      oldContents->WasHidden();
     }
   }
 
   // First get the vector of indices, which is allays sorted in ascending order.
   TabStripSelectionModel::SelectedIndices selection(
       tabStripModel_->selection_model().selected_indices());
   // Iterate through all of the tabs, selecting each as necessary.
   TabStripSelectionModel::SelectedIndices::iterator iter = selection.begin();
   int i = 0;
   for (TabController* current in tabArray_.get()) {
@@ skipping 14 matching lines @@
 
   // 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->web_contents()->WasShown();
-    newContents->web_contents()->GetView()->RestoreFocus();
+    newContents->WasShown();
+    newContents->GetView()->RestoreFocus();
 
-    FindTabHelper* findTabHelper =
-        FindTabHelper::FromWebContents(newContents->web_contents());
+    FindTabHelper* findTabHelper = FindTabHelper::FromWebContents(newContents);
     if (findTabHelper->find_ui_active())
       browser_->GetFindBarController()->find_bar()->SetFocusAndSelection();
   }
 }
 
-- (void)tabReplacedWithContents:(TabContents*)newContents
-               previousContents:(TabContents*)oldContents
+- (void)tabReplacedWithContents:(content::WebContents*)newContents
+               previousContents:(content::WebContents*)oldContents
                         atIndex:(NSInteger)modelIndex {
   NSInteger index = [self indexFromModelIndex:modelIndex];
   TabContentsController* oldController =
       [tabContentsArray_ objectAtIndex:index];
-  DCHECK_EQ(oldContents->web_contents(), [oldController webContents]);
+  DCHECK_EQ(oldContents, [oldController webContents]);
 
   // Simply create a new TabContentsController for |newContents| and place it
   // into the array, replacing |oldContents|.  A ActiveTabChanged notification
   // will follow, at which point we will install the new view.
   scoped_nsobject<TabContentsController> newController(
-      [[TabContentsController alloc]
-          initWithContents:newContents->web_contents()]);
+      [[TabContentsController alloc] initWithContents:newContents]);
 
   // Bye bye, |oldController|.
   [tabContentsArray_ replaceObjectAtIndex:index withObject:newController];
 
   // Fake a tab changed notification to force tab titles and favicons to update.
   [self tabChangedWithContents:newContents
                        atIndex:modelIndex
                     changeType:TabStripModelObserver::ALL];
 }
 
@@ skipping 79 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:(content::WebContents*)contents
                         atIndex:(NSInteger)modelIndex {
   // Take closing tabs into account.
   NSInteger index = [self indexFromModelIndex:modelIndex];
 
   // Cancel any pending tab transition.
   hoverTabSelector_->CancelTabTransition();
 
   TabController* tab = [tabArray_ objectAtIndex:index];
   if (tabStripModel_->count() > 0) {
     [self startClosingTabWithAnimation:tab];
     [self layoutTabs];
   } else {
     [self removeTab:tab];
   }
 
-  [delegate_ onTabDetachedWithContents:contents->web_contents()];
+  [delegate_ onTabDetachedWithContents:contents];
 }
 
 // A helper routine for creating an NSImageView to hold the favicon or app icon
 // for |contents|.
-- (NSImageView*)iconImageViewForContents:(TabContents*)contents {
+- (NSImageView*)iconImageViewForContents:(content::WebContents*)contents {
   extensions::TabHelper* extensions_tab_helper =
-      extensions::TabHelper::FromWebContents(contents->web_contents());
+      extensions::TabHelper::FromWebContents(contents);
   BOOL isApp = extensions_tab_helper->is_app();
   NSImage* image = nil;
   // Favicons come from the renderer, and the renderer draws everything in the
   // system color space.
   CGColorSpaceRef colorSpace = base::mac::GetSystemColorSpace();
   if (isApp) {
     SkBitmap* icon = extensions_tab_helper->GetExtensionAppIcon();
     if (icon)
       image = gfx::SkBitmapToNSImageWithColorSpace(*icon, colorSpace);
   } else {
-    image = mac::FaviconForTabContents(contents);
+    image = mac::FaviconForWebContents(contents);
   }
 
   // Either we don't have a valid favicon or there was some issue converting it
   // from an SkBitmap. Either way, just show the default.
   if (!image)
     image = defaultFavicon_.get();
   NSRect frame = NSMakeRect(0, 0, kIconWidthAndHeight, kIconWidthAndHeight);
   NSImageView* view = [[[NSImageView alloc] initWithFrame:frame] autorelease];
   [view setImage:image];
   return view;
 }
 
 // Updates the current loading state, replacing the icon view with a favicon,
 // a throbber, the default icon, or nothing at all.
-- (void)updateFaviconForContents:(TabContents*)contents
+- (void)updateFaviconForContents:(content::WebContents*)contents
                          atIndex:(NSInteger)modelIndex {
   if (!contents)
     return;
 
   static NSImage* throbberWaitingImage =
       ResourceBundle::GetSharedInstance().GetNativeImageNamed(
           IDR_THROBBER_WAITING).CopyNSImage();
   static NSImage* throbberLoadingImage =
       ResourceBundle::GetSharedInstance().GetNativeImageNamed(
           IDR_THROBBER).CopyNSImage();
   static NSImage* sadFaviconImage =
       ResourceBundle::GetSharedInstance().GetNativeImageNamed(
           IDR_SAD_FAVICON).CopyNSImage();
 
   // Take closing tabs into account.
   NSInteger index = [self indexFromModelIndex:modelIndex];
   TabController* tabController = [tabArray_ objectAtIndex:index];
 
   FaviconTabHelper* favicon_tab_helper =
-      FaviconTabHelper::FromWebContents(contents->web_contents());
+      FaviconTabHelper::FromWebContents(contents);
   bool oldHasIcon = [tabController iconView] != nil;
   bool newHasIcon = favicon_tab_helper->ShouldDisplayFavicon() ||
       tabStripModel_->IsMiniTab(modelIndex);  // Always show icon if mini.
 
   TabLoadingState oldState = [tabController loadingState];
   TabLoadingState newState = kTabDone;
   NSImage* throbberImage = nil;
-  if (contents->web_contents()->IsCrashed()) {
+  if (contents->IsCrashed()) {
     newState = kTabCrashed;
     newHasIcon = true;
-  } else if (contents->web_contents()->IsWaitingForResponse()) {
+  } else if (contents->IsWaitingForResponse()) {
     newState = kTabWaiting;
     throbberImage = throbberWaitingImage;
-  } else if (contents->web_contents()->IsLoading()) {
+  } else if (contents->IsLoading()) {
     newState = kTabLoading;
     throbberImage = throbberLoadingImage;
   }
 
   if (oldState != newState)
     [tabController setLoadingState:newState];
 
   // While loading, this function is called repeatedly with the same state.
   // To avoid expensive unnecessary view manipulation, only make changes when
   // the state is actually changing.  When loading is complete (kTabDone),
@@ skipping 27 matching lines @@
       // some tests.
       //DCHECK_LE(NSMaxX([iconView frame]),
       //          NSWidth([[tabController view] frame]) - kTabOverlap);
     }
   }
 }
 
 // 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:(content::WebContents*)contents
                        atIndex:(NSInteger)modelIndex
                     changeType:(TabStripModelObserver::TabChangeType)change {
   // Take closing tabs into account.
   NSInteger index = [self indexFromModelIndex:modelIndex];
 
   if (modelIndex == tabStripModel_->active_index())
-    [delegate_ onTabChanged:change withContents:contents->web_contents()];
+    [delegate_ onTabChanged:change withContents:contents];
 
   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->web_contents()];
+    [self setTabTitle:tabController withContents:contents];
 
   [self updateFaviconForContents:contents atIndex:modelIndex];
 
   TabContentsController* updatedController =
       [tabContentsArray_ objectAtIndex:index];
-  [updatedController tabDidChange:contents->web_contents()];
+  [updatedController tabDidChange: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:(content::WebContents*)contents
                    fromIndex:(NSInteger)modelFrom
                      toIndex:(NSInteger)modelTo {
   // Take closing tabs into account.
   NSInteger from = [self indexFromModelIndex:modelFrom];
   NSInteger to = [self indexFromModelIndex:modelTo];
 
   // Cancel any pending tab transition.
   hoverTabSelector_->CancelTabTransition();
 
   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:(content::WebContents*)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)];
-  [tabController setUrl:contents->web_contents()->GetURL()];
+  [tabController setUrl:contents->GetURL()];
   [self updateFaviconForContents: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)setFrameOfActiveTab:(NSRect)frame {
   NSView* view = [self activeTabView];
   NSValue* identifier = [NSValue valueWithPointer:view];
@@ skipping 489 matching lines @@
 NSView* GetSheetParentViewForWebContents(WebContents* web_contents) {
   // View hierarchy of the contents view:
   // NSView  -- switchView, same for all tabs
   // +- NSView  -- TabContentsController's view
   //    +- TabContentsViewCocoa
   //
   // Changing it? Do not forget to modify
   // -[TabStripController swapInTabAtIndex:] too.
   return [web_contents->GetNativeView() superview];
 }