MouseMove when the mouse is down to signal compositor priority

content/renderer/input/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 "content/renderer/input/input_handler_proxy.h"
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/swap_promise_monitor.h"
 #include "content/common/input/did_overscroll_params.h"
@@ skipping 12 matching lines @@
 using blink::WebFloatSize;
 using blink::WebGestureDevice;
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebKeyboardEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebPoint;
 using blink::WebSize;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
+using testing::Field;
 
 namespace content {
 namespace {
 
 double InSecondsF(const base::TimeTicks& time) {
   return (time - base::TimeTicks()).InSecondsF();
 }
 
 WebGestureEvent CreateFling(base::TimeTicks timestamp,
                             WebGestureDevice source_device,
@@ skipping 130 matching lines @@
       WebGestureDevice deviceSource,
       const WebFloatPoint& velocity,
       const WebSize& cumulative_scroll) override {
     return new FakeWebGestureCurve(
         blink::WebFloatSize(velocity.x, velocity.y),
         blink::WebFloatSize(cumulative_scroll.width, cumulative_scroll.height));
   }
 
   MOCK_METHOD1(DidOverscroll, void(const DidOverscrollParams&));
   virtual void DidStopFlinging() override {}
-  virtual void DidReceiveInputEvent(blink::WebInputEvent::Type) override {}
+  virtual void DidReceiveInputEvent(const blink::WebInputEvent&) override {}
   virtual void DidAnimateForInput() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockInputHandlerProxyClient);
 };
 
 class MockInputHandlerProxyClientWithDidReceiveInputEvent
     : public MockInputHandlerProxyClient {
  public:
   MockInputHandlerProxyClientWithDidReceiveInputEvent() {}
   virtual ~MockInputHandlerProxyClientWithDidReceiveInputEvent() {}
 
-  MOCK_METHOD1(DidReceiveInputEvent, void(blink::WebInputEvent::Type type));
+  MOCK_METHOD1(DidReceiveInputEvent, void(const blink::WebInputEvent&));
   MOCK_METHOD0(DidAnimateForInput, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockInputHandlerProxyClientWithDidReceiveInputEvent);
 };
 
 WebTouchPoint CreateWebTouchPoint(WebTouchPoint::State state, float x,
                                   float y) {
   WebTouchPoint point;
   point.state = state;
@@ skipping 1878 matching lines @@
   testing::StrictMock<
       MockInputHandlerProxyClientWithDidReceiveInputEvent> mock_client;
   input_handler_.reset(
         new content::InputHandlerProxy(&mock_input_handler_, &mock_client));
 
   // Note the type of input event isn't important.
   WebMouseWheelEvent wheel;
   wheel.type = WebInputEvent::MouseWheel;
   wheel.scrollByPage = true;
 
-  EXPECT_CALL(mock_client, DidReceiveInputEvent(WebInputEvent::MouseWheel));
+  EXPECT_CALL(mock_client,
+              DidReceiveInputEvent(
+                  Field(&WebInputEvent::type, WebInputEvent::MouseWheel)));
 
   input_handler_->HandleInputEvent(wheel);
   testing::Mock::VerifyAndClearExpectations(&mock_client);
 }
 
 TEST_F(InputHandlerProxyTest, DidReceiveInputEvent_ForFling) {
   testing::StrictMock<
       MockInputHandlerProxyClientWithDidReceiveInputEvent> mock_client;
   input_handler_.reset(
         new content::InputHandlerProxy(&mock_input_handler_, &mock_client));
 
   gesture_.type = WebInputEvent::GestureFlingStart;
   WebFloatPoint fling_delta = WebFloatPoint(100, 100);
   gesture_.data.flingStart.velocityX = fling_delta.x;
   gesture_.data.flingStart.velocityY = fling_delta.y;
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   EXPECT_CALL(mock_client,
-      DidReceiveInputEvent(WebInputEvent::GestureFlingStart));
+              DidReceiveInputEvent(Field(&WebInputEvent::type,
+                                         WebInputEvent::GestureFlingStart)));
   EXPECT_EQ(InputHandlerProxy::DID_HANDLE,
       input_handler_->HandleInputEvent(gesture_));
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
   testing::Mock::VerifyAndClearExpectations(&mock_client);
 
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_client, DidAnimateForInput());
   base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_client);
 }
 
 } // namespace
 } // namespace content