Changeset 106987 in webkit

Timestamp:

Feb 7, 2012 1:52:21 PM (12 years ago)

Author:

commit-queue@webkit.org

Message:

Process Scroll-gesture events from the compositor.
​https://bugs.webkit.org/show_bug.cgi?id=77477

Patch by Sadrul Habib Chowdhury <​sadrul@chromium.org> on 2012-02-07
Reviewed by James Robinson.

• src/WebCompositorInputHandlerImpl.cpp:

(WebKit::WebCompositorInputHandlerImpl::WebCompositorInputHandlerImpl):
(WebKit::WebCompositorInputHandlerImpl::handleInputEvent):

• src/WebCompositorInputHandlerImpl.h:

(WebCompositorInputHandlerImpl):

Location:

trunk/Source/WebKit/chromium

Files:

• ChangeLog (modified) (1 diff)
• src/WebCompositorInputHandlerImpl.cpp (modified) (2 diffs)
• src/WebCompositorInputHandlerImpl.h (modified) (1 diff)
• tests/WebCompositorInputHandlerImplTest.cpp (modified) (4 diffs)

trunk/Source/WebKit/chromium/ChangeLog

@@ +1 @@
+2012-02-07  Sadrul Habib Chowdhury  <sadrul@chromium.org>
+
+        Process Scroll-gesture events from the compositor.
+        https://bugs.webkit.org/show_bug.cgi?id=77477
+
+        Reviewed by James Robinson.
+
+        * src/WebCompositorInputHandlerImpl.cpp:
+        (WebKit::WebCompositorInputHandlerImpl::WebCompositorInputHandlerImpl):
+        (WebKit::WebCompositorInputHandlerImpl::handleInputEvent):
+        * src/WebCompositorInputHandlerImpl.h:
+        (WebCompositorInputHandlerImpl):
+
 2012-02-07  Anders Carlsson  <andersca@apple.com>
 

trunk/Source/WebKit/chromium/src/WebCompositorInputHandlerImpl.cpp

@@ -82 +82 @@
     , m_identifier(s_nextAvailableIdentifier++)
     , m_inputHandlerClient(inputHandlerClient)
+#ifndef NDEBUG
+    , m_expectScrollUpdateEnd(false)
+#endif
+    , m_scrollStarted(false)
 {
     ASSERT(CCProxy::isImplThread());
@@ -132 +136 @@
             break;
         }
+    } else if (event.type == WebInputEvent::GestureScrollBegin) {
+        ASSERT(!m_scrollStarted);
+        ASSERT(!m_expectScrollUpdateEnd);
+#ifndef NDEBUG
+        m_expectScrollUpdateEnd = true;
+#endif
+        const WebGestureEvent& gestureEvent = *static_cast<const WebGestureEvent*>(&event);
+        CCInputHandlerClient::ScrollStatus scrollStatus = m_inputHandlerClient->scrollBegin(IntPoint(gestureEvent.x, gestureEvent.y));
+        switch (scrollStatus) {
+        case CCInputHandlerClient::ScrollStarted:
+            m_scrollStarted = true;
+            m_client->didHandleInputEvent();
+            return;
+        case CCInputHandlerClient::ScrollIgnored:
+            m_client->didNotHandleInputEvent(false /* sendToWidget */);
+            return;
+        case CCInputHandlerClient::ScrollFailed:
+            break;
+        }
+    } else if (event.type == WebInputEvent::GestureScrollUpdate) {
+        ASSERT(m_expectScrollUpdateEnd);
+        if (m_scrollStarted) {
+            const WebGestureEvent& gestureEvent = *static_cast<const WebGestureEvent*>(&event);
+            m_inputHandlerClient->scrollBy(IntSize(-gestureEvent.deltaX, -gestureEvent.deltaY));
+            m_client->didHandleInputEvent();
+            return;
+        }
+    } else if (event.type == WebInputEvent::GestureScrollEnd) {
+        ASSERT(m_expectScrollUpdateEnd);
+#ifndef NDEBUG
+        m_expectScrollUpdateEnd = false;
+#endif
+        if (m_scrollStarted) {
+            m_inputHandlerClient->scrollEnd();
+            m_client->didHandleInputEvent();
+            m_scrollStarted = false;
+            return;
+        }
     }
     m_client->didNotHandleInputEvent(true /* sendToWidget */);

trunk/Source/WebKit/chromium/src/WebCompositorInputHandlerImpl.h

@@ -71 +71 @@
     WebCore::CCInputHandlerClient* m_inputHandlerClient;
 
+#ifndef NDEBUG
+    bool m_expectScrollUpdateEnd;
+#endif
+    bool m_scrollStarted;
+
     static int s_nextAvailableIdentifier;
     static HashSet<WebCompositorInputHandlerImpl*>* s_compositors;

trunk/Source/WebKit/chromium/tests/WebCompositorInputHandlerImplTest.cpp

@@ -29 +29 @@
 
 #include "WebCompositor.h"
+#include "WebCompositorInputHandlerClient.h"
+#include "WebInputEvent.h"
+#include "cc/CCInputHandler.h"
 #include "cc/CCSingleThreadProxy.h"
 
