Implement dropping of tabs into an existing tab strip from another window.

chrome/browser/cocoa/tab_strip_controller.mm

 // Copyright (c) 2009 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"
 
 #include "base/sys_string_conversions.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/profile.h"
@@ skipping 118 matching lines @@
     if (index >= 0 && tabModel_->ContainsIndex(index))
       tabModel_->CloseTabContentsAt(index);
   } else {
     // Use the standard window close if this is the last tab
     // this prevents the tab from being removed from the model until after
     // the window dissapears
     [[tabView_ window] performClose:nil];
   }
 }
 
-
 - (void)insertPlaceholderForTab:(TabView*)tab
                           frame:(NSRect)frame
                   yStretchiness:(CGFloat)yStretchiness {
   placeholderTab_ = tab;
   placeholderFrame_ = frame;
   placeholderStretchiness_ = yStretchiness;
   [self layoutTabs];
 }
 
-
 // Lay out all tabs in the order of their TabContentsControllers, which matches
 // the ordering in the TabStripModel. This call isn't that expensive, though
 // it is O(n) in the number of tabs. Tabs will animate to their new position
 // if the window is visible.
 // TODO(pinkerton): Handle drag placeholders via proxy objects, perhaps a
 // subclass of TabContentsController with everything stubbed out or by
 // abstracting a base class interface.
 // TODO(pinkerton): Note this doesn't do too well when the number of min-sized
 // tabs would cause an overflow.
 - (void)layoutTabs {
@@ skipping 183 matching lines @@
                        atIndex:(NSInteger)index
                    loadingOnly:(BOOL)loading {
   if (!loading)
     [self setTabTitle:[tabArray_ objectAtIndex:index] withContents:contents];
 
   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.
+- (void)tabMovedWithContents:(TabContents*)contents
+                    fromIndex:(NSInteger)from
+                      toIndex:(NSInteger)to {
+  scoped_nsobject<TabContentsController> movedController(
+      [[tabContentsArray_ objectAtIndex:from] retain]);
+  [tabContentsArray_ removeObjectAtIndex:from];
+  [tabContentsArray_ insertObject:movedController.get() atIndex:to];
+  scoped_nsobject<TabView> movedView(
+      [[tabArray_ objectAtIndex:from] retain]);
+  [tabArray_ removeObjectAtIndex:from];
+  [tabArray_ insertObject:movedView.get() atIndex:to];
+
+  [self layoutTabs];
+}
+
 - (NSView *)selectedTabView {
   int selectedIndex = tabModel_->selected_index();
   return [self viewAtIndex:selectedIndex];
 }
 
-- (void)dropTabView:(NSView *)view atIndex:(NSUInteger)index {
-  // TODO(pinkerton): implement drop
-  NOTIMPLEMENTED();
+// Find the index based on the x coordinate of the placeholder. If there is
+// no placeholder, this returns the end of the tab strip.
+- (int)indexOfPlaceholder {
+  double placeholderX = placeholderFrame_.origin.x;
+  int index = 0;
+  int location = 0;
+  const int count = tabModel_->count();
+  while (index < count) {
+    NSView* curr = [self viewAtIndex:index];
+    // The placeholder tab works by changing the frame of the tab being dragged
+    // to be the bounds of the placeholder, so we need to skip it while we're
+    // iterating, otherwise we'll end up off by one.  Note This only effects
+    // dragging to the right, not to the left.
+    if (curr == placeholderTab_) {
+      index++;
+      continue;
+    }
+    if (placeholderX <= NSMinX([curr frame]))
+      break;
+    index++;
+    location++;
+  }
+  return location;
+}
+
+// Move the given tab at index |from| in this window to the location of the
+// current placeholder.
+- (void)moveTabFromIndex:(NSInteger)from {
+  int toIndex = [self indexOfPlaceholder];
+  tabModel_->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.
+- (void)dropTabContents:(TabContents*)contents {
+  int index = [self indexOfPlaceholder];
+
+  // Insert it into this tab strip. We want it in the foreground and to not
+  // inherit the current tab's group.
+  tabModel_->InsertTabContentsAt(index, contents, true, false);
 }
 
 // Return the rect, in WebKit coordinates (flipped), of the window's grow box
 // in the coordinate system of the content area of the currently selected tab.
 - (NSRect)selectedTabGrowBoxRect {
   int selectedIndex = tabModel_->selected_index();
   if (selectedIndex == TabStripModel::kNoTab) {
     // When the window is initially being constructed, there may be no currently
     // selected tab, so pick the first one. If there aren't any, just bail with
     // an empty rect.
     selectedIndex = 0;
   }
   TabContentsController* selectedController =
       [tabContentsArray_ objectAtIndex:selectedIndex];
   if (!selectedController)
     return NSZeroRect;
   return [selectedController growBoxRect];
 }
 
 @end