sync compositor: Merge input path with chrome

Use chrome's async input delivery path in Android WebView. See bug
for potential incompatibility risk. Existing code path is not removed
in case compatibility is an issue.

Refactor out ui::SynchronousInputHandlerProxy parts from
InputHandlerManagerClient into a separate interface so that sync
compositor can use SynchronousInputHandlerProxy even without
routing input synchronously. Then just stop filtering input events in
sync compositor, hook up overscroll, and everything just works.

Tests:
testNoSpuriousOverScrolls requires synchronous input to maintain
the property that a single scroll call happens. Asynchronously the
test is not valid
AwContents.zoomIn is no longer synchronous which breaks
testPinchZoomUpdatesScrollRangeSynchronously. Can fix this
independently if this becomes a problem later.

BUG=545628

Review URL: https://codereview.chromium.org/1620053002

Cr-Commit-Position: refs/heads/master@{#380563}

25 files changed, 188 insertions, 131 deletions

diff --git a/android_webview/javatests/src/org/chromium/android_webview/test/AndroidScrollIntegrationTest.java b/android_webview/javatests/src/org/chromium/android_webview/test/AndroidScrollIntegrationTest.java
index 473acd4..ca277ba 100644
--- a/android_webview/javatests/src/org/chromium/android_webview/test/AndroidScrollIntegrationTest.java
+++ b/android_webview/javatests/src/org/chromium/android_webview/test/AndroidScrollIntegrationTest.java
@@ -15,6 +15,7 @@ import org.chromium.android_webview.test.util.CommonResources;
 import org.chromium.android_webview.test.util.JavascriptEventObserver;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.annotations.SuppressFBWarnings;
+import org.chromium.base.test.util.DisabledTest;
 import org.chromium.base.test.util.Feature;
 import org.chromium.content.browser.test.util.CallbackHelper;
 import org.chromium.content_public.browser.GestureStateListener;
@@ -23,7 +24,6 @@ import org.chromium.ui.gfx.DeviceDisplayInfo;
 
 import java.util.Locale;
 import java.util.concurrent.Callable;
-import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
@@ -472,8 +472,7 @@ public class AndroidScrollIntegrationTest extends AwTestBase {
         AwTestTouchUtils.dragCompleteView(testContainerView,
                 0, -targetScrollXPix, // these need to be negative as we're scrolling down.
                 0, -targetScrollYPix,
-                dragSteps,
-                null /* completionLatch */);
+                dragSteps);
 
         for (int i = 1; i <= dragSteps; ++i) {
             onScrollToCallbackHelper.waitForCallback(scrollToCallCount, i);
@@ -487,38 +486,6 @@ public class AndroidScrollIntegrationTest extends AwTestBase {
 
     @SmallTest
     @Feature({"AndroidWebView"})
-    public void testNoSpuriousOverScrolls() throws Throwable {
-        final TestAwContentsClient contentsClient = new TestAwContentsClient();
-        final ScrollTestContainerView testContainerView =
-                (ScrollTestContainerView) createAwTestContainerViewOnMainSync(contentsClient);
-        enableJavaScriptOnUiThread(testContainerView.getAwContents());
-
-        final int dragSteps = 1;
-        final int targetScrollYPix = 40;
-
-        setMaxScrollOnMainSync(testContainerView, 0, 0);
-
-        loadTestPageAndWaitForFirstFrame(testContainerView, contentsClient, null, "");
-
-        final CallbackHelper onScrollToCallbackHelper =
-                testContainerView.getOnScrollToCallbackHelper();
-        final int scrollToCallCount = onScrollToCallbackHelper.getCallCount();
-        CountDownLatch scrollingCompleteLatch = new CountDownLatch(1);
-        AwTestTouchUtils.dragCompleteView(testContainerView,
-                0, 0, // these need to be negative as we're scrolling down.
-                0, -targetScrollYPix,
-                dragSteps,
-                scrollingCompleteLatch);
-        try {
-            scrollingCompleteLatch.await();
-        } catch (InterruptedException ex) {
-            // ignore
-        }
-        assertEquals(scrollToCallCount + 1, onScrollToCallbackHelper.getCallCount());
-    }
-
-    @SmallTest
-    @Feature({"AndroidWebView"})
     public void testOverScrollX() throws Throwable {
         final TestAwContentsClient contentsClient = new TestAwContentsClient();
         final ScrollTestContainerView testContainerView =
@@ -538,8 +505,7 @@ public class AndroidScrollIntegrationTest extends AwTestBase {
         AwTestTouchUtils.dragCompleteView(testContainerView,
                 0, overScrollDeltaX,
                 0, 0,
-                oneStep,
-                null /* completionLatch */);
+                oneStep);
         overScrollByCallbackHelper.waitForCallback(overScrollCallCount);
         // Unfortunately the gesture detector seems to 'eat' some number of pixels. For now
         // checking that the value is < 0 (overscroll is reported as negative values) will have to
@@ -569,8 +535,7 @@ public class AndroidScrollIntegrationTest extends AwTestBase {
         AwTestTouchUtils.dragCompleteView(testContainerView,
                 0, 0,
                 0, overScrollDeltaY,
-                oneStep,
-                null /* completionLatch */);
+                oneStep);
         overScrollByCallbackHelper.waitForCallback(overScrollCallCount);
         assertEquals(0, overScrollByCallbackHelper.getDeltaX());
         assertTrue(0 > overScrollByCallbackHelper.getDeltaY());
@@ -802,13 +767,17 @@ public class AndroidScrollIntegrationTest extends AwTestBase {
         AwTestTouchUtils.dragCompleteView(testContainerView,
                 0, -targetScrollXPix, // these need to be negative as we're scrolling down.
                 0, -targetScrollYPix,
-                dragSteps,
-                null /* completionLatch */);
+                dragSteps);
         onScrollUpdateGestureConsumedHelper.waitForCallback(callCount);
     }
 
+    /*
     @SmallTest
     @Feature({"AndroidWebView"})
+    Disabled because zoomIn is no longer synchronous. Fix if it's a compatibility problem.
+    See crbug.com/545628.
+    */
+    @DisabledTest
     public void testPinchZoomUpdatesScrollRangeSynchronously() throws Throwable {
         final TestAwContentsClient contentsClient = new TestAwContentsClient();
         final ScrollTestContainerView testContainerView =
diff --git a/android_webview/javatests/src/org/chromium/android_webview/test/util/AwTestTouchUtils.java b/android_webview/javatests/src/org/chromium/android_webview/test/util/AwTestTouchUtils.java
index bdae4ec..c733076 100644
--- a/android_webview/javatests/src/org/chromium/android_webview/test/util/AwTestTouchUtils.java
+++ b/android_webview/javatests/src/org/chromium/android_webview/test/util/AwTestTouchUtils.java
@@ -8,8 +8,6 @@ import android.os.SystemClock;
 import android.view.MotionEvent;
 import android.view.View;
 
-import java.util.concurrent.CountDownLatch;
-
 /**
  * A touch utility class that injects the events directly into the view.
  * TODO(mkosiba): Merge with TestTouchUtils.
@@ -59,20 +57,15 @@ public class AwTestTouchUtils {
      * @param fromY The relative y-coordinate of the start point of the drag.
      * @param toY The relative y-coordinate of the end point of the drag.
      * @param stepCount The total number of motion events that should be generated during the drag.
-     * @param completionLatch The .countDown method is called on this latch once the drag finishes.
      */
     public static void dragCompleteView(final View view, final int fromX, final int toX,
-            final int fromY, final int toY, final int stepCount,
-            final CountDownLatch completionLatch) {
+            final int fromY, final int toY, final int stepCount) {
         view.post(new Runnable() {
             @Override
             public void run() {
                 long downTime = dragStart(view, fromX, fromY);
                 dragTo(view, fromX, toX, fromY, toY, stepCount, downTime);
                 dragEnd(view, toX, toY, downTime);
-                if (completionLatch != null) {
-                    completionLatch.countDown();
-                }
             }
         });
     }
diff --git a/content/browser/android/in_process/synchronous_compositor_factory_impl.cc b/content/browser/android/in_process/synchronous_compositor_factory_impl.cc
index 385bb4f..4dba524b 100644
--- a/content/browser/android/in_process/synchronous_compositor_factory_impl.cc
+++ b/content/browser/android/in_process/synchronous_compositor_factory_impl.cc
@@ -118,6 +118,11 @@ SynchronousCompositorFactoryImpl::GetInputHandlerManagerClient() {
   return synchronous_input_event_filter();
 }
 
+SynchronousInputHandlerProxyClient*
+SynchronousCompositorFactoryImpl::GetSynchronousInputHandlerProxyClient() {
+  return synchronous_input_event_filter();
+}
+
 scoped_ptr<cc::BeginFrameSource>
 SynchronousCompositorFactoryImpl::CreateExternalBeginFrameSource(
     int routing_id) {
diff --git a/content/browser/android/in_process/synchronous_compositor_factory_impl.h b/content/browser/android/in_process/synchronous_compositor_factory_impl.h
index be0d978..79b2625 100644
--- a/content/browser/android/in_process/synchronous_compositor_factory_impl.h
+++ b/content/browser/android/in_process/synchronous_compositor_factory_impl.h
@@ -45,6 +45,8 @@ class SynchronousCompositorFactoryImpl : public SynchronousCompositorFactory {
       const scoped_refptr<cc::ContextProvider>& onscreen_context,
       const scoped_refptr<cc::ContextProvider>& worker_context) override;
   InputHandlerManagerClient* GetInputHandlerManagerClient() override;
+  SynchronousInputHandlerProxyClient* GetSynchronousInputHandlerProxyClient()
+      override;
   scoped_ptr<cc::BeginFrameSource> CreateExternalBeginFrameSource(
       int routing_id) override;
 
diff --git a/content/browser/android/in_process/synchronous_compositor_impl.cc b/content/browser/android/in_process/synchronous_compositor_impl.cc
index a10e608..ed99e093 100644
--- a/content/browser/android/in_process/synchronous_compositor_impl.cc
+++ b/content/browser/android/in_process/synchronous_compositor_impl.cc
@@ -279,7 +279,7 @@ void SynchronousCompositorImpl::UpdateNeedsBeginFrames() {
   rwhva_->OnSetNeedsBeginFrames(is_active_ && renderer_needs_begin_frames_);
 }
 
-void SynchronousCompositorImpl::DidOverscroll(
+void SynchronousCompositorImpl::DidOverscrollInProcess(
     const DidOverscrollParams& params) {
   if (registered_with_client_) {
     compositor_client_->DidOverscroll(params.accumulated_overscroll,
@@ -303,6 +303,13 @@ InputEventAckState SynchronousCompositorImpl::HandleInputEvent(
       routing_id_, input_event);
 }
 
+void SynchronousCompositorImpl::DidOverscroll(
+    const DidOverscrollParams& params) {
+  // SynchronousCompositorImpl uses synchronous DidOverscrollInProcess for
+  // overscroll instead of this async path.
+  NOTREACHED();
+}
+
 bool SynchronousCompositorImpl::OnMessageReceived(const IPC::Message& message) {
   NOTREACHED();
   return false;
diff --git a/content/browser/android/in_process/synchronous_compositor_impl.h b/content/browser/android/in_process/synchronous_compositor_impl.h
index b788405..2c7e5b5 100644
--- a/content/browser/android/in_process/synchronous_compositor_impl.h
+++ b/content/browser/android/in_process/synchronous_compositor_impl.h
@@ -79,6 +79,7 @@ class SynchronousCompositorImpl
   void BeginFrame(const cc::BeginFrameArgs& args) override;
   InputEventAckState HandleInputEvent(
       const blink::WebInputEvent& input_event) override;
+  void DidOverscroll(const DidOverscrollParams& params) override;
   bool OnMessageReceived(const IPC::Message& message) override;
   void DidBecomeCurrent() override;
 
@@ -91,7 +92,7 @@ class SynchronousCompositorImpl
                             float min_page_scale_factor,
                             float max_page_scale_factor) override;
 
-  void DidOverscroll(const DidOverscrollParams& params);
+  void DidOverscrollInProcess(const DidOverscrollParams& params);
   void DidStopFlinging();
 
  private:
diff --git a/content/browser/android/in_process/synchronous_input_event_filter.cc b/content/browser/android/in_process/synchronous_input_event_filter.cc
index 80f1025..9057da83 100644
--- a/content/browser/android/in_process/synchronous_input_event_filter.cc
+++ b/content/browser/android/in_process/synchronous_input_event_filter.cc
@@ -40,26 +40,15 @@ void SynchronousInputEventFilter::SetBoundHandler(const Handler& handler) {
                  base::Unretained(this), handler));
 }
 
+void SynchronousInputEventFilter::DidAddInputHandler(int routing_id) {}
+void SynchronousInputEventFilter::DidRemoveInputHandler(int routing_id) {}
+
 void SynchronousInputEventFilter::SetBoundHandlerOnUIThread(
     const Handler& handler) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   handler_ = handler;
 }
 
-void SynchronousInputEventFilter::DidAddInputHandler(
-    int routing_id,
-    ui::SynchronousInputHandlerProxy* synchronous_input_handler_proxy) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  SynchronousCompositorRegistryInProc::GetInstance()->RegisterInputHandler(
-      routing_id, synchronous_input_handler_proxy);
-}
-
-void SynchronousInputEventFilter::DidRemoveInputHandler(int routing_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  SynchronousCompositorRegistryInProc::GetInstance()->UnregisterInputHandler(
-      routing_id);
-}
-
 void SynchronousInputEventFilter::DidOverscroll(
     int routing_id,
     const DidOverscrollParams& params) {
@@ -68,7 +57,7 @@ void SynchronousInputEventFilter::DidOverscroll(
   SynchronousCompositorImpl* compositor =
       SynchronousCompositorImpl::FromRoutingID(routing_id);
   if (compositor)
-    compositor->DidOverscroll(params);
+    compositor->DidOverscrollInProcess(params);
 }
 
 void SynchronousInputEventFilter::DidStopFlinging(int routing_id) {
@@ -84,4 +73,19 @@ void SynchronousInputEventFilter::NonBlockingInputEventHandled(
     int routing_id,
     blink::WebInputEvent::Type type) {}
 
+void SynchronousInputEventFilter::DidAddSynchronousHandlerProxy(
+    int routing_id,
+    ui::SynchronousInputHandlerProxy* synchronous_input_handler_proxy) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  SynchronousCompositorRegistryInProc::GetInstance()->RegisterInputHandler(
+      routing_id, synchronous_input_handler_proxy);
+}
+
+void SynchronousInputEventFilter::DidRemoveSynchronousHandlerProxy(
+    int routing_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  SynchronousCompositorRegistryInProc::GetInstance()->UnregisterInputHandler(
+      routing_id);
+}
+
 }  // namespace content
diff --git a/content/browser/android/in_process/synchronous_input_event_filter.h b/content/browser/android/in_process/synchronous_input_event_filter.h
index 32b6ecb..61ba62b 100644
--- a/content/browser/android/in_process/synchronous_input_event_filter.h
+++ b/content/browser/android/in_process/synchronous_input_event_filter.h
@@ -26,7 +26,9 @@ namespace content {
 // The provided |handler| process WebInputEvents synchronously on the merged
 // UI and compositing thread. If the event goes unhandled, that is reflected in
 // the InputEventAckState; no forwarding is performed.
-class SynchronousInputEventFilter : public InputHandlerManagerClient {
+class SynchronousInputEventFilter
+    : public InputHandlerManagerClient,
+      public SynchronousInputHandlerProxyClient {
  public:
   SynchronousInputEventFilter();
   ~SynchronousInputEventFilter() override;
@@ -36,10 +38,7 @@ class SynchronousInputEventFilter : public InputHandlerManagerClient {
 
   // InputHandlerManagerClient implementation.
   void SetBoundHandler(const Handler& handler) override;
-  void DidAddInputHandler(
-      int routing_id,
-      ui::SynchronousInputHandlerProxy*
-          synchronous_input_handler_proxy) override;
+  void DidAddInputHandler(int routing_id) override;
   void DidRemoveInputHandler(int routing_id) override;
   void DidOverscroll(int routing_id,
                      const DidOverscrollParams& params) override;
@@ -47,6 +46,13 @@ class SynchronousInputEventFilter : public InputHandlerManagerClient {
   void NonBlockingInputEventHandled(int routing_id,
                                     blink::WebInputEvent::Type type) override;
 
+  // SynchronousInputHandlerProxyClient overrides.
+  void DidAddSynchronousHandlerProxy(
+      int routing_id,
+      ui::SynchronousInputHandlerProxy* synchronous_input_handler_proxy)
+      override;
+  void DidRemoveSynchronousHandlerProxy(int routing_id) override;
+
  private:
   void SetBoundHandlerOnUIThread(const Handler& handler);
 
diff --git a/content/browser/android/synchronous_compositor_base.cc b/content/browser/android/synchronous_compositor_base.cc
index 39d8b24..0d08509 100644
--- a/content/browser/android/synchronous_compositor_base.cc
+++ b/content/browser/android/synchronous_compositor_base.cc
@@ -66,11 +66,13 @@ scoped_ptr<SynchronousCompositorBase> SynchronousCompositorBase::Create(
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kIPCSyncCompositing)) {
+    bool async_input =
+        !command_line->HasSwitch(switches::kSyncInputForSyncCompositor);
     bool use_in_proc_software_draw =
         command_line->HasSwitch(switches::kSingleProcess);
     return make_scoped_ptr(new SynchronousCompositorHost(
         rwhva, web_contents_android->synchronous_compositor_client(),
-        use_in_proc_software_draw));
+        async_input, use_in_proc_software_draw));
   }
   return make_scoped_ptr(new SynchronousCompositorImpl(
       rwhva, web_contents_android->synchronous_compositor_client()));
diff --git a/content/browser/android/synchronous_compositor_base.h b/content/browser/android/synchronous_compositor_base.h
index c269ed4..218e821 100644
--- a/content/browser/android/synchronous_compositor_base.h
+++ b/content/browser/android/synchronous_compositor_base.h
@@ -26,6 +26,7 @@ namespace content {
 class RenderWidgetHostViewAndroid;
 class SynchronousCompositorStreamTextureFactoryImpl;
 class WebContents;
+struct DidOverscrollParams;
 
 class SynchronousCompositorBase : public SynchronousCompositor {
  public:
@@ -38,6 +39,7 @@ class SynchronousCompositorBase : public SynchronousCompositor {
   virtual void BeginFrame(const cc::BeginFrameArgs& args) = 0;
   virtual InputEventAckState HandleInputEvent(
       const blink::WebInputEvent& input_event) = 0;
+  virtual void DidOverscroll(const DidOverscrollParams& over_scroll_params) = 0;
   virtual bool OnMessageReceived(const IPC::Message& message) = 0;
 
   virtual void DidBecomeCurrent() = 0;
diff --git a/content/browser/android/synchronous_compositor_host.cc b/content/browser/android/synchronous_compositor_host.cc
index 658c818..6cb4907 100644
--- a/content/browser/android/synchronous_compositor_host.cc
+++ b/content/browser/android/synchronous_compositor_host.cc
@@ -30,6 +30,7 @@ namespace content {
 SynchronousCompositorHost::SynchronousCompositorHost(
     RenderWidgetHostViewAndroid* rwhva,
     SynchronousCompositorClient* client,
+    bool async_input,
     bool use_in_proc_software_draw)
     : rwhva_(rwhva),
       client_(client),
@@ -37,6 +38,7 @@ SynchronousCompositorHost::SynchronousCompositorHost(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)),
       routing_id_(rwhva_->GetRenderWidgetHost()->GetRoutingID()),
       sender_(rwhva_->GetRenderWidgetHost()),
+      async_input_(async_input),
       use_in_process_zero_copy_software_draw_(use_in_proc_software_draw),
       is_active_(false),
       bytes_limit_(0u),
@@ -338,6 +340,8 @@ void SynchronousCompositorHost::OnComputeScroll(
 
 InputEventAckState SynchronousCompositorHost::HandleInputEvent(
     const blink::WebInputEvent& input_event) {
+  if (async_input_)
+    return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
   SyncCompositorCommonBrowserParams common_browser_params;
   PopulateCommonParams(&common_browser_params);
   SyncCompositorCommonRendererParams common_renderer_params;
@@ -351,8 +355,15 @@ InputEventAckState SynchronousCompositorHost::HandleInputEvent(
   return ack;
 }
 
+void SynchronousCompositorHost::DidOverscroll(
+    const DidOverscrollParams& over_scroll_params) {
+  client_->DidOverscroll(over_scroll_params.accumulated_overscroll,
+                         over_scroll_params.latest_overscroll_delta,
+                         over_scroll_params.current_fling_velocity);
+}
+
 void SynchronousCompositorHost::BeginFrame(const cc::BeginFrameArgs& args) {
-  if (!is_active_ || !need_begin_frame_)
+  if (!is_active_)
     return;
 
   SyncCompositorCommonBrowserParams common_browser_params;
@@ -370,9 +381,7 @@ void SynchronousCompositorHost::OnOverScroll(
     const SyncCompositorCommonRendererParams& params,
     const DidOverscrollParams& over_scroll_params) {
   ProcessCommonParams(params);
-  client_->DidOverscroll(over_scroll_params.accumulated_overscroll,
-                         over_scroll_params.latest_overscroll_delta,
-                         over_scroll_params.current_fling_velocity);
+  DidOverscroll(over_scroll_params);
 }
 
 void SynchronousCompositorHost::PopulateCommonParams(
diff --git a/content/browser/android/synchronous_compositor_host.h b/content/browser/android/synchronous_compositor_host.h
index 1d7f58d..90aafe5 100644
--- a/content/browser/android/synchronous_compositor_host.h
+++ b/content/browser/android/synchronous_compositor_host.h
@@ -51,6 +51,7 @@ class SynchronousCompositorHost : public SynchronousCompositorBase {
   // SynchronousCompositorBase overrides.
   InputEventAckState HandleInputEvent(
       const blink::WebInputEvent& input_event) override;
+  void DidOverscroll(const DidOverscrollParams& over_scroll_params) override;
   void BeginFrame(const cc::BeginFrameArgs& args) override;
   bool OnMessageReceived(const IPC::Message& message) override;
   void DidBecomeCurrent() override;
@@ -63,6 +64,7 @@ class SynchronousCompositorHost : public SynchronousCompositorBase {
 
   SynchronousCompositorHost(RenderWidgetHostViewAndroid* rwhva,
                             SynchronousCompositorClient* client,
+                            bool async_input,
                             bool use_in_proc_software_draw);
   void PopulateCommonParams(SyncCompositorCommonBrowserParams* params);
   void ProcessCommonParams(const SyncCompositorCommonRendererParams& params);
@@ -81,6 +83,7 @@ class SynchronousCompositorHost : public SynchronousCompositorBase {
   const scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
   const int routing_id_;
   IPC::Sender* const sender_;
+  const bool async_input_;
   const bool use_in_process_zero_copy_software_draw_;
 
   bool is_active_;
diff --git a/content/browser/renderer_host/render_widget_host_view_android.cc b/content/browser/renderer_host/render_widget_host_view_android.cc
index a7586d0..f5f06c0 100644
--- a/content/browser/renderer_host/render_widget_host_view_android.cc
+++ b/content/browser/renderer_host/render_widget_host_view_android.cc
@@ -1717,6 +1717,9 @@ SkColor RenderWidgetHostViewAndroid::GetCachedBackgroundColor() const {
 
 void RenderWidgetHostViewAndroid::DidOverscroll(
     const DidOverscrollParams& params) {
+  if (sync_compositor_)
+    sync_compositor_->DidOverscroll(params);
+
   if (!content_view_core_ || !layer_.get() || !is_showing_)
     return;
 
diff --git a/content/public/common/content_switches.cc b/content/public/common/content_switches.cc
index 4a84e56..570d7f1 100644
--- a/content/public/common/content_switches.cc
+++ b/content/public/common/content_switches.cc
@@ -950,6 +950,12 @@ const char kRemoteDebuggingSocketName[]     = "remote-debugging-socket-name";
 // Block ChildProcessMain thread of the renderer's ChildProcessService until a
 // Java debugger is attached.
 const char kRendererWaitForJavaDebugger[] = "renderer-wait-for-java-debugger";
+
+// Use synchronous input code path for IPC-synchronous compositing. This is the
+// legacy input code path used by the in-process synchronous compositor.
+// Maintaining this code path in case there are compatibility bugs with the
+// standard async input path. Remove tracked as part of crbug.com/545628.
+const char kSyncInputForSyncCompositor[]    = "sync-input-for-sync-compositor";
 #endif
 
 // Enable the aggressive flushing of DOM Storage to minimize data loss.
diff --git a/content/public/common/content_switches.h b/content/public/common/content_switches.h
index bf8979c..4ff3369 100644
--- a/content/public/common/content_switches.h
+++ b/content/public/common/content_switches.h
@@ -274,6 +274,7 @@ CONTENT_EXPORT extern const char kHideScrollbars[];
 extern const char kNetworkCountryIso[];
 CONTENT_EXPORT extern const char kRemoteDebuggingSocketName[];
 CONTENT_EXPORT extern const char kRendererWaitForJavaDebugger[];
+CONTENT_EXPORT extern const char kSyncInputForSyncCompositor[];
 #endif
 
 #if defined(OS_CHROMEOS)
diff --git a/content/renderer/android/synchronous_compositor_factory.h b/content/renderer/android/synchronous_compositor_factory.h
index c8fece9..18ada90 100644
--- a/content/renderer/android/synchronous_compositor_factory.h
+++ b/content/renderer/android/synchronous_compositor_factory.h
@@ -31,6 +31,7 @@ class WebGraphicsContext3DInProcessCommandBufferImpl;
 namespace content {
 
 class InputHandlerManagerClient;
+class SynchronousInputHandlerProxyClient;
 class StreamTextureFactory;
 class FrameSwapMessageQueue;
 
@@ -55,6 +56,8 @@ class SynchronousCompositorFactory {
 
   // The factory maintains ownership of the returned interface.
   virtual InputHandlerManagerClient* GetInputHandlerManagerClient() = 0;
+  virtual SynchronousInputHandlerProxyClient*
+  GetSynchronousInputHandlerProxyClient() = 0;
 
   virtual scoped_ptr<cc::BeginFrameSource> CreateExternalBeginFrameSource(
       int routing_id) = 0;
diff --git a/content/renderer/android/synchronous_compositor_filter.cc b/content/renderer/android/synchronous_compositor_filter.cc
index 54dfed3..aadedb2 100644
--- a/content/renderer/android/synchronous_compositor_filter.cc
+++ b/content/renderer/android/synchronous_compositor_filter.cc
@@ -210,34 +210,15 @@ void SynchronousCompositorFilter::SetBoundHandler(const Handler& handler) {
           handler));
 }
 
+void SynchronousCompositorFilter::DidAddInputHandler(int routing_id) {}
+void SynchronousCompositorFilter::DidRemoveInputHandler(int routing_id) {}
+
 void SynchronousCompositorFilter::SetBoundHandlerOnCompositorThread(
     const Handler& handler) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
   input_handler_ = handler;
 }
 
-void SynchronousCompositorFilter::DidAddInputHandler(
-    int routing_id,
-    ui::SynchronousInputHandlerProxy* synchronous_input_handler_proxy) {
-  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
-  DCHECK(synchronous_input_handler_proxy);
-  Entry& entry = entry_map_[routing_id];
-  DCHECK(!entry.synchronous_input_handler_proxy);
-  entry.synchronous_input_handler_proxy = synchronous_input_handler_proxy;
-  CheckIsReady(routing_id);
-}
-
-void SynchronousCompositorFilter::DidRemoveInputHandler(int routing_id) {
-  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
-  DCHECK(ContainsKey(entry_map_, routing_id));
-  Entry& entry = entry_map_[routing_id];
-
-  if (entry.IsReady())
-    UnregisterObjects(routing_id);
-  entry.synchronous_input_handler_proxy = nullptr;
-  RemoveEntryIfNeeded(routing_id);
-}
-
 void SynchronousCompositorFilter::DidOverscroll(
     int routing_id,
     const DidOverscrollParams& params) {
@@ -259,6 +240,29 @@ void SynchronousCompositorFilter::NonBlockingInputEventHandled(
     int routing_id,
     blink::WebInputEvent::Type type) {}
 
+void SynchronousCompositorFilter::DidAddSynchronousHandlerProxy(
+    int routing_id,
+    ui::SynchronousInputHandlerProxy* synchronous_input_handler_proxy) {
+  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
+  DCHECK(synchronous_input_handler_proxy);
+  Entry& entry = entry_map_[routing_id];
+  DCHECK(!entry.synchronous_input_handler_proxy);
+  entry.synchronous_input_handler_proxy = synchronous_input_handler_proxy;
+  CheckIsReady(routing_id);
+}
+
+void SynchronousCompositorFilter::DidRemoveSynchronousHandlerProxy(
+    int routing_id) {
+  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
+  DCHECK(ContainsKey(entry_map_, routing_id));
+  Entry& entry = entry_map_[routing_id];
+
+  if (entry.IsReady())
+    UnregisterObjects(routing_id);
+  entry.synchronous_input_handler_proxy = nullptr;
+  RemoveEntryIfNeeded(routing_id);
+}
+
 SynchronousCompositorFilter::Entry::Entry()
     : begin_frame_source(nullptr),
       output_surface(nullptr),
diff --git a/content/renderer/android/synchronous_compositor_filter.h b/content/renderer/android/synchronous_compositor_filter.h
index bfab1f6..7310c0a 100644
--- a/content/renderer/android/synchronous_compositor_filter.h
+++ b/content/renderer/android/synchronous_compositor_filter.h
@@ -23,10 +23,12 @@ namespace content {
 
 class SynchronousCompositorProxy;
 
-class SynchronousCompositorFilter : public IPC::MessageFilter,
-                                    public IPC::Sender,
-                                    public SynchronousCompositorRegistry,
-                                    public InputHandlerManagerClient {
+class SynchronousCompositorFilter
+    : public IPC::MessageFilter,
+      public IPC::Sender,
+      public SynchronousCompositorRegistry,
+      public InputHandlerManagerClient,
+      public SynchronousInputHandlerProxyClient {
  public:
   SynchronousCompositorFilter(const scoped_refptr<base::SingleThreadTaskRunner>&
                                   compositor_task_runner);
@@ -58,10 +60,7 @@ class SynchronousCompositorFilter : public IPC::MessageFilter,
 
   // InputHandlerManagerClient overrides.
   void SetBoundHandler(const Handler& handler) override;
-  void DidAddInputHandler(
-      int routing_id,
-      ui::SynchronousInputHandlerProxy*
-          synchronous_input_handler_proxy) override;
+  void DidAddInputHandler(int routing_id) override;
   void DidRemoveInputHandler(int routing_id) override;
   void DidOverscroll(int routing_id,
                      const DidOverscrollParams& params) override;
@@ -69,6 +68,13 @@ class SynchronousCompositorFilter : public IPC::MessageFilter,
   void NonBlockingInputEventHandled(int routing_id,
                                     blink::WebInputEvent::Type type) override;
 
+  // SynchronousInputHandlerProxyClient overrides.
+  void DidAddSynchronousHandlerProxy(
+      int routing_id,
+      ui::SynchronousInputHandlerProxy* synchronous_input_handler_proxy)
+      override;
+  void DidRemoveSynchronousHandlerProxy(int routing_id) override;
+
  private:
   ~SynchronousCompositorFilter() override;
 
diff --git a/content/renderer/input/input_event_filter.cc b/content/renderer/input/input_event_filter.cc
index 9a90141..eede217 100644
--- a/content/renderer/input/input_event_filter.cc
+++ b/content/renderer/input/input_event_filter.cc
@@ -19,7 +19,6 @@
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
-#include "ui/events/blink/synchronous_input_handler_proxy.h"
 #include "ui/gfx/geometry/vector2d_f.h"
 
 using blink::WebInputEvent;
@@ -59,10 +58,7 @@ void InputEventFilter::SetBoundHandler(const Handler& handler) {
   handler_ = handler;
 }
 
-void InputEventFilter::DidAddInputHandler(
-    int routing_id,
-    ui::SynchronousInputHandlerProxy*
-        synchronous_input_handler_proxy) {
+void InputEventFilter::DidAddInputHandler(int routing_id) {
   base::AutoLock locked(routes_lock_);
   routes_.insert(routing_id);
   route_queues_[routing_id].reset(new NonBlockingEventQueue(routing_id, this));
diff --git a/content/renderer/input/input_event_filter.h b/content/renderer/input/input_event_filter.h
index 71d22f7..b1e888d 100644
--- a/content/renderer/input/input_event_filter.h
+++ b/content/renderer/input/input_event_filter.h
@@ -61,10 +61,7 @@ class CONTENT_EXPORT InputEventFilter : public InputHandlerManagerClient,
   // InputHostMsg_HandleInputEvent_ACK.
   //
   void SetBoundHandler(const Handler& handler) override;
-  void DidAddInputHandler(
-      int routing_id,
-      ui::SynchronousInputHandlerProxy*
-          synchronous_input_handler_proxy) override;
+  void DidAddInputHandler(int routing_id) override;
   void DidRemoveInputHandler(int routing_id) override;
   void DidOverscroll(int routing_id,
                      const DidOverscrollParams& params) override;
diff --git a/content/renderer/input/input_event_filter_unittest.cc b/content/renderer/input/input_event_filter_unittest.cc
index 8027752..4520228 100644
--- a/content/renderer/input/input_event_filter_unittest.cc
+++ b/content/renderer/input/input_event_filter_unittest.cc
@@ -178,7 +178,7 @@ TEST_F(InputEventFilterTest, Basic) {
   EXPECT_EQ(0U, event_recorder_.record_count());
   EXPECT_EQ(0U, message_recorder_.message_count());
 
-  filter_->DidAddInputHandler(kTestRoutingID, nullptr);
+  filter_->DidAddInputHandler(kTestRoutingID);
 
   AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   ASSERT_EQ(arraysize(kEvents), ipc_sink_.message_count());
@@ -254,7 +254,7 @@ TEST_F(InputEventFilterTest, Basic) {
 }
 
 TEST_F(InputEventFilterTest, PreserveRelativeOrder) {
-  filter_->DidAddInputHandler(kTestRoutingID, nullptr);
+  filter_->DidAddInputHandler(kTestRoutingID);
   event_recorder_.set_send_to_widget(true);
 
 
@@ -313,7 +313,7 @@ TEST_F(InputEventFilterTest, NonBlockingWheel) {
       SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false),
   };
 
-  filter_->DidAddInputHandler(kTestRoutingID, nullptr);
+  filter_->DidAddInputHandler(kTestRoutingID);
   event_recorder_.set_send_to_widget(true);
   event_recorder_.set_passive(true);
 
@@ -390,7 +390,7 @@ TEST_F(InputEventFilterTest, NonBlockingTouch) {
   kEvents[3].PressPoint(10, 10);
   kEvents[3].MovePoint(0, 35, 35);
 
-  filter_->DidAddInputHandler(kTestRoutingID, nullptr);
+  filter_->DidAddInputHandler(kTestRoutingID);
   event_recorder_.set_send_to_widget(true);
   event_recorder_.set_passive(true);
 
diff --git a/content/renderer/input/input_handler_manager.cc b/content/renderer/input/input_handler_manager.cc
index 58fd95f..5f1bfe0 100644
--- a/content/renderer/input/input_handler_manager.cc
+++ b/content/renderer/input/input_handler_manager.cc
@@ -48,9 +48,11 @@ InputEventAckState InputEventDispositionToAck(
 InputHandlerManager::InputHandlerManager(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     InputHandlerManagerClient* client,
+    SynchronousInputHandlerProxyClient* sync_handler_client,
     scheduler::RendererScheduler* renderer_scheduler)
     : task_runner_(task_runner),
       client_(client),
+      synchronous_handler_proxy_client_(sync_handler_client),
       renderer_scheduler_(renderer_scheduler) {
   DCHECK(client_);
   client_->SetBoundHandler(base::Bind(&InputHandlerManager::HandleInputEvent,
@@ -105,7 +107,11 @@ void InputHandlerManager::AddInputHandlerOnCompositorThread(
   scoped_ptr<InputHandlerWrapper> wrapper(new InputHandlerWrapper(
       this, routing_id, main_task_runner, input_handler, render_view_impl,
       enable_smooth_scrolling, enable_wheel_gestures));
-  client_->DidAddInputHandler(routing_id, wrapper->input_handler_proxy());
+  client_->DidAddInputHandler(routing_id);
+  if (synchronous_handler_proxy_client_) {
+    synchronous_handler_proxy_client_->DidAddSynchronousHandlerProxy(
+        routing_id, wrapper->input_handler_proxy());
+  }
   input_handlers_.add(routing_id, std::move(wrapper));
 }
 
@@ -116,6 +122,10 @@ void InputHandlerManager::RemoveInputHandler(int routing_id) {
   TRACE_EVENT0("input", "InputHandlerManager::RemoveInputHandler");
 
   client_->DidRemoveInputHandler(routing_id);
+  if (synchronous_handler_proxy_client_) {
+    synchronous_handler_proxy_client_->DidRemoveSynchronousHandlerProxy(
+        routing_id);
+  }
   input_handlers_.erase(routing_id);
 }
 
diff --git a/content/renderer/input/input_handler_manager.h b/content/renderer/input/input_handler_manager.h
index 1bebf91..3211a1f 100644
--- a/content/renderer/input/input_handler_manager.h
+++ b/content/renderer/input/input_handler_manager.h
@@ -33,6 +33,7 @@ class RendererScheduler;
 namespace content {
 
 class InputHandlerWrapper;
+class SynchronousInputHandlerProxyClient;
 class InputHandlerManagerClient;
 struct DidOverscrollParams;
 
@@ -47,6 +48,7 @@ class CONTENT_EXPORT InputHandlerManager {
   InputHandlerManager(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       InputHandlerManagerClient* client,
+      SynchronousInputHandlerProxyClient* sync_handler_client,
       scheduler::RendererScheduler* renderer_scheduler);
   ~InputHandlerManager();
 
@@ -106,9 +108,11 @@ class CONTENT_EXPORT InputHandlerManager {
       InputHandlerMap;
   InputHandlerMap input_handlers_;
 
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  InputHandlerManagerClient* client_;
-  scheduler::RendererScheduler* renderer_scheduler_;  // Not owned.
+  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  InputHandlerManagerClient* const client_;
+  // May be null.
+  SynchronousInputHandlerProxyClient* const synchronous_handler_proxy_client_;
+  scheduler::RendererScheduler* const renderer_scheduler_;  // Not owned.
 };
 
 }  // namespace content
diff --git a/content/renderer/input/input_handler_manager_client.h b/content/renderer/input/input_handler_manager_client.h
index c794bd2..71dc3e9 100644
--- a/content/renderer/input/input_handler_manager_client.h
+++ b/content/renderer/input/input_handler_manager_client.h
@@ -44,9 +44,7 @@ class CONTENT_EXPORT InputHandlerManagerClient {
   virtual void SetBoundHandler(const Handler& handler) = 0;
 
   // Called from the compositor thread.
-  virtual void DidAddInputHandler(
-      int routing_id,
-      ui::SynchronousInputHandlerProxy* synchronous_handler) = 0;
+  virtual void DidAddInputHandler(int routing_id) = 0;
   virtual void DidRemoveInputHandler(int routing_id) = 0;
   virtual void DidOverscroll(int routing_id,
                              const DidOverscrollParams& params) = 0;
@@ -62,6 +60,22 @@ class CONTENT_EXPORT InputHandlerManagerClient {
   DISALLOW_COPY_AND_ASSIGN(InputHandlerManagerClient);
 };
 
+class CONTENT_EXPORT SynchronousInputHandlerProxyClient {
+ public:
+  virtual ~SynchronousInputHandlerProxyClient() {}
+
+  virtual void DidAddSynchronousHandlerProxy(
+      int routing_id,
+      ui::SynchronousInputHandlerProxy* synchronous_handler) = 0;
+  virtual void DidRemoveSynchronousHandlerProxy(int routing_id) = 0;
+
+ protected:
+  SynchronousInputHandlerProxyClient() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SynchronousInputHandlerProxyClient);
+};
+
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_INPUT_INPUT_HANDLER_MANAGER_CLIENT_H_
diff --git a/content/renderer/render_thread_impl.cc b/content/renderer/render_thread_impl.cc
index 202c5f9..b1b76c9 100644
--- a/content/renderer/render_thread_impl.cc
+++ b/content/renderer/render_thread_impl.cc
@@ -1177,10 +1177,13 @@ void RenderThreadImpl::InitializeCompositorThread() {
 #if defined(OS_ANDROID)
   SynchronousCompositorFactory* sync_compositor_factory =
       SynchronousCompositorFactory::GetInstance();
+  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   bool using_ipc_sync_compositing =
-      base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kIPCSyncCompositing);
+      cmd_line->HasSwitch(switches::kIPCSyncCompositing);
+  bool sync_input_for_sync_compositing =
+      cmd_line->HasSwitch(switches::kSyncInputForSyncCompositor);
   DCHECK(!sync_compositor_factory || !using_ipc_sync_compositing);
+  DCHECK(!sync_input_for_sync_compositing || using_ipc_sync_compositing);
 
   if (sync_compositor_factory) {
     compositor_task_runner_ =
@@ -1201,16 +1204,23 @@ void RenderThreadImpl::InitializeCompositorThread() {
                    false));
   }
 
-  InputHandlerManagerClient* input_handler_manager_client = NULL;
+  InputHandlerManagerClient* input_handler_manager_client = nullptr;
+  SynchronousInputHandlerProxyClient* synchronous_input_handler_proxy_client =
+      nullptr;
 #if defined(OS_ANDROID)
   if (using_ipc_sync_compositing) {
     sync_compositor_message_filter_ =
         new SynchronousCompositorFilter(compositor_task_runner_);
     AddFilter(sync_compositor_message_filter_.get());
-    input_handler_manager_client = sync_compositor_message_filter_.get();
+    if (sync_input_for_sync_compositing)
+      input_handler_manager_client = sync_compositor_message_filter_.get();
+    synchronous_input_handler_proxy_client =
+        sync_compositor_message_filter_.get();
   } else if (sync_compositor_factory) {
     input_handler_manager_client =
         sync_compositor_factory->GetInputHandlerManagerClient();
+    synchronous_input_handler_proxy_client =
+        sync_compositor_factory->GetSynchronousInputHandlerProxyClient();
   }
 #endif
   if (!input_handler_manager_client) {
@@ -1223,7 +1233,7 @@ void RenderThreadImpl::InitializeCompositorThread() {
   }
   input_handler_manager_.reset(new InputHandlerManager(
       compositor_task_runner_, input_handler_manager_client,
-      renderer_scheduler_.get()));
+      synchronous_input_handler_proxy_client, renderer_scheduler_.get()));
 }
 
 void RenderThreadImpl::EnsureWebKitInitialized() {