void RenderLayerModelObject::styleWillChange(StyleDifference diff, const RenderStyle* newStyle)
{
s_wasFloating = isFloating();
s_hadLayer = hasLayer();
s_hadTransform = hasTransform();
if (s_hadLayer)
s_layerWasSelfPainting = layer()->isSelfPaintingLayer();
// If our z-index changes value or our visibility changes,
// we need to dirty our stacking context's z-order list.
RenderStyle* oldStyle = style();
if (oldStyle && newStyle) {
if (parent()) {
// Do a repaint with the old style first, e.g., for example if we go from
// having an outline to not having an outline.
if (diff == StyleDifferenceRepaintLayer) {
layer()->repaintIncludingDescendants();
if (!(oldStyle->clip() == newStyle->clip()))
layer()->clearClipRectsIncludingDescendants();
} else if (diff == StyleDifferenceRepaint || newStyle->outlineSize() < oldStyle->outlineSize())
repaint();
}
if (diff == StyleDifferenceLayout || diff == StyleDifferenceSimplifiedLayout) {
// When a layout hint happens, we go ahead and do a repaint of the layer, since the layer could
// end up being destroyed.
if (hasLayer()) {
if (oldStyle->position() != newStyle->position()
|| oldStyle->zIndex() != newStyle->zIndex()
|| oldStyle->hasAutoZIndex() != newStyle->hasAutoZIndex()
|| !(oldStyle->clip() == newStyle->clip())
|| oldStyle->hasClip() != newStyle->hasClip()
|| oldStyle->opacity() != newStyle->opacity()
|| oldStyle->transform() != newStyle->transform()
#if ENABLE(CSS_FILTERS)
|| oldStyle->filter() != newStyle->filter()
#endif
)
layer()->repaintIncludingDescendants();
} else if (newStyle->hasTransform() || newStyle->opacity() < 1 || newStyle->hasFilter()) {
// If we don't have a layer yet, but we are going to get one because of transform or opacity,
// then we need to repaint the old position of the object.
repaint();
}
}
}
RenderObject::styleWillChange(diff, newStyle);
}
bool RenderWidget::setWidgetGeometry(const LayoutRect& frame)
{
if (!node())
return false;
IntRect clipRect = roundedIntRect(enclosingLayer()->childrenClipRect());
IntRect newFrame = roundedIntRect(frame);
bool clipChanged = m_clipRect != clipRect;
bool frameRectChanged = m_widget->frameRect() != newFrame;
if (!frameRectChanged && !clipChanged)
return false;
m_clipRect = clipRect;
RefPtr<RenderWidget> protector(this);
RefPtr<Node> protectedNode(node());
m_widget->setFrameRect(newFrame);
if (clipChanged && !frameRectChanged)
m_widget->clipRectChanged();
if (hasLayer() && layer()->compositingState() == PaintsIntoOwnBacking)
layer()->compositedLayerMapping()->updateAfterWidgetResize();
bool boundsChanged = m_widget->frameRect().size() != newFrame.size();
return boundsChanged;
}
void RenderBoxModelObject::contentChanged(ContentChangeType changeType)
{
if (!hasLayer())
return;
layer()->contentChanged(changeType);
}
void RenderLayerModelObject::styleWillChange(StyleDifference diff, const RenderStyle& newStyle)
{
s_wasFloating = isFloating();
// If our z-index changes value or our visibility changes,
// we need to dirty our stacking context's z-order list.
RenderStyle* oldStyle = style();
if (oldStyle) {
// Do a repaint with the old style first through RenderLayerRepainter.
// RenderObject::styleWillChange takes care of repainting objects without RenderLayers.
if (parent() && diff.needsRepaintLayer()) {
layer()->repainter().repaintIncludingNonCompositingDescendants();
if (oldStyle->hasClip() != newStyle.hasClip()
|| oldStyle->clip() != newStyle.clip())
layer()->clipper().clearClipRectsIncludingDescendants();
} else if (diff.needsFullLayout()) {
if (hasLayer()) {
if (!layer()->hasCompositedLayerMapping() && oldStyle->position() != newStyle.position())
layer()->repainter().repaintIncludingNonCompositingDescendants();
} else if (newStyle.hasTransform() || newStyle.opacity() < 1 || newStyle.hasFilter()) {
// If we don't have a layer yet, but we are going to get one because of transform or opacity,
// then we need to repaint the old position of the object.
paintInvalidationForWholeRenderer();
}
}
}
RenderObject::styleWillChange(diff, newStyle);
}
bool RenderWidget::setWidgetGeometry(const LayoutRect& frame)
{
IntRect clipRect = roundedIntRect(enclosingLayer()->childrenClipRect());
IntRect newFrameRect = roundedIntRect(frame);
IntRect oldFrameRect = m_widget->frameRect();
bool clipChanged = m_clipRect != clipRect;
bool boundsChanged = oldFrameRect != newFrameRect;
if (!boundsChanged && !clipChanged)
return false;
m_clipRect = clipRect;
WeakPtr<RenderWidget> weakThis = createWeakPtr();
// These calls *may* cause this renderer to disappear from underneath...
if (boundsChanged)
m_widget->setFrameRect(newFrameRect);
else if (clipChanged)
m_widget->clipRectChanged();
// ...so we follow up with a sanity check.
if (!weakThis)
return true;
#if USE(ACCELERATED_COMPOSITING)
if (boundsChanged && hasLayer() && layer()->isComposited())
layer()->backing()->updateAfterWidgetResize();
#endif
return oldFrameRect.size() != newFrameRect.size();
}
void RenderLayerModelObject::destroyLayer()
{
ASSERT(!hasLayer()); // Callers should have already called setHasLayer(false)
ASSERT(m_layer);
m_layer->destroy(renderArena());
m_layer = 0;
}
void Identification::destroyByLayer(const std::string& layer){
assert(hasLayer(layer));
std::queue<uint64_t> destroy;
for (uint64_t id : _layers[layer])
_engine.manager.destroyEntity(id);
}
void RenderWidget::destroy()
{
// We can't call the base class's destroy because we don't
// want to unconditionally delete ourselves (we're ref-counted).
// So the code below includes copied and pasted contents of
// both RenderBox::destroy() and RenderObject::destroy().
// Fix originally made for <rdar://problem/4228818>.
animation()->cancelAnimations(this);
if (RenderView* v = view())
v->removeWidget(this);
if (AXObjectCache::accessibilityEnabled()) {
document()->axObjectCache()->childrenChanged(this->parent());
document()->axObjectCache()->remove(this);
}
remove();
if (m_widget) {
if (m_view)
m_view->removeChild(m_widget);
widgetRendererMap().remove(m_widget);
}
// removes from override size map
if (hasOverrideSize())
setOverrideSize(-1);
RenderArena* arena = renderArena();
if (hasLayer())
layer()->clearClipRects();
if (style() && (style()->height().isPercent() || style()->minHeight().isPercent() || style()->maxHeight().isPercent()))
RenderBlock::removePercentHeightDescendant(this);
setNode(0);
if (hasLayer())
layer()->destroy(arena);
deref(arena);
}
uint64_t Identification::getByLayer(const std::string& layer, size_t number){
assert(hasLayer(layer) > number);
auto iter = _layers[layer].begin();
if (number)
std::advance(iter, number);
return *iter;
}
RenderLayerModelObject::~RenderLayerModelObject()
{
if (isPositioned()) {
if (style().hasViewportConstrainedPosition())
view().frameView().removeViewportConstrainedObject(this);
}
// Our layer should have been destroyed and cleared by now
ASSERT(!hasLayer());
ASSERT(!m_layer);
}
void RenderWidget::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
if (!shouldPaint(paintInfo, paintOffset))
return;
LayoutPoint adjustedPaintOffset = paintOffset + location();
if (hasBoxDecorations() && (paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection))
paintBoxDecorations(paintInfo, adjustedPaintOffset);
if (paintInfo.phase == PaintPhaseMask) {
paintMask(paintInfo, adjustedPaintOffset);
return;
}
if ((paintInfo.phase == PaintPhaseOutline || paintInfo.phase == PaintPhaseSelfOutline) && hasOutline())
paintOutline(paintInfo, LayoutRect(adjustedPaintOffset, size()));
if (paintInfo.phase != PaintPhaseForeground)
return;
#if PLATFORM(MAC)
if (style().highlight() != nullAtom && !paintInfo.context->paintingDisabled())
paintCustomHighlight(paintOffset, style().highlight(), true);
#endif
if (style().hasBorderRadius()) {
LayoutRect borderRect = LayoutRect(adjustedPaintOffset, size());
if (borderRect.isEmpty())
return;
// Push a clip if we have a border radius, since we want to round the foreground content that gets painted.
paintInfo.context->save();
RoundedRect roundedInnerRect = style().getRoundedInnerBorderFor(borderRect,
paddingTop() + borderTop(), paddingBottom() + borderBottom(), paddingLeft() + borderLeft(), paddingRight() + borderRight(), true, true);
clipRoundedInnerRect(paintInfo.context, borderRect, roundedInnerRect);
}
if (m_widget)
paintContents(paintInfo, paintOffset);
if (style().hasBorderRadius())
paintInfo.context->restore();
// Paint a partially transparent wash over selected widgets.
if (isSelected() && !document().printing()) {
// FIXME: selectionRect() is in absolute, not painting coordinates.
paintInfo.context->fillRect(pixelSnappedIntRect(selectionRect()), selectionBackgroundColor(), style().colorSpace());
}
if (hasLayer() && layer()->canResize())
layer()->paintResizer(paintInfo.context, roundedIntPoint(adjustedPaintOffset), paintInfo.rect);
}
bool removeLayer(const std::string &key)
{
if(hasLayer(key) == false)
{
return false;
}
delete layers[key];
layers.erase(key);
return true;
}
void defiFill::print(FILE* f) const {
int i, j;
struct defiPoints points;
if (hasLayer())
fprintf(f, "- LAYER %s", layerName());
if (layerMask())
fprintf(f, " + Mask %d", layerMask());
if (hasLayerOpc())
fprintf(f, " + OPC");
fprintf(f, "\n");
for (i = 0; i < numRectangles(); i++) {
fprintf(f, " RECT %d %d %d %d\n", xl(i),
yl(i), xh(i),
yh(i));
}
for (i = 0; i < numPolygons(); i++) {
fprintf(f, " POLYGON ");
points = getPolygon(i);
for (j = 0; j < points.numPoints; j++)
fprintf(f, "%d %d ", points.x[j], points.y[j]);
fprintf(f, "\n");
}
fprintf(f,"\n");
if (hasVia())
fprintf(f, "- VIA %s", viaName());
if (viaTopMask() || viaCutMask()
|| viaBottomMask()) {
fprintf(f, " + MASK %d", viaTopMask(),
viaCutMask(),
viaBottomMask());
}
if (hasViaOpc())
fprintf(f, " + OPC");
fprintf(f, "\n");
for (i = 0; i < numViaPts(); i++) {
fprintf(f, " ");
points = getViaPts(i);
for (j = 0; j < points.numPoints; j++)
fprintf(f, "%d %d ", points.x[j], points.y[j]);
fprintf(f, "\n");
}
fprintf(f,"\n");
}
GridMap<T>& addLayer(const std::string &key, const T &default_value)
{
if (hasLayer(key) == true)
{
throw std::out_of_range("LayeredGridMap::addLayer: The grid with the key '" + key + "' exists already.");
}
GridMap<T> *new_grid = new GridMap<T>(num_cells, resolution, default_value, this->getLocalMapData());
layers[key] = new_grid;
return *new_grid;
}
void RenderLayerModelObject::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
bool hadTransform = hasTransform();
bool hadLayer = hasLayer();
bool layerWasSelfPainting = hadLayer && layer()->isSelfPaintingLayer();
RenderObject::styleDidChange(diff, oldStyle);
updateFromStyle();
LayerType type = layerTypeRequired();
if (type != NoLayer) {
if (!layer() && layerCreationAllowedForSubtree()) {
if (s_wasFloating && isFloating())
setChildNeedsLayout();
createLayer(type);
if (parent() && !needsLayout()) {
// FIXME: We should call a specialized version of this function.
layer()->updateLayerPositionsAfterLayout();
}
}
} else if (layer() && layer()->parent()) {
setHasTransform(false); // Either a transform wasn't specified or the object doesn't support transforms, so just null out the bit.
setHasReflection(false);
layer()->removeOnlyThisLayer(); // calls destroyLayer() which clears m_layer
if (s_wasFloating && isFloating())
setChildNeedsLayout();
if (hadTransform)
setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
}
if (layer()) {
// FIXME: Ideally we shouldn't need this setter but we can't easily infer an overflow-only layer
// from the style.
layer()->setLayerType(type);
layer()->styleChanged(diff, oldStyle);
if (hadLayer && layer()->isSelfPaintingLayer() != layerWasSelfPainting)
setChildNeedsLayout();
}
if (FrameView *frameView = view()->frameView()) {
bool newStyleIsViewportConstained = style()->hasViewportConstrainedPosition();
bool oldStyleIsViewportConstrained = oldStyle && oldStyle->hasViewportConstrainedPosition();
if (newStyleIsViewportConstained != oldStyleIsViewportConstrained) {
if (newStyleIsViewportConstained && layer())
frameView->addViewportConstrainedObject(this);
else
frameView->removeViewportConstrainedObject(this);
}
}
}
GridMap<T>* getGridMapPtr(const std::string &key) const
{
GridMap<T>* grid = NULL;
if (hasLayer(key) == false)
throw std::out_of_range("The map does not contain the grid with the key '" + key + "'.");
grid = dynamic_cast<GridMap<T>*>(layers.at(key));
if (grid == NULL)
throw std::runtime_error("The grid with the key '" + key + "' is not of required type.");
return grid;
}
void RenderLayerModelObject::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
bool hadTransform = hasTransform();
bool hadLayer = hasLayer();
bool layerWasSelfPainting = hadLayer && layer()->isSelfPaintingLayer();
RenderObject::styleDidChange(diff, oldStyle);
updateFromStyle();
if (requiresLayer()) {
if (!layer() && layerCreationAllowedForSubtree()) {
if (s_wasFloating && isFloating())
setChildNeedsLayout();
createLayer();
if (parent() && !needsLayout() && containingBlock()) {
layer()->repainter().setRepaintStatus(NeedsFullRepaint);
// There is only one layer to update, it is not worth using |cachedOffset| since
// we are not sure the value will be used.
layer()->updateLayerPositions(0);
}
}
} else if (layer() && layer()->parent()) {
setHasTransform(false); // Either a transform wasn't specified or the object doesn't support transforms, so just null out the bit.
setHasReflection(false);
layer()->removeOnlyThisLayer(); // calls destroyLayer() which clears m_layer
if (s_wasFloating && isFloating())
setChildNeedsLayout();
if (hadTransform)
setNeedsLayoutAndPrefWidthsRecalc();
}
if (layer()) {
layer()->styleChanged(diff, oldStyle);
if (hadLayer && layer()->isSelfPaintingLayer() != layerWasSelfPainting)
setChildNeedsLayout();
}
if (FrameView *frameView = view()->frameView()) {
bool newStyleIsViewportConstained = style()->hasViewportConstrainedPosition();
bool oldStyleIsViewportConstrained = oldStyle && oldStyle->hasViewportConstrainedPosition();
if (newStyleIsViewportConstained != oldStyleIsViewportConstrained) {
if (newStyleIsViewportConstained && layer())
frameView->addViewportConstrainedObject(this);
else
frameView->removeViewportConstrainedObject(this);
}
}
}
void RenderReplaced::setSelectionState(SelectionState state)
{
// The selection state for our containing block hierarchy is updated by the base class call.
RenderBox::setSelectionState(state);
if (!inlineBoxWrapper())
return;
// We only include the space below the baseline in our layer's cached paint invalidation rect if the
// image is selected. Since the selection state has changed update the rect.
if (hasLayer())
setPreviousPaintInvalidationRect(boundsRectForPaintInvalidation(containerForPaintInvalidation()));
if (canUpdateSelectionOnRootLineBoxes())
inlineBoxWrapper()->root().setHasSelectedChildren(isSelected());
}
void RenderWidget::willBeDestroyed()
{
#if PLATFORM(IOS)
if (hasLayer())
layer()->willBeDestroyed();
#endif
if (AXObjectCache* cache = document().existingAXObjectCache()) {
cache->childrenChanged(this->parent());
cache->remove(this);
}
setWidget(nullptr);
RenderReplaced::willBeDestroyed();
}
//Creates our vulkan instance and returns an error if it fails
VkResult gvkInitUtils::initVulkan(VkInstance * inst)
{
VkApplicationInfo appinfo = {};
appinfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appinfo.pNext = nullptr;
appinfo.pApplicationName = "TODO: CHANGE THIS";
appinfo.pEngineName = "VKEngine";
appinfo.apiVersion = VK_API_VERSION_1_0;
appinfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appinfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
std::vector<const char *> enableExtensions = { VK_KHR_SURFACE_EXTENSION_NAME};
#ifdef _WIN32
enableExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
#elif defined(__linux__)
enableExtensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
#endif
VkInstanceCreateInfo instCrInfo = {};
instCrInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instCrInfo.pApplicationInfo = &appinfo;
instCrInfo.pNext = nullptr;
#ifdef _DEBUG
std::array<const char*, 1> enabledLayers = {"VK_LAYER_LUNARG_standard_validation" };
if (!hasLayer("VK_LAYER_LUNARG_standard_validation")) {
std::cerr << "ERROR REQUIRED LAYER DOES NOT EXIST" << std::endl;
return VK_ERROR_INCOMPATIBLE_DRIVER;
}
enableExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
instCrInfo.enabledLayerCount = enabledLayers.size();
instCrInfo.ppEnabledLayerNames = enabledLayers.data();
if (!hasExtension(VK_EXT_DEBUG_REPORT_EXTENSION_NAME, "VK_LAYER_LUNARG_standard_validation")) {
std::cerr << "ERROR: REQUIRED EXTENSION DOES NOT EXIST" << std::endl;
return VK_ERROR_INCOMPATIBLE_DRIVER;
}
#else
instCrInfo.enabledLayerCount = 0;
instCrInfo.ppEnabledLayerNames = nullptr;
#endif
instCrInfo.flags = 0;
instCrInfo.enabledExtensionCount = enableExtensions.size();
instCrInfo.ppEnabledExtensionNames = enableExtensions.data();
return vkCreateInstance(&instCrInfo, nullptr, inst);
}
void RenderLayerModelObject::addLayerHitTestRects(LayerHitTestRects& rects, const RenderLayer* currentLayer, const LayoutPoint& layerOffset, const LayoutRect& containerRect) const
{
if (hasLayer()) {
if (isRenderView()) {
// RenderView is handled with a special fast-path, but it needs to know the current layer.
RenderObject::addLayerHitTestRects(rects, layer(), LayoutPoint(), LayoutRect());
} else {
// Since a RenderObject never lives outside it's container RenderLayer, we can switch
// to marking entire layers instead. This may sometimes mark more than necessary (when
// a layer is made of disjoint objects) but in practice is a significant performance
// savings.
layer()->addLayerHitTestRects(rects);
}
} else {
RenderObject::addLayerHitTestRects(rects, currentLayer, layerOffset, containerRect);
}
}
void LayoutReplaced::setSelectionState(SelectionState state) {
// The selection state for our containing block hierarchy is updated by the
// base class call.
LayoutBox::setSelectionState(state);
if (!inlineBoxWrapper())
return;
// We only include the space below the baseline in our layer's cached paint
// invalidation rect if the image is selected. Since the selection state has
// changed update the rect.
if (hasLayer()) {
LayoutRect rect = localVisualRect();
PaintLayer::mapRectToPaintInvalidationBacking(
*this, containerForPaintInvalidation(), rect);
setPreviousVisualRect(rect);
}
if (canUpdateSelectionOnRootLineBoxes())
inlineBoxWrapper()->root().setHasSelectedChildren(state != SelectionNone);
}
const RenderObject* RenderBoxModelObject::pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
{
ASSERT(ancestorToStopAt != this);
bool ancestorSkipped;
RenderObject* container = this->container(ancestorToStopAt, &ancestorSkipped);
if (!container)
return 0;
bool isInline = isRenderInline();
bool isFixedPos = !isInline && style()->position() == FixedPosition;
bool hasTransform = !isInline && hasLayer() && layer()->transform();
LayoutSize adjustmentForSkippedAncestor;
if (ancestorSkipped) {
// There can't be a transform between paintInvalidationContainer and o, because transforms create containers, so it should be safe
// to just subtract the delta between the ancestor and o.
adjustmentForSkippedAncestor = -ancestorToStopAt->offsetFromAncestorContainer(container);
}
bool offsetDependsOnPoint = false;
LayoutSize containerOffset = offsetFromContainer(container, LayoutPoint(), &offsetDependsOnPoint);
bool preserve3D = container->style()->preserves3D() || style()->preserves3D();
if (shouldUseTransformFromContainer(container)) {
TransformationMatrix t;
getTransformFromContainer(container, containerOffset, t);
t.translateRight(adjustmentForSkippedAncestor.width().toFloat(), adjustmentForSkippedAncestor.height().toFloat());
geometryMap.push(this, t, preserve3D, offsetDependsOnPoint, isFixedPos, hasTransform);
} else {
containerOffset += adjustmentForSkippedAncestor;
geometryMap.push(this, containerOffset, preserve3D, offsetDependsOnPoint, isFixedPos, hasTransform);
}
return ancestorSkipped ? ancestorToStopAt : container;
}
RenderLayerModelObject::~RenderLayerModelObject()
{
// Our layer should have been destroyed and cleared by now
ASSERT(!hasLayer());
ASSERT(!m_layer);
}
void RenderReplaced::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
ANNOTATE_GRAPHICS_CONTEXT(paintInfo, this);
if (!shouldPaint(paintInfo, paintOffset))
return;
LayoutPoint adjustedPaintOffset = paintOffset + location();
if (hasBoxDecorationBackground() && (paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection))
paintBoxDecorationBackground(paintInfo, adjustedPaintOffset);
if (paintInfo.phase == PaintPhaseMask) {
paintMask(paintInfo, adjustedPaintOffset);
return;
}
if (paintInfo.phase == PaintPhaseClippingMask && (!hasLayer() || !layer()->hasCompositedClippingMask()))
return;
LayoutRect paintRect = LayoutRect(adjustedPaintOffset, size());
if ((paintInfo.phase == PaintPhaseOutline || paintInfo.phase == PaintPhaseSelfOutline) && style()->outlineWidth())
paintOutline(paintInfo, paintRect);
if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection && !canHaveChildren() && paintInfo.phase != PaintPhaseClippingMask)
return;
if (!paintInfo.shouldPaintWithinRoot(this))
return;
bool drawSelectionTint = selectionState() != SelectionNone && !document().printing();
if (paintInfo.phase == PaintPhaseSelection) {
if (selectionState() == SelectionNone)
return;
drawSelectionTint = false;
}
bool completelyClippedOut = false;
if (style()->hasBorderRadius()) {
LayoutRect borderRect = LayoutRect(adjustedPaintOffset, size());
if (borderRect.isEmpty())
completelyClippedOut = true;
else {
// Push a clip if we have a border radius, since we want to round the foreground content that gets painted.
paintInfo.context->save();
RoundedRect roundedInnerRect = style()->getRoundedInnerBorderFor(paintRect,
paddingTop() + borderTop(), paddingBottom() + borderBottom(), paddingLeft() + borderLeft(), paddingRight() + borderRight(), true, true);
clipRoundedInnerRect(paintInfo.context, paintRect, roundedInnerRect);
}
}
if (!completelyClippedOut) {
if (paintInfo.phase == PaintPhaseClippingMask) {
paintClippingMask(paintInfo, adjustedPaintOffset);
} else {
paintReplaced(paintInfo, adjustedPaintOffset);
}
if (style()->hasBorderRadius())
paintInfo.context->restore();
}
// The selection tint never gets clipped by border-radius rounding, since we want it to run right up to the edges of
// surrounding content.
if (drawSelectionTint) {
LayoutRect selectionPaintingRect = localSelectionRect();
selectionPaintingRect.moveBy(adjustedPaintOffset);
paintInfo.context->fillRect(pixelSnappedIntRect(selectionPaintingRect), selectionBackgroundColor());
}
}