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

chrome/browser/cocoa/browser_window_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/browser_window_controller.h"
 
 #include <Carbon/Carbon.h>
 
 #include "app/l10n_util_mac.h"
 #include "base/mac_util.h"
@@ skipping 347 matching lines @@
              withObject:nil
              afterDelay:0];
 }
 
 // Called when the window meets the criteria to be closed (ie,
 // |-windowShouldClose:| returns YES). We must be careful to preserve the
 // semantics of BrowserWindow::Close() and not call the Browser's dtor directly
 // from this method.
 - (void)windowWillClose:(NSNotification*)notification {
   DCHECK_EQ([notification object], [self window]);
-  DCHECK(!browser_->tabstrip_model()->count());
+  DCHECK(!browser_->tabstrip_model()->HasNonPhantomTabs() ||
+         !browser_->tabstrip_model()->count());
   [savedRegularWindow_ close];
   // We delete statusBubble here because we need to kill off the dependency
   // that its window has on our window before our window goes away.
   delete statusBubble_;
   statusBubble_ = NULL;
   // We can't actually use |-autorelease| here because there's an embedded
   // run loop in the |-performClose:| which contains its own autorelease pool.
   // Instead call it after a zero-length delay, which gets us back to the main
   // event loop.
   [self performSelector:@selector(autorelease)
@@ skipping 681 matching lines @@
     // 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_->tabstrip_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 TabContents' 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 withFrame:destinationFrame];
+    [tabStripController_ dropTabContents:contents
+                               withFrame:destinationFrame
+                             asPinnedTab:isPinned];
   } else {
     // Moving within a window.
     int index = [tabStripController_ modelIndexForTabView:view];
     [tabStripController_ moveTabFromIndex:index];
   }
 
   // Remove the placeholder since the drag is now complete.
   [self removePlaceholder];
 }
 
@@ skipping 22 matching lines @@
 }
 
 - (void)layoutTabs {
   [tabStripController_ layoutTabs];
 }
 
 - (TabWindowController*)detachTabToNewWindow:(TabView*)tabView {
   // Disable screen updates so that this appears as a single visual change.
   base::ScopedNSDisableScreenUpdates disabler;
 
-  // Fetch the tab contents for the tab being dragged
+  // Fetch the tab contents for the tab being dragged.
   int index = [tabStripController_ modelIndexForTabView:tabView];
   TabContents* contents = browser_->tabstrip_model()->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 =
       [screen frame].size.height - windowRect.size.height -
           windowRect.origin.y;
   gfx::Rect browserRect(windowRect.origin.x, windowRect.origin.y,
                         windowRect.size.width, windowRect.size.height);
 
   NSRect tabRect = [tabView frame];
 
+  // Before detaching the tab, store the pinned state.
+  bool isPinned = browser_->tabstrip_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 TabContents' delegate, which gets hooked
   // up during creation of the new window.
   browser_->tabstrip_model()->DetachTabContentsAt(index);
 
   // Create the new window with a single tab in its model, the one being
   // dragged.
   DockInfo dockInfo;
   Browser* newBrowser =
       browser_->tabstrip_model()->TearOffTabContents(contents,
                                                      browserRect,
                                                      dockInfo);
 
+  // Propagate the tab pinned state of the new tab (which is the only tab in
+  // this new window).
+  newBrowser->tabstrip_model()->SetTabPinned(0, isPinned);
+
   // Get the new controller by asking the new window for its delegate.
   BrowserWindowController* controller =
       reinterpret_cast<BrowserWindowController*>(
           [newBrowser->window()->GetNativeHandle() delegate]);
   DCHECK(controller && [controller isKindOfClass:[TabWindowController class]]);
 
   // Force the added tab to the right size (remove stretching.)
   tabRect.size.height = [TabStripController defaultTabHeight];
 
   // And make sure we use the correct frame in the new view.
@@ skipping 670 matching lines @@
 
 - (BOOL)supportsBookmarkBar {
   return [self supportsWindowFeature:Browser::FEATURE_BOOKMARKBAR];
 }
 
 - (BOOL)isNormalWindow {
   return browser_->type() == Browser::TYPE_NORMAL;
 }
 
 @end  // @implementation BrowserWindowController(WindowType)