| OLD | NEW |
|---|
| (Empty) |
| 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/filename_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 blink::WebDragOperation; | |
| 26 using blink::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 |= blink::WebInputEvent::ShiftKey; | |
| 40 if (state & GDK_CONTROL_MASK) | |
| 41 modifier_state |= blink::WebInputEvent::ControlKey; | |
| 42 if (state & GDK_MOD1_MASK) | |
| 43 modifier_state |= blink::WebInputEvent::AltKey; | |
| 44 if (state & GDK_META_MASK) | |
| 45 modifier_state |= blink::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 // Similarly, renderer taint must occur before anything else so we can | |
| 125 // ignore potentially forged filenames when handling text/uri-list. | |
| 126 static int supported_targets[] = { | |
| 127 ui::RENDERER_TAINT, | |
| 128 ui::TEXT_PLAIN, | |
| 129 ui::TEXT_URI_LIST, | |
| 130 ui::TEXT_HTML, | |
| 131 ui::NETSCAPE_URL, | |
| 132 ui::CHROME_NAMED_URL, | |
| 133 // TODO(estade): support image drags? | |
| 134 ui::CUSTOM_DATA, | |
| 135 }; | |
| 136 | |
| 137 // Add the delegate's requested target if applicable. Need to do this here | |
| 138 // since gtk_drag_get_data will dispatch to our drag-data-received. | |
| 139 data_requests_ = arraysize(supported_targets) + (delegate() ? 1 : 0); | |
| 140 for (size_t i = 0; i < arraysize(supported_targets); ++i) { | |
| 141 gtk_drag_get_data(widget_, context, | |
| 142 ui::GetAtomForTarget(supported_targets[i]), | |
| 143 time); | |
| 144 } | |
| 145 | |
| 146 if (delegate()) { | |
| 147 gtk_drag_get_data(widget_, context, delegate()->GetBookmarkTargetAtom(), | |
| 148 time); | |
| 149 } | |
| 150 } else if (data_requests_ == 0) { | |
| 151 if (canceled_) | |
| 152 return FALSE; | |
| 153 | |
| 154 GetRenderViewHost()->DragTargetDragOver( | |
| 155 ui::ClientPoint(widget_), | |
| 156 ui::ScreenPoint(widget_), | |
| 157 GdkDragActionToWebDragOp(context->actions), | |
| 158 GetModifierFlags(widget_)); | |
| 159 | |
| 160 if (delegate()) | |
| 161 delegate()->OnDragOver(); | |
| 162 | |
| 163 drag_over_time_ = time; | |
| 164 } | |
| 165 | |
| 166 // Pretend we are a drag destination because we don't want to wait for | |
| 167 // the renderer to tell us if we really are or not. | |
| 168 return TRUE; | |
| 169 } | |
| 170 | |
| 171 void WebDragDestGtk::OnDragDataReceived( | |
| 172 GtkWidget* sender, GdkDragContext* context, gint x, gint y, | |
| 173 GtkSelectionData* data, guint info, guint time) { | |
| 174 // We might get the data from an old get_data() request that we no longer | |
| 175 // care about. | |
| 176 if (context != context_) | |
| 177 return; | |
| 178 | |
| 179 data_requests_--; | |
| 180 | |
| 181 // Decode the data. | |
| 182 gint data_length = gtk_selection_data_get_length(data); | |
| 183 const guchar* raw_data = gtk_selection_data_get_data(data); | |
| 184 GdkAtom target = gtk_selection_data_get_target(data); | |
| 185 if (raw_data && data_length > 0) { | |
| 186 // If the source can't provide us with valid data for a requested target, | |
| 187 // raw_data will be NULL. | |
| 188 if (target == ui::GetAtomForTarget(ui::RENDERER_TAINT)) { | |
| 189 drop_data_->did_originate_from_renderer = true; | |
| 190 } else if (target == ui::GetAtomForTarget(ui::TEXT_PLAIN)) { | |
| 191 guchar* text = gtk_selection_data_get_text(data); | |
| 192 if (text) { | |
| 193 drop_data_->text = base::NullableString16( | |
| 194 base::UTF8ToUTF16(std::string(reinterpret_cast<const char*>(text))), | |
| 195 false); | |
| 196 g_free(text); | |
| 197 } | |
| 198 } else if (target == ui::GetAtomForTarget(ui::TEXT_URI_LIST)) { | |
| 199 gchar** uris = gtk_selection_data_get_uris(data); | |
| 200 if (uris) { | |
| 201 drop_data_->url = GURL(); | |
| 202 for (gchar** uri_iter = uris; *uri_iter; uri_iter++) { | |
| 203 // Most file managers populate text/uri-list with file URLs when | |
| 204 // dragging files. To avoid exposing file system paths to web content, | |
| 205 // file URLs are never set as the URL content for the drop. | |
| 206 // TODO(estade): Can the filenames have a non-UTF8 encoding? | |
| 207 GURL url(*uri_iter); | |
| 208 base::FilePath file_path; | |
| 209 if (url.SchemeIs(kFileScheme) && | |
| 210 net::FileURLToFilePath(url, &file_path)) { | |
| 211 drop_data_->filenames.push_back( | |
| 212 ui::FileInfo(file_path, base::FilePath())); | |
| 213 // This is a hack. Some file managers also populate text/plain with | |
| 214 // a file URL when dragging files, so we clear it to avoid exposing | |
| 215 // it to the web content. | |
| 216 drop_data_->text = base::NullableString16(); | |
| 217 } else if (!drop_data_->url.is_valid()) { | |
| 218 // Also set the first non-file URL as the URL content for the drop. | |
| 219 drop_data_->url = url; | |
| 220 } | |
| 221 } | |
| 222 g_strfreev(uris); | |
| 223 } | |
| 224 } else if (target == ui::GetAtomForTarget(ui::TEXT_HTML)) { | |
| 225 // TODO(estade): Can the html have a non-UTF8 encoding? | |
| 226 drop_data_->html = base::NullableString16( | |
| 227 base::UTF8ToUTF16(std::string(reinterpret_cast<const char*>(raw_data), | |
| 228 data_length)), | |
| 229 false); | |
| 230 // We leave the base URL empty. | |
| 231 } else if (target == ui::GetAtomForTarget(ui::NETSCAPE_URL)) { | |
| 232 std::string netscape_url(reinterpret_cast<const char*>(raw_data), | |
| 233 data_length); | |
| 234 size_t split = netscape_url.find_first_of('\n'); | |
| 235 if (split != std::string::npos) { | |
| 236 drop_data_->url = GURL(netscape_url.substr(0, split)); | |
| 237 if (split < netscape_url.size() - 1) { | |
| 238 drop_data_->url_title = | |
| 239 base::UTF8ToUTF16(netscape_url.substr(split + 1)); | |
| 240 } | |
| 241 } | |
| 242 } else if (target == ui::GetAtomForTarget(ui::CHROME_NAMED_URL)) { | |
| 243 ui::ExtractNamedURL(data, &drop_data_->url, &drop_data_->url_title); | |
| 244 } else if (target == ui::GetAtomForTarget(ui::CUSTOM_DATA)) { | |
| 245 ui::ReadCustomDataIntoMap( | |
| 246 raw_data, data_length, &drop_data_->custom_data); | |
| 247 } | |
| 248 } | |
| 249 | |
| 250 if (data_requests_ == 0) { | |
| 251 // Give the delegate an opportunity to cancel the drag. | |
| 252 canceled_ = !web_contents_->GetDelegate()->CanDragEnter( | |
| 253 web_contents_, | |
| 254 *drop_data_, | |
| 255 GdkDragActionToWebDragOp(context->actions)); | |
| 256 if (canceled_) { | |
| 257 drag_over_time_ = time; | |
| 258 UpdateDragStatus(WebDragOperationNone); | |
| 259 drop_data_.reset(); | |
| 260 return; | |
| 261 } | |
| 262 } | |
| 263 | |
| 264 // For CHROME_BOOKMARK_ITEM, we have to handle the case where the drag source | |
| 265 // doesn't have any data available for us. In this case we try to synthesize a | |
| 266 // URL bookmark. | |
| 267 // Note that bookmark drag data is encoded in the same format for both | |
| 268 // GTK and Views, hence we can share the same logic here. | |
| 269 if (delegate() && target == delegate()->GetBookmarkTargetAtom()) { | |
| 270 if (raw_data && data_length > 0) { | |
| 271 delegate()->OnReceiveDataFromGtk(data); | |
| 272 } else { | |
| 273 delegate()->OnReceiveProcessedData(drop_data_->url, | |
| 274 drop_data_->url_title); | |
| 275 } | |
| 276 } | |
| 277 | |
| 278 if (data_requests_ == 0) { | |
| 279 // Tell the renderer about the drag. | |
| 280 // |x| and |y| are seemingly arbitrary at this point. | |
| 281 GetRenderViewHost()->DragTargetDragEnter( | |
| 282 *drop_data_.get(), | |
| 283 ui::ClientPoint(widget_), | |
| 284 ui::ScreenPoint(widget_), | |
| 285 GdkDragActionToWebDragOp(context->actions), | |
| 286 GetModifierFlags(widget_)); | |
| 287 | |
| 288 if (delegate()) | |
| 289 delegate()->OnDragEnter(); | |
| 290 | |
| 291 drag_over_time_ = time; | |
| 292 } | |
| 293 } | |
| 294 | |
| 295 // The drag has left our widget; forward this information to the renderer. | |
| 296 void WebDragDestGtk::OnDragLeave(GtkWidget* sender, GdkDragContext* context, | |
| 297 guint time) { | |
| 298 // Set |context_| to NULL to make sure we will recognize the next DragMotion | |
| 299 // as an enter. | |
| 300 context_ = NULL; | |
| 301 | |
| 302 if (canceled_) | |
| 303 return; | |
| 304 | |
| 305 // Sometimes we get a drag-leave event before getting a drag-data-received | |
| 306 // event. In that case, we don't want to bother the renderer with a | |
| 307 // DragLeave event. | |
| 308 if (data_requests_ != 0) | |
| 309 return; | |
| 310 | |
| 311 // When GTK sends us a drag-drop signal, it is shortly (and synchronously) | |
| 312 // preceded by a drag-leave. The renderer doesn't like getting the signals | |
| 313 // in this order so delay telling it about the drag-leave till we are sure | |
| 314 // we are not getting a drop as well. | |
| 315 base::MessageLoop::current()->PostTask( | |
| 316 FROM_HERE, | |
| 317 base::Bind(&WebDragDestGtk::DragLeave, method_factory_.GetWeakPtr())); | |
| 318 } | |
| 319 | |
| 320 // Called by GTK when the user releases the mouse, executing a drop. | |
| 321 gboolean WebDragDestGtk::OnDragDrop(GtkWidget* sender, GdkDragContext* context, | |
| 322 gint x, gint y, guint time) { | |
| 323 // Cancel that drag leave! | |
| 324 method_factory_.InvalidateWeakPtrs(); | |
| 325 | |
| 326 GetRenderViewHost()-> | |
| 327 DragTargetDrop(ui::ClientPoint(widget_), ui::ScreenPoint(widget_), | |
| 328 GetModifierFlags(widget_)); | |
| 329 | |
| 330 if (delegate()) | |
| 331 delegate()->OnDrop(); | |
| 332 | |
| 333 // The second parameter is just an educated guess as to whether or not the | |
| 334 // drag succeeded, but at least we will get the drag-end animation right | |
| 335 // sometimes. | |
| 336 gtk_drag_finish(context, is_drop_target_, FALSE, time); | |
| 337 | |
| 338 return TRUE; | |
| 339 } | |
| 340 | |
| 341 RenderViewHostImpl* WebDragDestGtk::GetRenderViewHost() const { | |
| 342 return static_cast<RenderViewHostImpl*>(web_contents_->GetRenderViewHost()); | |
| 343 } | |
| 344 | |
| 345 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 231733005:
Delete the GTK+ port of Chrome. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src