[VSync Queue] Flush input in CommitComplete()

ui/events/blink/input_handler_proxy_unittest.cc

 // Copyright 2013 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/events/blink/input_handler_proxy.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 184 matching lines @@
                                gfx::ScrollOffset* offset) override {
     return false;
   }
   bool ScrollLayerTo(int layer_id, const gfx::ScrollOffset& offset) override {
     return false;
   }
 
   void BindToClient(cc::InputHandlerClient* client,
                     bool touchpad_and_wheel_scroll_latching_enabled) override {}
 
+  InputHandlerState GetInputHandlerState() const override {
+    return input_handler_state_;
+  }
+
   void MouseDown() override {}
   void MouseUp() override {}
   void MouseLeave() override {}
 
   void MouseMoveAt(const gfx::Point& mouse_position) override {}
 
   MOCK_CONST_METHOD2(IsCurrentlyScrollingLayerAt,
                      bool(const gfx::Point& point,
                           cc::InputHandler::ScrollInputType type));
 
   MOCK_CONST_METHOD1(
       GetEventListenerProperties,
       cc::EventListenerProperties(cc::EventListenerClass event_class));
   MOCK_METHOD1(
       EventListenerTypeForTouchStartAt,
       cc::InputHandler::TouchStartEventListenerType(const gfx::Point& point));
 
   MOCK_METHOD0(RequestUpdateForSynchronousInputHandler, void());
   MOCK_METHOD1(SetSynchronousInputHandlerRootScrollOffset,
                void(const gfx::ScrollOffset& root_offset));
 
   bool IsCurrentlyScrollingViewport() const override {
     return is_scrolling_root_;
   }
   void set_is_scrolling_root(bool is) { is_scrolling_root_ = is; }
+  void set_input_handler_state(InputHandlerState input_handler_state) {
+    input_handler_state_ = input_handler_state;
+  }
 
  private:
   bool is_scrolling_root_ = true;
+  InputHandlerState input_handler_state_ = InputHandlerState::IDLE;
   DISALLOW_COPY_AND_ASSIGN(MockInputHandler);
 };
 
 class MockSynchronousInputHandler : public SynchronousInputHandler {
  public:
   MOCK_METHOD0(SetNeedsSynchronousAnimateInput, void());
   MOCK_METHOD6(UpdateRootLayerState,
                void(const gfx::ScrollOffset& total_scroll_offset,
                     const gfx::ScrollOffset& max_scroll_offset,
                     const gfx::SizeF& scrollable_size,
@@ skipping 277 matching lines @@
   ~InputHandlerProxyEventQueueTest() { input_handler_proxy_.reset(); }
 
   void SetUp() override {
     bool wheel_scroll_latching_enabled = GetParam();
     event_disposition_recorder_.clear();
     input_handler_proxy_ = base::MakeUnique<TestInputHandlerProxy>(
         &mock_input_handler_, &mock_client_, wheel_scroll_latching_enabled);
     if (input_handler_proxy_->compositor_event_queue_)
       input_handler_proxy_->compositor_event_queue_ =
           base::MakeUnique<CompositorThreadEventQueue>();
+    mock_input_handler_.set_input_handler_state(
+        cc::InputHandler::InputHandlerState::INSIDE_IMPL_FRAME);
+  }
+
+  void TearDown() override {
+    mock_input_handler_.set_input_handler_state(
+        cc::InputHandler::InputHandlerState::IDLE);
   }
 
   void StartTracing() {
     base::trace_event::TraceLog::GetInstance()->SetEnabled(
         base::trace_event::TraceConfig("*"),
         base::trace_event::TraceLog::RECORDING_MODE);
   }
 
   void StopTracing() {
     base::trace_event::TraceLog::GetInstance()->SetDisabled();
@@ skipping 3278 matching lines @@
 INSTANTIATE_TEST_CASE_P(AnimateInput,
                         InputHandlerProxyWithoutWheelScrollLatchingTest,
                         testing::ValuesIn(test_types));
 
 INSTANTIATE_TEST_CASE_P(InputHandlerProxyEventQueueTests,
                         InputHandlerProxyEventQueueTest,
                         testing::Bool());
 
 }  // namespace test
 }  // namespace ui