Plumb the DragOperation through all the layers between the platform DnD code ...

chrome/browser/tab_contents/tab_contents_view_mac.mm

 // Copyright (c) 2006-2008 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.
 
 #include "chrome/browser/tab_contents/tab_contents_view_mac.h"
 
 #include <string>
 
 #include "chrome/browser/browser.h" // TODO(beng): this dependency is awful.
 #include "chrome/browser/cocoa/sad_tab_view.h"
 #import "chrome/browser/cocoa/web_drag_source.h"
 #import "chrome/browser/cocoa/web_drop_target.h"
 #include "chrome/browser/renderer_host/render_widget_host.h"
 #include "chrome/browser/renderer_host/render_widget_host_view_mac.h"
 #include "chrome/browser/tab_contents/render_view_context_menu_mac.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/render_messages.h"
 #import "third_party/mozilla/include/NSPasteboard+Utils.h"
 
 #include "chrome/common/temp_scaffolding_stubs.h"
 
+using WebKit::WebDragOperation;
+using WebKit::WebDragOperationsMask;
+
+// Ensure that the WebKit::WebDragOperation enum values stay in sync with
+// NSDragOperation constants, since the code below static_casts between 'em.
+#define COMPILE_ASSERT_MATCHING_ENUM(name) \
+  COMPILE_ASSERT(int(NS##name) == int(WebKit::Web##name), enum_mismatch_##name)
+COMPILE_ASSERT_MATCHING_ENUM(DragOperationNone);
+COMPILE_ASSERT_MATCHING_ENUM(DragOperationCopy);
+COMPILE_ASSERT_MATCHING_ENUM(DragOperationLink);
+COMPILE_ASSERT_MATCHING_ENUM(DragOperationGeneric);
+COMPILE_ASSERT_MATCHING_ENUM(DragOperationPrivate);
+COMPILE_ASSERT_MATCHING_ENUM(DragOperationMove);
+COMPILE_ASSERT_MATCHING_ENUM(DragOperationDelete);
+COMPILE_ASSERT_MATCHING_ENUM(DragOperationEvery);
+
 @interface TabContentsViewCocoa (Private)
 - (id)initWithTabContentsViewMac:(TabContentsViewMac*)w;
 - (void)processKeyboardEvent:(NSEvent*)event;
 - (void)registerDragTypes;
-- (void)setIsDropTarget:(BOOL)isTarget;
-- (void)startDragWithDropData:(const WebDropData&)dropData;
+- (void)setCurrentDragOperation:(NSDragOperation)operation;
+- (void)startDragWithDropData:(const WebDropData&)dropData
+            dragOperationMask:(NSDragOperation)operationMask;
 @end
 
 // static
 TabContentsView* TabContentsView::Create(TabContents* tab_contents) {
   return new TabContentsViewMac(tab_contents);
 }
 
 TabContentsViewMac::TabContentsViewMac(TabContents* tab_contents)
     : TabContentsView(tab_contents) {
   registrar_.Add(this, NotificationType::TAB_CONTENTS_CONNECTED,
@@ skipping 36 matching lines @@
 }
 
 gfx::NativeWindow TabContentsViewMac::GetTopLevelNativeWindow() const {
   return [cocoa_view_.get() window];
 }
 
 void TabContentsViewMac::GetContainerBounds(gfx::Rect* out) const {
   *out = [cocoa_view_.get() NSRectToRect:[cocoa_view_.get() bounds]];
 }
 
-void TabContentsViewMac::StartDragging(const WebDropData& drop_data) {
+void TabContentsViewMac::StartDragging(const WebDropData& drop_data,
+    WebDragOperationsMask allowed_operations) {
   // The drag invokes a nested event loop, but we need to continue processing
   // events.
   MessageLoop::current()->SetNestableTasksAllowed(true);
-  [cocoa_view_ startDragWithDropData:drop_data];
+  NSDragOperation mask = static_cast<NSDragOperation>(allowed_operations);
+  [cocoa_view_ startDragWithDropData:drop_data
+                   dragOperationMask:mask];
   MessageLoop::current()->SetNestableTasksAllowed(false);
 }
 
 void TabContentsViewMac::OnContentsDestroy() {
 }
 
 void TabContentsViewMac::RenderViewCreated(RenderViewHost* host) {
   // We want updates whenever the intrinsic width of the webpage
   // changes. Put the RenderView into that mode.
   int routing_id = host->routing_id();
@@ skipping 58 matching lines @@
     latent_focus_view_.reset();
   } else {
     // TODO(shess): If location-bar gets focus by default, this will
     // select-all in the field.  If there was a specific selection in
     // the field when we navigated away from it, we should restore
     // that selection.
     SetInitialFocus();
   }
 }
 
-void TabContentsViewMac::UpdateDragCursor(bool is_drop_target) {
-  [cocoa_view_ setIsDropTarget:is_drop_target ? YES : NO];
+void TabContentsViewMac::UpdateDragCursor(WebDragOperation operation) {
+  [cocoa_view_ setCurrentDragOperation: operation];
 }
 
 void TabContentsViewMac::GotFocus() {
   NOTIMPLEMENTED();
 }
 
 // This is called when we the renderer asks us to take focus back (i.e., it has
 // iterated past the last focusable element on the page).
 void TabContentsViewMac::TakeFocus(bool reverse) {
   if (reverse) {
@@ skipping 81 matching lines @@
 }
 
 // Registers for the view for the appropriate drag types.
 // TODO(pinkerton): register for file drags.
 - (void)registerDragTypes {
   NSArray* types = [NSArray arrayWithObjects:NSStringPboardType,
       NSHTMLPboardType, NSURLPboardType, nil];
   [self registerForDraggedTypes:types];
 }
 
-- (void)setIsDropTarget:(BOOL)isTarget {
-  [dropTarget_ setIsDropTarget:isTarget];
+- (void)setCurrentDragOperation:(NSDragOperation)operation {
+  [dropTarget_ setCurrentOperation:operation];
 }
 
 - (TabContents*)tabContents {
   return tabContentsView_->tab_contents();
 }
 
 - (void)processKeyboardEvent:(NSEvent*)event {
   if ([event type] == NSKeyDown)
     [super keyDown:event];
   else if ([event type] == NSKeyUp)
@@ skipping 34 matching lines @@
 
 - (void)paste:(id)sender {
   [self tabContents]->Paste();
 }
 
 - (void)pasteboard:(NSPasteboard*)sender provideDataForType:(NSString*)type {
   [dragSource_ lazyWriteToPasteboard:sender
                              forType:type];
 }
 
-- (void)startDragWithDropData:(const WebDropData&)dropData {
+- (void)startDragWithDropData:(const WebDropData&)dropData
+            dragOperationMask:(NSDragOperation)operationMask {
   dragSource_.reset([[WebDragSource alloc]
           initWithContentsView:self
                       dropData:&dropData
-                    pasteboard:[NSPasteboard pasteboardWithName:NSDragPboard]]);
+                    pasteboard:[NSPasteboard pasteboardWithName:NSDragPboard]
+             dragOperationMask:operationMask]);
   [dragSource_ startDrag];
 }
 
 // NSDraggingSource methods
 
 // Returns what kind of drag operations are available. This is a required
 // method for NSDraggingSource.
 - (NSDragOperation)draggingSourceOperationMaskForLocal:(BOOL)isLocal {
-  // TODO(pinkerton): I think this is right...
-  return NSDragOperationCopy;
+  return [dragSource_ draggingSourceOperationMaskForLocal:isLocal];
 }
 
 // Called when a drag initiated in our view ends.
 - (void)draggedImage:(NSImage*)anImage
              endedAt:(NSPoint)screenPoint
            operation:(NSDragOperation)operation {
-  [dragSource_ endDragAt:screenPoint
-             isCancelled:(operation == NSDragOperationNone)];
+  [dragSource_ endDragAt:screenPoint operation:operation];
 
   // Might as well throw out this object now.
   dragSource_.reset();
 }
 
 // Called when a drag initiated in our view moves.
 - (void)draggedImage:(NSImage*)draggedImage movedTo:(NSPoint)screenPoint {
   [dragSource_ moveDragTo:screenPoint];
 }
 
@@ skipping 24 matching lines @@
 }
 
 - (BOOL)performDragOperation:(id<NSDraggingInfo>)sender {
   return [dropTarget_ performDragOperation:sender view:self];
 }
 
 // Tons of stuff goes here, where we grab events going on in Cocoaland and send
 // them into the C++ system. TODO(avi): all that jazz
 
 @end