Enable touch-initiated drag-drop work on Windows

content/browser/web_contents/web_contents_drag_win.cc

 // Copyright (c) 2012 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 "content/browser/web_contents/web_contents_drag_win.h"
 
 #include <windows.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/message_loop.h"
 #include "base/pickle.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/download/drag_download_file.h"
 #include "content/browser/download/drag_download_util.h"
+#include "content/browser/renderer_host/render_widget_host_view_win.h"
 #include "content/browser/web_contents/web_drag_dest_win.h"
 #include "content/browser/web_contents/web_drag_source_win.h"
 #include "content/browser/web_contents/web_drag_utils_win.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/browser/web_drag_dest_delegate.h"
 #include "net/base/net_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 11 matching lines @@
 using WebKit::WebDragOperationCopy;
 using WebKit::WebDragOperationLink;
 using WebKit::WebDragOperationMove;
 
 namespace content {
 namespace {
 
 HHOOK msg_hook = NULL;
 DWORD drag_out_thread_id = 0;
 bool mouse_up_received = false;
+const int kMaxAbsoluteCoordinate = 65535;
 
 LRESULT CALLBACK MsgFilterProc(int code, WPARAM wparam, LPARAM lparam) {
   if (code == base::MessagePumpForUI::kMessageFilterCode &&
       !mouse_up_received) {
     MSG* msg = reinterpret_cast<MSG*>(lparam);
     // We do not care about WM_SYSKEYDOWN and WM_SYSKEYUP because when ALT key
     // is pressed down on drag-and-drop, it means to create a link.
     if (msg->message == WM_MOUSEMOVE || msg->message == WM_LBUTTONUP ||
         msg->message == WM_KEYDOWN || msg->message == WM_KEYUP) {
       // Forward the message from the UI thread to the drag-and-drop thread.
@@ skipping 95 matching lines @@
                                        WebDragOperationsMask ops,
                                        const gfx::ImageSkia& image,
                                        const gfx::Vector2d& image_offset) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   drag_source_ = new WebDragSource(source_window_, web_contents_);
 
   const GURL& page_url = web_contents_->GetURL();
   const std::string& page_encoding = web_contents_->GetEncoding();
 
+  RenderWidgetHostViewWin* rwhv =
+      static_cast<RenderWidgetHostViewWin*>
+          (web_contents_->GetRenderWidgetHostView());
   // If it is not drag-out, do the drag-and-drop in the current UI thread.
   if (drop_data.download_metadata.empty()) {
+    // If RWHV has a valid long press gesture, since DoDragDrop will run into
+    // itself loop and start a dragging session if and only if a mouse button
+    // is down and then moves, so we need to programmatically send out
+    // mouse down event and adjust the cursor position for DoDragDrop.
+    if (rwhv->has_valid_long_press_gesture())
+      SendMouseEventForTouchDnD();
+
     if (DoDragging(drop_data, ops, page_url, page_encoding,
                    image, image_offset))
       EndDragging();
     return;
   }
 
   // Start a background thread to do the drag-and-drop.
   DCHECK(!drag_drop_thread_.get());
   drag_drop_thread_.reset(new DragDropThread(this));
   base::Thread::Options options;
@@ skipping 221 matching lines @@
 
   drag_source_->CancelDrag();
 }
 
 void WebContentsDragWin::CloseThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   drag_drop_thread_.reset();
 }
 
+void WebContentsDragWin::SendMouseEventForTouchDnD() {
+  RenderWidgetHostViewWin* rwhv =
+      static_cast<RenderWidgetHostViewWin*>
+          (web_contents_->GetRenderWidgetHostView());
+
+  if (!rwhv)
+    return;
+
+  RECT screen_rect;
+  ::GetWindowRect(::GetDesktopWindow(), &screen_rect);
+  int screen_width = screen_rect.right - screen_rect.left;
+  int screen_height = screen_rect.bottom - screen_rect.top;
+  gfx::Point last_touch_position = rwhv->GetLastTouchEventLocation();
+
+  // Map the screen coordinate to the normalized absolute coordinate.
+  int absolute_x =
+      last_touch_position.x() * kMaxAbsoluteCoordinate / screen_width;
+  int absolute_y =
+      last_touch_position.y() * kMaxAbsoluteCoordinate / screen_height;
+
+  // Send MOUSEEVENTF_RIGHTDOWN event followed by MOUSEEVENTF_MOVE event.
+  //
+  // The reason why not to merge these 2 mouse events into one is, we don't
+  // want DoDragDrop to get mouse event firstly which lead to drop the drag
+  // source.
+  //
+  // On Windows, once a touch point is removed from screen after long press,
+  // a MOUSEEVENTF_RIGHTUP event will be sent out, so we send the down event
+  // paired with it to complete DoDragDrop session.
+  INPUT ip;

[dcheng, 2013/04/15 18:07:37]

Initialize this with = {}? The current code leaves random stuff in some of the
other fields for MOUSEINPUT. This way, you can also skip initializing ip.mi.time
explicitly below.

+  ip.type = INPUT_MOUSE;
+  ip.mi.dwFlags = MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_ABSOLUTE;

[dcheng, 2013/04/15 18:07:37]

Why do we use the right mouse button? How come we can't just simulate a normal
DnD by using the left mouse button?

[Hongbo Min, 2013/04/16 01:13:44]

The reason is, if we just simulate left mouse button down, then left mouse
button up event won't get fired to exit DoDragDrop loop, and wo also don't know
when to simulate the left mouse button up event, and so DoDragDrop won't exit
forever.

[dcheng, 2013/04/16 01:27:28]

Who's triggering the right mouse button up event then? Is that something the
system is magically triggering somewhere? It seems kind of fragile as well; if
the user also presses right-click on his pointing device during a long-press
drag, won't it cause the logic to get confused?

It seems like it would be more appropriate to teach ui::DragSourceWin about
gesture-initiated drags (e.g. add a set_in_gesture_drag() setter) so
QueryContinueDrag() can use that information to determine whether or not to exit
the dragging loop.

+  ip.mi.time = 0;
+  ip.mi.dx = absolute_x;
+  ip.mi.dy = absolute_y;
+  ::SendInput(1, &ip, sizeof(INPUT));
+
+  // Send MOUSEEVENTF_MOVE input event.
+  ip.mi.dwFlags = MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE;
+  ::SendInput(1, &ip, sizeof(INPUT));
+}
+
 void WebContentsDragWin::OnWaitForData() {
   DCHECK(drag_drop_thread_id_ == base::PlatformThread::CurrentId());
 
   // When the left button is release and we start to wait for the data, end
   // the dragging before DoDragDrop returns. This makes the page leave the drag
   // mode so that it can start to process the normal input events.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&WebContentsDragWin::EndDragging, this));
 }
 
 void WebContentsDragWin::OnDataObjectDisposed() {
   DCHECK(drag_drop_thread_id_ == base::PlatformThread::CurrentId());
 
   // The drag-and-drop thread is only closed after OLE is done with
   // DataObjectImpl.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&WebContentsDragWin::CloseThread, this));
 }
 
 }  // namespace content