void PageOverlay::update() {
  if (!m_frameImpl->frameWidget()->isAcceleratedCompositingActive())
    return;

  LocalFrame* frame = m_frameImpl->frame();
  if (!frame)
    return;

  if (!m_layer) {
    m_layer = GraphicsLayer::create(this);
    m_layer->setDrawsContent(true);

    if (WebDevToolsAgentImpl* devTools = m_frameImpl->devToolsAgentImpl())
      devTools->willAddPageOverlay(m_layer.get());

    // This is required for contents of overlay to stay in sync with the page
    // while scrolling.
    WebLayer* platformLayer = m_layer->platformLayer();
    platformLayer->addMainThreadScrollingReasons(
        MainThreadScrollingReason::kPageOverlay);
    if (frame->isMainFrame()) {
      frame->host()->visualViewport().containerLayer()->addChild(m_layer.get());
    } else {
      toWebFrameWidgetImpl(m_frameImpl->frameWidget())
          ->rootGraphicsLayer()
          ->addChild(m_layer.get());
    }
  }

  FloatSize size(frame->host()->visualViewport().size());
  if (size != m_layer->size())
    m_layer->setSize(size);

  m_layer->setNeedsDisplay();
}

TEST_F(ScrollingCoordinatorTest, fastFractionalScrollingDiv)
{
    registerMockedHttpURLLoad("fractional-scroll-div.html");
    navigateTo(m_baseURL + "fractional-scroll-div.html");
    forceFullCompositingUpdate();

    Document* document = frame()->document();
    Element* scrollableElement = document->getElementById("scroller");
    ASSERT(scrollableElement);

    scrollableElement->setScrollTop(1.0);
    scrollableElement->setScrollLeft(1.0);
    forceFullCompositingUpdate();

    // Make sure the fractional scroll offset change 1.0 -> 1.2 gets propagated
    // to compositor.
    scrollableElement->setScrollTop(1.2);
    scrollableElement->setScrollLeft(1.2);
    forceFullCompositingUpdate();

    LayoutObject* layoutObject = scrollableElement->layoutObject();
    ASSERT_TRUE(layoutObject->isBox());
    LayoutBox* box = toLayoutBox(layoutObject);
    ASSERT_TRUE(box->usesCompositedScrolling());
    CompositedLayerMapping* compositedLayerMapping = box->layer()->compositedLayerMapping();
    ASSERT_TRUE(compositedLayerMapping->hasScrollingLayer());
    ASSERT(compositedLayerMapping->scrollingContentsLayer());
    WebLayer* webScrollLayer = compositedLayerMapping->scrollingContentsLayer()->platformLayer();
    ASSERT_TRUE(webScrollLayer);
    ASSERT_NEAR(1.2, webScrollLayer->scrollPositionDouble().x, 0.01);
    ASSERT_NEAR(1.2, webScrollLayer->scrollPositionDouble().y, 0.01);
}

