Use input events to improve vsync scheduling

content/browser/android/content_view_core_impl.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/android/content_view_core_impl.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
@@ skipping 133 matching lines @@
 ContentViewCoreImpl::ContentViewCoreImpl(JNIEnv* env, jobject obj,
                                          bool hardware_accelerated,
                                          bool input_events_delivered_at_vsync,
                                          WebContents* web_contents,
                                          ui::WindowAndroid* window_android)
     : java_ref_(env, obj),
       web_contents_(static_cast<WebContentsImpl*>(web_contents)),
       root_layer_(cc::Layer::create()),
       tab_crashed_(false),
       input_events_delivered_at_vsync_(input_events_delivered_at_vsync),
+      has_touch_event_handlers_(false),
       renderer_frame_pending_(false),
       window_android_(window_android) {
   CHECK(web_contents) <<
       "A ContentViewCoreImpl should be created with a valid WebContents.";
 
   // When a tab is restored (from a saved state), it does not have a renderer
   // process.  We treat it like the tab is crashed. If the content is loaded
   // when the tab is shown, tab_crashed_ will be reset.  Since
   // RenderWidgetHostView is associated with the lifetime of the renderer
   // process, we use it to test whether there is a renderer process.
@@ skipping 327 matching lines @@
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return;
   Java_ContentViewCore_confirmTouchEvent(env, j_obj.obj(),
                                          static_cast<jint>(ack_result));
 }
 
 void ContentViewCoreImpl::HasTouchEventHandlers(bool need_touch_events) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
+  has_touch_event_handlers_ = need_touch_events;
   if (j_obj.is_null())
     return;
   Java_ContentViewCore_hasTouchEventHandlers(env,
                                              j_obj.obj(),
                                              need_touch_events);
 }
 
 bool ContentViewCoreImpl::HasFocus() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
@@ skipping 348 matching lines @@
   event.x = x / DpiScale();
   event.y = y / DpiScale();
   event.timeStampSeconds = time_ms / 1000.0;
   event.sourceDevice = WebGestureEvent::Touchscreen;
   UpdateVSyncFlagOnInputEvent(&event);
   return event;
 }
 
 void ContentViewCoreImpl::UpdateVSyncFlagOnInputEvent(
     WebKit::WebInputEvent* event) const {
-  if (!input_events_delivered_at_vsync_)
+  if (!input_events_delivered_at_vsync_ || has_touch_event_handlers_)
     return;
   if (event->type == WebInputEvent::GestureScrollUpdate ||
-      event->type == WebInputEvent::GesturePinchUpdate ||
-      event->type == WebInputEvent::TouchMove)

[jamesr, 2013/01/16 04:13:26]

whaaaa? why was this here?

actually, this whole function seems kind of like bullshit.  we don't have any
way to tell that we're in this mode from the android framework?

[Sami, 2013/01/16 10:49:15]

From Android's point of view input events are always delivered right before
vsync if we're on JB+, but the problem is that we have at least two different
event queues between the framework and the renderer which affect which events
get sent and when.

Here I'm limiting the vsync bit to those events that are guaranteed to be sent
at the right time -- it doesn't make sense to do it for, e.g., the touch handler
case because the real vsync signal will have reached the renderer by the time we
get an ack from JS.

Maybe it would help if I move this logic to where the events are generated in
Java?

+      event->type == WebInputEvent::GesturePinchUpdate)
     event->modifiers |= WebInputEvent::IsLastInputEventForCurrentVSync;
 }
 
 void ContentViewCoreImpl::ScrollBegin(JNIEnv* env, jobject obj, jlong time_ms,
                                       jint x, jint y) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureScrollBegin, time_ms, x, y);
   if (GetRenderWidgetHostViewAndroid())
     GetRenderWidgetHostViewAndroid()->SendGestureEvent(event);
 }
@@ skipping 488 matching lines @@
   if (!HasField(env, clazz, "mNativeContentViewCore", "I")) {
     DLOG(ERROR) << "Unable to find ContentView.mNativeContentViewCore!";
     return false;
   }
   g_native_content_view = GetFieldID(env, clazz, "mNativeContentViewCore", "I");
 
   return RegisterNativesImpl(env) >= 0;
 }
 
 }  // namespace content