Remove TabContents from TabStripModelObserverBridge.

chrome/browser/ui/cocoa/tabpose_window.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/tabpose_window.h"
 
 #import <QuartzCore/QuartzCore.h>
 
 #include <algorithm>
 
@@ skipping 86 matching lines @@
           grayColorSpace.get(), grays, locations, arraysize(locations)));
   CGPoint topLeft = CGPointMake(0.0, self.bounds.size.height);
   CGContextDrawLinearGradient(context, gradient.get(), topLeft, CGPointZero, 0);
 }
 @end
 
 namespace tabpose {
 class ThumbnailLoader;
 }
 
-// A CALayer that draws a thumbnail for a TabContents object. The layer
+// A CALayer that draws a thumbnail for a WebContents object. The layer
 // tries to draw the WebContents's backing store directly if possible, and
 // requests a thumbnail bitmap from the WebContents's renderer process if not.
 @interface ThumbnailLayer : CALayer {
-  // The TabContents the thumbnail is for.
-  TabContents* contents_;  // weak
+  // The WebContents the thumbnail is for.
+  content::WebContents* contents_;  // weak
 
   // The size the thumbnail is drawn at when zoomed in.
   NSSize fullSize_;
 
   // Used to load a thumbnail, if required.
   scoped_refptr<tabpose::ThumbnailLoader> loader_;
 
   // If the backing store couldn't be used and a thumbnail was returned from a
   // renderer process, it's stored in |thumbnail_|.
   base::mac::ScopedCFTypeRef<CGImageRef> thumbnail_;
 
   // True if the layer already sent a thumbnail request to a renderer.
   BOOL didSendLoad_;
 }
-- (id)initWithTabContents:(TabContents*)contents
+- (id)initWithWebContents:(content::WebContents*)contents
                  fullSize:(NSSize)fullSize;
 - (void)drawInContext:(CGContextRef)context;
 - (void)setThumbnail:(const SkBitmap&)bitmap;
 @end
 
 namespace tabpose {
 
 // ThumbnailLoader talks to the renderer process to load a thumbnail of a given
 // RenderWidgetHost, and sends the thumbnail back to a ThumbnailLayer once it
 // comes back from the renderer.
@@ skipping 40 matching lines @@
       base::Bind(&ThumbnailLoader::DidReceiveBitmap,
                  weak_factory_.GetWeakPtr()),
       page_size,
       pixel_size);
 }
 
 }  // namespace tabpose
 
 @implementation ThumbnailLayer
 
-- (id)initWithTabContents:(TabContents*)contents
+- (id)initWithWebContents:(content::WebContents*)contents
                  fullSize:(NSSize)fullSize {
   CHECK(contents);
   if ((self = [super init])) {
     contents_ = contents;
     fullSize_ = fullSize;
   }
   return self;
 }
 
