Android WebView: flush input events during onVSync

content/browser/renderer_host/render_widget_host_view_android.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/renderer_host/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 183 matching lines @@
           switches::kDisableOverscrollEdgeEffect)),
       gesture_provider_(CreateGestureProviderConfig(), this),
       gesture_text_selector_(this),
       touch_scrolling_(false),
       potentially_active_fling_count_(0),
       flush_input_requested_(false),
       accelerated_surface_route_id_(0),
       using_synchronous_compositor_(SynchronousCompositorImpl::FromID(
                                         widget_host->GetProcess()->GetID(),
                                         widget_host->GetRoutingID()) != NULL),
+      vsync_subscribers_(0),
       frame_evictor_(new DelegatedFrameEvictor(this)),
       locks_on_frame_count_(0),
       observing_root_window_(false) {

[boliu, 2014/08/20 02:54:16]

vsync_subscribers_ can replace observing_root_window_ I think?

[hush (inactive), 2014/08/20 03:47:21]

yes indeed.

   host_->SetView(this);
   SetContentViewCore(content_view_core);
   ImageTransportFactoryAndroid::AddObserver(this);
 }
 
 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
   ImageTransportFactoryAndroid::RemoveObserver(this);
   SetContentViewCore(NULL);
   DCHECK(ack_callbacks_.empty());
   if (resource_collection_.get())
@@ skipping 36 matching lines @@
   return host_;
 }
 
 void RenderWidgetHostViewAndroid::WasShown() {
   if (!host_ || !host_->is_hidden())
     return;
 
   host_->WasShown(ui::LatencyInfo());
 
   if (content_view_core_ && !using_synchronous_compositor_) {
-    content_view_core_->GetWindowAndroid()->AddObserver(this);
+    SubscribeToVSync(INPUT | BEGIN_FRAME);
     content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
-    observing_root_window_ = true;
   }
 }
 
 void RenderWidgetHostViewAndroid::WasHidden() {
   RunAckCallbacks();
 
   if (!host_ || host_->is_hidden())
     return;
 
   // Inform the renderer that we are being hidden so it can reduce its resource
@@ skipping 528 matching lines @@
 void RenderWidgetHostViewAndroid::ShowDisambiguationPopup(
     const gfx::Rect& target_rect, const SkBitmap& zoomed_bitmap) {
   if (!content_view_core_)
     return;
 
   content_view_core_->ShowDisambiguationPopup(target_rect, zoomed_bitmap);
 }
 
 scoped_ptr<SyntheticGestureTarget>
 RenderWidgetHostViewAndroid::CreateSyntheticGestureTarget() {
+  DCHECK(content_view_core_);
+  if (using_synchronous_compositor_)
+    SubscribeToVSync(INPUT);
+
   return scoped_ptr<SyntheticGestureTarget>(new SyntheticGestureTargetAndroid(
       host_, content_view_core_->CreateTouchEventSynthesizer()));
 }
 
 void RenderWidgetHostViewAndroid::SendDelegatedFrameAck(
     uint32 output_surface_id) {
   DCHECK(host_);
   cc::CompositorFrameAck ack;
   if (resource_collection_.get())
     resource_collection_->TakeUnusedResourcesForChildCompositor(&ack.resources);
@@ skipping 639 matching lines @@
       obj = content_view_core_->GetJavaObject();
     manager->ToBrowserAccessibilityManagerAndroid()->SetContentViewCore(obj);
   }
 
   AttachLayers();
 
   if (!content_view_core_)
     return;
 
   if (!using_synchronous_compositor_) {
-    content_view_core_->GetWindowAndroid()->AddObserver(this);
-    observing_root_window_ = true;
+    SubscribeToVSync(INPUT | BEGIN_FRAME);
     if (needs_begin_frame_)
       content_view_core_->GetWindowAndroid()->RequestVSyncUpdate();
   }
 
   if (resize)
     WasResized();
 
   if (!selection_controller_)
     selection_controller_.reset(new TouchSelectionController(this));
 
@@ skipping 26 matching lines @@
 void RenderWidgetHostViewAndroid::OnCompositingDidCommit() {
   RunAckCallbacks();
 }
 
 void RenderWidgetHostViewAndroid::OnDetachCompositor() {
   DCHECK(content_view_core_);
   DCHECK(!using_synchronous_compositor_);
   RunAckCallbacks();
 }
 
+void RenderWidgetHostViewAndroid::SubscribeToVSync(int type) {

[boliu, 2014/08/20 02:54:16]

Where is Unsubscribe?

[hush (inactive), 2014/08/20 03:47:21]

Will add it...
On 2014/08/20 02:54:16, boliu wrote:

+  if (!observing_root_window_) {
+    content_view_core_->GetWindowAndroid()->AddObserver(this);
+    observing_root_window_ = true;
+  }
+
+  vsync_subscribers_ |= type;
+  // Synchronous compositor does not request begin frames OnVSync.
+  DCHECK(using_synchronous_compositor_ && !(vsync_subscribers_ & BEGIN_FRAME));

[boliu, 2014/08/20 02:54:16]

This DCHECK can't be right. It fails if using_synchronous_compositor is false.

I think you want

DCHECK(!using_synchronous_compositor || !(vsync_subscribers_ & BEGIN_FRAME));

[hush (inactive), 2014/08/20 03:47:21]

yeah.. you are right.
Done
On 2014/08/20 02:54:16, boliu wrote:

+}
+
 void RenderWidgetHostViewAndroid::OnVSync(base::TimeTicks frame_time,
                                           base::TimeDelta vsync_period) {
   TRACE_EVENT0("cc", "RenderWidgetHostViewAndroid::OnVSync");
   if (!host_)
     return;
 
-  if (flush_input_requested_) {
+  if (vsync_subscribers_ & INPUT & flush_input_requested_) {
     flush_input_requested_ = false;
     host_->FlushInput();
   }
 
+  if (!(vsync_subscribers_ & BEGIN_FRAME))
+    return;
+
   TRACE_EVENT0("cc", "RenderWidgetHostViewAndroid::SendBeginFrame");
   base::TimeTicks display_time = frame_time + vsync_period;
 
   // TODO(brianderson): Use adaptive draw-time estimation.
   base::TimeDelta estimated_browser_composite_time =
       base::TimeDelta::FromMicroseconds(
           (1.0f * base::Time::kMicrosecondsPerSecond) / (3.0f * 60));
 
   base::TimeTicks deadline = display_time - estimated_browser_composite_time;
 
@@ skipping 149 matching lines @@
   results->orientationAngle = display.RotationAsDegree();
   results->orientationType =
       RenderWidgetHostViewBase::GetOrientationTypeForMobile(display);
   gfx::DeviceDisplayInfo info;
   results->depth = info.GetBitsPerPixel();
   results->depthPerComponent = info.GetBitsPerComponent();
   results->isMonochrome = (results->depthPerComponent == 0);
 }
 
 } // namespace content