TabContentsWrapper -> TabContents, part 37.

chrome/browser/ui/cocoa/browser_window_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/browser_window_controller.h"
 
 #include <cmath>
 #include <numeric>
 
 #include "base/command_line.h"
@@ skipping 39 matching lines @@
 #import "chrome/browser/ui/cocoa/status_bubble_mac.h"
 #import "chrome/browser/ui/cocoa/tab_contents/previewable_contents_controller.h"
 #import "chrome/browser/ui/cocoa/tab_contents/sad_tab_controller.h"
 #import "chrome/browser/ui/cocoa/tab_contents/tab_contents_controller.h"
 #import "chrome/browser/ui/cocoa/tabpose_window.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_strip_controller.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_strip_view.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_view.h"
 #import "chrome/browser/ui/cocoa/toolbar/toolbar_controller.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/dock_info.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/toolbar/encoding_menu_controller.h"
 #include "chrome/browser/ui/window_sizer.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.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/generated_resources.h"
@@ skipping 515 matching lines @@
 
   // TODO(viettrungluu): For some reason, the above doesn't suffice.
   if ([self isFullscreen])
     [floatingBarBackingView_ setNeedsDisplay:YES];  // Okay even if nil.
 }
 
 // Called when we are activated (when we gain focus).
 - (void)windowDidBecomeKey:(NSNotification*)notification {
   // We need to activate the controls (in the "WebView"). To do this, get the
   // selected WebContents's RenderWidgetHostView and tell it to activate.
-  if (WebContents* contents = browser_->GetSelectedWebContents()) {
+  if (WebContents* contents = browser_->GetActiveWebContents()) {
     if (RenderWidgetHostView* rwhv = contents->GetRenderWidgetHostView())
       rwhv->SetActive(true);
   }
 }
 
 // Called when we are deactivated (when we lose focus).
 - (void)windowDidResignKey:(NSNotification*)notification {
   // If our app is still active and we're still the key window, ignore this
   // message, since it just means that a menu extra (on the "system status bar")
   // was activated; we'll get another |-windowDidResignKey| if we ever really
   // lose key window status.
   if ([NSApp isActive] && ([NSApp keyWindow] == [self window]))
     return;
 
   // We need to deactivate the controls (in the "WebView"). To do this, get the
   // selected WebContents's RenderWidgetHostView and tell it to deactivate.
-  if (WebContents* contents = browser_->GetSelectedWebContents()) {
+  if (WebContents* contents = browser_->GetActiveWebContents()) {
     if (RenderWidgetHostView* rwhv = contents->GetRenderWidgetHostView())
       rwhv->SetActive(false);
   }
 }
 
 // Called when we have been minimized.
 - (void)windowDidMiniaturize:(NSNotification *)notification {
   [self saveWindowPositionIfNeeded];
 
   // Let the selected RenderWidgetHostView know, so that it can tell plugins.
-  if (WebContents* contents = browser_->GetSelectedWebContents()) {
+  if (WebContents* contents = browser_->GetActiveWebContents()) {
     if (RenderWidgetHostView* rwhv = contents->GetRenderWidgetHostView())
       rwhv->SetWindowVisibility(false);
   }
 }
 
 // Called when we have been unminimized.
 - (void)windowDidDeminiaturize:(NSNotification *)notification {
   // Let the selected RenderWidgetHostView know, so that it can tell plugins.
-  if (WebContents* contents = browser_->GetSelectedWebContents()) {
+  if (WebContents* contents = browser_->GetActiveWebContents()) {
     if (RenderWidgetHostView* rwhv = contents->GetRenderWidgetHostView())
       rwhv->SetWindowVisibility(true);
   }
 }
 
 // Called when the application has been hidden.
 - (void)applicationDidHide:(NSNotification *)notification {
   // Let the selected RenderWidgetHostView know, so that it can tell plugins
   // (unless we are minimized, in which case nothing has really changed).
   if (![[self window] isMiniaturized]) {
-    if (WebContents* contents = browser_->GetSelectedWebContents()) {
+    if (WebContents* contents = browser_->GetActiveWebContents()) {
       if (RenderWidgetHostView* rwhv = contents->GetRenderWidgetHostView())
         rwhv->SetWindowVisibility(false);
     }
   }
 }
 
 // Called when the application has been unhidden.
 - (void)applicationDidUnhide:(NSNotification *)notification {
   // Let the selected RenderWidgetHostView know, so that it can tell plugins
   // (unless we are minimized, in which case nothing has really changed).
   if (![[self window] isMiniaturized]) {
-    if (WebContents* contents = browser_->GetSelectedWebContents()) {
+    if (WebContents* contents = browser_->GetActiveWebContents()) {
       if (RenderWidgetHostView* rwhv = contents->GetRenderWidgetHostView())
         rwhv->SetWindowVisibility(true);
     }
   }
 }
 
 // Called when the user clicks the zoom button (or selects it from the Window
 // menu) to determine the "standard size" of the window, based on the content
 // and other factors. If the current size/location differs nontrivally from the
 // standard size, Cocoa resizes the window to the standard size, and saves the
@@ skipping 24 matching lines @@
   }
 
   // To prevent strange results on portrait displays, the basic minimum zoomed
   // width is the larger of: 60% of available width, 60% of available height
   // (bounded by available width).
   const CGFloat kProportion = 0.6;
   CGFloat zoomedWidth =
       std::max(kProportion * NSWidth(frame),
                std::min(kProportion * NSHeight(frame), NSWidth(frame)));
 
-  WebContents* contents = browser_->GetSelectedWebContents();
+  WebContents* contents = browser_->GetActiveWebContents();
   if (contents) {
     // If the intrinsic width is bigger, then make it the zoomed width.
     const int kScrollbarWidth = 16;  // TODO(viettrungluu): ugh.
     CGFloat intrinsicWidth = static_cast<CGFloat>(
         contents->GetPreferredSize().width() + kScrollbarWidth);
     zoomedWidth = std::max(zoomedWidth,
                            std::min(intrinsicWidth, NSWidth(frame)));
   }
 
   // Never shrink from the current size on zoom (see above).
@@ skipping 216 matching lines @@
     }
   }
 
   frame.size.height = height;
   // TODO(rohitrao): Determine if calling setFrame: twice is bad.
   [view setFrame:frame];
   [self layoutSubviews];
 
   if (resizeRectDirty) {
     // Send new resize rect to foreground tab.
-    if (content::WebContents* contents = browser_->GetSelectedWebContents()) {
+    if (content::WebContents* contents = browser_->GetActiveWebContents()) {
       if (content::RenderViewHost* rvh = contents->GetRenderViewHost()) {
         rvh->ResizeRectChanged(windowShim_->GetRootWindowResizerRect());
       }
     }
   }
 }
 
 - (void)setAnimationInProgress:(BOOL)inProgress {
   [[self tabContentArea] setFastResizeMode:inProgress];
 }
@@ skipping 19 matching lines @@
   }
 
   // Update the checked/Unchecked state of items in the encoding menu.
   // On Windows, this logic is part of |EncodingMenuModel| in
   // browser/ui/views/toolbar_view.h.
   EncodingMenuController encoding_controller;
   if (encoding_controller.DoesCommandBelongToEncodingMenu(tag)) {
     DCHECK(browser_.get());
     Profile* profile = browser_->profile();
     DCHECK(profile);
-    WebContents* current_tab = browser_->GetSelectedWebContents();
+    WebContents* current_tab = browser_->GetActiveWebContents();
     if (!current_tab) {
       return;
     }
     const std::string encoding = current_tab->GetEncoding();
 
     bool toggled = encoding_controller.IsItemChecked(profile, encoding, tag);
     NSInteger oldState = [item state];
     NSInteger newState = toggled ? NSOnState : NSOffState;
     if (oldState != newState)
       [item setState:newState];
@@ skipping 232 matching lines @@
      fromController:(TabWindowController*)dragController {
   if (dragController) {
     // Moving between windows. Figure out the WebContents to drop into our tab
     // model from the source window's model.
     BOOL isBrowser =
         [dragController isKindOfClass:[BrowserWindowController class]];
     DCHECK(isBrowser);
     if (!isBrowser) return;
     BrowserWindowController* dragBWC = (BrowserWindowController*)dragController;
     int index = [dragBWC->tabStripController_ modelIndexForTabView:view];
-    TabContentsWrapper* contents =
-        dragBWC->browser_->GetTabContentsWrapperAt(index);
+    TabContents* contents = dragBWC->browser_->GetTabContentsAt(index);
     // The tab contents may have gone away if given a window.close() while it
     // is being dragged. If so, bail, we've got nothing to drop.
     if (!contents)
       return;
 
     // Convert |view|'s frame (which starts in the source tab strip's coordinate
     // system) to the coordinate system of the destination tab strip. This needs
     // to be done before being detached so the window transforms can be
     // performed.
     NSRect destinationFrame = [view frame];
@@ skipping 57 matching lines @@
 - (void)layoutTabs {
   [tabStripController_ layoutTabs];
 }
 
 - (TabWindowController*)detachTabToNewWindow:(TabView*)tabView {
   // Disable screen updates so that this appears as a single visual change.
   gfx::ScopedNSDisableScreenUpdates disabler;
 
   // Fetch the tab contents for the tab being dragged.
   int index = [tabStripController_ modelIndexForTabView:tabView];
-  TabContentsWrapper* contents = browser_->GetTabContentsWrapperAt(index);
+  TabContents* contents = browser_->GetTabContentsAt(index);
 
   // Set the window size. Need to do this before we detach the tab so it's
   // still in the window. We have to flip the coordinates as that's what
   // is expected by the Browser code.
   NSWindow* sourceWindow = [tabView window];
   NSRect windowRect = [sourceWindow frame];
   NSScreen* screen = [sourceWindow screen];
   windowRect.origin.y = NSHeight([screen frame]) - NSMaxY(windowRect);
   gfx::Rect browserRect(windowRect.origin.x, windowRect.origin.y,
                         NSWidth(windowRect), NSHeight(windowRect));
@@ skipping 162 matching lines @@
 - (NSInteger)numberOfTabs {
   // count() includes pinned tabs.
   return browser_->tab_count();
 }
 
 - (BOOL)hasLiveTabs {
   return !browser_->tab_strip_model()->empty();
 }
 
 - (NSString*)activeTabTitle {
-  WebContents* contents = browser_->GetSelectedWebContents();
+  WebContents* contents = browser_->GetActiveWebContents();
   return base::SysUTF16ToNSString(contents->GetTitle());
 }
 
 - (NSRect)regularWindowFrame {
   return [self isFullscreen] ? savedRegularWindowFrame_ :
                                [[self window] frame];
 }
 
 // (Override of |TabWindowController| method.)
 - (BOOL)hasTabStrip {
@@ skipping 11 matching lines @@
   [devToolsController_ updateDevToolsForWebContents:contents
                                         withProfile:browser_->profile()];
 
   // Update the bookmark bar.
   // Must do it after devtools updates, otherwise bookmark bar might
   // call resizeView -> layoutSubviews and cause unnecessary relayout.
   // TODO(viettrungluu): perhaps update to not terminate running animations (if
   // applicable)?
   [self updateBookmarkBarVisibilityWithAnimation:NO];
 
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(contents);
+  TabContents* tabContents = TabContents::FromWebContents(contents);
   // Without the .get(), xcode fails.
-  [infoBarContainerController_.get() changeTabContents:wrapper];
+  [infoBarContainerController_.get() changeTabContents:tabContents];
 }
 
 - (void)onReplaceTabWithContents:(WebContents*)contents {
   // Simply remove the preview view if it exists; the tab strip
   // controller will reinstall the view as the active view.
   [previewableContentsController_ hidePreview];
   [self updateBookmarkBarVisibilityWithAnimation:NO];
 }
 
 - (void)onTabChanged:(TabStripModelObserver::TabChangeType)change
         withContents:(WebContents*)contents {
   // Update titles if this is the currently selected tab and if it isn't just
   // the loading state which changed.
   if (change != TabStripModelObserver::LOADING_ONLY)
     windowShim_->UpdateTitleBar();
 
   // Update the bookmark bar if this is the currently selected tab and if it
   // isn't just the title which changed. This for transitions between the NTP
   // (showing its floating bookmark bar) and normal web pages (showing no
   // bookmark bar).
   // TODO(viettrungluu): perhaps update to not terminate running animations?
   if (change != TabStripModelObserver::TITLE_NOT_LOADING)
     [self updateBookmarkBarVisibilityWithAnimation:NO];
 }
 
 - (void)onTabDetachedWithContents:(WebContents*)contents {
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(contents);
-  [infoBarContainerController_ tabDetachedWithContents:wrapper];
+  TabContents* tabContents = TabContents::FromWebContents(contents);
+  [infoBarContainerController_ tabDetachedWithContents:tabContents];
 }
 
 - (void)userChangedTheme {
   // TODO(dmaclach): Instead of redrawing the whole window, views that care
   // about the active window state should be registering for notifications.
   [[self window] setViewsNeedDisplay:YES];
 }
 
 - (ui::ThemeProvider*)themeProvider {
   return ThemeServiceFactory::GetForProfile(browser_->profile());
@@ skipping 185 matching lines @@
 - (void)windowDidResize:(NSNotification*)notification {
   [self saveWindowPositionIfNeeded];
 
   // Resize (and possibly move) the status bubble. Note that we may get called
   // when the status bubble does not exist.
   if (statusBubble_) {
     statusBubble_->UpdateSizeAndPosition();
   }
 
   // Let the selected RenderWidgetHostView know, so that it can tell plugins.
-  if (WebContents* contents = browser_->GetSelectedWebContents()) {
+  if (WebContents* contents = browser_->GetActiveWebContents()) {
     if (RenderWidgetHostView* rwhv = contents->GetRenderWidgetHostView())
       rwhv->WindowFrameChanged();
   }
 
   // The FindBar needs to know its own position to properly detect overlaps
   // with find results. The position changes whenever the window is resized,
   // and |layoutSubviews| computes the FindBar's position.
   // TODO: calling |layoutSubviews| here is a waste, find a better way to
   // do this.
   if ([findBarCocoaController_ isFindBarVisible])
@@ skipping 33 matching lines @@
   // |-windowWillMove| is called too early for us to apply our heuristic. (The
   // heuristic we use for detecting window movement is that if |windowTopGrowth_
   // > 0|, then we should be at the bottom of the work area -- if we're not,
   // we've moved. Similarly for the other side.)
   if (!NSContainsRect(workarea, windowFrame) ||
       (windowTopGrowth_ > 0 && NSMinY(windowFrame) != NSMinY(workarea)) ||
       (windowBottomGrowth_ > 0 && NSMaxY(windowFrame) != NSMaxY(workarea)))
     [self resetWindowGrowthState];
 
   // Let the selected RenderWidgetHostView know, so that it can tell plugins.
-  if (WebContents* contents = browser_->GetSelectedWebContents()) {
+  if (WebContents* contents = browser_->GetActiveWebContents()) {
     if (RenderWidgetHostView* rwhv = contents->GetRenderWidgetHostView())
       rwhv->WindowFrameChanged();
   }
 }
 
 // Delegate method called when window will be resized; not called for
 // |-setFrame:display:|.
 - (NSSize)windowWillResize:(NSWindow*)sender toSize:(NSSize)frameSize {
   [self resetWindowGrowthState];
   return frameSize;
@@ skipping 392 matching lines @@
 
 - (BOOL)supportsBookmarkBar {
   return [self supportsWindowFeature:Browser::FEATURE_BOOKMARKBAR];
 }
 
 - (BOOL)isTabbedWindow {
   return browser_->is_type_tabbed();
 }
 
 @end  // @implementation BrowserWindowController(WindowType)