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

chrome/browser/tab_contents/tab_contents_view_gtk.cc

 // 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.
 
 #include "chrome/browser/tab_contents/tab_contents_view_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
@@ skipping 18 matching lines @@
 #include "chrome/browser/tab_contents/interstitial_page.h"
 #include "chrome/browser/tab_contents/render_view_context_menu_gtk.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_delegate.h"
 #include "chrome/common/gtk_util.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
 #include "webkit/glue/webdropdata.h"
 
+using WebKit::WebDragOperation;
+using WebKit::WebDragOperationCopy;
+using WebKit::WebDragOperationNone;
+using WebKit::WebDragOperationsMask;
+
 namespace {
 
 // TODO(erg): I have no idea how to programatically figure out how wide the
 // vertical scrollbar is. Hack it with a hardcoded value for now.
 const int kScrollbarWidthHack = 25;
 
 // Called when the content view gtk widget is tabbed to, or after the call to
 // gtk_widget_child_focus() in TakeFocus(). We return true
 // and grab focus if we don't have it. The call to
 // FocusThroughTabTraversal(bool) forwards the "move focus forward" effect to
@@ skipping 83 matching lines @@
 
   ~WebDragDest() {
     if (widget_) {
       gtk_drag_dest_unset(widget_);
       g_signal_handler_disconnect(widget_, destroy_handler_);
     }
   }
 
   // This is called when the renderer responds to a drag motion event. We must
   // update the system drag cursor.
-  void UpdateDragStatus(bool is_drop_target) {
+  void UpdateDragStatus(WebDragOperation operation) {
     if (context_) {
       // TODO(estade): we might want to support other actions besides copy,
       // but that would increase the cost of getting our drag success guess
       // wrong.
-      gdk_drag_status(context_, is_drop_target ? GDK_ACTION_COPY :
+      is_drop_target_ = operation != WebDragOperationNone;
+      // TODO(snej): Pass appropriate GDK action instead of hardcoding COPY
+      gdk_drag_status(context_, is_drop_target_ ? GDK_ACTION_COPY :
                                 static_cast<GdkDragAction>(0),
                       drag_over_time_);
-      is_drop_target_ = false;
     }
   }
 
   // Informs the renderer when a system drag has left the render view.
   // See OnDragLeave().
   void DragLeave() {
     tab_contents_->render_view_host()->DragTargetDragLeave();
   }
 
  private:
@@ skipping 35 matching lines @@
 
       data_requests_ = arraysize(supported_targets);
       for (size_t i = 0; i < arraysize(supported_targets); ++i) {
         gtk_drag_get_data(widget_, context,
                           GtkDndUtil::GetAtomForTarget(supported_targets[i]),
                           time);
       }
     } else if (data_requests_ == 0) {
       tab_contents_->render_view_host()->
           DragTargetDragOver(gtk_util::ClientPoint(widget_),
-                             gtk_util::ScreenPoint(widget_));
+                             gtk_util::ScreenPoint(widget_),
+                             WebDragOperationCopy);
+      // TODO(snej): Pass appropriate DragOperation instead of hardcoding
       drag_over_time_ = time;
     }
 
     // Pretend we are a drag destination because we don't want to wait for
     // the renderer to tell us if we really are or not.
     return TRUE;
   }
 
   // We make a series of requests for the drag data when the drag first enters
   // the render view. This is the callback that is used to give us the data
@@ skipping 42 matching lines @@
         // We leave the base URL empty.
       }
     }
 
     if (data_requests_ == 0) {
       // Tell the renderer about the drag.
       // |x| and |y| are seemingly arbitrary at this point.
       tab_contents_->render_view_host()->
           DragTargetDragEnter(*drop_data_.get(),
                               gtk_util::ClientPoint(widget_),
-                              gtk_util::ScreenPoint(widget_));
+                              gtk_util::ScreenPoint(widget_),
+                              WebDragOperationCopy);
+      // TODO(snej): Pass appropriate DragOperation instead of hardcoding
       drag_over_time_ = time;
     }
   }
 
   // The drag has left our widget; forward this information to the renderer.
   void OnDragLeave(GdkDragContext* context, guint time) {
     // Set |context_| to NULL to make sure we will recognize the next DragMotion
     // as an enter.
     context_ = NULL;
     drop_data_.reset();
@@ skipping 246 matching lines @@
   focus_store_.Store(GetNativeView());
 }
 
 void TabContentsViewGtk::RestoreFocus() {
   if (focus_store_.widget())
     gtk_widget_grab_focus(focus_store_.widget());
   else
     SetInitialFocus();
 }
 
-void TabContentsViewGtk::UpdateDragCursor(bool is_drop_target) {
-  drag_dest_->UpdateDragStatus(is_drop_target);
+void TabContentsViewGtk::UpdateDragCursor(WebDragOperation operation) {
+  drag_dest_->UpdateDragStatus(operation);
 }
 
 void TabContentsViewGtk::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 TabContentsViewGtk::TakeFocus(bool reverse) {
   gtk_widget_child_focus(GTK_WIDGET(GetTopLevelNativeWindow()),
@@ skipping 43 matching lines @@
 
 void TabContentsViewGtk::ShowContextMenu(const ContextMenuParams& params) {
   context_menu_.reset(new RenderViewContextMenuGtk(tab_contents(), params,
                                                    last_mouse_down_.time));
   context_menu_->Init();
   context_menu_->Popup();
 }
 
 // Render view DnD -------------------------------------------------------------
 
-void TabContentsViewGtk::StartDragging(const WebDropData& drop_data) {
+void TabContentsViewGtk::StartDragging(const WebDropData& drop_data,
+                                       WebDragOperationsMask ops) {
   DCHECK(GetContentNativeView());
 
   drag_source_->StartDragging(drop_data, &last_mouse_down_);
+  // TODO(snej): Make use of the WebDragOperationsMask somehow
 }
 
 // -----------------------------------------------------------------------------
 
 void TabContentsViewGtk::InsertIntoContentArea(GtkWidget* widget) {
   gtk_fixed_put(GTK_FIXED(fixed_), widget, 0, 0);
 }
 
 gboolean TabContentsViewGtk::OnMouseDown(GtkWidget* widget,
     GdkEventButton* event, TabContentsViewGtk* view) {
@@ skipping 67 matching lines @@
     gtk_container_child_set_property(GTK_CONTAINER(floating_container),
                                      widget, "x", &value);
 
     int child_y = std::max(half_view_height - (requisition.height / 2), 0);
     g_value_set_int(&value, child_y);
     gtk_container_child_set_property(GTK_CONTAINER(floating_container),
                                      widget, "y", &value);
     g_value_unset(&value);
   }
 }