GTK: Support for more drag targets in renderer destination....

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 <gtk/gtk.h>
 
 #include "base/mime_util.h"
@@ skipping 161 matching lines @@
     dest->OnDragDataReceived(drag_context, x, y, data, info, time);
   }
 
   // Called when a system drag crosses over the render view. As there is no drag
   // enter event, we treat it as an enter event (and not a regular motion event)
   // when |context_| is NULL.
   gboolean OnDragMotion(GdkDragContext* context, gint x, gint y, guint time) {
     if (context_ != context) {
       context_ = context;
       drop_data_.reset(new WebDropData);
-      data_requests_ = 0;
       is_drop_target_ = false;
 
-      // TODO(estade): support other targets. When we start support URL drags,
-      // we'll have to worry about interstitial pages (see web_drop_target.cc).
-      data_requests_++;
-      gtk_drag_get_data(widget_, context,
-                        gdk_atom_intern("text/plain", FALSE), time);
+      static int supported_targets[] = {
+        GtkDndUtil::X_CHROME_TEXT_PLAIN,
+        GtkDndUtil::X_CHROME_TEXT_URI_LIST,
+        GtkDndUtil::X_CHROME_TEXT_HTML,
+        // TODO(estade): support image drags?
+      };
+
+      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(ClientPoint(), ScreenPoint());
       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
   // for each individual target. When |data_requests_| reaches 0, we know we
   // have attained all the data, and we can finally tell the renderer about the
   // drag.
   void OnDragDataReceived(GdkDragContext* context, gint x, gint y,
                           GtkSelectionData* data, guint info, guint time) {
     // We might get the data from an old get_data() request that we no longer
     // care about.
     if (context != context_)
       return;
 
     data_requests_--;
 
-    // If the source can't provide us with valid data for a requested target,
-    // data->data will be NULL.
+    // Decode the data.
     if (data->data) {
-      drop_data_->plain_text = UTF8ToUTF16(std::string(
-          reinterpret_cast<char*>(data->data), data->length));
+      // If the source can't provide us with valid data for a requested target,
+      // data->data will be NULL.
+      if (data->target ==
+          GtkDndUtil::GetAtomForTarget(GtkDndUtil::X_CHROME_TEXT_PLAIN)) {
+        guchar* text = gtk_selection_data_get_text(data);
+        if (text) {
+          drop_data_->plain_text = UTF8ToUTF16(std::string(
+              reinterpret_cast<char*>(text), data->length));
+          g_free(text);
+        }
+      } else if (data->target ==
+          GtkDndUtil::GetAtomForTarget(GtkDndUtil::X_CHROME_TEXT_URI_LIST)) {
+        gchar** uris = gtk_selection_data_get_uris(data);
+        if (uris) {
+          for (gchar** uri_iter = uris; *uri_iter; uri_iter++) {
+            // TODO(estade): Can the filenames have a non-UTF8 encoding?
+            drop_data_->filenames.push_back(UTF8ToUTF16(*uri_iter));
+          }
+          // Also, write the first URI as the URL.
+          if (uris[0])
+            drop_data_->url = GURL(uris[0]);
+          g_strfreev(uris);
+        }
+      } else if (data->target ==
+          GtkDndUtil::GetAtomForTarget(GtkDndUtil::X_CHROME_TEXT_HTML)) {
+        // TODO(estade): Can the html have a non-UTF8 encoding?
+        drop_data_->text_html = UTF8ToUTF16(std::string(
+            reinterpret_cast<char*>(data->data), data->length));
+        // 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(), ClientPoint(), ScreenPoint());
       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
@@ skipping 197 matching lines @@
   // animation.
   int x = 0;
   int y = 0;
   if (fixed_->window)
     gdk_window_get_origin(fixed_->window, &x, &y);
   out->SetRect(x + fixed_->allocation.x, y + fixed_->allocation.y,
                fixed_->allocation.width, fixed_->allocation.height);
 }
 
 void TabContentsViewGtk::OnContentsDestroy() {
-  // TODO(estade): Windows uses this function cancel pending drag-n-drop drags.
-  // We don't have drags yet, so do nothing for now.
+  // TODO(estade): Windows uses this for some sort of plugin-related stuff.
 }
 
 void TabContentsViewGtk::SetPageTitle(const std::wstring& title) {
   // Set the window name to include the page title so it's easier to spot
   // when debugging (e.g. via xwininfo -tree).
   gfx::NativeView content_view = GetContentNativeView();
   if (content_view && content_view->window)
     gdk_window_set_title(content_view->window, WideToUTF8(title).c_str());
 }
 
@@ skipping 282 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);
   }
 }