2012-09-13  Sami Kyostila  <skyostil@chromium.org>

        [chromium] Add test for ScrollingCoordinatorChromium

        https://bugs.webkit.org/show_bug.cgi?id=96657

        Reviewed by NOBODY (OOPS!).

        Add tests for ScrollingCoordinatorChromium. These tests mainly verify that

        fast (non-main thread) scrolling is enabled when necessary and that a proper

        compositing layer structure is created for fixed position and accelerated

        scrolling layers.

        Tests: ScrollingCoordinatorChromiumTest.fastScrollingByDefault

               ScrollingCoordinatorChromiumTest.fastScrollingForFixedPosition

               ScrollingCoordinatorChromiumTest.slowScrollingForNonCompositedFixedPosition

               ScrollingCoordinatorChromiumTest.nonFastScrollableRegion

               ScrollingCoordinatorChromiumTest.wheelEventHandler

               ScrollingCoordinatorChromiumTest.touchOverflowScrolling

        * WebKit.gypi:

        * tests/ScrollingCoordinatorChromiumTest.cpp: Added.

        (WebKit):

        (MockWebViewClient):

        (ScrollingCoordinatorChromiumTest):

        (WebKit::ScrollingCoordinatorChromiumTest::ScrollingCoordinatorChromiumTest):

        (WebKit::ScrollingCoordinatorChromiumTest::createCompositedWebViewImpl):

        (WebKit::ScrollingCoordinatorChromiumTest::registerMockedHttpURLLoad):

        (WebKit::ScrollingCoordinatorChromiumTest::getRootScrollLayer):

        (WebKit::TEST_F):

        * tests/data/fixed_position.html: Added.

        * tests/data/fixed_position_non_composited.html: Added.

        * tests/data/non_fast_scrollable.html: Added.

        * tests/data/touch_overflow_scrolling.html: Added.

        * tests/data/wheel_event_handler.html: Added.

    virtual WebSize maxScrollPosition() const = 0;

    virtual bool scrollable() const = 0;

    virtual bool haveWheelEventHandlers() const = 0;

    virtual bool shouldScrollOnMainThread() const = 0;

    virtual WebVector<WebRect> nonFastScrollableRegion() const = 0;

    virtual bool isContainerForFixedPositionLayers() const = 0;

    virtual bool fixedToContainerLayer() const = 0;

                                'tests/ScrollingCoordinatorChromiumTest.cpp',

            'tests/ScrollingCoordinatorChromiumTest.cpp',

