cc/scrollbar_layer_unittest.cc

// Copyright 2012 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 "cc/scrollbar_layer.h"

#include "cc/append_quads_data.h"
#include "cc/prioritized_resource_manager.h"
#include "cc/priority_calculator.h"
#include "cc/resource_update_queue.h"
#include "cc/scrollbar_animation_controller.h"
#include "cc/scrollbar_layer_impl.h"
#include "cc/single_thread_proxy.h"
#include "cc/solid_color_draw_quad.h"
#include "cc/test/fake_impl_proxy.h"
#include "cc/test/fake_layer_tree_host_client.h"
#include "cc/test/fake_layer_tree_host_impl.h"
#include "cc/test/fake_scrollbar_theme_painter.h"
#include "cc/test/fake_web_scrollbar.h"
#include "cc/test/fake_web_scrollbar_theme_geometry.h"
#include "cc/test/geometry_test_utils.h"
#include "cc/test/layer_tree_test_common.h"
#include "cc/test/mock_quad_culler.h"
#include "cc/test/test_web_graphics_context_3d.h"
#include "cc/tree_synchronizer.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/WebKit/Source/Platform/chromium/public/WebScrollbar.h"
#include "third_party/WebKit/Source/Platform/chromium/public/WebScrollbarThemeGeometry.h"

namespace cc {
namespace {

scoped_ptr<LayerImpl> layerImplForScrollAreaAndScrollbar(
    FakeLayerTreeHostImpl* host_impl,
    scoped_ptr<WebKit::WebScrollbar> scrollbar,
    bool reverse_order)
{
    scoped_refptr<Layer> layerTreeRoot = Layer::Create();
    scoped_refptr<Layer> child1 = Layer::Create();
    scoped_refptr<Layer> child2 = ScrollbarLayer::Create(scrollbar.Pass(), FakeScrollbarThemePainter::Create(false).PassAs<ScrollbarThemePainter>(), FakeWebScrollbarThemeGeometry::create(true), child1->id());
    layerTreeRoot->AddChild(child1);
    layerTreeRoot->InsertChild(child2, reverse_order ? 0 : 1);
    scoped_ptr<LayerImpl> layerImpl = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), host_impl->active_tree());
    TreeSynchronizer::pushProperties(layerTreeRoot.get(), layerImpl.get());
    return layerImpl.Pass();
}

TEST(ScrollbarLayerTest, resolveScrollLayerPointer)
{
    FakeImplProxy proxy;
    FakeLayerTreeHostImpl hostImpl(&proxy);

    {
        scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
        scoped_ptr<LayerImpl> layerImplTreeRoot = layerImplForScrollAreaAndScrollbar(&hostImpl, scrollbar.Pass(), false);

        LayerImpl* ccChild1 = layerImplTreeRoot->children()[0];
        ScrollbarLayerImpl* ccChild2 = static_cast<ScrollbarLayerImpl*>(layerImplTreeRoot->children()[1]);

        EXPECT_EQ(ccChild1->horizontal_scrollbar_layer(), ccChild2);
    }

    { // another traverse order
        scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
        scoped_ptr<LayerImpl> layerImplTreeRoot = layerImplForScrollAreaAndScrollbar(&hostImpl, scrollbar.Pass(), true);

        ScrollbarLayerImpl* ccChild1 = static_cast<ScrollbarLayerImpl*>(layerImplTreeRoot->children()[0]);
        LayerImpl* ccChild2 = layerImplTreeRoot->children()[1];

        EXPECT_EQ(ccChild2->horizontal_scrollbar_layer(), ccChild1);
    }
}

