content/browser/web_contents/web_drag_dest_gtk.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/web_contents/web_drag_dest_gtk.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/files/file_path.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "content/browser/renderer_host/render_view_host_impl.h"
  14 #include "content/browser/web_contents/drag_utils_gtk.h"
  15 #include "content/browser/web_contents/web_contents_impl.h"
  16 #include "content/public/browser/web_contents_delegate.h"
  17 #include "content/public/browser/web_drag_dest_delegate.h"
  18 #include "content/public/common/url_constants.h"
  19 #include "net/base/net_util.h"
  20 #include "third_party/WebKit/public/web/WebInputEvent.h"
  21 #include "ui/base/clipboard/custom_data_helper.h"
  22 #include "ui/base/dragdrop/gtk_dnd_util.h"
  23 #include "ui/base/gtk/gtk_screen_util.h"
  24
  25 using WebKit::WebDragOperation;
  26 using WebKit::WebDragOperationNone;
  27
  28 namespace content {
  29
  30 namespace {
  31 const int kNumGtkHandlers = 5;
  32
  33 int GetModifierFlags(GtkWidget* widget) {
  34   int modifier_state = 0;
  35   GdkModifierType state;
  36   gdk_window_get_pointer(gtk_widget_get_window(widget), NULL, NULL, &state);
  37
  38   if (state & GDK_SHIFT_MASK)
  39     modifier_state |= WebKit::WebInputEvent::ShiftKey;
  40   if (state & GDK_CONTROL_MASK)
  41     modifier_state |= WebKit::WebInputEvent::ControlKey;
  42   if (state & GDK_MOD1_MASK)
  43     modifier_state |= WebKit::WebInputEvent::AltKey;
  44   if (state & GDK_META_MASK)
  45     modifier_state |= WebKit::WebInputEvent::MetaKey;
  46   return modifier_state;
  47 }
  48
  49 }  // namespace
  50
  51 WebDragDestGtk::WebDragDestGtk(WebContents* web_contents, GtkWidget* widget)
  52     : web_contents_(web_contents),
  53       widget_(widget),
  54       context_(NULL),
  55       data_requests_(0),
  56       delegate_(NULL),
  57       canceled_(false),
  58       method_factory_(this) {
  59   gtk_drag_dest_set(widget, static_cast<GtkDestDefaults>(0),
  60                     NULL, 0,
  61                     static_cast<GdkDragAction>(GDK_ACTION_COPY |
  62                                                GDK_ACTION_LINK |
  63                                                GDK_ACTION_MOVE));
  64
  65   // If adding a handler, make sure to update kNumGtkHandlers and add it to the
  66   // |handlers_| array so that it can be disconnected later on.
  67   handlers_.reset(new int[kNumGtkHandlers]);
  68   handlers_.get()[0] = g_signal_connect(
  69       widget, "drag-motion", G_CALLBACK(OnDragMotionThunk), this);
  70   handlers_.get()[1] = g_signal_connect(
  71       widget, "drag-leave", G_CALLBACK(OnDragLeaveThunk), this);
  72   handlers_.get()[2] = g_signal_connect(
  73       widget, "drag-drop", G_CALLBACK(OnDragDropThunk), this);
  74   handlers_.get()[3] = g_signal_connect(
  75       widget, "drag-data-received", G_CALLBACK(OnDragDataReceivedThunk), this);
  76   // TODO(tony): Need a drag-data-delete handler for moving content out of
  77   // the WebContents.  http://crbug.com/38989
  78
  79   handlers_.get()[4] = g_signal_connect(
  80       widget, "destroy", G_CALLBACK(gtk_widget_destroyed), &widget_);
  81 }
  82
  83 WebDragDestGtk::~WebDragDestGtk() {
  84   if (widget_) {
  85     gtk_drag_dest_unset(widget_);
  86     for (int i = 0; i < kNumGtkHandlers; ++i)
  87       g_signal_handler_disconnect(widget_, handlers_.get()[i]);
  88   }
  89 }
  90
  91 void WebDragDestGtk::UpdateDragStatus(WebDragOperation operation) {
  92   if (context_) {
  93     is_drop_target_ = operation != WebDragOperationNone;
  94     gdk_drag_status(context_, WebDragOpToGdkDragAction(operation),
  95                     drag_over_time_);
  96   }
  97 }
  98
  99 void WebDragDestGtk::DragLeave() {
 100   GetRenderViewHost()->DragTargetDragLeave();
 101   if (delegate())
 102     delegate()->OnDragLeave();
 103
 104   drop_data_.reset();
 105 }
 106
 107 gboolean WebDragDestGtk::OnDragMotion(GtkWidget* sender,
 108                                       GdkDragContext* context,
 109                                       gint x, gint y,
 110                                       guint time) {
 111   if (context_ != context) {
 112     context_ = context;
 113     drop_data_.reset(new DropData);
 114     is_drop_target_ = false;
 115
 116     if (delegate())
 117       delegate()->DragInitialize(web_contents_);
 118
 119     // text/plain must come before text/uri-list. This is a hack that works in
 120     // conjunction with OnDragDataReceived. Since some file managers populate
 121     // text/plain with file URLs when dragging files, we want to handle
 122     // text/uri-list after text/plain so that the plain text can be cleared if
 123     // it's a file drag.
 124     static int supported_targets[] = {
 125       ui::TEXT_PLAIN,
 126       ui::TEXT_URI_LIST,
 127       ui::TEXT_HTML,
 128       ui::NETSCAPE_URL,
 129       ui::CHROME_NAMED_URL,
 130       // TODO(estade): support image drags?
 131       ui::CUSTOM_DATA,
 132     };
 133
 134     // Add the delegate's requested target if applicable. Need to do this here
 135     // since gtk_drag_get_data will dispatch to our drag-data-received.
 136     data_requests_ = arraysize(supported_targets) + (delegate() ? 1 : 0);
 137     for (size_t i = 0; i < arraysize(supported_targets); ++i) {
 138       gtk_drag_get_data(widget_, context,
 139                         ui::GetAtomForTarget(supported_targets[i]),
 140                         time);
 141     }
 142
 143     if (delegate()) {
 144       gtk_drag_get_data(widget_, context, delegate()->GetBookmarkTargetAtom(),
 145                         time);
 146     }
 147   } else if (data_requests_ == 0) {
 148     if (canceled_)
 149       return FALSE;
 150
 151     GetRenderViewHost()->DragTargetDragOver(
 152         ui::ClientPoint(widget_),
 153         ui::ScreenPoint(widget_),
 154         GdkDragActionToWebDragOp(context->actions),
 155         GetModifierFlags(widget_));
 156
 157     if (delegate())
 158       delegate()->OnDragOver();
 159
 160     drag_over_time_ = time;
 161   }
 162
 163   // Pretend we are a drag destination because we don't want to wait for
 164   // the renderer to tell us if we really are or not.
 165   return TRUE;
 166 }
 167
 168 void WebDragDestGtk::OnDragDataReceived(
 169     GtkWidget* sender, GdkDragContext* context, gint x, gint y,
 170     GtkSelectionData* data, guint info, guint time) {
 171   // We might get the data from an old get_data() request that we no longer
 172   // care about.
 173   if (context != context_)
 174     return;
 175
 176   data_requests_--;
 177
 178   // Decode the data.
 179   gint data_length = gtk_selection_data_get_length(data);
 180   const guchar* raw_data = gtk_selection_data_get_data(data);
 181   GdkAtom target = gtk_selection_data_get_target(data);
 182   if (raw_data && data_length > 0) {
 183     // If the source can't provide us with valid data for a requested target,
 184     // raw_data will be NULL.
 185     if (target == ui::GetAtomForTarget(ui::TEXT_PLAIN)) {
 186       guchar* text = gtk_selection_data_get_text(data);
 187       if (text) {
 188         drop_data_->text = base::NullableString16(
 189             UTF8ToUTF16(std::string(reinterpret_cast<const char*>(text))),
 190             false);
 191         g_free(text);
 192       }
 193     } else if (target == ui::GetAtomForTarget(ui::TEXT_URI_LIST)) {
 194       gchar** uris = gtk_selection_data_get_uris(data);
 195       if (uris) {
 196         drop_data_->url = GURL();
 197         for (gchar** uri_iter = uris; *uri_iter; uri_iter++) {
 198           // Most file managers populate text/uri-list with file URLs when
 199           // dragging files. To avoid exposing file system paths to web content,
 200           // file URLs are never set as the URL content for the drop.
 201           // TODO(estade): Can the filenames have a non-UTF8 encoding?
 202           GURL url(*uri_iter);
 203           base::FilePath file_path;
 204           if (url.SchemeIs(chrome::kFileScheme) &&
 205               net::FileURLToFilePath(url, &file_path)) {
 206             drop_data_->filenames.push_back(
 207                 DropData::FileInfo(UTF8ToUTF16(file_path.value()), string16()));
 208             // This is a hack. Some file managers also populate text/plain with
 209             // a file URL when dragging files, so we clear it to avoid exposing
 210             // it to the web content.
 211             drop_data_->text = base::NullableString16();
 212           } else if (!drop_data_->url.is_valid()) {
 213             // Also set the first non-file URL as the URL content for the drop.
 214             drop_data_->url = url;
 215           }
 216         }
 217         g_strfreev(uris);
 218       }
 219     } else if (target == ui::GetAtomForTarget(ui::TEXT_HTML)) {
 220       // TODO(estade): Can the html have a non-UTF8 encoding?
 221       drop_data_->html = base::NullableString16(
 222           UTF8ToUTF16(std::string(reinterpret_cast<const char*>(raw_data),
 223                                   data_length)),
 224           false);
 225       // We leave the base URL empty.
 226     } else if (target == ui::GetAtomForTarget(ui::NETSCAPE_URL)) {
 227       std::string netscape_url(reinterpret_cast<const char*>(raw_data),
 228                                data_length);
 229       size_t split = netscape_url.find_first_of('\n');
 230       if (split != std::string::npos) {
 231         drop_data_->url = GURL(netscape_url.substr(0, split));
 232         if (split < netscape_url.size() - 1)
 233           drop_data_->url_title = UTF8ToUTF16(netscape_url.substr(split + 1));
 234       }
 235     } else if (target == ui::GetAtomForTarget(ui::CHROME_NAMED_URL)) {
 236       ui::ExtractNamedURL(data, &drop_data_->url, &drop_data_->url_title);
 237     } else if (target == ui::GetAtomForTarget(ui::CUSTOM_DATA)) {
 238       ui::ReadCustomDataIntoMap(
 239           raw_data, data_length, &drop_data_->custom_data);
 240     }
 241   }
 242
 243   if (data_requests_ == 0) {
 244     // Give the delegate an opportunity to cancel the drag.
 245     canceled_ = !web_contents_->GetDelegate()->CanDragEnter(
 246         web_contents_,
 247         *drop_data_,
 248         GdkDragActionToWebDragOp(context->actions));
 249     if (canceled_) {
 250       drag_over_time_ = time;
 251       UpdateDragStatus(WebDragOperationNone);
 252       drop_data_.reset();
 253       return;
 254     }
 255   }
 256
 257   // For CHROME_BOOKMARK_ITEM, we have to handle the case where the drag source
 258   // doesn't have any data available for us. In this case we try to synthesize a
 259   // URL bookmark.
 260   // Note that bookmark drag data is encoded in the same format for both
 261   // GTK and Views, hence we can share the same logic here.
 262   if (delegate() && target == delegate()->GetBookmarkTargetAtom()) {
 263     if (raw_data && data_length > 0) {
 264       delegate()->OnReceiveDataFromGtk(data);
 265     } else {
 266       delegate()->OnReceiveProcessedData(drop_data_->url,
 267                                          drop_data_->url_title);
 268     }
 269   }
 270
 271   if (data_requests_ == 0) {
 272     // Tell the renderer about the drag.
 273     // |x| and |y| are seemingly arbitrary at this point.
 274     GetRenderViewHost()->DragTargetDragEnter(
 275         *drop_data_.get(),
 276         ui::ClientPoint(widget_),
 277         ui::ScreenPoint(widget_),
 278         GdkDragActionToWebDragOp(context->actions),
 279         GetModifierFlags(widget_));
 280
 281     if (delegate())
 282       delegate()->OnDragEnter();
 283
 284     drag_over_time_ = time;
 285   }
 286 }
 287
 288 // The drag has left our widget; forward this information to the renderer.
 289 void WebDragDestGtk::OnDragLeave(GtkWidget* sender, GdkDragContext* context,
 290                                  guint time) {
 291   // Set |context_| to NULL to make sure we will recognize the next DragMotion
 292   // as an enter.
 293   context_ = NULL;
 294
 295   if (canceled_)
 296     return;
 297
 298   // Sometimes we get a drag-leave event before getting a drag-data-received
 299   // event. In that case, we don't want to bother the renderer with a
 300   // DragLeave event.
 301   if (data_requests_ != 0)
 302     return;
 303
 304   // When GTK sends us a drag-drop signal, it is shortly (and synchronously)
 305   // preceded by a drag-leave. The renderer doesn't like getting the signals
 306   // in this order so delay telling it about the drag-leave till we are sure
 307   // we are not getting a drop as well.
 308   base::MessageLoop::current()->PostTask(
 309       FROM_HERE,
 310       base::Bind(&WebDragDestGtk::DragLeave, method_factory_.GetWeakPtr()));
 311 }
 312
 313 // Called by GTK when the user releases the mouse, executing a drop.
 314 gboolean WebDragDestGtk::OnDragDrop(GtkWidget* sender, GdkDragContext* context,
 315                                     gint x, gint y, guint time) {
 316   // Cancel that drag leave!
 317   method_factory_.InvalidateWeakPtrs();
 318
 319   GetRenderViewHost()->
 320       DragTargetDrop(ui::ClientPoint(widget_), ui::ScreenPoint(widget_),
 321           GetModifierFlags(widget_));
 322
 323   if (delegate())
 324     delegate()->OnDrop();
 325
 326   // The second parameter is just an educated guess as to whether or not the
 327   // drag succeeded, but at least we will get the drag-end animation right
 328   // sometimes.
 329   gtk_drag_finish(context, is_drop_target_, FALSE, time);
 330
 331   return TRUE;
 332 }
 333
 334 RenderViewHostImpl* WebDragDestGtk::GetRenderViewHost() const {
 335   return static_cast<RenderViewHostImpl*>(web_contents_->GetRenderViewHost());
 336 }
 337
 338 }  // namespace content