TabContentsWrapper -> TabContents, part 37.

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>
 
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/extensions/extension_tab_helper.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/thumbnail_generator.h"
 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper.h"
 #include "chrome/browser/ui/cocoa/animation_utils.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_constants.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
 #import "chrome/browser/ui/cocoa/infobars/infobar_container_controller.h"
 #import "chrome/browser/ui/cocoa/tab_contents/favicon_util.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_strip_controller.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_strip_model_observer_bridge.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "skia/ext/skia_utils_mac.h"
 #include "third_party/skia/include/utils/mac/SkCGUtils.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image.h"
@@ skipping 56 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 TabContentsWrapper object. The layer
+// A CALayer that draws a thumbnail for a TabContents 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 TabContentsWrapper the thumbnail is for.
-  TabContentsWrapper* contents_;  // weak
+  // The TabContents the thumbnail is for.
+  TabContents* 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:(TabContentsWrapper*)contents
+- (id)initWithTabContents:(TabContents*)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 51 matching lines @@
       base::Bind(&ThumbnailLoader::DidReceiveBitmap,
                  weak_factory_.GetWeakPtr()),
       page_size,
       pixel_size);
 }
 
 }  // namespace tabpose
 
 @implementation ThumbnailLayer
 
-- (id)initWithTabContents:(TabContentsWrapper*)contents
+- (id)initWithTabContents:(TabContents*)contents
                  fullSize:(NSSize)fullSize {
   CHECK(contents);
   if ((self = [super init])) {
     contents_ = contents;
     fullSize_ = fullSize;
   }
   return self;
 }
 
-- (void)setTabContents:(TabContentsWrapper*)contents {
+- (void)setTabContents:(TabContents*)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];
@@ skipping 23 matching lines @@
       contents_->bookmark_tab_helper()->ShouldShowBookmarkBar() &&
       !always_show_bookmark_bar;
   if (has_detached_bookmark_bar)
     topOffset += bookmarks::kNTPBookmarkBarHeight;
 
   return topOffset;
 }
 
 - (int)bottomOffset {
   int bottomOffset = 0;
-  TabContentsWrapper* devToolsContents =
+  TabContents* devToolsContents =
       DevToolsWindow::GetDevToolsContents(contents_->web_contents());
   if (devToolsContents && devToolsContents->web_contents() &&
       devToolsContents->web_contents()->GetRenderViewHost() &&
       devToolsContents->web_contents()->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->web_contents()->GetRenderViewHost()->GetView()->
             GetViewBounds().height();
@@ skipping 145 matching lines @@
   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();
   }
 
-  TabContentsWrapper* tab_contents() const { return contents_; }
-  void set_tab_contents(TabContentsWrapper* new_contents) {
+  TabContents* tab_contents() const { return contents_; }
+  void set_tab_contents(TabContents* 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_;
 
-  TabContentsWrapper* contents_;  // weak
+  TabContents* 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;
 }
@@ skipping 72 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, TabContentsWrapper* contents);
+  void InsertTileAt(int index, TabContents* 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 245 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, TabContentsWrapper* contents) {
+void TileSet::InsertTileAt(int index, TabContents* 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 708 matching lines @@
 
   CALayer* titleLayer = [allTitleLayers_ objectAtIndex:i];
   AnimateCALayerFrameFromTo(
       titleLayer,
       NSRectFromCGRect(titleLayer.frame),
       tile.title_rect(),
       kObserverChangeAnimationDuration,
       nil);
 }
 
-- (void)insertTabWithContents:(TabContentsWrapper*)contents
+- (void)insertTabWithContents:(TabContents*)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:(TabContentsWrapper*)contents
+- (void)tabClosingWithContents:(TabContents*)contents
                        atIndex:(NSInteger)index {
   // We will also get a -tabDetachedWithContents:atIndex: notification for
   // closing tabs, so do nothing here.
 }
 
-- (void)tabDetachedWithContents:(TabContentsWrapper*)contents
+- (void)tabDetachedWithContents:(TabContents*)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:(TabContentsWrapper*)contents
+- (void)tabMovedWithContents:(TabContents*)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:(TabContentsWrapper*)contents
+- (void)tabChangedWithContents:(TabContents*)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()) {
     // 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];
 }
 
 - (void)tabStripModelDeleted {
   [self close];
 }
 
 @end