TEST(ScrollbarLayerTest, shouldScrollNonOverlayOnMainThread)
{
    FakeImplProxy proxy;
    FakeLayerTreeHostImpl hostImpl(&proxy);

    // Create and attach a non-overlay scrollbar.
    scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
    static_cast<FakeWebScrollbar*>(scrollbar.get())->setOverlay(false);
    scoped_ptr<LayerImpl> layerImplTreeRoot = layerImplForScrollAreaAndScrollbar(&hostImpl, scrollbar.Pass(), false);
    ScrollbarLayerImpl* scrollbarLayerImpl = static_cast<ScrollbarLayerImpl*>(layerImplTreeRoot->children()[1]);

    // When the scrollbar is not an overlay scrollbar, the scroll should be
    // responded to on the main thread as the compositor does not yet implement
    // scrollbar scrolling.
    EXPECT_EQ(InputHandlerClient::ScrollOnMainThread, scrollbarLayerImpl->TryScroll(gfx::Point(0, 0), InputHandlerClient::Gesture));

    // Create and attach an overlay scrollbar.
    scrollbar = FakeWebScrollbar::Create();
    static_cast<FakeWebScrollbar*>(scrollbar.get())->setOverlay(true);

    layerImplTreeRoot = layerImplForScrollAreaAndScrollbar(&hostImpl, scrollbar.Pass(), false);
    scrollbarLayerImpl = static_cast<ScrollbarLayerImpl*>(layerImplTreeRoot->children()[1]);

    // The user shouldn't be able to drag an overlay scrollbar and the scroll
    // may be handled in the compositor.
    EXPECT_EQ(InputHandlerClient::ScrollIgnored, scrollbarLayerImpl->TryScroll(gfx::Point(0, 0), InputHandlerClient::Gesture));
}

TEST(ScrollbarLayerTest, scrollOffsetSynchronization)
{
    FakeImplProxy proxy;
    FakeLayerTreeHostImpl hostImpl(&proxy);

    scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
    scoped_refptr<Layer> layerTreeRoot = Layer::Create();
    scoped_refptr<Layer> contentLayer = Layer::Create();
    scoped_refptr<Layer> scrollbarLayer = ScrollbarLayer::Create(scrollbar.Pass(), FakeScrollbarThemePainter::Create(false).PassAs<ScrollbarThemePainter>(), FakeWebScrollbarThemeGeometry::create(true), layerTreeRoot->id());
    layerTreeRoot->AddChild(contentLayer);
    layerTreeRoot->AddChild(scrollbarLayer);

    layerTreeRoot->SetScrollOffset(gfx::Vector2d(10, 20));
    layerTreeRoot->SetMaxScrollOffset(gfx::Vector2d(30, 50));
    layerTreeRoot->SetBounds(gfx::Size(100, 200));
    contentLayer->SetBounds(gfx::Size(100, 200));

    scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), hostImpl.active_tree());
    TreeSynchronizer::pushProperties(layerTreeRoot.get(), layerImplTreeRoot.get());

    ScrollbarLayerImpl* ccScrollbarLayer = static_cast<ScrollbarLayerImpl*>(layerImplTreeRoot->children()[1]);

    EXPECT_EQ(10, ccScrollbarLayer->CurrentPos());
    EXPECT_EQ(100, ccScrollbarLayer->TotalSize());
    EXPECT_EQ(30, ccScrollbarLayer->Maximum());

    layerTreeRoot->SetScrollOffset(gfx::Vector2d(100, 200));
    layerTreeRoot->SetMaxScrollOffset(gfx::Vector2d(300, 500));
    layerTreeRoot->SetBounds(gfx::Size(1000, 2000));
    contentLayer->SetBounds(gfx::Size(1000, 2000));

    ScrollbarAnimationController* scrollbarController = layerImplTreeRoot->scrollbar_animation_controller();
    layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), hostImpl.active_tree());
    TreeSynchronizer::pushProperties(layerTreeRoot.get(), layerImplTreeRoot.get());
    EXPECT_EQ(scrollbarController, layerImplTreeRoot->scrollbar_animation_controller());

    EXPECT_EQ(100, ccScrollbarLayer->CurrentPos());
    EXPECT_EQ(1000, ccScrollbarLayer->TotalSize());
    EXPECT_EQ(300, ccScrollbarLayer->Maximum());

    layerImplTreeRoot->ScrollBy(gfx::Vector2d(12, 34));

    EXPECT_EQ(112, ccScrollbarLayer->CurrentPos());
    EXPECT_EQ(1000, ccScrollbarLayer->TotalSize());
    EXPECT_EQ(300, ccScrollbarLayer->Maximum());
}