-- (void)setTabContents:(TabContents*)contents {
+- (void)setWebContents:(content::WebContents*)contents {
   contents_ = contents;
 }
 
 - (void)setThumbnail:(const SkBitmap&)bitmap {
   // SkCreateCGImageRef() holds on to |bitmaps|'s memory, so this doesn't
   // create a copy. The renderer always draws data in the system colorspace.
   thumbnail_.reset(SkCreateCGImageRefWithColorspace(
       bitmap, base::mac::GetSystemColorSpace()));
   loader_ = NULL;
   [self setNeedsDisplay];
 }
 
 - (int)topOffset {
   int topOffset = 0;
 
   // Medium term, we want to show thumbs of the actual info bar views, which
   // means I need to create InfoBarControllers here.
-  NSWindow* window = [contents_->web_contents()->GetNativeView() window];
+  NSWindow* window = [contents_->GetNativeView() window];
   NSWindowController* windowController = [window windowController];
   if ([windowController isKindOfClass:[BrowserWindowController class]]) {
     BrowserWindowController* bwc =
         static_cast<BrowserWindowController*>(windowController);
     InfoBarContainerController* infoBarContainer =
         [bwc infoBarContainerController];
     // TODO(thakis|rsesek): This is not correct for background tabs with
     // infobars as the aspect ratio will be wrong. Fix that.
     topOffset += NSHeight([[infoBarContainer view] frame]) -
         [infoBarContainer overlappingTipHeight];
   }
 
   BookmarkTabHelper* bookmark_tab_helper =
-      BookmarkTabHelper::FromWebContents(contents_->web_contents());
+      BookmarkTabHelper::FromWebContents(contents_);
+  Profile* profile =
+      Profile::FromBrowserContext(contents_->GetBrowserContext());
   bool always_show_bookmark_bar =
-      contents_->profile()->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
+      profile->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
   bool has_detached_bookmark_bar =
       bookmark_tab_helper->ShouldShowBookmarkBar() &&
       !always_show_bookmark_bar;
   if (has_detached_bookmark_bar)
     topOffset += chrome::kNTPBookmarkBarHeight;
 
   return topOffset;
 }
 
 - (int)bottomOffset {
   int bottomOffset = 0;
   DevToolsWindow* devToolsWindow =
-      DevToolsWindow::GetDockedInstanceForInspectedTab(
-          contents_->web_contents());
+      DevToolsWindow::GetDockedInstanceForInspectedTab(contents_);
   content::WebContents* devToolsContents = devToolsWindow ?
       devToolsWindow->tab_contents()->web_contents() : NULL;
   if (devToolsContents && devToolsContents->GetRenderViewHost() &&
       devToolsContents->GetRenderViewHost()->GetView()) {
     // The devtool's size might not be up-to-date, but since its height doesn't
     // change on window resize, and since most users don't use devtools, this is
     // good enough.
     bottomOffset += devToolsContents->GetRenderViewHost()->GetView()->
         GetViewBounds().height();
     bottomOffset += 1;  // :-( Divider line between web contents and devtools.
   }
   return bottomOffset;
 }
 
 - (void)drawInContext:(CGContextRef)context {
-  RenderWidgetHost* rwh = contents_->web_contents()->GetRenderViewHost();
+  RenderWidgetHost* rwh = contents_->GetRenderViewHost();
   // NULL if renderer crashed.
   content::RenderWidgetHostView* rwhv = rwh ? rwh->GetView() : NULL;
   if (!rwhv) {
     // TODO(thakis): Maybe draw a sad tab layer?
     [super drawInContext:context];
     return;
   }
 
   // The size of the WebContents's RenderWidgetHost might not fit to the
   // current browser window at all, for example if the window was resized while
@@ skipping 125 matching lines @@
   // 3. calls |set_font_metrics()| which updates the title rect
   // 4. receives the title rect and puts the title on it with the font from 2.
   void set_font_metrics(CGFloat ascender, CGFloat descender);
   CGFloat title_font_size() const { return title_font_size_; }
 
   NSRect GetTitleStartRectRelativeTo(const Tile& tile) const;
   NSRect title_rect() const { return NSIntegralRect(title_rect_); }
 
   // Returns an unelided title. The view logic is responsible for eliding.
   const string16& title() const {
-    return contents_->web_contents()->GetTitle();
+    return contents_->GetTitle();
   }
 
-  TabContents* tab_contents() const { return contents_; }
-  void set_tab_contents(TabContents* new_contents) {
+  content::WebContents* web_contents() const { return contents_; }
+  void set_tab_contents(content::WebContents* new_contents) {
     contents_ = new_contents;
   }
 
  private:
   friend class TileSet;
 
   // The thumb rect includes infobars, detached thumbnail bar, web contents,
   // and devtools.
   NSRect thumb_rect_;
   NSRect start_thumb_rect_;
 
   NSRect favicon_rect_;
 
   CGFloat title_font_size_;
   NSRect title_rect_;
 
-  TabContents* contents_;  // weak
+  content::WebContents* contents_;  // weak
 
   DISALLOW_COPY_AND_ASSIGN(Tile);
 };
 
 NSRect Tile::GetStartRectRelativeTo(const Tile& tile) const {
   NSRect rect = start_thumb_rect_;
   rect.origin.x -= tile.start_thumb_rect_.origin.x;
   rect.origin.y -= tile.start_thumb_rect_.origin.y;
   return rect;
 }
 
 NSRect Tile::GetFaviconStartRectRelativeTo(const Tile& tile) const {
   NSRect thumb_start = GetStartRectRelativeTo(tile);
   CGFloat scale_to_start = NSWidth(thumb_start) / NSWidth(thumb_rect_);
   NSRect rect =
       ScaleRectWithOrigin(favicon_rect_, thumb_rect_.origin, scale_to_start);
   rect.origin.x += NSMinX(thumb_start) - NSMinX(thumb_rect_);
   rect.origin.y += NSMinY(thumb_start) - NSMinY(thumb_rect_);
   return rect;
 }
 
 NSImage* Tile::favicon() const {
   extensions::TabHelper* extensions_tab_helper =
-      extensions::TabHelper::FromWebContents(contents_->web_contents());
+      extensions::TabHelper::FromWebContents(contents_);
   if (extensions_tab_helper->is_app()) {
     SkBitmap* bitmap = extensions_tab_helper->GetExtensionAppIcon();
     if (bitmap)
       return gfx::SkBitmapToNSImage(*bitmap);
   }
-  return mac::FaviconForTabContents(contents_);
+  return mac::FaviconForWebContents(contents_);
 }
 
 NSRect Tile::GetTitleStartRectRelativeTo(const Tile& tile) const {
   NSRect thumb_start = GetStartRectRelativeTo(tile);
   CGFloat scale_to_start = NSWidth(thumb_start) / NSWidth(thumb_rect_);
   NSRect rect =
       ScaleRectWithOrigin(title_rect_, thumb_rect_.origin, scale_to_start);
   rect.origin.x += NSMinX(thumb_start) - NSMinX(thumb_rect_);
   rect.origin.y += NSMinY(thumb_start) - NSMinY(thumb_rect_);
   return rect;
@@ skipping 44 matching lines @@
   int down_index() const;
   int left_index() const;
   int right_index() const;
 
   // These return which index needs to be selected on tab / shift-tab.
   int next_index() const;
   int previous_index() const;
 
   // Inserts a new Tile object containing |contents| at |index|. Does no
   // relayout.
-  void InsertTileAt(int index, TabContents* contents);
+  void InsertTileAt(int index, content::WebContents* contents);
 
   // Removes the Tile object at |index|. Does no relayout.
   void RemoveTileAt(int index);
 
   // Moves the Tile object at |from_index| to |to_index|. Since this doesn't
   // change the number of tiles, relayout can be done just by swapping the
   // tile rectangles in the index interval [from_index, to_index], so this does
   // layout.
   void MoveTileFromTo(int from_index, int to_index);
 
@@ skipping 23 matching lines @@
   int count_y_;
 
   DISALLOW_COPY_AND_ASSIGN(TileSet);
 };
 
 void TileSet::Build(TabStripModel* source_model) {
   selected_index_ =  source_model->active_index();
   tiles_.resize(source_model->count());
   for (size_t i = 0; i < tiles_.size(); ++i) {
     tiles_[i] = new Tile;
-    tiles_[i]->contents_ = source_model->GetTabContentsAt(i);
+    tiles_[i]->contents_ = source_model->GetWebContentsAt(i);
   }
 }
 
 void TileSet::Layout(NSRect containing_rect) {
   int tile_count = tiles_.size();
   if (tile_count == 0)  // Happens e.g. during test shutdown.
     return;
 
   // Room around the tiles insde of |containing_rect|.
   const int kSmallPaddingTop = 30;
@@ skipping 201 matching lines @@
   return new_index;
 }
 
 int TileSet::previous_index() const {
   int new_index = selected_index() - 1;
   if (new_index < 0)
     new_index = tiles_.size() - 1;
   return new_index;
 }
 
-void TileSet::InsertTileAt(int index, TabContents* contents) {
+void TileSet::InsertTileAt(int index, content::WebContents* contents) {
   tiles_.insert(tiles_.begin() + index, new Tile);
   tiles_[index]->contents_ = contents;
 }
 
 void TileSet::RemoveTileAt(int index) {
   tiles_.erase(tiles_.begin() + index);
 }
 
 // Moves the Tile object at |from_index| to |to_index|. Also updates rectangles
 // so that the tiles stay in a left-to-right, top-to-bottom layout when walked
@@ skipping 167 matching lines @@
   tileSet_->set_selected_index(newIndex);
 
   [self updateClosebuttonLayersVisibility];
 }
 
 - (void)addLayersForTile:(tabpose::Tile&)tile
                 showZoom:(BOOL)showZoom
                    slomo:(BOOL)slomo
        animationDelegate:(id)animationDelegate {
   scoped_nsobject<CALayer> layer([[ThumbnailLayer alloc]
-      initWithTabContents:tile.tab_contents()
+      initWithWebContents:tile.web_contents()
                  fullSize:tile.GetStartRectRelativeTo(
                      tileSet_->selected_tile()).size]);
   [layer setNeedsDisplay];
 
   NSTimeInterval interval =
       kDefaultAnimationDuration * (slomo ? kSlomoFactor : 1);
 
   // Background color as placeholder for now.
   layer.get().backgroundColor = CGColorGetConstantColor(kCGColorWhite);
   if (showZoom) {
@@ skipping 520 matching lines @@
 
   CALayer* titleLayer = [allTitleLayers_ objectAtIndex:i];
   AnimateCALayerFrameFromTo(
       titleLayer,
       NSRectFromCGRect(titleLayer.frame),
       tile.title_rect(),
       kObserverChangeAnimationDuration,
       nil);
 }
 
-- (void)insertTabWithContents:(TabContents*)contents
+- (void)insertTabWithContents:(content::WebContents*)contents
                       atIndex:(NSInteger)index
                  inForeground:(bool)inForeground {
   // This happens if you cmd-click a link and then immediately open tabpose
   // on a slowish machine.
   ScopedCAActionSetDuration durationSetter(kObserverChangeAnimationDuration);
 
   // Insert new layer and relayout.
   tileSet_->InsertTileAt(index, contents);
   tileSet_->Layout(containingRect_);
   [self  addLayersForTile:tileSet_->tile_at(index)
@@ skipping 16 matching lines @@
   [self selectTileAtIndexWithoutAnimation:selectedIndex];
 
   // Animate everything into its new place.
   for (int i = 0; i < tabStripModel_->count(); ++i) {
     if (i == index)  // The new layer.
       continue;
     [self refreshLayerFramesAtIndex:i];
   }
 }
 
-- (void)tabClosingWithContents:(TabContents*)contents
+- (void)tabClosingWithContents:(content::WebContents*)contents
                        atIndex:(NSInteger)index {
   // We will also get a -tabDetachedWithContents:atIndex: notification for
   // closing tabs, so do nothing here.
 }
 
-- (void)tabDetachedWithContents:(TabContents*)contents
+- (void)tabDetachedWithContents:(content::WebContents*)contents
                         atIndex:(NSInteger)index {
   ScopedCAActionSetDuration durationSetter(kObserverChangeAnimationDuration);
 
   // Remove layer and relayout.
   tileSet_->RemoveTileAt(index);
   tileSet_->Layout(containingRect_);
 
   {
     ScopedCAActionDisabler disabler;
     [[allThumbnailLayers_ objectAtIndex:index] removeFromSuperlayer];
@@ skipping 20 matching lines @@
   if (selectedIndex > index || selectedIndex >= tabStripModel_->count())
     selectedIndex--;
   if (selectedIndex >= 0)
     [self selectTileAtIndexWithoutAnimation:selectedIndex];
 
   // Animate everything into its new place.
   for (int i = 0; i < tabStripModel_->count(); ++i)
     [self refreshLayerFramesAtIndex:i];
 }
 
-- (void)tabMovedWithContents:(TabContents*)contents
+- (void)tabMovedWithContents:(content::WebContents*)contents
                     fromIndex:(NSInteger)from
                       toIndex:(NSInteger)to {
   ScopedCAActionSetDuration durationSetter(kObserverChangeAnimationDuration);
 
   // Move tile from |from| to |to|.
   tileSet_->MoveTileFromTo(from, to);
 
   // Move corresponding layers from |from| to |to|.
   scoped_nsobject<CALayer> thumbLayer(
       [[allThumbnailLayers_ objectAtIndex:from] retain]);
@@ skipping 16 matching lines @@
     selectedIndex--;
   else if (to <= selectedIndex && selectedIndex < from)
     selectedIndex++;
   [self selectTileAtIndexWithoutAnimation:selectedIndex];
 
   // Update frames of the layers.
   for (int i = std::min(from, to); i <= std::max(from, to); ++i)
     [self refreshLayerFramesAtIndex:i];
 }
 
-- (void)tabChangedWithContents:(TabContents*)contents
+- (void)tabChangedWithContents:(content::WebContents*)contents
                        atIndex:(NSInteger)index
                     changeType:(TabStripModelObserver::TabChangeType)change {
   // Tell the window to update text, title, and thumb layers at |index| to get
   // their data from |contents|. |contents| can be different from the old
   // contents at that index!
   // While a tab is loading, this is unfortunately called quite often for
   // both the "loading" and the "all" change types, so we don't really want to
   // send thumb requests to the corresponding renderer when this is called.
   // For now, just make sure that we don't hold on to an invalid WebContents
   // object.
   tabpose::Tile& tile = tileSet_->tile_at(index);
-  if (contents == tile.tab_contents()) {
+  if (contents == tile.web_contents()) {
     // TODO(thakis): Install a timer to send a thumb request/update title/update
     // favicon after 20ms or so, and reset the timer every time this is called
     // to make sure we get an updated thumb, without requesting them all over.
     return;
   }
 
   tile.set_tab_contents(contents);
   ThumbnailLayer* thumbLayer = [allThumbnailLayers_ objectAtIndex:index];
-  [thumbLayer setTabContents:contents];
+  [thumbLayer setWebContents:contents];
 }
 
 - (void)tabStripModelDeleted {
   [self close];
 }
 
 @end