/*

 * Copyright (C) 2012 Google Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1.  Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 * 2.  Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "ScrollingCoordinator.h"

#include "CompositorFakeWebGraphicsContext3D.h"

#include "FakeWebCompositorOutputSurface.h"

#include "FrameTestHelpers.h"

#include "RenderLayerCompositor.h"

#include "RenderView.h"

#include "URLTestHelpers.h"

#include "WebFrameClient.h"

#include "WebFrameImpl.h"

#include "WebSettings.h"

#include "WebViewClient.h"

#include "WebViewImpl.h"

#include <gtest/gtest.h>

#include <public/WebCompositorSupport.h>

#include <public/WebLayer.h>

#include <webkit/support/webkit_support.h>

#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)

#include "GraphicsLayerChromium.h"

#endif

using namespace WebCore;

using namespace WebKit;

namespace {

class MockWebViewClient : public WebViewClient {

public:

    virtual WebCompositorOutputSurface* createOutputSurface() OVERRIDE

    {

        return FakeWebCompositorOutputSurface::create(CompositorFakeWebGraphicsContext3D::create(WebGraphicsContext3D::Attributes())).leakPtr();

    }

};

class MockWebFrameClient : public WebFrameClient {

};

class ScrollingCoordinatorChromiumTest : public testing::Test {

public:

    ScrollingCoordinatorChromiumTest()

        : m_baseURL("http://www.test.com/")

        , m_webViewImpl(0) { }

    WebViewImpl* createCompositedWebViewImpl(const std::string& url)

    {

        ASSERT(!m_webViewImpl);

        WebKit::Platform::current()->compositorSupport()->initialize(0);

        // We cannot reuse FrameTestHelpers::createWebViewAndLoad here because the compositing

        // settings need to be set before the page is loaded.

        m_webViewImpl = static_cast<WebViewImpl*>(WebView::create(&m_mockWebViewClient));

        m_webViewImpl->settings()->setJavaScriptEnabled(true);

        m_webViewImpl->settings()->setForceCompositingMode(true);

        m_webViewImpl->settings()->setAcceleratedCompositingEnabled(true);

        m_webViewImpl->settings()->setAcceleratedCompositingForFixedPositionEnabled(true);

        m_webViewImpl->initializeMainFrame(&m_mockWebFrameClient);

        m_webViewImpl->resize(IntSize(320, 240));

        FrameTestHelpers::loadFrame(m_webViewImpl->mainFrame(), url);

        webkit_support::ServeAsynchronousMockedRequests();

        return m_webViewImpl;

    }

    virtual void TearDown() OVERRIDE

    {

        webkit_support::UnregisterAllMockedURLs();

        if (m_webViewImpl) {

            m_webViewImpl->close();

            m_webViewImpl = 0;

            WebKit::Platform::current()->compositorSupport()->shutdown();

        }

    }

    void registerMockedHttpURLLoad(const std::string& fileName)

    {

        URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8(fileName.c_str()));

    }

    WebLayer* getRootScrollLayer(WebViewImpl* webViewImpl)

    {

        RenderLayerCompositor* compositor = webViewImpl->mainFrameImpl()->frame()->contentRenderer()->compositor();

        ASSERT(compositor);

        ASSERT(compositor->scrollLayer());

        WebLayer* webScrollLayer = static_cast<WebLayer*>(compositor->scrollLayer()->platformLayer());

        return webScrollLayer;

    }

protected:

    std::string m_baseURL;

    MockWebFrameClient m_mockWebFrameClient;

    MockWebViewClient m_mockWebViewClient;

    WebViewImpl* m_webViewImpl;

};

TEST_F(ScrollingCoordinatorChromiumTest, fastScrollingByDefault)

{

    WebViewImpl* webViewImpl = createCompositedWebViewImpl("about:blank");

    // Make sure the scrolling coordinator is active.

    FrameView* frameView = webViewImpl->mainFrameImpl()->frameView();

    Page* page = webViewImpl->mainFrameImpl()->frame()->page();

    ASSERT_TRUE(page->scrollingCoordinator());

    ASSERT_TRUE(page->scrollingCoordinator()->coordinatesScrollingForFrameView(frameView));

    // Fast scrolling should be enabled by default.

    WebLayer* rootScrollLayer = getRootScrollLayer(webViewImpl);

    ASSERT_TRUE(rootScrollLayer->scrollable());

    ASSERT_FALSE(rootScrollLayer->shouldScrollOnMainThread());

    ASSERT_FALSE(rootScrollLayer->haveWheelEventHandlers());

}

TEST_F(ScrollingCoordinatorChromiumTest, fastScrollingForFixedPosition)

{

    registerMockedHttpURLLoad("fixed_position.html");

    WebViewImpl* webViewImpl = createCompositedWebViewImpl(m_baseURL + "fixed_position.html");

    Page* page = webViewImpl->mainFrameImpl()->frame()->page();

    ASSERT_TRUE(page->scrollingCoordinator()->supportsFixedPositionLayers());

    // Fixed position should not fall back to main thread scrolling.

    WebLayer* rootScrollLayer = getRootScrollLayer(webViewImpl);

    ASSERT_FALSE(rootScrollLayer->shouldScrollOnMainThread());

    // Verify the properties of the fixed position element starting from the RenderObject all the

    // way to the LayerChromium.

    Element* fixedElement = webViewImpl->mainFrameImpl()->frame()->document()->getElementById("fixed");

    ASSERT(fixedElement);

    RenderObject* renderer = fixedElement->renderer();

    ASSERT_TRUE(renderer->isBoxModelObject());

    ASSERT_TRUE(renderer->hasLayer());

    RenderLayer* layer = toRenderBoxModelObject(renderer)->layer();

    ASSERT_TRUE(layer->isComposited());

    RenderLayerBacking* layerBacking = layer->backing();

    WebLayer* webLayer = static_cast<WebLayer*>(layerBacking->graphicsLayer()->platformLayer());

    ASSERT_TRUE(webLayer->fixedToContainerLayer());

}

TEST_F(ScrollingCoordinatorChromiumTest, slowScrollingForNonCompositedFixedPosition)

{

    registerMockedHttpURLLoad("fixed_position_non_composited.html");

    WebViewImpl* webViewImpl = createCompositedWebViewImpl(m_baseURL + "fixed_position_non_composited.html");

    Page* page = webViewImpl->mainFrameImpl()->frame()->page();

    ASSERT_TRUE(page->scrollingCoordinator()->supportsFixedPositionLayers());

    // Non-composited fixed position should fall back to main thread scrolling.

    WebLayer* rootScrollLayer = getRootScrollLayer(webViewImpl);

    ASSERT_TRUE(rootScrollLayer->shouldScrollOnMainThread());

}

TEST_F(ScrollingCoordinatorChromiumTest, nonFastScrollableRegion)

{

    registerMockedHttpURLLoad("non_fast_scrollable.html");

    WebViewImpl* webViewImpl = createCompositedWebViewImpl(m_baseURL + "non_fast_scrollable.html");

    WebLayer* rootScrollLayer = getRootScrollLayer(webViewImpl);

    WebVector<WebRect> nonFastScrollableRegion = rootScrollLayer->nonFastScrollableRegion();

    ASSERT_EQ(1u, nonFastScrollableRegion.size());

    ASSERT_EQ(WebRect(8, 8, 10, 10), nonFastScrollableRegion[0]);

}

TEST_F(ScrollingCoordinatorChromiumTest, wheelEventHandler)

{

    registerMockedHttpURLLoad("wheel_event_handler.html");

    WebViewImpl* webViewImpl = createCompositedWebViewImpl(m_baseURL + "wheel_event_handler.html");

    WebLayer* rootScrollLayer = getRootScrollLayer(webViewImpl);

    ASSERT_TRUE(rootScrollLayer->haveWheelEventHandlers());

}

#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)

TEST_F(ScrollingCoordinatorChromiumTest, touchOverflowScrolling)

{

    registerMockedHttpURLLoad("touch_overflow_scrolling.html");

    WebViewImpl* webViewImpl = createCompositedWebViewImpl(m_baseURL + "touch_overflow_scrolling.html");

    // Verify the properties of the accelerated scrolling element starting from the RenderObject

    // all the way to the LayerChromium.

    Element* scrollableElement = webViewImpl->mainFrameImpl()->frame()->document()->getElementById("scrollable");

    ASSERT(scrollableElement);

    RenderObject* renderer = scrollableElement->renderer();

    ASSERT_TRUE(renderer->isBoxModelObject());

    ASSERT_TRUE(renderer->hasLayer());

    RenderLayer* layer = toRenderBoxModelObject(renderer)->layer();

    ASSERT_TRUE(layer->usesCompositedScrolling());

    ASSERT_TRUE(layer->isComposited());

    RenderLayerBacking* layerBacking = layer->backing();

    ASSERT_TRUE(layerBacking->hasScrollingLayer());

    ASSERT(layerBacking->scrollingContentsLayer());

    GraphicsLayerChromium* layerChromium = static_cast<GraphicsLayerChromium*>(layerBacking->scrollingContentsLayer());

    ASSERT_EQ(layer, layerChromium->scrollableArea());

    WebLayer* webScrollLayer = static_cast<WebLayer*>(layerBacking->scrollingContentsLayer()->platformLayer());

    ASSERT_TRUE(webScrollLayer->scrollable());

}

#endif // ENABLE(ACCELERATED_OVERFLOW_SCROLLING)

} // namespace

<!DOCTYPE html>

<html>

<head>

  <style type="text/css">

    #fixed {

      position: fixed;

      /* Use a stacking context to enable composition. */

      z-index: 0;

    }

  </style>

</head>

<body>

  <div id="fixed">

    Fixed positioned.

  </div>

</body>

</html>

<!DOCTYPE html>

<html>

<head>

  <style type="text/css">

    .fixed {

      position: fixed;

    }

  </style>

</head>

<body>

  <div class="fixed">

    Fixed positioned.

  </div>

</body>

</html>

<!DOCTYPE html>

<html>

<head>

  <style type="text/css">

    .scrollable {

      width: 10px;

      height: 10px;

      overflow: scroll;

    }

  </style>

</head>

<body>

  <div class="scrollable">

    Scrolling content.

  </div>

</body>

</html>

<!DOCTYPE html>

<html>

<head>

  <style type="text/css">

    #scrollable {

      width: 10px;

      height: 10px;

      overflow: scroll;

      -webkit-overflow-scrolling: touch;

    }

    .content {

      width: 100px;

      height: 1000px;

    }

  </style>

</head>

<body>

  <div id="scrollable">

    <div class="content"></div>

  </div>

</body>

</html>

<!DOCTYPE html>

<html>

<head>

  <script type="text/javascript">

      window.addEventListener('mousewheel', function(event) {

      });

  </script>

</head>

</html>