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 13 matching lines @@
 using WebKit::WebDragOperationMove;
 
 namespace content {
 namespace {
 
 bool run_do_drag_drop = true;
 
 HHOOK msg_hook = NULL;
 DWORD drag_out_thread_id = 0;
 bool mouse_up_received = false;
+// True if the drag-drop is initiated by touch event.
+bool touch_initiated_drag_drop = false;
 
 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) {
+        msg->message == WM_KEYDOWN || msg->message == WM_KEYUP ||

[dcheng, 2013/05/29 20:16:43]

WM_LBUTTONUP here and lines 75 should probably be tied to
!touch_initiated_drag_drop.

[Hongbo Min, 2013/05/30 01:31:50]

Done.

+        (touch_initiated_drag_drop && msg->message == WM_RBUTTONUP)) {
       // Forward the message from the UI thread to the drag-and-drop thread.
       PostThreadMessage(drag_out_thread_id,
                         msg->message,
                         msg->wParam,
                         msg->lParam);
 
-      // If the left button is up, we do not need to forward the message any
-      // more.
+      // If the left button is up, we do not need to forward the message
+      // any more.
       if (msg->message == WM_LBUTTONUP || !(GetKeyState(VK_LBUTTON) & 0x8000))
         mouse_up_received = true;
 
+      // In case of touch-initiated drag, we need to take care of right
+      // mouse up event since a mouse right button down event is triggered
+      // programmatically for DoDragDrop running.
+      if (touch_initiated_drag_drop && (msg->message == WM_RBUTTONUP ||

[dcheng, 2013/05/29 20:16:43]

I think this should be (touch_initiated_drag_drop && ((msg->message == ... ||
!(GetKeyState(...))))

[Hongbo Min, 2013/05/30 01:31:50]

Why do we need additional '(...)' to wrap "msg->message == .." again?

[dcheng, 2013/05/31 00:57:05]

I mismatched the parens. See my next comment =)

+          !(GetKeyState(VK_RBUTTON) & 0x8000)))
+          mouse_up_received = true;
+
       return TRUE;
     }
   }
   return CallNextHookEx(msg_hook, code, wparam, lparam);
 }
 
 void EnableBackgroundDraggingSupport(DWORD thread_id) {
   // Install a hook procedure to monitor the messages so that we can forward
   // the appropriate ones to the background thread.
   drag_out_thread_id = thread_id;
@@ skipping 70 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!drag_drop_thread_.get());
 }
 
 void WebContentsDragWin::StartDragging(const WebDropData& drop_data,
                                        WebDragOperationsMask ops,
                                        const gfx::ImageSkia& image,
                                        const gfx::Vector2d& image_offset) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  drag_source_ = new WebDragSource(source_window_, web_contents_);
+  RenderWidgetHostViewWin* rwhv =
+      static_cast<RenderWidgetHostViewWin*>(
+          web_contents_->GetRenderWidgetHostView());
+
+  ui::DragDropTypes::DragEventSource event_source;
+  if (rwhv->in_long_press_gesture()) {
+    event_source = ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
+    touch_initiated_drag_drop = true;
+  }
+  else {
+    event_source = ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
+    touch_initiated_drag_drop = false;
+  }
+
+  drag_source_ = new WebDragSource(source_window_, web_contents_, event_source);
 
   const GURL& page_url = web_contents_->GetURL();
   const std::string& page_encoding = web_contents_->GetEncoding();
 
   // If it is not drag-out, do the drag-and-drop in the current UI thread.
   if (drop_data.download_metadata.empty()) {
     if (DoDragging(drop_data, ops, page_url, page_encoding,
                    image, image_offset))
       EndDragging();
     return;
@@ skipping 133 matching lines @@
 }
 
 bool WebContentsDragWin::DoDragging(const WebDropData& drop_data,
                                     WebDragOperationsMask ops,
                                     const GURL& page_url,
                                     const std::string& page_encoding,
                                     const gfx::ImageSkia& image,
                                     const gfx::Vector2d& image_offset) {
   ui::OSExchangeData data;
 
+  RenderWidgetHostViewWin* rwhv =
+      static_cast<RenderWidgetHostViewWin*>(
+          web_contents_->GetRenderWidgetHostView());
+  // 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->in_long_press_gesture())
+    SendMouseEventForTouchDnD();
+
   if (!drop_data.download_metadata.empty()) {
     PrepareDragForDownload(drop_data, &data, page_url, page_encoding);
 
     // Set the observer.
     ui::OSExchangeDataProviderWin::GetDataObjectImpl(data)->set_observer(this);
   }
 
   // We set the file contents before the URL because the URL also sets file
   // contents (to a .URL shortcut).  We want to prefer file content data over
   // a shortcut so we add it first.
@@ skipping 77 matching lines @@
 
   drag_source_->CancelDrag();
 }
 
 void WebContentsDragWin::CloseThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   drag_drop_thread_.reset();
 }
 
+void WebContentsDragWin::SendMouseEventForTouchDnD() {
+  static const int kMaxAbsoluteCoordinate = 65535;
+
+  RenderWidgetHostViewWin* rwhv =
+      static_cast<RenderWidgetHostViewWin*>(
+          web_contents_->GetRenderWidgetHostView());
+
+  if (!rwhv)
+    return;
+
+  gfx::Point last_touch_position = rwhv->GetLastTouchEventLocation();
+  gfx::Screen* screen = gfx::Screen::GetScreenFor(rwhv->GetNativeView());
+  gfx::Display display = screen->GetDisplayNearestPoint(last_touch_position);

[oshima, 2013/05/29 14:41:01]

It may be better to use GetDisplayNearestWindow as you have access to
native view. Please ignore if you think it's better to use touch position
instead.

[Hongbo Min, 2013/05/30 01:36:03]

Thanks for your information. I still think it should be better to use the touch
position since the native window may cross more than one display, but the point
can be tied to only one display.

+  int screen_width = display.size().width();
+  int screen_height = display.size().height();
+
+  // 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. 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 input = { 0 };
+  input.type = INPUT_MOUSE;
+  input.mi.dwFlags = MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_ABSOLUTE;
+  input.mi.dx = absolute_x;
+  input.mi.dy = absolute_y;
+  ::SendInput(1, &input, sizeof(input));
+
+  // Send MOUSEEVENTF_MOVE input event to set cursor to the right position.
+  input.mi.dwFlags = MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE;
+  ::SendInput(1, &input, 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));
 }
 
 // static
 void WebContentsDragWin::DisableDragDropForTesting() {
   run_do_drag_drop = false;
 }
 
 }  // namespace content