Route OnDragEvent through ViewAndroid tree

ui/android/event_forwarder.cc

 // Copyright 2017 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 "ui/android/event_forwarder.h"
 
+#include "base/android/jni_array.h"
+#include "base/android/jni_string.h"
 #include "base/metrics/histogram_macros.h"
 #include "jni/EventForwarder_jni.h"
 #include "ui/android/view_android.h"
 #include "ui/android/view_client.h"
+#include "ui/base/ui_base_switches_util.h"
+#include "ui/events/android/drag_event_android.h"
 #include "ui/events/android/motion_event_android.h"
 #include "ui/events/base_event_utils.h"
 
 namespace ui {
 
+using base::android::AppendJavaStringArrayToStringVector;
 using base::android::JavaParamRef;
 using base::android::ScopedJavaLocalRef;
+using base::android::ConvertJavaStringToUTF16;
 
 EventForwarder::EventForwarder(ViewAndroid* view) : view_(view) {}
 
 EventForwarder::~EventForwarder() {
   if (!java_obj_.is_null()) {
     Java_EventForwarder_destroy(base::android::AttachCurrentThread(),
                                 java_obj_);
     java_obj_.Reset();
   }
 }
 
 ScopedJavaLocalRef<jobject> EventForwarder::GetJavaObject() {
   if (java_obj_.is_null()) {
+    JNIEnv* env = base::android::AttachCurrentThread();
     java_obj_.Reset(
-        Java_EventForwarder_create(base::android::AttachCurrentThread(),
-                                   reinterpret_cast<intptr_t>(this)));
+        Java_EventForwarder_create(env, reinterpret_cast<intptr_t>(this),
+                                   switches::IsTouchDragDropEnabled()));
   }
   return ScopedJavaLocalRef<jobject>(java_obj_);
 }
 
 jboolean EventForwarder::OnTouchEvent(JNIEnv* env,
                                       const JavaParamRef<jobject>& obj,
                                       const JavaParamRef<jobject>& motion_event,
                                       jlong time_ms,
                                       jint android_action,
                                       jint pointer_count,
@@ skipping 86 matching lines @@
   ui::MotionEventAndroid event(env, nullptr, 1.f / view_->GetDipScale(),
                                ticks_x, ticks_y, pixels_per_tick, time_ms,
                                0 /* action */, 1 /* pointer_count */,
                                0 /* history_size */, 0 /* action_index */, 0, 0,
                                0, 0 /* raw_offset_x_pixels */,
                                0 /* raw_offset_y_pixels */, &pointer, nullptr);
 
   view_->OnMouseWheelEvent(event);
 }
 
+void EventForwarder::OnDragEvent(JNIEnv* env,
+                                 const JavaParamRef<jobject>& jobj,
+                                 jint action,
+                                 jint x,
+                                 jint y,
+                                 jint screen_x,
+                                 jint screen_y,
+                                 const JavaParamRef<jobjectArray>& j_mimeTypes,
+                                 const JavaParamRef<jstring>& j_content) {
+  base::string16 drop_content = ConvertJavaStringToUTF16(env, j_content);

[boliu, 2017/05/24 22:54:02]

depending on how big the payload is, that's potentially a *lot* of unnecessary
copying. just take a global ref to the java object, and convert lazily?

[Jinsuk Kim, 2017/05/25 03:18:18]

Done.

+  float dip_scale = view_->GetDipScale();
+  gfx::PointF location(x / dip_scale, y / dip_scale);
+  gfx::PointF root_location(screen_x / dip_scale, screen_y / dip_scale);
+  std::vector<base::string16> mime_types;
+  AppendJavaStringArrayToStringVector(env, j_mimeTypes, &mime_types);
+
+  DragEventAndroid event(action, location, root_location, mime_types,
+                         drop_content);
+  view_->OnDragEvent(event);
+}
+
 bool RegisterEventForwarder(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace ui