TEST(ScrollbarLayerTest, solidColorThicknessOverride)
{
    LayerTreeSettings layerTreeSettings;
    layerTreeSettings.solidColorScrollbars = true;
    layerTreeSettings.solidColorScrollbarThicknessDIP = 3;
    FakeImplProxy proxy;
    FakeLayerTreeHostImpl hostImpl(layerTreeSettings, &proxy);

    scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
    static_cast<FakeWebScrollbar*>(scrollbar.get())->setOverlay(true);
    scoped_ptr<LayerImpl> layerImplTreeRoot = layerImplForScrollAreaAndScrollbar(&hostImpl, scrollbar.Pass(), false);
    ScrollbarLayerImpl* scrollbarLayerImpl = static_cast<ScrollbarLayerImpl*>(layerImplTreeRoot->children()[1]);
    scrollbarLayerImpl->SetThumbSize(gfx::Size(4, 4));

    // Thickness should be overridden to 3.
    {
        MockQuadCuller quadCuller;
        AppendQuadsData data;
        scrollbarLayerImpl->AppendQuads(&quadCuller, &data);

        const QuadList& quads = quadCuller.quadList();
        ASSERT_EQ(1, quads.size());
        EXPECT_EQ(DrawQuad::SOLID_COLOR, quads[0]->material);
        EXPECT_RECT_EQ(gfx::Rect(1, 0, 4, 3), quads[0]->rect);
    }

    // Contents scale should scale the draw quad.
    scrollbarLayerImpl->draw_properties().contents_scale_x = 2;
    scrollbarLayerImpl->draw_properties().contents_scale_y = 2;
    {
        MockQuadCuller quadCuller;
        AppendQuadsData data;
        scrollbarLayerImpl->AppendQuads(&quadCuller, &data);

        const QuadList& quads = quadCuller.quadList();
        ASSERT_EQ(1, quads.size());
        EXPECT_EQ(DrawQuad::SOLID_COLOR, quads[0]->material);
        EXPECT_RECT_EQ(gfx::Rect(2, 0, 8, 6), quads[0]->rect);
    }

}

class ScrollbarLayerTestMaxTextureSize : public ThreadedTest {
public:
    ScrollbarLayerTestMaxTextureSize() {}

    void setScrollbarBounds(gfx::Size bounds) {
        bounds_ = bounds;
    }

    virtual void beginTest() OVERRIDE
    {
        m_layerTreeHost->InitializeRendererIfNeeded();

        scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
        m_scrollbarLayer = ScrollbarLayer::Create(scrollbar.Pass(), FakeScrollbarThemePainter::Create(false).PassAs<ScrollbarThemePainter>(), FakeWebScrollbarThemeGeometry::create(true), 1);
        m_scrollbarLayer->SetLayerTreeHost(m_layerTreeHost.get());
        m_scrollbarLayer->SetBounds(bounds_);
        m_layerTreeHost->root_layer()->AddChild(m_scrollbarLayer);

        m_scrollLayer = Layer::Create();
        m_scrollbarLayer->SetScrollLayerId(m_scrollLayer->id());
        m_layerTreeHost->root_layer()->AddChild(m_scrollLayer);

        postSetNeedsCommitToMainThread();
    }

    virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
    {
        const int kMaxTextureSize = impl->GetRendererCapabilities().max_texture_size;

        // Check first that we're actually testing something.
        EXPECT_GT(m_scrollbarLayer->bounds().width(), kMaxTextureSize);

        EXPECT_EQ(m_scrollbarLayer->content_bounds().width(), kMaxTextureSize - 1);
        EXPECT_EQ(m_scrollbarLayer->content_bounds().height(), kMaxTextureSize - 1);

        endTest();
    }

