Move tab functions off Browser into browser_tabstrip and browser_tabrestore.

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 11 matching lines @@
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/sync_ui_util_mac.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_command_controller.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_list.h"
+#include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window_state.h"
 #import "chrome/browser/ui/cocoa/background_gradient_view.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_controller.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_editor_controller.h"
 #import "chrome/browser/ui/cocoa/browser/avatar_button_controller.h"
 #import "chrome/browser/ui/cocoa/browser_window_cocoa.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller_private.h"
 #import "chrome/browser/ui/cocoa/browser_window_utils.h"
 #import "chrome/browser/ui/cocoa/chrome_to_mobile_bubble_controller.h"
 #import "chrome/browser/ui/cocoa/dev_tools_controller.h"
@@ skipping 371 matching lines @@
 }
 
 - (void)awakeFromNib {
   // Set different minimum sizes on tabbed windows vs non-tabbed, e.g. popups.
   NSSize minSize = [self isTabbedWindow] ?
       NSMakeSize(400, 272) : NSMakeSize(100, 122);
   [[self window] setMinSize:minSize];
 }
 
 - (void)dealloc {
-  browser_->CloseAllTabs();
+  chrome::CloseAllTabs(browser_.get());
   [downloadShelfController_ exiting];
 
   // Explicitly release |presentationModeController_| here, as it may call back
   // to this BWC in |-dealloc|.  We are required to call |-exitPresentationMode|
   // before releasing the controller.
   [presentationModeController_ exitPresentationMode];
   presentationModeController_.reset();
 
   // Under certain testing configurations we may not actually own the browser.
   if (ownsBrowser_ == NO)
@@ skipping 157 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_->GetActiveWebContents()) {
+  if (WebContents* contents = chrome::GetActiveWebContents(browser_.get())) {
     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_->GetActiveWebContents()) {
+  if (WebContents* contents = chrome::GetActiveWebContents(browser_.get())) {
     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_->GetActiveWebContents()) {
+  if (WebContents* contents = chrome::GetActiveWebContents(browser_.get())) {
     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_->GetActiveWebContents()) {
+  if (WebContents* contents = chrome::GetActiveWebContents(browser_.get())) {
     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_->GetActiveWebContents()) {
+    if (WebContents* contents = chrome::GetActiveWebContents(browser_.get())) {
       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_->GetActiveWebContents()) {
+    if (WebContents* contents = chrome::GetActiveWebContents(browser_.get())) {
       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_->GetActiveWebContents();
+  WebContents* contents = chrome::GetActiveWebContents(browser_.get());
   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_->GetActiveWebContents()) {
+    if (content::WebContents* contents =
+            chrome::GetActiveWebContents(browser_.get())) {
       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_->GetActiveWebContents();
+    WebContents* current_tab = chrome::GetActiveWebContents(browser_.get());
     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];
-    TabContents* contents = dragBWC->browser_->GetTabContentsAt(index);
+    TabContents* contents =
+        chrome::GetTabContentsAt(dragBWC->browser_.get(), 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];
     NSPoint tabOrigin = destinationFrame.origin;
     tabOrigin = [[dragController tabStripView] convertPoint:tabOrigin
                                                      toView:nil];
     tabOrigin = [[view window] convertBaseToScreen:tabOrigin];
     tabOrigin = [[self window] convertScreenToBase:tabOrigin];
     tabOrigin = [[self tabStripView] convertPoint:tabOrigin fromView:nil];
     destinationFrame.origin = tabOrigin;
 
     // Before the tab is detached from its originating tab strip, store the
     // pinned state so that it can be maintained between the windows.
-    bool isPinned = dragBWC->browser_->IsTabPinned(index);
+    bool isPinned = dragBWC->browser_->tab_strip_model()->IsTabPinned(index);
 
     // Now that we have enough information about the tab, we can remove it from
     // the dragging window. We need to do this *before* we add it to the new
     // window as this will remove the WebContents' delegate.
     [dragController detachTabView:view];
 
     // Deposit it into our model at the appropriate location (it already knows
     // where it should go from tracking the drag). Doing this sets the tab's
     // delegate to be the Browser.
     [tabStripController_ dropTabContents:contents
@@ skipping 36 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];
-  TabContents* contents = browser_->GetTabContentsAt(index);
+  TabContents* contents = chrome::GetTabContentsAt(browser_.get(), 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));
 
   NSRect sourceTabRect = [tabView frame];
   NSView* tabStrip = [self tabStripView];
 
   // Pushes tabView's frame back inside the tabstrip.
   NSSize tabOverflow =
       [self overflowFrom:[tabStrip convertRect:sourceTabRect toView:nil]
                       to:[tabStrip frame]];
   NSRect tabRect = NSOffsetRect(sourceTabRect,
                                 -tabOverflow.width, -tabOverflow.height);
 
   // Before detaching the tab, store the pinned state.
-  bool isPinned = browser_->IsTabPinned(index);
+  bool isPinned = browser_->tab_strip_model()->IsTabPinned(index);
 
   // Detach it from the source window, which just updates the model without
   // deleting the tab contents. This needs to come before creating the new
   // Browser because it clears the WebContents' delegate, which gets hooked
   // up during creation of the new window.
   browser_->tab_strip_model()->DetachTabContentsAt(index);
 
   // Create the new window with a single tab in its model, the one being
   // dragged.
   DockInfo dockInfo;
@@ skipping 139 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_->GetActiveWebContents();
+  WebContents* contents = chrome::GetActiveWebContents(browser_.get());
   return base::SysUTF16ToNSString(contents->GetTitle());
 }
 
 - (NSRect)regularWindowFrame {
   return [self isFullscreen] ? savedRegularWindowFrame_ :
                                [[self window] frame];
 }
 
 // (Override of |TabWindowController| method.)
 - (BOOL)hasTabStrip {
@@ skipping 252 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_->GetActiveWebContents()) {
+  if (WebContents* contents = chrome::GetActiveWebContents(browser_.get())) {
     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_->GetActiveWebContents()) {
+  if (WebContents* contents = chrome::GetActiveWebContents(browser_.get())) {
     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 376 matching lines @@
 
 - (BOOL)supportsBookmarkBar {
   return [self supportsWindowFeature:Browser::FEATURE_BOOKMARKBAR];
 }
 
 - (BOOL)isTabbedWindow {
   return browser_->is_type_tabbed();
 }
 
 @end  // @implementation BrowserWindowController(WindowType)