[Mac] Re-enable pinned tabs; add support for mini-tabs and phantom tabs.

chrome/browser/cocoa/tab_strip_controller.mm

 // Copyright (c) 2010 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/cocoa/tab_strip_controller.h"
 
 #import <QuartzCore/QuartzCore.h>
 
 #include <limits>
 #include <string>
@@ skipping 105 matching lines @@
 - (void)regenerateSubviewList;
 - (NSInteger)indexForContentsView:(NSView*)view;
 - (void)updateFavIconForContents:(TabContents*)contents
                          atIndex:(NSInteger)modelIndex;
 - (void)layoutTabsWithAnimation:(BOOL)animate
              regenerateSubviews:(BOOL)doUpdate;
 - (void)animationDidStopForController:(TabController*)controller
                              finished:(BOOL)finished;
 - (NSInteger)indexFromModelIndex:(NSInteger)index;
 - (NSInteger)numberOfOpenTabs;
-- (NSInteger)numberOfOpenPinnedTabs;
-- (NSInteger)numberOfOpenUnpinnedTabs;
+- (NSInteger)numberOfOpenMiniTabs;
+- (NSInteger)numberOfOpenNonMiniTabs;
 - (void)mouseMoved:(NSEvent*)event;
 - (void)setTabTrackingAreasEnabled:(BOOL)enabled;
 - (void)droppingURLsAt:(NSPoint)point
             givesIndex:(NSInteger*)index
            disposition:(WindowOpenDisposition*)disposition;
 @end
 
 // A simple view class that prevents the Window Server from dragging the area
 // behind tabs. Sometimes core animation confuses it. Unfortunately, it can also
 // falsely pick up clicks during rapid tab closure, so we have to account for
@@ skipping 317 matching lines @@
   return controller;
 }
 
 // (Private) Returns the number of open tabs in the tab strip. This is the
 // number of TabControllers we know about (as there's a 1-to-1 mapping from
 // these controllers to a tab) less the number of closing tabs.
 - (NSInteger)numberOfOpenTabs {
   return static_cast<NSInteger>(tabStripModel_->count());
 }
 
