Respect Spaces when dragging tabs on OS X

chrome/browser/cocoa/tab_view.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_view.h"
 
 #include "base/logging.h"
+#import "base/mac_util.h"
 #include "base/nsimage_cache_mac.h"
+#include "base/scoped_cftyperef.h"
 #include "chrome/browser/browser_theme_provider.h"
 #import "chrome/browser/cocoa/tab_controller.h"
 #import "chrome/browser/cocoa/tab_window_controller.h"
 #import "chrome/browser/cocoa/themed_window.h"
 #include "grit/theme_resources.h"
 
 namespace {
 
 // Constants for inset and control points for tab shape.
 const CGFloat kInsetMultiplier = 2.0/3.0;
@@ skipping 20 matching lines @@
 // has moved less than the threshold, we want to close the tab.
 const CGFloat kRapidCloseDist = 2.5;
 
 }  // namespace
 
 @interface TabView(Private)
 
 - (void)resetLastGlowUpdateTime;
 - (NSTimeInterval)timeElapsedSinceLastGlowUpdate;
 - (void)adjustGlowValue;
+// TODO(davidben): When we stop supporting 10.5, this can be removed.
+- (int)getWorkspaceID:(NSWindow*)window useCache:(BOOL)useCache;
 
 @end  // TabView(Private)
 
 @implementation TabView
 
 @synthesize state = state_;
 @synthesize hoverAlpha = hoverAlpha_;
 @synthesize alertAlpha = alertAlpha_;
 @synthesize closing = closing_;
 
@@ skipping 95 matching lines @@
 
 // Returns an array of controllers that could be a drop target, ordered front to
 // back. It has to be of the appropriate class, and visible (obviously). Note
 // that the window cannot be a target for itself.
 - (NSArray*)dropTargetsForController:(TabWindowController*)dragController {
   NSMutableArray* targets = [NSMutableArray array];
   NSWindow* dragWindow = [dragController window];
   for (NSWindow* window in [NSApp orderedWindows]) {
     if (window == dragWindow) continue;
     if (![window isVisible]) continue;
+    // Skip windows on the wrong space.
+    if ([window respondsToSelector:@selector(isOnActiveSpace)]) {
+      if (![window performSelector:@selector(isOnActiveSpace)])
+        continue;
+    } else {
+      // TODO(davidben): When we stop supporting 10.5, this can be
+      // removed.
+      //
+      // We don't cache the workspace of |dragWindow| because it may
+      // move around spaces.
+      if ([self getWorkspaceID:dragWindow useCache:NO] !=
+          [self getWorkspaceID:window useCache:YES])
+        continue;
+    }
     NSWindowController* controller = [window windowController];
     if ([controller isKindOfClass:[TabWindowController class]]) {
       TabWindowController* realController =
           static_cast<TabWindowController*>(controller);
       if ([realController canReceiveFrom:dragController])
         [targets addObject:controller];
     }
   }
   return targets;
 }
 
 // Call to clear out transient weak references we hold during drags.
 - (void)resetDragControllers {
   draggedController_ = nil;
   dragWindow_ = nil;
   dragOverlay_ = nil;
   sourceController_ = nil;
   sourceWindow_ = nil;
   targetController_ = nil;
+  workspaceIDCache_.clear();
 }
 
 // Sets whether the window background should be visible or invisible when
 // dragging a tab. The background should be invisible when the mouse is over a
 // potential drop target for the tab (the tab strip). It should be visible when
 // there's no drop target so the window looks more fully realized and ready to
 // become a stand-alone window.
 - (void)setWindowBackgroundVisibility:(BOOL)shouldBeVisible {
   if (chromeIsVisible_ == shouldBeVisible)
     return;
@@ skipping 766 matching lines @@
     }
   }
 
   if (nextUpdate < kNoUpdate)
     [self performSelector:_cmd withObject:nil afterDelay:nextUpdate];
 
   [self resetLastGlowUpdateTime];
   [self setNeedsDisplay:YES];
 }
 
+// Returns the workspace id of |window|. If |useCache|, then we lookup

[pink (ping after 24hrs), 2010/07/19 17:14:35]

avoid the use of "we", it makes mark grumpy.

[davidben, 2010/07/19 17:25:17]

...I've really got to do something about that habit. :-)

+// and remember the value in |workspaceIDCache_| until the end of the
+// current drag.
+- (int)getWorkspaceID:(NSWindow*)window useCache:(BOOL)useCache {
+  CGWindowID windowID = [window windowNumber];
+  if (useCache) {
+    std::map<CGWindowID, int>::iterator iter =
+        workspaceIDCache_.find(windowID);
+    if (iter != workspaceIDCache_.end())
+      return iter->second;
+  }
+
+  int workspace = -1;
+  // It's possible to query in bulk, but probably not necessary.
+  scoped_cftyperef<CFArrayRef> windowIDs(CFArrayCreate(
+      NULL, reinterpret_cast<const void **>(&windowID), 1, NULL));
+  scoped_cftyperef<CFArrayRef> descriptions(
+      CGWindowListCreateDescriptionFromArray(windowIDs));
+  DCHECK(CFArrayGetCount(descriptions.get()) <= 1);
+  if (CFArrayGetCount(descriptions.get()) > 0) {
+    CFDictionaryRef dict = static_cast<CFDictionaryRef>(
+        CFArrayGetValueAtIndex(descriptions.get(), 0));
+    DCHECK(CFGetTypeID(dict) == CFDictionaryGetTypeID());
+
+    // Sanity check the ID.
+    CFNumberRef otherIDRef = (CFNumberRef)mac_util::GetValueFromDictionary(
+        dict, kCGWindowNumber, CFNumberGetTypeID());
+    CGWindowID otherID;
+    if (otherIDRef &&
+        CFNumberGetValue(otherIDRef, kCGWindowIDCFNumberType, &otherID) &&
+        otherID == windowID) {
+      // And then get the workspace.
+      CFNumberRef workspaceRef = (CFNumberRef)mac_util::GetValueFromDictionary(
+          dict, kCGWindowWorkspace, CFNumberGetTypeID());
+      if (!workspaceRef ||
+          !CFNumberGetValue(workspaceRef, kCFNumberIntType, &workspace)) {
+        workspace = -1;
+      }
+    } else {
+      NOTREACHED();
+    }
+  }
+  if (useCache) {
+    workspaceIDCache_[windowID] = workspace;
+  }
+  return workspace;
+}
+
 @end  // @implementation TabView(Private)