void RenderLayerClipper::calculateRects(const ClipRectsContext& context, const LayoutRect& paintDirtyRect, LayoutRect& layerBounds,
ClipRect& backgroundRect, ClipRect& foregroundRect, ClipRect& outlineRect, const LayoutPoint* offsetFromRoot) const
{
bool isClippingRoot = m_renderer.layer() == context.rootLayer;
if (!isClippingRoot && m_renderer.layer()->parent()) {
backgroundRect = backgroundClipRect(context);
backgroundRect.move(roundedIntSize(context.subPixelAccumulation));
backgroundRect.intersect(paintDirtyRect);
} else {
backgroundRect = paintDirtyRect;
}
foregroundRect = backgroundRect;
outlineRect = backgroundRect;
LayoutPoint offset;
if (offsetFromRoot)
offset = *offsetFromRoot;
else
m_renderer.layer()->convertToLayerCoords(context.rootLayer, offset);
layerBounds = LayoutRect(offset, m_renderer.layer()->size());
// Update the clip rects that will be passed to child layers.
if (m_renderer.hasOverflowClip()) {
// This layer establishes a clip of some kind.
if (!isClippingRoot || context.respectOverflowClip == RespectOverflowClip) {
foregroundRect.intersect(toRenderBox(m_renderer).overflowClipRect(offset));
if (m_renderer.style()->hasBorderRadius())
foregroundRect.setHasRadius(true);
}
// If we establish an overflow clip at all, then go ahead and make sure our background
// rect is intersected with our layer's bounds including our visual overflow,
// since any visual overflow like box-shadow or border-outset is not clipped by overflow:auto/hidden.
if (toRenderBox(m_renderer).hasVisualOverflow()) {
// FIXME: Perhaps we should be propagating the borderbox as the clip rect for children, even though
// we may need to inflate our clip specifically for shadows or outsets.
// FIXME: Does not do the right thing with CSS regions yet, since we don't yet factor in the
// individual region boxes as overflow.
LayoutRect layerBoundsWithVisualOverflow = toRenderBox(m_renderer).visualOverflowRect();
layerBoundsWithVisualOverflow.moveBy(offset);
if (!isClippingRoot || context.respectOverflowClip == RespectOverflowClip)
backgroundRect.intersect(layerBoundsWithVisualOverflow);
} else {
LayoutRect bounds = toRenderBox(m_renderer).borderBoxRect();
bounds.moveBy(offset);
if (!isClippingRoot || context.respectOverflowClip == RespectOverflowClip)
backgroundRect.intersect(bounds);
}
}
// CSS clip (different than clipping due to overflow) can clip to any box, even if it falls outside of the border box.
if (m_renderer.hasClip()) {
// Clip applies to *us* as well, so go ahead and update the damageRect.
LayoutRect newPosClip = toRenderBox(m_renderer).clipRect(offset);
backgroundRect.intersect(newPosClip);
foregroundRect.intersect(newPosClip);
outlineRect.intersect(newPosClip);
}
}
IntSize SVGImageForContainer::size() const
{
FloatSize scaledContainerSize(m_containerSize);
scaledContainerSize.scale(m_zoom);
return roundedIntSize(scaledContainerSize);
}
RenderNamedFlowFragment* RenderNamedFlowThread::fragmentFromAbsolutePointAndBox(const IntPoint& absolutePoint, const RenderBox& flowedBox)
{
RenderRegion* startRegion = nullptr;
RenderRegion* endRegion = nullptr;
if (!getRegionRangeForBox(&flowedBox, startRegion, endRegion))
return nullptr;
for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
RenderNamedFlowFragment* fragment = toRenderNamedFlowFragment(*iter);
RenderBlockFlow& fragmentContainer = fragment->fragmentContainer();
IntRect fragmentAbsoluteRect(roundedIntPoint(fragmentContainer.localToAbsolute()), roundedIntSize(fragmentContainer.paddingBoxRect().size()));
if (fragmentAbsoluteRect.contains(absolutePoint))
return fragment;
if (fragment == endRegion)
break;
}
return nullptr;
}
IntRect roundedIntRect(const FloatRect& rect)
{
return IntRect(roundedIntPoint(rect.location()), roundedIntSize(rect.size()));
}
WebCore::IntSize WebView::viewSize()
{
return roundedIntSize(dipSize());
}
// Widgets are always placed on integer boundaries, so rounding the size is actually
// the desired behavior. This function is here because it's otherwise seldom what we
// want to do with a LayoutRect.
static inline IntRect roundedIntRect(const LayoutRect& rect)
{
return IntRect(roundedIntPoint(rect.location()), roundedIntSize(rect.size()));
}
static void getShapeImageAndRect(const ShapeValue& shapeValue, const RenderBox& renderBox, const LayoutSize& referenceBoxSize, Image*& image, LayoutRect& rect)
{
ASSERT(shapeValue.isImageValid());
StyleImage* styleImage = shapeValue.image();
const LayoutSize& imageSize = renderBox.calculateImageIntrinsicDimensions(styleImage, roundedIntSize(referenceBoxSize), RenderImage::ScaleByEffectiveZoom);
styleImage->setContainerSizeForRenderer(&renderBox, imageSize, renderBox.style().effectiveZoom());
image = nullptr;
if (styleImage->isCachedImage() || styleImage->isCachedImageSet())
image = styleImage->cachedImage()->imageForRenderer(&renderBox);
else if (styleImage->isGeneratedImage())
image = styleImage->image(const_cast<RenderBox*>(&renderBox), imageSize).get();
if (renderBox.isRenderImage())
rect = toRenderImage(&renderBox)->replacedContentRect(renderBox.intrinsicSize());
else
rect = LayoutRect(LayoutPoint(), imageSize);
}
PassOwnPtr<Shape> ShapeOutsideInfo::createShapeForImage(StyleImage* styleImage, float shapeImageThreshold, WritingMode writingMode, float margin) const
{
const IntSize& imageSize = m_layoutBox.calculateImageIntrinsicDimensions(styleImage, roundedIntSize(m_referenceBoxLogicalSize), LayoutImage::ScaleByEffectiveZoom);
styleImage->setContainerSizeForLayoutObject(&m_layoutBox, imageSize, m_layoutBox.style()->effectiveZoom());
const LayoutRect& marginRect = getShapeImageMarginRect(m_layoutBox, m_referenceBoxLogicalSize);
const LayoutRect& imageRect = (m_layoutBox.isLayoutImage())
? toLayoutImage(m_layoutBox).replacedContentRect()
: LayoutRect(LayoutPoint(), LayoutSize(imageSize));
if (!isValidRasterShapeRect(marginRect) || !isValidRasterShapeRect(imageRect)) {
m_layoutBox.document().addConsoleMessage(ConsoleMessage::create(RenderingMessageSource, ErrorMessageLevel, "The shape-outside image is too large."));
return Shape::createEmptyRasterShape(writingMode, margin);
}
ASSERT(!styleImage->isPendingImage());
RefPtr<Image> image = styleImage->image(const_cast<LayoutBox*>(&m_layoutBox), imageSize);
return Shape::createRasterShape(image.get(), shapeImageThreshold, imageRect, marginRect, writingMode, margin);
}
bool ImageQualityController::shouldPaintAtLowQuality(GraphicsContext* context, RenderObject* object, Image* image, const void *layer, const LayoutSize& layoutSize)
{
// If the image is not a bitmap image, then none of this is relevant and we just paint at high
// quality.
if (!image || !image->isBitmapImage())
return false;
if (object->style()->imageRendering() == ImageRenderingOptimizeContrast)
return true;
// Look ourselves up in the hashtables.
ObjectLayerSizeMap::iterator i = m_objectLayerSizeMap.find(object);
LayerSizeMap* innerMap = i != m_objectLayerSizeMap.end() ? &i->value : 0;
LayoutSize oldSize;
bool isFirstResize = true;
if (innerMap) {
LayerSizeMap::iterator j = innerMap->find(layer);
if (j != innerMap->end()) {
isFirstResize = false;
oldSize = j->value;
}
}
const AffineTransform& currentTransform = context->getCTM();
bool contextIsScaled = !currentTransform.isIdentityOrTranslationOrFlipped();
// Make sure to use the unzoomed image size, since if a full page zoom is in effect, the image
// is actually being scaled.
LayoutSize scaledImageSize = currentTransform.mapSize(image->size());
LayoutSize scaledLayoutSize = currentTransform.mapSize(roundedIntSize(layoutSize));
// If the containing FrameView is being resized, paint at low quality until resizing is finished.
if (LocalFrame* frame = object->document().frame()) {
bool frameViewIsCurrentlyInLiveResize = frame->view() && frame->view()->inLiveResize();
if (frameViewIsCurrentlyInLiveResize) {
set(object, innerMap, layer, scaledLayoutSize);
restartTimer();
m_liveResizeOptimizationIsActive = true;
return true;
}
if (m_liveResizeOptimizationIsActive) {
// Live resize has ended, paint in HQ and remove this object from the list.
removeLayer(object, innerMap, layer);
return false;
}
}
// See crbug.com/382491. This test is insufficient to ensure that there is no scale
// applied in the compositor, but it is probably adequate here. In the worst case we
// draw at high quality when we need not.
if (!contextIsScaled && scaledLayoutSize == scaledImageSize) {
// There is no scale in effect. If we had a scale in effect before, we can just remove this object from the list.
removeLayer(object, innerMap, layer);
return false;
}
// If an animated resize is active, paint in low quality and kick the timer ahead.
if (m_animatedResizeIsActive) {
set(object, innerMap, layer, scaledLayoutSize);
restartTimer();
return true;
}
// If this is the first time resizing this image, or its size is the
// same as the last resize, draw at high res, but record the paint
// size and set the timer.
if (isFirstResize || oldSize == scaledLayoutSize) {
restartTimer();
set(object, innerMap, layer, scaledLayoutSize);
return false;
}
// If the timer is no longer active, draw at high quality and don't
// set the timer.
if (!m_timer.isActive()) {
removeLayer(object, innerMap, layer);
return false;
}
// This object has been resized to two different sizes while the timer
// is active, so draw at low quality, set the flag for animated resizes and
// the object to the list for high quality redraw.
set(object, innerMap, layer, scaledLayoutSize);
m_animatedResizeIsActive = true;
restartTimer();
return true;
}
void ChromeClientJS::attachRootGraphicsLayer(Frame* frame, GraphicsLayer* rootLayer)
{
webkitTrace();
if(m_view->m_private->acceleratedContext) {
bool turningOffCompositing = !rootLayer && m_view->m_private->acceleratedContext->enabled();
bool turningOnCompositing = rootLayer && !m_view->m_private->acceleratedContext->enabled();
m_view->m_private->acceleratedContext->setRootCompositingLayer(rootLayer);
if (turningOnCompositing) {
m_displayTimer.stop();
m_view->m_private->backingStore = WidgetBackingStoreCairo::create(0, IntSize(1, 1));
}
if (turningOffCompositing) {
m_view->m_private->backingStore = WidgetBackingStoreCairo::create(m_view->m_private->sdl_screen, roundedIntSize(m_view->positionAndSize().size()));
RefPtr<cairo_t> cr = adoptRef(cairo_create(m_view->m_private->backingStore->cairoSurface()));
clearEverywhereInBackingStore(m_view, cr.get());
}
}
}
ChromeClientJS* ChromeClientJS::createClient(WebView *view) {
ChromeClientJS* client = new ChromeClientJS(view);
IntSize size = roundedIntSize(view->positionAndSize().size());
client->setWindowRect(FloatRect(0,0,size.width(),size.height()));
return client;
}