-// (Private) Returns the number of open, pinned tabs.
-- (NSInteger)numberOfOpenPinnedTabs {
-  // Ask the model for the number of pinned tabs. Note that tabs which are in
+// (Private) Returns the number of open, mini-tabs.
+- (NSInteger)numberOfOpenMiniTabs {
+  // Ask the model for the number of mini tabs. Note that tabs which are in
   // the process of closing (i.e., whose controllers are in
   // |closingControllers_|) have already been removed from the model.
-  // TODO: convert to apps.
-  return 0;
+  return tabStripModel_->IndexOfFirstNonMiniTab();
 }
 
-// (Private) Returns the number of open, unpinned tabs.
-- (NSInteger)numberOfOpenUnpinnedTabs {
-  NSInteger number = [self numberOfOpenTabs] - [self numberOfOpenPinnedTabs];
+// (Private) Returns the number of open, non-mini tabs.
+- (NSInteger)numberOfOpenNonMiniTabs {
+  NSInteger number = [self numberOfOpenTabs] - [self numberOfOpenMiniTabs];
   DCHECK_GE(number, 0);
   return number;
 }
 
 // Given an index into the tab model, returns the index into the tab controller
 // or tab contents controller array accounting for tabs that are currently
 // closing. For example, if there are two tabs in the process of closing before
 // |index|, this returns |index| + 2. If there are no closing tabs, this will
 // return |index|.
 - (NSInteger)indexFromModelIndex:(NSInteger)index {
@@ skipping 160 matching lines @@
 // tabs would cause an overflow. http://crbug.com/188
 - (void)layoutTabsWithAnimation:(BOOL)animate
              regenerateSubviews:(BOOL)doUpdate {
   DCHECK([NSThread isMainThread]);
   if (![tabArray_ count])
     return;
 
   const CGFloat kMaxTabWidth = [TabController maxTabWidth];
   const CGFloat kMinTabWidth = [TabController minTabWidth];
   const CGFloat kMinSelectedTabWidth = [TabController minSelectedTabWidth];
-  const CGFloat kPinnedTabWidth = [TabController pinnedTabWidth];
+  const CGFloat kMiniTabWidth = [TabController miniTabWidth];
 
   NSRect enclosingRect = NSZeroRect;
   ScopedNSAnimationContextGroup mainAnimationGroup(animate);
   mainAnimationGroup.SetCurrentContextDuration(kAnimationDuration);
 
   // Update the current subviews and their z-order if requested.
   if (doUpdate)
     [self regenerateSubviewList];
 
   // Compute the base width of tabs given how much room we're allowed. Note that
-  // pinned tabs have a fixed width. We may not be able to use the entire width
+  // mini-tabs have a fixed width. We may not be able to use the entire width
   // if the user is quickly closing tabs. This may be negative, but that's okay
   // (taken care of by |MAX()| when calculating tab sizes).
   CGFloat availableWidth = 0;
   if ([self inRapidClosureMode]) {
     availableWidth = availableResizeWidth_;
   } else {
     availableWidth = NSWidth([tabStripView_ frame]);
     // Account for the new tab button and the incognito badge.
     availableWidth -= NSWidth([newTabButton_ frame]) + kNewTabButtonOffset;
     if (browser_->profile()->IsOffTheRecord())
       availableWidth -= kIncognitoBadgeTabStripShrink;
   }
   availableWidth -= [self indentForControls];
 
   // This may be negative, but that's okay (taken care of by |MAX()| when
   // calculating tab sizes).
-  CGFloat availableWidthForUnpinned = availableWidth -
-      [self numberOfOpenPinnedTabs] * (kPinnedTabWidth - kTabOverlap);
+  CGFloat availableWidthForNonMini = availableWidth -
+      [self numberOfOpenMiniTabs] * (kMiniTabWidth - kTabOverlap);
 
-  // Initialize |unpinnedTabWidth| in case there aren't any unpinned tabs; this
+  // Initialize |nonMiniTabWidth| in case there aren't any non-mini-tabs; this
   // value shouldn't actually be used.
-  CGFloat unpinnedTabWidth = kMaxTabWidth;
-  const NSInteger numberOfOpenUnpinnedTabs = [self numberOfOpenUnpinnedTabs];
-  if (numberOfOpenUnpinnedTabs) {  // Find the width of an unpinned tab.
+  CGFloat nonMiniTabWidth = kMaxTabWidth;
+  const NSInteger numberOfOpenNonMiniTabs = [self numberOfOpenNonMiniTabs];
+  if (numberOfOpenNonMiniTabs) {  // Find the width of a non-mini-tab.
     // Add in the amount we "get back" from the tabs overlapping.
-    availableWidthForUnpinned += (numberOfOpenUnpinnedTabs - 1) * kTabOverlap;
+    availableWidthForNonMini += (numberOfOpenNonMiniTabs - 1) * kTabOverlap;
 
-    // Divide up the space between the unpinned tabs.
-    unpinnedTabWidth = availableWidthForUnpinned / numberOfOpenUnpinnedTabs;
+    // Divide up the space between the non-mini-tabs.
+    nonMiniTabWidth = availableWidthForNonMini / numberOfOpenNonMiniTabs;
 
     // Clamp the width between the max and min.
-    unpinnedTabWidth = MAX(MIN(unpinnedTabWidth, kMaxTabWidth), kMinTabWidth);
+    nonMiniTabWidth = MAX(MIN(nonMiniTabWidth, kMaxTabWidth), kMinTabWidth);
   }
 
   const CGFloat minX = NSMinX(placeholderFrame_);
   BOOL visible = [[tabStripView_ window] isVisible];
 
   CGFloat offset = [self indentForControls];
   NSUInteger i = 0;
   bool hasPlaceholderGap = false;
   for (TabController* tab in tabArray_.get()) {
     // Ignore a tab that is going through a close animation.
@@ skipping 35 matching lines @@
     // to the right of it we should slide over to make space for it.
     if (placeholderTab_ && !hasPlaceholderGap && NSMidX(tabFrame) > minX) {
       hasPlaceholderGap = true;
       offset += NSWidth(placeholderFrame_);
       offset -= kTabOverlap;
       tabFrame.origin.x = offset;
     }
 
     // Set the width. Selected tabs are slightly wider when things get really
     // small and thus we enforce a different minimum width.
-    tabFrame.size.width = [tab pinned] ? kPinnedTabWidth : unpinnedTabWidth;
+    tabFrame.size.width = [tab mini] ? kMiniTabWidth : nonMiniTabWidth;
     if ([tab selected])
       tabFrame.size.width = MAX(tabFrame.size.width, kMinSelectedTabWidth);
 
     // Animate a new tab in by putting it below the horizon unless told to put
     // it in a specific location (i.e., from a drop).
     if (newTab && visible && animate) {
       if (NSEqualRects(droppedTabFrame_, NSZeroRect)) {
         [[tab view] setFrame:NSOffsetRect(tabFrame, 0, -NSHeight(tabFrame))];
       } else {
         [[tab view] setFrame:droppedTabFrame_];
@@ skipping 110 matching lines @@
   // 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.
   TabContentsController* contentsController =
       [[[TabContentsController alloc] initWithNibName:@"TabContents"
                                              contents:contents]
           autorelease];
   [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)];
   [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];
@@ skipping 24 matching lines @@
 
 // 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)selectTabWithContents:(TabContents*)newContents
              previousContents:(TabContents*)oldContents
                       atIndex:(NSInteger)modelIndex
                   userGesture:(bool)wasUserGesture {
   // Take closing tabs into account.
   NSInteger index = [self indexFromModelIndex:modelIndex];
 
+  if (oldContents) {
+    int oldModelIndex =
+        browser_->GetIndexOfController(&(oldContents->controller()));
+    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->view()->StoreFocus();
+      oldContents->WasHidden();
+      // If the selection changed because the tab was made phantom, update the
+      // Cocoa side of the state.
+      TabController* tabController = [tabArray_ objectAtIndex:oldIndex];
+      [tabController setPhantom:tabStripModel_->IsPhantomTab(oldModelIndex)];
+    }
+  }
+
   // De-select all other tabs and select the new tab.
   int i = 0;
   for (TabController* current in tabArray_.get()) {
     [current setSelected:(i == index) ? YES : NO];
     ++i;
   }
 
   // Tell the new tab contents it is about to become the selected tab. Here it
   // can do things like make sure the toolbar is up to date.
   TabContentsController* newController =
       [tabContentsArray_ objectAtIndex:index];
   [newController willBecomeSelectedTab];
 
   // 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];
 
-  if (oldContents) {
-    int oldModelIndex =
-        browser_->GetIndexOfController(&(oldContents->controller()));
-    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->view()->StoreFocus();
-      oldContents->WasHidden();
-    }
-  }
-
   // Swap in the contents for the new tab.
   [self swapInTabAtIndex:modelIndex];
   [self updateDevToolsForContents:newContents];
 
   if (newContents) {
     newContents->DidBecomeSelected();
     newContents->view()->RestoreFocus();
 
     if (newContents->find_ui_active())
       browser_->GetFindBarController()->find_bar()->SetFocusAndSelection();
@@ skipping 145 matching lines @@
         retain];
   static NSImage* sadFaviconImage =
       [ResourceBundle::GetSharedInstance().GetNSImageNamed(IDR_SAD_FAVICON)
         retain];
 
   // Take closing tabs into account.
   NSInteger index = [self indexFromModelIndex:modelIndex];
 
   TabController* tabController = [tabArray_ objectAtIndex:index];
 
+  // Since the tab is loading, it cannot be phantom any more.
+  if ([tabController phantom]) {
+    [tabController setPhantom:NO];
+    [[tabController view] setNeedsDisplay:YES];
+  }
+
   bool oldHasIcon = [tabController iconView] != nil;
   bool newHasIcon = contents->ShouldDisplayFavIcon() ||
-      tabStripModel_->IsTabPinned(modelIndex);  // always show icon if pinned
+      tabStripModel_->IsMiniTab(modelIndex);  // Always show icon if mini.
 
   TabLoadingState oldState = [tabController loadingState];
   TabLoadingState newState = kTabDone;
   NSImage* throbberImage = nil;
   if (contents->is_crashed()) {
     newState = kTabCrashed;
     newHasIcon = true;
   } else if (contents->waiting_for_response()) {
     newState = kTabWaiting;
     throbberImage = throbberWaitingImage;
@@ skipping 40 matching lines @@
                     changeType:(TabStripModelObserver::TabChangeType)change {
   // Take closing tabs into account.
   NSInteger index = [self indexFromModelIndex:modelIndex];
 
   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:[tabArray_ objectAtIndex:index] withContents:contents];
+    [self setTabTitle:tabController withContents:contents];
+
+  // See if the change was to/from phantom.
+  bool isPhantom = tabStripModel_->IsPhantomTab(modelIndex);
+  if (isPhantom != [tabController phantom])
+    [tabController setPhantom:isPhantom];
 
   [self updateFavIconForContents:contents atIndex:modelIndex];
 
   TabContentsController* updatedController =
       [tabContentsArray_ objectAtIndex:index];
   [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
                    fromIndex:(NSInteger)modelFrom
-                     toIndex:(NSInteger)modelTo
-          pinnedStateChanged:(BOOL)pinnedChanged {
+                     toIndex:(NSInteger)modelTo {
   // Take closing tabs into account.
   NSInteger from = [self indexFromModelIndex:modelFrom];
   NSInteger to = [self indexFromModelIndex:modelTo];
 
   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];
 
-  if (pinnedChanged) {
-    [movedTabController
-        setPinned:(tabStripModel_->IsTabPinned(modelTo) ? YES : NO)];
-    [self updateFavIconForContents:contents atIndex:modelTo];
-  }
-
-  // TODO(viettrungluu): I don't think this is needed. Investigate. See also
-  // |-tabPinnedStateChangedWithContents:...|.
-  [self layoutTabs];
+  // The tab moved, which means that the mini-tab state may have changed.
+  if (tabStripModel_->IsMiniTab(modelTo) != [movedTabController mini])
+    [self tabMiniStateChangedWithContents:contents atIndex:modelTo];
 }
 
 // Called when a tab is pinned or unpinned without moving.
-- (void)tabPinnedStateChangedWithContents:(TabContents*)contents
-                                  atIndex:(NSInteger)modelIndex {
+- (void)tabMiniStateChangedWithContents:(TabContents*)contents
+                                atIndex:(NSInteger)modelIndex {
   // Take closing tabs into account.
   NSInteger index = [self indexFromModelIndex:modelIndex];
 
   TabController* tabController = [tabArray_ objectAtIndex:index];
   DCHECK([tabController isKindOfClass:[TabController class]]);
-  [tabController setPinned:
-      (tabStripModel_->IsTabPinned(modelIndex) ? YES : NO)];
+  [tabController setMini:
+      (tabStripModel_->IsMiniTab(modelIndex) ? YES : NO)];
   [self updateFavIconForContents:contents atIndex:modelIndex];
-
-  // TODO(viettrungluu): I don't think this is needed. Investigate. See also
-  // |-tabMovedWithContents:...|.
-  [self layoutTabs];
 }
 
 - (void)setFrameOfSelectedTab:(NSRect)frame {
   NSView* view = [self selectedTabView];
   NSValue* identifier = [NSValue valueWithPointer:view];
   [targetFrames_ setObject:[NSValue valueWithRect:frame]
                     forKey:identifier];
   [view setFrame:frame];
 }
 
@@ skipping 45 matching lines @@
 - (void)moveTabFromIndex:(NSInteger)from {
   int toIndex = [self indexOfPlaceholder];
   tabStripModel_->MoveTabContentsAt(from, toIndex, true);
 }
 
 // Drop a given TabContents at the location of the current placeholder. If there
 // is no placeholder, it will go at the end. Used when dragging from another
 // window when we don't have access to the TabContents as part of our strip.
 // |frame| is in the coordinate system of the tab strip view and represents
 // where the user dropped the new tab so it can be animated into its correct
-// location when the tab is added to the model.
-- (void)dropTabContents:(TabContents*)contents withFrame:(NSRect)frame {
+// location when the tab is added to the model. If the tab was pinned in its
+// previous window, setting |pinned| to YES will propagate that state to the
+// new window. Mini-tabs are either app or pinned tabs; the app state is stored
+// by the |contents|, but the |pinned| state is the caller's responsibility.
+- (void)dropTabContents:(TabContents*)contents
+              withFrame:(NSRect)frame
+            asPinnedTab:(BOOL)pinned {
   int modelIndex = [self indexOfPlaceholder];
 
   // Mark that the new tab being created should start at |frame|. It will be
   // reset as soon as the tab has been positioned.
   droppedTabFrame_ = frame;
 
   // Insert it into this tab strip. We want it in the foreground and to not
   // inherit the current tab's group.
-  tabStripModel_->InsertTabContentsAt(modelIndex, contents, true, false);
-
-  // Take closing tabs into account.
-  NSInteger index = [self indexFromModelIndex:modelIndex];
-
-  // The tab's pinned status may have changed.
-  // TODO(viettrungluu): Improve the behaviour for drops at the dividing point
-  // between pinned and unpinned tabs.
-  TabController* tabController = [tabArray_ objectAtIndex:index];
-  DCHECK([tabController isKindOfClass:[TabController class]]);
-  [tabController setPinned:
-      (tabStripModel_->IsTabPinned(modelIndex) ? YES : NO)];
-  [self updateFavIconForContents:contents atIndex:modelIndex];
+  tabStripModel_->InsertTabContentsAt(modelIndex, contents, true, false,
+                                      pinned);
 }
 
 // Called when the tab strip view changes size. As we only registered for
 // changes on our view, we know it's only for our view. Layout w/out
 // animations since they are blocked by the resize nested runloop. We need
 // the views to adjust immediately. Neither the tabs nor their z-order are
 // changed, so we don't need to update the subviews.
 - (void)tabViewFrameChanged:(NSNotification*)info {
   [self layoutTabsWithAnimation:NO regenerateSubviews:NO];
 }
@@ skipping 384 matching lines @@
     return;
 
   TabContentsController* tabController =
       [tabContentsArray_ objectAtIndex:index];
   TabContents* devtoolsContents = contents ?
       DevToolsWindow::GetDevToolsContents(contents) : NULL;
   [tabController showDevToolsContents:devtoolsContents];
 }
 
 @end