@@ -38 +41 @@
 
 namespace {
+
+class MockInputHandlerClient : public WebCore::CCInputHandlerClient {
+    WTF_MAKE_NONCOPYABLE(MockInputHandlerClient);
+public:
+    MockInputHandlerClient()
+        : m_scrollStatus(ScrollStarted)
+    {
+    }
+    virtual ~MockInputHandlerClient() { }
+
+    void setScrollStatus(ScrollStatus status) { m_scrollStatus = status; }
+
+private:
+    virtual void setNeedsRedraw() OVERRIDE { }
+    virtual ScrollStatus scrollBegin(const WebCore::IntPoint&) OVERRIDE
+    {
+        return m_scrollStatus;
+    }
+    virtual void scrollBy(const WebCore::IntSize&) OVERRIDE { }
+    virtual void scrollEnd() OVERRIDE { }
+
+    virtual bool haveWheelEventHandlers() OVERRIDE { return false; }
+    virtual void pinchGestureBegin() OVERRIDE { }
+    virtual void pinchGestureUpdate(float magnifyDelta, const WebCore::IntPoint& anchor) OVERRIDE { }
+    virtual void pinchGestureEnd() OVERRIDE { }
+    virtual void startPageScaleAnimation(const WebCore::IntSize& targetPosition,
+                                         bool anchorPoint,
+                                         float pageScale,
+                                         double startTimeMs,
+                                         double durationMs) OVERRIDE { }
+
+    ScrollStatus m_scrollStatus;
+};
+
+class MockWebCompositorInputHandlerClient : public WebKit::WebCompositorInputHandlerClient {
+    WTF_MAKE_NONCOPYABLE(MockWebCompositorInputHandlerClient);
+public:
+    MockWebCompositorInputHandlerClient()
+        : m_handled(false)
+        , m_sendToWidget(false)
+    {
+    }
+    virtual ~MockWebCompositorInputHandlerClient() { }
+
+    void reset()
+    {
+        m_handled = false;
+        m_sendToWidget = false;
+    }
+
+    bool handled() const { return m_handled; }
+    bool sendToWidget() const { return m_sendToWidget; }
+
+private:
+    virtual void willShutdown() OVERRIDE { }
+    virtual void didHandleInputEvent() OVERRIDE
+    {
+        m_handled = true;
+    }
+    virtual void didNotHandleInputEvent(bool sendToWidget) OVERRIDE
+    {
+        m_sendToWidget = sendToWidget;
+    }
+
+    bool m_handled;
+    bool m_sendToWidget;
+};
 
 TEST(WebCompositorInputHandlerImpl, fromIdentifier)
@@ -54 +124 @@
     int compositorIdentifier = -1;
     {
-        OwnPtr<WebCompositorInputHandlerImpl> comp = WebCompositorInputHandlerImpl::create(0);
-        compositorIdentifier = comp->identifier();
+        OwnPtr<WebCompositorInputHandlerImpl> inputHandler = WebCompositorInputHandlerImpl::create(0);
+        compositorIdentifier = inputHandler->identifier();
         // The compositor we just created should be locatable.
-        EXPECT_EQ(comp.get(), WebCompositorInputHandler::fromIdentifier(compositorIdentifier));
+        EXPECT_EQ(inputHandler.get(), WebCompositorInputHandler::fromIdentifier(compositorIdentifier));
 
         // But nothing else.
-        EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(comp->identifier() + 10));
+        EXPECT_EQ(0, WebCompositorInputHandler::fromIdentifier(inputHandler->identifier() + 10));
     }
 
@@ -69 +139 @@
 }
 
+TEST(WebCompositorInputHandlerImpl, gestureScroll)
+{
+    WebKit::WebCompositor::initialize(0);
+#ifndef NDEBUG
+    // WebCompositorInputHandler APIs can only be called from the compositor thread.
+    WebCore::DebugScopedSetImplThread alwaysImplThread;
+#endif
+
+    MockInputHandlerClient mockInputHandler;
+    OwnPtr<WebCompositorInputHandlerImpl> inputHandler = WebCompositorInputHandlerImpl::create(&mockInputHandler);
+    MockWebCompositorInputHandlerClient mockClient;
+    inputHandler->setClient(&mockClient);
+
+    WebKit::WebGestureEvent gesture;
+
+    gesture.type = WebKit::WebInputEvent::GestureScrollBegin;
+    inputHandler->handleInputEvent(gesture);
+    EXPECT_TRUE(mockClient.handled());
+    EXPECT_FALSE(mockClient.sendToWidget());
+    mockClient.reset();
+
+    gesture.type = WebKit::WebInputEvent::GestureScrollUpdate;
+    gesture.deltaY = 40;
+    inputHandler->handleInputEvent(gesture);
+    EXPECT_TRUE(mockClient.handled());
+    EXPECT_FALSE(mockClient.sendToWidget());
+    mockClient.reset();
+
+    gesture.type = WebKit::WebInputEvent::GestureScrollEnd;
+    gesture.deltaY = 0;
+    inputHandler->handleInputEvent(gesture);
+    EXPECT_TRUE(mockClient.handled());
+    EXPECT_FALSE(mockClient.sendToWidget());
+    mockClient.reset();
+
+    mockInputHandler.setScrollStatus(WebCore::CCInputHandlerClient::ScrollFailed);
+
+    gesture.type = WebKit::WebInputEvent::GestureScrollBegin;
+    inputHandler->handleInputEvent(gesture);
+    EXPECT_FALSE(mockClient.handled());
+    EXPECT_TRUE(mockClient.sendToWidget());
+    mockClient.reset();
+
+    gesture.type = WebKit::WebInputEvent::GestureScrollUpdate;
+    gesture.deltaY = 40;
+    inputHandler->handleInputEvent(gesture);
+    EXPECT_FALSE(mockClient.handled());
+    EXPECT_TRUE(mockClient.sendToWidget());
+    mockClient.reset();
+
+    gesture.type = WebKit::WebInputEvent::GestureScrollEnd;
+    gesture.deltaY = 0;
+    inputHandler->handleInputEvent(gesture);
+    EXPECT_FALSE(mockClient.handled());
+    EXPECT_TRUE(mockClient.sendToWidget());
+    mockClient.reset();
+
+    inputHandler->setClient(0);
+
+    WebKit::WebCompositor::shutdown();
 }
+
+}