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

webkit/glue/webview_impl.cc

 // Copyright (c) 2007-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.
 
 #include "config.h"
 #include "build/build_config.h"
 
 #include "base/compiler_specific.h"
 MSVC_PUSH_WARNING_LEVEL(0);
 #include "CSSStyleSelector.h"
@@ skipping 83 matching lines @@
 using namespace WebCore;
 
 using WebKit::PlatformKeyboardEventBuilder;
 using WebKit::PlatformMouseEventBuilder;
 using WebKit::PlatformWheelEventBuilder;
 using WebKit::WebCanvas;
 using WebKit::WebCompositionCommand;
 using WebKit::WebCompositionCommandConfirm;
 using WebKit::WebCompositionCommandDiscard;
 using WebKit::WebDragData;
+using WebKit::WebDragOperation;
+using WebKit::WebDragOperationCopy;
+using WebKit::WebDragOperationNone;
+using WebKit::WebDragOperationsMask;
 using WebKit::WebFrame;
 using WebKit::WebInputEvent;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
 using WebKit::WebPoint;
 using WebKit::WebRect;
 using WebKit::WebSettings;
 using WebKit::WebSettingsImpl;
 using WebKit::WebSize;
@@ skipping 12 matching lines @@
 static const double kTextSizeMultiplierRatio = 1.2;
 static const double kMinTextSizeMultiplier = 0.5;
 static const double kMaxTextSizeMultiplier = 3.0;
 
 // The group name identifies a namespace of pages.  Page group is used on OSX
 // for some programs that use HTML views to display things that don't seem like
 // web pages to the user (so shouldn't have visited link coloring).  We only use
 // one page group.
 static const char* kPageGroupName = "default";
 