TEST_F(ScrollingCoordinatorChromiumTest, fastScrollingForFixedPosition)
{
    registerMockedHttpURLLoad("fixed-position.html");
    navigateTo(m_baseURL + "fixed-position.html");

    Page* page = m_webViewImpl->mainFrameImpl()->frame()->page();
    ASSERT_TRUE(page->scrollingCoordinator()->supportsFixedPositionLayers());

    // Fixed position should not fall back to main thread scrolling.
    WebLayer* rootScrollLayer = getRootScrollLayer();
    ASSERT_FALSE(rootScrollLayer->shouldScrollOnMainThread());

    // Verify the properties of the fixed position element starting from the RenderObject all the
    // way to the WebLayer.
    Element* fixedElement = m_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_P(CompositorWorkerTest, disconnectedProxies) {
  // This case is identical to compositor-proxy-basic, but the proxies are
  // disconnected (the result should be the same as
  // compositor-proxy-plumbing-no-proxies).
  registerMockedHttpURLLoad("compositor-proxy-basic-disconnected.html");
  navigateTo(m_baseURL + "compositor-proxy-basic-disconnected.html");

  forceFullCompositingUpdate();

  Document* document = frame()->document();

  Element* tallElement = document->getElementById("tall");
  WebLayer* tallLayer = webLayerFromElement(tallElement);
  EXPECT_TRUE(!tallLayer);

  Element* proxiedElement = document->getElementById("proxied");
  WebLayer* proxiedLayer = webLayerFromElement(proxiedElement);
  EXPECT_TRUE(!proxiedLayer);

  Element* scrollElement = document->getElementById("proxied-scroller");
  WebLayer* scrollLayer = scrollingWebLayerFromElement(scrollElement);
  EXPECT_FALSE(!!scrollLayer->compositorMutableProperties());

  WebLayer* rootScrollLayer = getRootScrollLayer();
  EXPECT_FALSE(!!rootScrollLayer->compositorMutableProperties());
}

TEST_F(ScrollingCoordinatorTest, scrollEventHandler)
{
    registerMockedHttpURLLoad("scroll-event-handler.html");
    navigateTo(m_baseURL + "scroll-event-handler.html");
    forceFullCompositingUpdate();

    WebLayer* rootScrollLayer = getRootScrollLayer();
    ASSERT_TRUE(rootScrollLayer->haveScrollEventHandlers());
}

void GraphicsLayerChromium::updateContentsRect()
{
    WebLayer* contentsLayer = contentsLayerIfRegistered();
    if (!contentsLayer)
        return;

    contentsLayer->setPosition(FloatPoint(m_contentsRect.x(), m_contentsRect.y()));
    contentsLayer->setBounds(IntSize(m_contentsRect.width(), m_contentsRect.height()));
}

void GraphicsLayer::setContentsClippingMaskLayer(GraphicsLayer* contentsClippingMaskLayer)
{
    if (contentsClippingMaskLayer == m_contentsClippingMaskLayer)
        return;

    m_contentsClippingMaskLayer = contentsClippingMaskLayer;
    WebLayer* contentsLayer = contentsLayerIfRegistered();
    if (!contentsLayer)
        return;
    WebLayer* contentsClippingMaskWebLayer = m_contentsClippingMaskLayer ? m_contentsClippingMaskLayer->platformLayer() : 0;
    contentsLayer->setMaskLayer(contentsClippingMaskWebLayer);
    updateContentsRect();
}

void ScrollingCoordinatorChromium::scrollableAreaScrollLayerDidChange(ScrollableArea* scrollableArea)
{
    GraphicsLayerChromium* scrollLayer = static_cast<GraphicsLayerChromium*>(scrollLayerForScrollableArea(scrollableArea));
    if (scrollLayer)
        scrollLayer->setScrollableArea(scrollableArea);

    WebLayer* webLayer = scrollingWebLayerForScrollableArea(scrollableArea);
    if (webLayer) {
        webLayer->setScrollable(true);
        webLayer->setScrollPosition(IntPoint(scrollableArea->scrollPosition() - scrollableArea->minimumScrollPosition()));
        webLayer->setMaxScrollPosition(IntSize(scrollableArea->scrollSize(HorizontalScrollbar), scrollableArea->scrollSize(VerticalScrollbar)));
    }
    if (WebScrollbarLayer* scrollbarLayer = getWebScrollbarLayer(scrollableArea, HorizontalScrollbar))
        setupScrollbarLayer(horizontalScrollbarLayerForScrollableArea(scrollableArea), scrollbarLayer, webLayer);
    if (WebScrollbarLayer* scrollbarLayer = getWebScrollbarLayer(scrollableArea, VerticalScrollbar))
        setupScrollbarLayer(verticalScrollbarLayerForScrollableArea(scrollableArea), scrollbarLayer, webLayer);
}

static std::unique_ptr<Array<protocol::LayerTree::ScrollRect>>
buildScrollRectsForLayer(GraphicsLayer* graphicsLayer,
                         bool reportWheelScrollers) {
  std::unique_ptr<Array<protocol::LayerTree::ScrollRect>> scrollRects =
      Array<protocol::LayerTree::ScrollRect>::create();
  WebLayer* webLayer = graphicsLayer->platformLayer();
  WebVector<WebRect> nonFastScrollableRects =
      webLayer->nonFastScrollableRegion();
  for (size_t i = 0; i < nonFastScrollableRects.size(); ++i) {
    scrollRects->addItem(buildScrollRect(
        nonFastScrollableRects[i],
        protocol::LayerTree::ScrollRect::TypeEnum::RepaintsOnScroll));
  }
  WebVector<WebRect> touchEventHandlerRects =
      webLayer->touchEventHandlerRegion();
  for (size_t i = 0; i < touchEventHandlerRects.size(); ++i) {
    scrollRects->addItem(buildScrollRect(
        touchEventHandlerRects[i],
        protocol::LayerTree::ScrollRect::TypeEnum::TouchEventHandler));
  }
  if (reportWheelScrollers) {
    WebRect webRect(webLayer->position().x, webLayer->position().y,
                    webLayer->bounds().width, webLayer->bounds().height);
    scrollRects->addItem(buildScrollRect(
        webRect, protocol::LayerTree::ScrollRect::TypeEnum::WheelEventHandler));
  }
  return scrollRects->length() ? std::move(scrollRects) : nullptr;
}

static std::unique_ptr<protocol::LayerTree::Layer> buildObjectForLayer(
    GraphicsLayer* graphicsLayer,
    int nodeId,
    bool reportWheelEventListeners) {
  WebLayer* webLayer = graphicsLayer->platformLayer();
  std::unique_ptr<protocol::LayerTree::Layer> layerObject =
      protocol::LayerTree::Layer::create()
          .setLayerId(idForLayer(graphicsLayer))
          .setOffsetX(webLayer->position().x)
          .setOffsetY(webLayer->position().y)
          .setWidth(webLayer->bounds().width)
          .setHeight(webLayer->bounds().height)
          .setPaintCount(graphicsLayer->paintCount())
          .setDrawsContent(webLayer->drawsContent())
          .build();

  if (nodeId)
    layerObject->setBackendNodeId(nodeId);

  GraphicsLayer* parent = graphicsLayer->parent();
  if (parent)
    layerObject->setParentLayerId(idForLayer(parent));
  if (!graphicsLayer->contentsAreVisible())
    layerObject->setInvisible(true);
  const TransformationMatrix& transform = graphicsLayer->transform();
  if (!transform.isIdentity()) {
    TransformationMatrix::FloatMatrix4 flattenedMatrix;
    transform.toColumnMajorFloatArray(flattenedMatrix);
    std::unique_ptr<Array<double>> transformArray = Array<double>::create();
    for (size_t i = 0; i < WTF_ARRAY_LENGTH(flattenedMatrix); ++i)
      transformArray->addItem(flattenedMatrix[i]);
    layerObject->setTransform(std::move(transformArray));
    const FloatPoint3D& transformOrigin = graphicsLayer->transformOrigin();
    // FIXME: rename these to setTransformOrigin*
    if (webLayer->bounds().width > 0)
      layerObject->setAnchorX(transformOrigin.x() / webLayer->bounds().width);
    else
      layerObject->setAnchorX(0.0);
    if (webLayer->bounds().height > 0)
      layerObject->setAnchorY(transformOrigin.y() / webLayer->bounds().height);
    else
      layerObject->setAnchorY(0.0);
    layerObject->setAnchorZ(transformOrigin.z());
  }
  std::unique_ptr<Array<protocol::LayerTree::ScrollRect>> scrollRects =
      buildScrollRectsForLayer(graphicsLayer, reportWheelEventListeners);
  if (scrollRects)
    layerObject->setScrollRects(std::move(scrollRects));
  return layerObject;
}

static PassRefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect> > buildScrollRectsForLayer(GraphicsLayer* graphicsLayer)
{
    RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect> > scrollRects = TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect>::create();
    WebLayer* webLayer = graphicsLayer->platformLayer();
    for (size_t i = 0; i < webLayer->nonFastScrollableRegion().size(); ++i) {
        scrollRects->addItem(buildScrollRect(webLayer->nonFastScrollableRegion()[i], TypeBuilder::LayerTree::ScrollRect::Type::RepaintsOnScroll));
    }
    for (size_t i = 0; i < webLayer->touchEventHandlerRegion().size(); ++i) {
        scrollRects->addItem(buildScrollRect(webLayer->touchEventHandlerRegion()[i], TypeBuilder::LayerTree::ScrollRect::Type::TouchEventHandler));
    }
    if (webLayer->haveWheelEventHandlers()) {
        WebRect webRect(webLayer->position().x, webLayer->position().y, webLayer->bounds().width, webLayer->bounds().height);
        scrollRects->addItem(buildScrollRect(webRect, TypeBuilder::LayerTree::ScrollRect::Type::WheelEventHandler));
    }
    return scrollRects->length() ? scrollRects.release() : nullptr;
}

void GraphicsLayer::updateChildList()
{
    WebLayer* childHost = m_layer->layer();
    childHost->removeAllChildren();

    clearContentsLayerIfUnregistered();

    if (m_contentsLayer) {
        // FIXME: add the contents layer in the correct order with negative z-order children.
        // This does not cause visible rendering issues because currently contents layers are only used
        // for replaced elements that don't have children.
        childHost->addChild(m_contentsLayer);
    }

    for (size_t i = 0; i < m_children.size(); ++i)
        childHost->addChild(m_children[i]->platformLayer());

    for (size_t i = 0; i < m_linkHighlights.size(); ++i)
        childHost->addChild(m_linkHighlights[i]->layer());
}

void GraphicsLayerChromium::updateChildList()
{
    WebLayer* childHost = m_transformLayer ? m_transformLayer.get() : m_layer->layer();
    childHost->removeAllChildren();

    clearContentsLayerIfUnregistered();

    if (m_transformLayer) {
        // Add the primary layer first. Even if we have negative z-order children, the primary layer always comes behind.
        childHost->addChild(m_layer->layer());
    } else if (m_contentsLayer) {
        // FIXME: add the contents layer in the correct order with negative z-order children.
        // This does not cause visible rendering issues because currently contents layers are only used
        // for replaced elements that don't have children.
        childHost->addChild(m_contentsLayer);
    }

    const Vector<GraphicsLayer*>& childLayers = children();
    size_t numChildren = childLayers.size();
    for (size_t i = 0; i < numChildren; ++i) {
        GraphicsLayerChromium* curChild = static_cast<GraphicsLayerChromium*>(childLayers[i]);

        childHost->addChild(curChild->platformLayer());
    }

    if (m_linkHighlight)
        childHost->addChild(m_linkHighlight->layer());

    if (m_transformLayer && m_contentsLayer) {
        // If we have a transform layer, then the contents layer is parented in the
        // primary layer (which is itself a child of the transform layer).
        m_layer->layer()->removeAllChildren();
        m_layer->layer()->addChild(m_contentsLayer);
    }
}

void NonCompositedContentHost::setViewport(const WebCore::IntSize& viewportSize, const WebCore::IntSize& contentsSize, const WebCore::IntPoint& scrollPosition, const WebCore::IntPoint& scrollOrigin)
{
    if (!haveScrollLayer())
        return;

    bool visibleRectChanged = m_viewportSize != viewportSize;

    m_viewportSize = viewportSize;
    WebLayer* layer = scrollLayer();
    layer->setScrollPosition(scrollPosition + scrollOrigin);
    layer->setPosition(WebFloatPoint(-scrollPosition));
    // Due to the possibility of pinch zoom, the noncomposited layer is always
    // assumed to be scrollable.
    layer->setScrollable(true);
    m_graphicsLayer->setSize(contentsSize);

    // In RTL-style pages, the origin of the initial containing block for the
    // root layer may be positive; translate the layer to avoid negative
    // coordinates.
    m_layerAdjust = -toSize(scrollOrigin);
    if (m_graphicsLayer->transform().m41() != m_layerAdjust.width() || m_graphicsLayer->transform().m42() != m_layerAdjust.height()) {
        WebCore::TransformationMatrix transform = m_graphicsLayer->transform();
        transform.setM41(m_layerAdjust.width());
        transform.setM42(m_layerAdjust.height());
        m_graphicsLayer->setTransform(transform);

        // If a tiled layer is shifted left or right, the content that goes into
        // each tile will change. Invalidate the entire layer when this happens.
        m_graphicsLayer->setNeedsDisplay();
    } else if (visibleRectChanged)
        m_graphicsLayer->setNeedsDisplay();

    WebCore::GraphicsLayer* clipLayer = m_graphicsLayer->parent()->parent();
    WebCore::GraphicsLayer* rootLayer = clipLayer;
    while (rootLayer->parent())
        rootLayer = rootLayer->parent();
    setScrollbarBoundsContainPageScale(rootLayer, clipLayer);
}