    virtual void afterTest() OVERRIDE
    {
    }

private:
    scoped_refptr<ScrollbarLayer> m_scrollbarLayer;
    scoped_refptr<Layer> m_scrollLayer;
    gfx::Size bounds_;
};

TEST_F(ScrollbarLayerTestMaxTextureSize, runTest) {
    scoped_ptr<TestWebGraphicsContext3D> context = TestWebGraphicsContext3D::Create();
    int max_size = 0;
    context->getIntegerv(GL_MAX_TEXTURE_SIZE, &max_size);
    setScrollbarBounds(gfx::Size(max_size + 100, max_size + 100));
    runTest(true);
}

class MockLayerTreeHost : public LayerTreeHost {
public:
    MockLayerTreeHost(const LayerTreeSettings& settings)
        : LayerTreeHost(&m_fakeClient, settings)
    {
        Initialize(scoped_ptr<Thread>(NULL));
    }

private:
    FakeLayerImplTreeHostClient m_fakeClient;
};


class ScrollbarLayerTestResourceCreation : public testing::Test {
public:
    ScrollbarLayerTestResourceCreation()
    {
    }

    void testResourceUpload(int expectedResources)
    {
        m_layerTreeHost.reset(new MockLayerTreeHost(m_layerTreeSettings));

        scoped_ptr<WebKit::WebScrollbar> scrollbar(FakeWebScrollbar::Create());
        scoped_refptr<Layer> layerTreeRoot = Layer::Create();
        scoped_refptr<Layer> contentLayer = Layer::Create();
        scoped_refptr<Layer> scrollbarLayer = ScrollbarLayer::Create(scrollbar.Pass(), FakeScrollbarThemePainter::Create(false).PassAs<ScrollbarThemePainter>(), FakeWebScrollbarThemeGeometry::create(true), layerTreeRoot->id());
        layerTreeRoot->AddChild(contentLayer);
        layerTreeRoot->AddChild(scrollbarLayer);

        m_layerTreeHost->InitializeRendererIfNeeded();
        m_layerTreeHost->contents_texture_manager()->setMaxMemoryLimitBytes(1024 * 1024);
        m_layerTreeHost->SetRootLayer(layerTreeRoot);

        scrollbarLayer->SetIsDrawable(true);
        scrollbarLayer->SetBounds(gfx::Size(100, 100));
        layerTreeRoot->SetScrollOffset(gfx::Vector2d(10, 20));
        layerTreeRoot->SetMaxScrollOffset(gfx::Vector2d(30, 50));
        layerTreeRoot->SetBounds(gfx::Size(100, 200));
        contentLayer->SetBounds(gfx::Size(100, 200));
        scrollbarLayer->draw_properties().content_bounds = gfx::Size(100, 200);
        scrollbarLayer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
        scrollbarLayer->CreateRenderSurface();
        scrollbarLayer->draw_properties().render_target = scrollbarLayer;

        testing::Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
        EXPECT_EQ(scrollbarLayer->layer_tree_host(), m_layerTreeHost.get());

        PriorityCalculator calculator;
        ResourceUpdateQueue queue;
        OcclusionTracker occlusionTracker(gfx::Rect(), false);

        scrollbarLayer->SetTexturePriorities(calculator);
        m_layerTreeHost->contents_texture_manager()->prioritizeTextures();
        scrollbarLayer->Update(&queue, &occlusionTracker, NULL);
        EXPECT_EQ(0, queue.fullUploadSize());
        EXPECT_EQ(expectedResources, queue.partialUploadSize());

        testing::Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
    }

protected:
    scoped_ptr<MockLayerTreeHost> m_layerTreeHost;
    LayerTreeSettings m_layerTreeSettings;
};

TEST_F(ScrollbarLayerTestResourceCreation, resourceUpload)
{
    m_layerTreeSettings.solidColorScrollbars = false;
    testResourceUpload(2);
}

TEST_F(ScrollbarLayerTestResourceCreation, solidColorNoResourceUpload)
{
    m_layerTreeSettings.solidColorScrollbars = true;
    testResourceUpload(0);
}

}  // namespace
}  // namespace cc