static FloatRect toNormalizedRect(const FloatRect& absoluteRect, const RenderObject* renderer, const RenderBlock* container)
{
ASSERT(renderer);
ASSERT(container || renderer->isRenderView());
if (!container)
return FloatRect();
// We want to normalize by the max layout overflow size instead of only the visible bounding box.
// Quads and their enclosing bounding boxes need to be used in order to keep results transform-friendly.
FloatPoint scrolledOrigin;
// For overflow:scroll we need to get where the actual origin is independently of the scroll.
if (container->hasOverflowClip())
scrolledOrigin = -IntPoint(container->scrolledContentOffset());
FloatRect overflowRect(scrolledOrigin, container->maxLayoutOverflow());
FloatRect containerRect = container->localToAbsoluteQuad(FloatQuad(overflowRect)).enclosingBoundingBox();
if (containerRect.isEmpty())
return FloatRect();
// Make the coordinates relative to the container enclosing bounding box.
// Since we work with rects enclosing quad unions this is still transform-friendly.
FloatRect normalizedRect = absoluteRect;
normalizedRect.moveBy(-containerRect.location());
// Fixed positions do not make sense in this coordinate system, but need to leave consistent tickmarks.
// So, use their position when the view is not scrolled, like an absolute position.
if (renderer->style()->position() == FixedPosition && container->isRenderView())
normalizedRect.move(-toRenderView(container)->frameView()->scrollOffsetForFixedPosition());
normalizedRect.scale(1 / containerRect.width(), 1 / containerRect.height());
return normalizedRect;
}
InRegionScrollableArea::InRegionScrollableArea(WebPagePrivate* webPage, RenderLayer* layer)
: m_webPage(webPage)
, m_layer(layer)
{
ASSERT(webPage);
ASSERT(layer);
m_isNull = false;
// FIXME: Add an ASSERT here as the 'layer' must be scrollable.
RenderObject* layerRenderer = layer->renderer();
ASSERT(layerRenderer);
if (layerRenderer->isRenderView()) { // #document case
FrameView* view = toRenderView(layerRenderer)->frameView();
ASSERT(view);
Frame* frame = view->frame();
ASSERT_UNUSED(frame, frame);
m_scrollPosition = m_webPage->mapToTransformed(view->scrollPosition());
m_contentsSize = m_webPage->mapToTransformed(view->contentsSize());
m_viewportSize = m_webPage->mapToTransformed(view->visibleContentRect(false /*includeScrollbars*/)).size();
m_visibleWindowRect = m_webPage->mapToTransformed(m_webPage->getRecursiveVisibleWindowRect(view));
IntRect transformedWindowRect = IntRect(IntPoint::zero(), m_webPage->transformedViewportSize());
m_visibleWindowRect.intersect(transformedWindowRect);
m_scrollsHorizontally = view->contentsWidth() > view->visibleWidth();
m_scrollsVertically = view->contentsHeight() > view->visibleHeight();
m_overscrollLimitFactor = 0.0; // FIXME eventually support overscroll
} else { // RenderBox-based elements case (scrollable boxes (div's, p's, textarea's, etc)).
RenderBox* box = m_layer->renderBox();
ASSERT(box);
ASSERT(box->canBeScrolledAndHasScrollableArea());
ScrollableArea* scrollableArea = static_cast<ScrollableArea*>(m_layer);
m_scrollPosition = m_webPage->mapToTransformed(scrollableArea->scrollPosition());
m_contentsSize = m_webPage->mapToTransformed(scrollableArea->contentsSize());
m_viewportSize = m_webPage->mapToTransformed(scrollableArea->visibleContentRect(false /*includeScrollbars*/)).size();
m_visibleWindowRect = m_layer->renderer()->absoluteClippedOverflowRect();
m_visibleWindowRect = m_layer->renderer()->frame()->view()->contentsToWindow(m_visibleWindowRect);
IntRect visibleFrameWindowRect = m_webPage->getRecursiveVisibleWindowRect(m_layer->renderer()->frame()->view());
m_visibleWindowRect.intersect(visibleFrameWindowRect);
m_visibleWindowRect = m_webPage->mapToTransformed(m_visibleWindowRect);
IntRect transformedWindowRect = IntRect(IntPoint::zero(), m_webPage->transformedViewportSize());
m_visibleWindowRect.intersect(transformedWindowRect);
m_scrollsHorizontally = box->scrollWidth() != box->clientWidth() && box->scrollsOverflowX();
m_scrollsVertically = box->scrollHeight() != box->clientHeight() && box->scrollsOverflowY();
m_overscrollLimitFactor = 0.0; // FIXME eventually support overscroll
}
}
void computePageRectsForFrame(Frame* frame, const IntRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, Vector<IntRect>& pages, int& outPageHeight)
{
ASSERT(frame);
pages.clear();
outPageHeight = 0;
if (!frame->document() || !frame->view() || !frame->document()->renderer())
return;
RenderView* root = toRenderView(frame->document()->renderer());
if (!root) {
LOG_ERROR("document to be printed has no renderer");
return;
}
if (userScaleFactor <= 0) {
LOG_ERROR("userScaleFactor has bad value %.2f", userScaleFactor);
return;
}
float ratio = static_cast<float>(printRect.height()) / static_cast<float>(printRect.width());
float pageWidth = static_cast<float>(root->overflowWidth());
float pageHeight = pageWidth * ratio;
outPageHeight = static_cast<int>(pageHeight); // this is the height of the page adjusted by margins
pageHeight -= (headerHeight + footerHeight);
if (pageHeight <= 0) {
LOG_ERROR("pageHeight has bad value %.2f", pageHeight);
return;
}
float currPageHeight = pageHeight / userScaleFactor;
float docHeight = root->layer()->height();
float currPageWidth = pageWidth / userScaleFactor;
// always return at least one page, since empty files should print a blank page
float printedPagesHeight = 0.0f;
do {
float proposedBottom = min(docHeight, printedPagesHeight + pageHeight);
frame->view()->adjustPageHeight(&proposedBottom, printedPagesHeight, proposedBottom, printedPagesHeight);
currPageHeight = max(1.0f, proposedBottom - printedPagesHeight);
pages.append(IntRect(0, printedPagesHeight, currPageWidth, currPageHeight));
printedPagesHeight += currPageHeight;
} while (printedPagesHeight < docHeight);
}
void PrintContext::computePageRects(const FloatRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, float& outPageHeight, bool allowHorizontalTiling)
{
m_pageRects.clear();
outPageHeight = 0;
if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
return;
if (userScaleFactor <= 0) {
LOG_ERROR("userScaleFactor has bad value %.2f", userScaleFactor);
return;
}
RenderView* view = toRenderView(m_frame->document()->renderer());
bool isHorizontal = view->style()->isHorizontalWritingMode();
float pageWidth;
float pageHeight;
if (isHorizontal) {
pageWidth = view->docWidth();
///NOTE: if we do not reuse the previously set logical page height,
/// we can end up with off-by-one erros in the page height,
/// leading to rendering issues (e.g. rows overlap pagebreaks)
if (view->pageLogicalHeight() == 0) {
float ratio = printRect.height() / printRect.width();
pageHeight = floorf(pageWidth * ratio);
} else {
pageHeight = view->pageLogicalHeight();
}
} else {
float ratio = printRect.width() / printRect.height();
pageHeight = view->docHeight();
pageWidth = floorf(pageHeight * ratio);
}
outPageHeight = pageHeight; // this is the height of the page adjusted by margins
pageHeight -= headerHeight + footerHeight;
if (pageHeight <= 0) {
LOG_ERROR("pageHeight has bad value %.2f", pageHeight);
return;
}
computePageRectsWithPageSizeInternal(FloatSize(pageWidth / userScaleFactor, pageHeight / userScaleFactor), allowHorizontalTiling);
}
bool SVGLength::determineViewport(const SVGElement* context, float& width, float& height) const
{
if (!context)
return false;
// Take size from outermost <svg> element.
Document* document = context->document();
if (document->documentElement() == context) {
if (RenderView* view = toRenderView(document->renderer())) {
width = view->viewWidth();
height = view->viewHeight();
return true;
}
return false;
}
// Resolve value against nearest viewport element (common case: inner <svg> elements)
SVGElement* viewportElement = context->viewportElement();
if (viewportElement && viewportElement->isSVG()) {
const SVGSVGElement* svg = static_cast<const SVGSVGElement*>(viewportElement);
if (svg->hasAttribute(SVGNames::viewBoxAttr)) {
width = svg->viewBox().width();
height = svg->viewBox().height();
} else {
width = svg->width().value(svg);
height = svg->height().value(svg);
}
return true;
}
// Resolve value against enclosing non-SVG RenderBox
if (!context->parentNode() || context->parentNode()->isSVGElement())
return false;
RenderObject* renderer = context->renderer();
if (!renderer || !renderer->isBox())
return false;
RenderBox* box = toRenderBox(renderer);
width = box->width();
height = box->height();
return true;
}
float SVGLength::PercentageOfViewport(float value, const SVGElement* context, SVGLengthMode mode)
{
ASSERT(context);
float width = 0.0f, height = 0.0f;
SVGElement* viewportElement = context->viewportElement();
// PercentageOfViewport() is used to resolve all relative-positioned values within a SVG document (fragment)
Document* doc = context->document();
if (doc->documentElement() == context) {
// Resolve value against outermost <svg> element
if (RenderView* view = toRenderView(doc->renderer())) {
width = view->viewWidth();
height = view->viewHeight();
}
} else if (viewportElement && viewportElement->isSVG()) {
// Resolve value against nearest viewport element (common case: inner <svg> elements)
const SVGSVGElement* svg = static_cast<const SVGSVGElement*>(viewportElement);
if (svg->hasAttribute(SVGNames::viewBoxAttr)) {
width = svg->viewBox().width();
height = svg->viewBox().height();
} else {
width = svg->width().value(svg);
height = svg->height().value(svg);
}
} else if (context->parent() && !context->parent()->isSVGElement()) {
// Resolve value against enclosing non-SVG RenderBox
if (RenderObject* renderer = context->renderer()) {
if (renderer->isBox()) {
RenderBox* box = toRenderBox(renderer);
width = box->width();
height = box->height();
}
}
}
if (mode == LengthModeWidth)
return value * width;
else if (mode == LengthModeHeight)
return value * height;
else if (mode == LengthModeOther)
return value * sqrtf(powf(width, 2) + powf(height, 2)) / sqrtf(2.0f);
return 0.0f;
}
float SVGLength::PercentageOfViewport(float value, const SVGElement* context, SVGLengthMode mode)
{
ASSERT(context);
float width = 0.0f, height = 0.0f;
SVGElement* viewportElement = context->viewportElement();
Document* doc = context->document();
if (doc->documentElement() == context) {
// We have to ask the canvas for the full "canvas size"...
RenderView* view = toRenderView(doc->renderer());
if (view && view->frameView()) {
width = view->frameView()->visibleWidth(); // TODO: recheck!
height = view->frameView()->visibleHeight(); // TODO: recheck!
}
} else if (viewportElement && viewportElement->isSVG()) {
const SVGSVGElement* svg = static_cast<const SVGSVGElement*>(viewportElement);
if (svg->hasAttribute(SVGNames::viewBoxAttr)) {
width = svg->viewBox().width();
height = svg->viewBox().height();
} else {
width = svg->width().value(svg);
height = svg->height().value(svg);
}
} else if (context->parent() && !context->parent()->isSVGElement()) {
if (RenderObject* renderer = context->renderer()) {
if (renderer->isBox()) {
RenderBox* box = toRenderBox(renderer);
width = box->width();
height = box->height();
}
}
}
if (mode == LengthModeWidth)
return value * width;
else if (mode == LengthModeHeight)
return value * height;
else if (mode == LengthModeOther)
return value * sqrtf(powf(width, 2) + powf(height, 2)) / sqrtf(2.0f);
return 0.0f;
}
void PrintContext::computePageRects(const FloatRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, float& outPageHeight, bool allowHorizontalTiling)
{
m_pageRects.clear();
outPageHeight = 0;
if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
return;
if (userScaleFactor <= 0) {
LOG_ERROR("userScaleFactor has bad value %.2f", userScaleFactor);
return;
}
RenderView* view = toRenderView(m_frame->document()->renderer());
bool isHorizontal = view->style()->isHorizontalWritingMode();
float pageWidth;
float pageHeight;
const IntRect& documentRect = view->documentRect();
if (isHorizontal) {
float ratio = printRect.height() / printRect.width();
pageWidth = documentRect.width();
pageHeight = floorf(pageWidth * ratio);
} else {
float ratio = printRect.width() / printRect.height();
pageHeight = documentRect.height();
pageWidth = floorf(pageHeight * ratio);
}
outPageHeight = pageHeight; // this is the height of the page adjusted by margins
pageHeight -= headerHeight + footerHeight;
if (pageHeight <= 0) {
LOG_ERROR("pageHeight has bad value %.2f", pageHeight);
return;
}
computePageRectsWithPageSizeInternal(FloatSize(pageWidth / userScaleFactor, pageHeight / userScaleFactor), allowHorizontalTiling);
}
void PrintContext::computePageRectsWithPageSizeInternal(const FloatSize& pageSizeInPixels, bool allowInlineDirectionTiling)
{
if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
return;
RenderView* view = toRenderView(m_frame->document()->renderer());
IntRect docRect = view->documentRect();
int pageWidth = pageSizeInPixels.width();
int pageHeight = pageSizeInPixels.height();
bool isHorizontal = view->style()->isHorizontalWritingMode();
int docLogicalHeight = isHorizontal ? docRect.height() : docRect.width();
int pageLogicalHeight = isHorizontal ? pageHeight : pageWidth;
int pageLogicalWidth = isHorizontal ? pageWidth : pageHeight;
int inlineDirectionStart;
int inlineDirectionEnd;
int blockDirectionStart;
int blockDirectionEnd;
if (isHorizontal) {
if (view->style()->isFlippedBlocksWritingMode()) {
blockDirectionStart = docRect.maxY();
blockDirectionEnd = docRect.y();
} else {
blockDirectionStart = docRect.y();
blockDirectionEnd = docRect.maxY();
}
inlineDirectionStart = view->style()->isLeftToRightDirection() ? docRect.x() : docRect.maxX();
inlineDirectionEnd = view->style()->isLeftToRightDirection() ? docRect.maxX() : docRect.x();
} else {
if (view->style()->isFlippedBlocksWritingMode()) {
blockDirectionStart = docRect.maxX();
blockDirectionEnd = docRect.x();
} else {
blockDirectionStart = docRect.x();
blockDirectionEnd = docRect.maxX();
}
inlineDirectionStart = view->style()->isLeftToRightDirection() ? docRect.y() : docRect.maxY();
inlineDirectionEnd = view->style()->isLeftToRightDirection() ? docRect.maxY() : docRect.y();
}
unsigned pageCount = ceilf((float)docLogicalHeight / pageLogicalHeight);
for (unsigned i = 0; i < pageCount; ++i) {
int pageLogicalTop = blockDirectionEnd > blockDirectionStart ?
blockDirectionStart + i * pageLogicalHeight :
blockDirectionStart - (i + 1) * pageLogicalHeight;
if (allowInlineDirectionTiling) {
for (int currentInlinePosition = inlineDirectionStart;
inlineDirectionEnd > inlineDirectionStart ? currentInlinePosition < inlineDirectionEnd : currentInlinePosition > inlineDirectionEnd;
currentInlinePosition += (inlineDirectionEnd > inlineDirectionStart ? pageLogicalWidth : -pageLogicalWidth)) {
int pageLogicalLeft = inlineDirectionEnd > inlineDirectionStart ? currentInlinePosition : currentInlinePosition - pageLogicalWidth;
IntRect pageRect(pageLogicalLeft, pageLogicalTop, pageLogicalWidth, pageLogicalHeight);
if (!isHorizontal)
pageRect = pageRect.transposedRect();
m_pageRects.append(pageRect);
}
} else {
int pageLogicalLeft = inlineDirectionEnd > inlineDirectionStart ? inlineDirectionStart : inlineDirectionStart - pageLogicalWidth;
IntRect pageRect(pageLogicalLeft, pageLogicalTop, pageLogicalWidth, pageLogicalHeight);
if (!isHorizontal)
pageRect = pageRect.transposedRect();
m_pageRects.append(pageRect);
}
}
}
InRegionScrollableArea::InRegionScrollableArea(WebPagePrivate* webPage, RenderLayer* layer)
: m_webPage(webPage)
, m_layer(layer)
, m_document(0)
, m_hasWindowVisibleRectCalculated(false)
{
ASSERT(webPage);
ASSERT(layer);
m_isNull = false;
// Add a pointer to the enclosing document as the pointer to layer or node along the way may become invalid.
if (m_layer->enclosingElement())
m_document = m_layer->enclosingElement()->document();
// FIXME: Add an ASSERT here as the 'layer' must be scrollable.
RenderObject* layerRenderer = layer->renderer();
ASSERT(layerRenderer);
if (layerRenderer->isRenderView()) { // #document case
RenderView* renderView = toRenderView(layerRenderer);
ASSERT(renderView);
FrameView* view = toRenderView(layerRenderer)->frameView();
ASSERT(view);
Frame* frame = view->frame();
ASSERT_UNUSED(frame, frame);
const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
m_scrollPosition = viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatPoint(view->scrollPosition()));
m_contentsSize = viewportAccessor->roundToPixelFromDocumentContents(Platform::FloatRect(Platform::FloatPoint::zero(), WebCore::FloatSize(view->contentsSize()))).size();
m_viewportSize = viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatRect(view->visibleContentRect(ScrollableArea::ExcludeScrollbars))).size();
m_documentViewportRect = view->frameRect();
m_scrollsHorizontally = view->contentsWidth() > view->visibleWidth();
m_scrollsVertically = view->contentsHeight() > view->visibleHeight();
m_supportsCompositedScrolling = true;
m_scrollTarget = InnerFrame;
ASSERT(!m_cachedNonCompositedScrollableNode);
m_camouflagedCompositedScrollableLayer = reinterpret_cast<unsigned>(renderView->compositor()->scrollLayer()->platformLayer());
m_cachedCompositedScrollableLayer = renderView->compositor()->scrollLayer()->platformLayer();
} else { // RenderBox-based elements case (scrollable boxes (div's, p's, textarea's, etc)).
RenderBox* box = m_layer->renderBox();
ASSERT(box);
ASSERT(InRegionScrollerPrivate::canScrollRenderBox(box));
const Platform::ViewportAccessor* viewportAccessor = m_webPage->m_webkitThreadViewportAccessor;
ScrollableArea* scrollableArea = static_cast<ScrollableArea*>(m_layer);
m_scrollPosition = viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatPoint(scrollableArea->scrollPosition()));
m_contentsSize = viewportAccessor->roundToPixelFromDocumentContents(Platform::FloatRect(Platform::FloatPoint::zero(), WebCore::FloatSize(scrollableArea->contentsSize()))).size();
m_viewportSize = viewportAccessor->roundToPixelFromDocumentContents(WebCore::FloatRect(scrollableArea->visibleContentRect(ScrollableArea::ExcludeScrollbars))).size();
m_documentViewportRect = enclosingIntRect(box->absoluteClippedOverflowRect());
m_scrollsHorizontally = box->scrollWidth() != box->clientWidth();
m_scrollsVertically = box->scrollHeight() != box->clientHeight();
// Check the overflow if its not an input field because overflow can be set to hidden etc. by the content.
if (!DOMSupport::isShadowHostTextInputElement(box->node())) {
m_scrollsHorizontally = m_scrollsHorizontally && box->scrollsOverflowX();
m_scrollsVertically = m_scrollsVertically && box->scrollsOverflowY();
}
m_scrollTarget = BlockElement;
// Both caches below are self-exclusive.
if (m_layer->usesCompositedScrolling()) {
m_forceContentToBeHorizontallyScrollable = m_scrollsHorizontally;
m_forceContentToBeVerticallyScrollable = m_scrollsVertically;
// Force content to be scrollable even if it doesn't need to scroll in either direction.
if (!m_scrollsHorizontally && !m_scrollsVertically) {
if (box->scrollsOverflowY())
m_forceContentToBeVerticallyScrollable = true;
else if (box->scrollsOverflowX()) // If it's already forced scrollable vertically, don't force it to scroll horizontally
m_forceContentToBeHorizontallyScrollable = true;
}
m_supportsCompositedScrolling = true;
ASSERT(m_layer->backing()->hasScrollingLayer());
m_camouflagedCompositedScrollableLayer = reinterpret_cast<unsigned>(m_layer->backing()->scrollingContentsLayer()->platformLayer());
m_cachedCompositedScrollableLayer = m_layer->backing()->scrollingContentsLayer()->platformLayer();
ASSERT(!m_cachedNonCompositedScrollableNode);
} else {
m_camouflagedCompositedScrollableLayer = reinterpret_cast<unsigned>(m_layer->enclosingElement());
m_cachedNonCompositedScrollableNode = m_layer->enclosingElement();
ASSERT(!m_cachedCompositedScrollableLayer);
}
}
}
InRegionScrollableArea::InRegionScrollableArea(WebPagePrivate* webPage, RenderLayer* layer)
: m_webPage(webPage)
, m_layer(layer)
, m_document(0)
, m_hasWindowVisibleRectCalculated(false)
{
ASSERT(webPage);
ASSERT(layer);
m_isNull = false;
// Add a pointer to the enclosing document as the pointer to layer or node along the way may become invalid.
if (m_layer->enclosingElement())
m_document = m_layer->enclosingElement()->document();
// FIXME: Add an ASSERT here as the 'layer' must be scrollable.
RenderObject* layerRenderer = layer->renderer();
ASSERT(layerRenderer);
if (layerRenderer->isRenderView()) { // #document case
RenderView* renderView = toRenderView(layerRenderer);
ASSERT(renderView);
FrameView* view = toRenderView(layerRenderer)->frameView();
ASSERT(view);
Frame* frame = view->frame();
ASSERT_UNUSED(frame, frame);
m_scrollPosition = m_webPage->mapToTransformed(view->scrollPosition());
m_contentsSize = m_webPage->mapToTransformed(view->contentsSize());
m_viewportSize = m_webPage->mapToTransformed(view->visibleContentRect(ScrollableArea::ExcludeScrollbars)).size();
m_documentViewportRect = view->frameRect();
m_scrollsHorizontally = view->contentsWidth() > view->visibleWidth();
m_scrollsVertically = view->contentsHeight() > view->visibleHeight();
m_supportsCompositedScrolling = true;
m_scrollTarget = InnerFrame;
ASSERT(!m_cachedNonCompositedScrollableNode);
m_camouflagedCompositedScrollableLayer = reinterpret_cast<unsigned>(renderView->compositor()->scrollLayer()->platformLayer());
m_cachedCompositedScrollableLayer = renderView->compositor()->scrollLayer()->platformLayer();
} else { // RenderBox-based elements case (scrollable boxes (div's, p's, textarea's, etc)).
RenderBox* box = m_layer->renderBox();
ASSERT(box);
ASSERT(InRegionScrollerPrivate::canScrollRenderBox(box));
ScrollableArea* scrollableArea = static_cast<ScrollableArea*>(m_layer);
m_scrollPosition = m_webPage->mapToTransformed(scrollableArea->scrollPosition());
m_contentsSize = m_webPage->mapToTransformed(scrollableArea->contentsSize());
m_viewportSize = m_webPage->mapToTransformed(scrollableArea->visibleContentRect(ScrollableArea::ExcludeScrollbars)).size();
m_documentViewportRect = enclosingIntRect(box->absoluteClippedOverflowRect());
m_scrollsHorizontally = box->scrollWidth() != box->clientWidth();
m_scrollsVertically = box->scrollHeight() != box->clientHeight();
// Check the overflow if its not an input field because overflow can be set to hidden etc. by the content.
if (!box->node() || !box->node()->rendererIsEditable()) {
m_scrollsHorizontally = m_scrollsHorizontally && box->scrollsOverflowX();
m_scrollsVertically = m_scrollsVertically && box->scrollsOverflowY();
}
m_scrollTarget = BlockElement;
// Both caches below are self-exclusive.
if (m_layer->usesCompositedScrolling()) {
m_forceContentToBeVerticallyScrollable = true;
m_supportsCompositedScrolling = true;
ASSERT(m_layer->backing()->hasScrollingLayer());
m_camouflagedCompositedScrollableLayer = reinterpret_cast<unsigned>(m_layer->backing()->scrollingContentsLayer()->platformLayer());
m_cachedCompositedScrollableLayer = m_layer->backing()->scrollingContentsLayer()->platformLayer();
ASSERT(!m_cachedNonCompositedScrollableNode);
} else {
m_camouflagedCompositedScrollableLayer = reinterpret_cast<unsigned>(m_layer->enclosingElement());
m_cachedNonCompositedScrollableNode = m_layer->enclosingElement();
ASSERT(!m_cachedCompositedScrollableLayer);
}
}
}