-// The webcore drag operation type when something is trying to be dropped on
-// the webview.  These values are taken from Apple's windows port.
-static const WebCore::DragOperation kDropTargetOperation =
-    static_cast<WebCore::DragOperation>(DragOperationCopy | DragOperationLink);
+// Ensure that the WebKit::WebDragOperation enum values stay in sync with
+// the original WebCore::DragOperation constants.
+#define COMPILE_ASSERT_MATCHING_ENUM(webcore_name) \
+   COMPILE_ASSERT(int(WebCore::webcore_name) == int(WebKit::Web##webcore_name),\
+                  dummy##webcore_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);
 
 // AutocompletePopupMenuClient
 class AutocompletePopupMenuClient : public WebCore::PopupMenuClient {
  public:
   AutocompletePopupMenuClient(WebViewImpl* webview) : text_field_(NULL),
                                                       selected_index_(0),
                                                       webview_(webview) {
   }
 
   void Init(WebCore::HTMLInputElement* text_field,
@@ skipping 222 matching lines @@
       zoom_level_(0),
       context_menu_allowed_(false),
       doing_drag_and_drop_(false),
       ignore_input_events_(false),
       suppress_next_keypress_event_(false),
       initial_navigation_policy_(WebKit::WebNavigationPolicyIgnore),
       ime_accept_events_(true),
       drag_target_dispatch_(false),
       drag_identity_(0),
       drop_effect_(DROP_EFFECT_DEFAULT),
-      drop_accept_(false),
+      operations_allowed_(WebKit::WebDragOperationNone),
+      drag_operation_(WebKit::WebDragOperationNone),
       autocomplete_popup_showing_(false),
       is_transparent_(false) {
   // WebKit/win/WebView.cpp does the same thing, except they call the
   // KJS specific wrapper around this method. We need to have threading
   // initialized because CollatorICU requires it.
   WTF::initializeThreading();
 
   // set to impossible point so we always get the first mouse pos
   last_mouse_position_ = WebPoint(-1, -1);
 
@@ skipping 1099 matching lines @@
       return;
 
     page_->inspectorController()->inspect(result.innerNonSharedNode());
   }
 }
 
 void WebViewImpl::ShowJavaScriptConsole() {
   page_->inspectorController()->showPanel(InspectorController::ConsolePanel);
 }
 
-void WebViewImpl::DragSourceCancelledAt(
-    const WebPoint& client_point,
-    const WebPoint& screen_point) {
-  PlatformMouseEvent pme(webkit_glue::WebPointToIntPoint(client_point),
-                         webkit_glue::WebPointToIntPoint(screen_point),
-                         NoButton, MouseEventMoved, 0, false, false, false,
-                         false, 0);
-  page_->mainFrame()->eventHandler()->dragSourceEndedAt(pme, DragOperationNone);
-}
-
 void WebViewImpl::DragSourceEndedAt(
     const WebPoint& client_point,
-    const WebPoint& screen_point) {
+    const WebPoint& screen_point,
+    WebDragOperation operation) {
   PlatformMouseEvent pme(webkit_glue::WebPointToIntPoint(client_point),
                          webkit_glue::WebPointToIntPoint(screen_point),
                          LeftButton, MouseEventMoved, 0, false, false, false,
                          false, 0);
-  page_->mainFrame()->eventHandler()->dragSourceEndedAt(pme, DragOperationCopy);
+  page_->mainFrame()->eventHandler()->dragSourceEndedAt(pme,
+      static_cast<WebCore::DragOperation>(operation));
 }
 
 void WebViewImpl::DragSourceMovedTo(
     const WebPoint& client_point,
     const WebPoint& screen_point) {
   PlatformMouseEvent pme(webkit_glue::WebPointToIntPoint(client_point),
                          webkit_glue::WebPointToIntPoint(screen_point),
                          LeftButton, MouseEventMoved, 0, false, false, false,
                          false, 0);
   page_->mainFrame()->eventHandler()->dragSourceMovedTo(pme);
 }
 
 void WebViewImpl::DragSourceSystemDragEnded() {
   // It's possible for us to get this callback while not doing a drag if
   // it's from a previous page that got unloaded.
   if (doing_drag_and_drop_) {
     page_->dragController()->dragEnded();
     doing_drag_and_drop_ = false;
   }
 }
 
-bool WebViewImpl::DragTargetDragEnter(
+WebDragOperation WebViewImpl::DragTargetDragEnter(
     const WebDragData& web_drag_data,
     int identity,
     const WebPoint& client_point,
-    const WebPoint& screen_point) {
+    const WebPoint& screen_point,
+    WebDragOperation operations_allowed) {
   DCHECK(!current_drag_data_.get());
 
   current_drag_data_ =
       webkit_glue::WebDragDataToChromiumDataObject(web_drag_data);
   drag_identity_ = identity;
+  operations_allowed_ = operations_allowed;
 
   DragData drag_data(
       current_drag_data_.get(),
       webkit_glue::WebPointToIntPoint(client_point),
       webkit_glue::WebPointToIntPoint(screen_point),
-      kDropTargetOperation);
+      static_cast<WebCore::DragOperation>(operations_allowed));
 
   drop_effect_ = DROP_EFFECT_DEFAULT;
   drag_target_dispatch_ = true;
   DragOperation effect = page_->dragController()->dragEntered(&drag_data);
+  // Mask the operation against the drag source's allowed operations.
+  if ((effect & drag_data.draggingSourceOperationMask()) != effect) {
+    effect = DragOperationNone;
+  }
   drag_target_dispatch_ = false;
 
   if (drop_effect_ != DROP_EFFECT_DEFAULT)
-    return drop_accept_ = (drop_effect_ != DROP_EFFECT_NONE);
-  return drop_accept_ = (effect != DragOperationNone);
+    drag_operation_ = (drop_effect_ != DROP_EFFECT_NONE) ?
+        WebDragOperationCopy : WebDragOperationNone;
+  else
+    drag_operation_ = static_cast<WebDragOperation>(effect);
+  return drag_operation_;
 }
 
-bool WebViewImpl::DragTargetDragOver(
+WebDragOperation WebViewImpl::DragTargetDragOver(
     const WebPoint& client_point,
-    const WebPoint& screen_point) {
+    const WebPoint& screen_point,
+    WebDragOperation operations_allowed) {
   DCHECK(current_drag_data_.get());
 
+  operations_allowed_ = operations_allowed;
   DragData drag_data(
       current_drag_data_.get(),
       webkit_glue::WebPointToIntPoint(client_point),
       webkit_glue::WebPointToIntPoint(screen_point),
-      kDropTargetOperation);
+      static_cast<WebCore::DragOperation>(operations_allowed));
 
   drop_effect_ = DROP_EFFECT_DEFAULT;
   drag_target_dispatch_ = true;
   DragOperation effect = page_->dragController()->dragUpdated(&drag_data);
+  // Mask the operation against the drag source's allowed operations.
+  if ((effect & drag_data.draggingSourceOperationMask()) != effect) {
+    effect = DragOperationNone;
+  }
   drag_target_dispatch_ = false;
 
   if (drop_effect_ != DROP_EFFECT_DEFAULT)
-    return drop_accept_ = (drop_effect_ != DROP_EFFECT_NONE);
-  return drop_accept_ = (effect != DragOperationNone);
+    drag_operation_ = (drop_effect_ != DROP_EFFECT_NONE) ?
+        WebDragOperationCopy : WebDragOperationNone;
+  else
+    drag_operation_ = static_cast<WebDragOperation>(effect);
+  return drag_operation_;
 }
 
 void WebViewImpl::DragTargetDragLeave() {
   DCHECK(current_drag_data_.get());
 
   DragData drag_data(
       current_drag_data_.get(),
       IntPoint(),
       IntPoint(),
-      kDropTargetOperation);
+      static_cast<WebCore::DragOperation>(operations_allowed_));
 
   drag_target_dispatch_ = true;
   page_->dragController()->dragExited(&drag_data);
   drag_target_dispatch_ = false;
 
   current_drag_data_ = NULL;
   drop_effect_ = DROP_EFFECT_DEFAULT;
-  drop_accept_ = false;
+  drag_operation_ = WebDragOperationNone;
   drag_identity_ = 0;
 }
 
 void WebViewImpl::DragTargetDrop(
     const WebPoint& client_point,
     const WebPoint& screen_point) {
   DCHECK(current_drag_data_.get());
 
   // If this webview transitions from the "drop accepting" state to the "not
   // accepting" state, then our IPC message reply indicating that may be in-
   // flight, or else delayed by javascript processing in this webview.  If a
   // drop happens before our IPC reply has reached the browser process, then
   // the browser forwards the drop to this webview.  So only allow a drop to
-  // proceed if our webview drop_accept_ state is true.
+  // proceed if our webview drag_operation_ state is not DragOperationNone.
 
-  if (!drop_accept_) {  // IPC RACE CONDITION: do not allow this drop.
+  if (drag_operation_ == WebDragOperationNone) {  // IPC RACE CONDITION: do not allow this drop.
     DragTargetDragLeave();
     return;
   }
 
   DragData drag_data(
       current_drag_data_.get(),
       webkit_glue::WebPointToIntPoint(client_point),
       webkit_glue::WebPointToIntPoint(screen_point),
-      kDropTargetOperation);
+      static_cast<WebCore::DragOperation>(operations_allowed_));
 
   drag_target_dispatch_ = true;
   page_->dragController()->performDrag(&drag_data);
   drag_target_dispatch_ = false;
 
   current_drag_data_ = NULL;
   drop_effect_ = DROP_EFFECT_DEFAULT;
-  drop_accept_ = false;
+  drag_operation_ = WebDragOperationNone;
   drag_identity_ = 0;
 }
 
 int32 WebViewImpl::GetDragIdentity() {
   if (drag_target_dispatch_)
     return drag_identity_;
   return 0;
 }
 
 bool WebViewImpl::SetDropEffect(bool accept) {
@@ skipping 144 matching lines @@
     *is_new_navigation = observed_new_navigation_;
 
 #ifndef NDEBUG
   DCHECK(!observed_new_navigation_ ||
     page_->mainFrame()->loader()->documentLoader() == new_navigation_loader_);
   new_navigation_loader_ = NULL;
 #endif
   observed_new_navigation_ = false;
 }
 
-void WebViewImpl::StartDragging(const WebDragData& drag_data) {
+void WebViewImpl::StartDragging(WebPoint event_pos,
+                                const WebDragData& drag_data,
+                                WebDragOperationsMask mask) {
   if (delegate_) {
     DCHECK(!doing_drag_and_drop_);
     doing_drag_and_drop_ = true;
-    delegate_->StartDragging(this, drag_data);
+    delegate_->StartDragging(this, event_pos, drag_data, mask);
   }
 }
 
 void WebViewImpl::OnImageFetchComplete(ImageResourceFetcher* fetcher,
                                        const SkBitmap& image) {
   if (delegate_) {
     delegate_->DidDownloadImage(fetcher->id(), fetcher->image_url(),
                                 image.isNull(), image);
   }
   DeleteImageResourceFetcher(fetcher);
@@ skipping 84 matching lines @@
 
   return document->focusedNode();
 }
 
 HitTestResult WebViewImpl::HitTestResultForWindowPos(const IntPoint& pos) {
   IntPoint doc_point(
       page_->mainFrame()->view()->windowToContents(pos));
   return page_->mainFrame()->eventHandler()->
       hitTestResultAtPoint(doc_point, false);
 }