Changeset 221958 in webkit


Ignore:
Timestamp:
Sep 12, 2017 11:44:45 PM (7 years ago)
Author:
fred.wang@free.fr
Message:

Rename isRootLayer to isRenderViewLayer
https://bugs.webkit.org/show_bug.cgi?id=176684

Patch by Frederic Wang <fwang@igalia.com> on 2017-09-12
Reviewed by Darin Adler.

This patch was generated with the help of do-webcore-rename with some coding style adjustment.

No new tests, behavior unchanged.

  • rendering/RenderLayer.cpp:

(WebCore::RenderLayer::RenderLayer):
(WebCore::RenderLayer::enclosingTransformedAncestor const):
(WebCore::RenderLayer::enclosingFilterRepaintLayer const):
(WebCore::RenderLayer::setFilterBackendNeedsRepaintingInRect):
(WebCore::RenderLayer::clippingRootForPainting const):
(WebCore::RenderLayer::beginTransparencyLayers):
(WebCore::shouldSuppressPaintingLayer):
(WebCore::RenderLayer::paintFixedLayersInNamedFlows):
(WebCore::RenderLayer::hitTest):
(WebCore::RenderLayer::hitTestFixedLayersInNamedFlows):
(WebCore::RenderLayer::calculateClipRects const):

  • rendering/RenderLayer.h:
  • rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::RenderLayerBacking):
(WebCore::RenderLayerBacking::updateConfiguration):
(WebCore::RenderLayerBacking::updateAfterDescendants):
(WebCore::RenderLayerBacking::paintsIntoWindow const):
(WebCore::RenderLayerBacking::paintIntoLayer):

  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::logLayerInfo):
(WebCore::RenderLayerCompositor::needsCompositingUpdateForStyleChangeOnNonCompositedLayer const):
(WebCore::RenderLayerCompositor::updateBacking):
(WebCore::RenderLayerCompositor::repaintInCompositedAncestor):
(WebCore::RenderLayerCompositor::addToOverlapMap):
(WebCore::RenderLayerCompositor::computeCompositingRequirementsForNamedFlowFixed):
(WebCore::RenderLayerCompositor::computeCompositingRequirements):
(WebCore::RenderLayerCompositor::rebuildCompositingLayerTreeForNamedFlowFixed):
(WebCore::RenderLayerCompositor::rebuildCompositingLayerTree):
(WebCore::RenderLayerCompositor::needsToBeComposited const):
(WebCore::RenderLayerCompositor::requiresOwnBackingStore const): Also move the IOS condition
up to avoid that check-webkit-style complains.
(WebCore::RenderLayerCompositor::reasonsForCompositing const):
(WebCore::RenderLayerCompositor::useCoordinatedScrollingForLayer const):
(WebCore::RenderLayerCompositor::needsFixedRootBackgroundLayer const):
(WebCore::RenderLayerCompositor::updateScrollCoordinatedLayer):

Location:
trunk/Source/WebCore
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r221952 r221958  
     12017-09-12  Frederic Wang  <fwang@igalia.com>
     2
     3        Rename isRootLayer to isRenderViewLayer
     4        https://bugs.webkit.org/show_bug.cgi?id=176684
     5
     6        Reviewed by Darin Adler.
     7
     8        This patch was generated with the help of do-webcore-rename with some coding style adjustment.
     9
     10        No new tests, behavior unchanged.
     11
     12        * rendering/RenderLayer.cpp:
     13        (WebCore::RenderLayer::RenderLayer):
     14        (WebCore::RenderLayer::enclosingTransformedAncestor const):
     15        (WebCore::RenderLayer::enclosingFilterRepaintLayer const):
     16        (WebCore::RenderLayer::setFilterBackendNeedsRepaintingInRect):
     17        (WebCore::RenderLayer::clippingRootForPainting const):
     18        (WebCore::RenderLayer::beginTransparencyLayers):
     19        (WebCore::shouldSuppressPaintingLayer):
     20        (WebCore::RenderLayer::paintFixedLayersInNamedFlows):
     21        (WebCore::RenderLayer::hitTest):
     22        (WebCore::RenderLayer::hitTestFixedLayersInNamedFlows):
     23        (WebCore::RenderLayer::calculateClipRects const):
     24        * rendering/RenderLayer.h:
     25        * rendering/RenderLayerBacking.cpp:
     26        (WebCore::RenderLayerBacking::RenderLayerBacking):
     27        (WebCore::RenderLayerBacking::updateConfiguration):
     28        (WebCore::RenderLayerBacking::updateAfterDescendants):
     29        (WebCore::RenderLayerBacking::paintsIntoWindow const):
     30        (WebCore::RenderLayerBacking::paintIntoLayer):
     31        * rendering/RenderLayerCompositor.cpp:
     32        (WebCore::RenderLayerCompositor::logLayerInfo):
     33        (WebCore::RenderLayerCompositor::needsCompositingUpdateForStyleChangeOnNonCompositedLayer const):
     34        (WebCore::RenderLayerCompositor::updateBacking):
     35        (WebCore::RenderLayerCompositor::repaintInCompositedAncestor):
     36        (WebCore::RenderLayerCompositor::addToOverlapMap):
     37        (WebCore::RenderLayerCompositor::computeCompositingRequirementsForNamedFlowFixed):
     38        (WebCore::RenderLayerCompositor::computeCompositingRequirements):
     39        (WebCore::RenderLayerCompositor::rebuildCompositingLayerTreeForNamedFlowFixed):
     40        (WebCore::RenderLayerCompositor::rebuildCompositingLayerTree):
     41        (WebCore::RenderLayerCompositor::needsToBeComposited const):
     42        (WebCore::RenderLayerCompositor::requiresOwnBackingStore const): Also move the IOS condition
     43        up to avoid that check-webkit-style complains.
     44        (WebCore::RenderLayerCompositor::reasonsForCompositing const):
     45        (WebCore::RenderLayerCompositor::useCoordinatedScrollingForLayer const):
     46        (WebCore::RenderLayerCompositor::needsFixedRootBackgroundLayer const):
     47        (WebCore::RenderLayerCompositor::updateScrollCoordinatedLayer):
     48
    1492017-09-12  Wenson Hsieh  <wenson_hsieh@apple.com>
    250
  • trunk/Source/WebCore/rendering/RenderLayer.cpp

    r220806 r221958  
    268268
    269269RenderLayer::RenderLayer(RenderLayerModelObject& rendererLayerModelObject)
    270     : m_isRootLayer(rendererLayerModelObject.isRenderView())
     270    : m_isRenderViewLayer(rendererLayerModelObject.isRenderView())
    271271    , m_forcedStackingContext(rendererLayerModelObject.isMedia())
    272272    , m_inResizeMode(false)
     
    15271527{
    15281528    RenderLayer* curr = parent();
    1529     while (curr && !curr->isRootLayer() && !curr->transform())
     1529    while (curr && !curr->isRenderViewLayer() && !curr->transform())
    15301530        curr = curr->parent();
    15311531
     
    15941594{
    15951595    for (const RenderLayer* curr = this; curr; curr = curr->parent()) {
    1596         if ((curr != this && curr->requiresFullLayerImageForFilters()) || compositedWithOwnBackingStore(*curr) || curr->isRootLayer())
     1596        if ((curr != this && curr->requiresFullLayerImageForFilters()) || compositedWithOwnBackingStore(*curr) || curr->isRenderViewLayer())
    15971597            return const_cast<RenderLayer*>(curr);
    15981598    }
     
    16311631    }
    16321632   
    1633     if (parentLayer->isRootLayer()) {
     1633    if (parentLayer->isRenderViewLayer()) {
    16341634        downcast<RenderView>(parentLayer->renderer()).repaintViewRectangle(parentLayerRect);
    16351635        return;
     
    16551655    const RenderLayer* current = this;
    16561656    while (current) {
    1657         if (current->isRootLayer())
     1657        if (current->isRenderViewLayer())
    16581658            return const_cast<RenderLayer*>(current);
    16591659
     
    18241824
    18251825#if ENABLE(CSS_COMPOSITING)
    1826         bool usesCompositeOperation = hasBlendMode() && !(renderer().isSVGRoot() && parent() && parent()->isRootLayer());
     1826        bool usesCompositeOperation = hasBlendMode() && !(renderer().isSVGRoot() && parent() && parent()->isRenderViewLayer());
    18271827        if (usesCompositeOperation)
    18281828            context.setCompositeOperation(context.compositeOperation(), blendMode());
     
    39413941static inline bool shouldSuppressPaintingLayer(RenderLayer* layer)
    39423942{
    3943     if (layer->renderer().style().isNotFinal() && !layer->isRootLayer() && !layer->renderer().isDocumentElementRenderer())
     3943    if (layer->renderer().style().isNotFinal() && !layer->isRenderViewLayer() && !layer->renderer().isDocumentElementRenderer())
    39443944        return true;
    39453945
     
    42724272void RenderLayer::paintFixedLayersInNamedFlows(GraphicsContext& context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
    42734273{
    4274     if (!isRootLayer())
     4274    if (!isRenderViewLayer())
    42754275        return;
    42764276
     
    49464946        // return ourselves. We do this so mouse events continue getting delivered after a drag has
    49474947        // exited the WebView, and so hit testing over a scrollbar hits the content document.
    4948         if (!request.isChildFrameHitTest() && (request.active() || request.release()) && isRootLayer()) {
     4948        if (!request.isChildFrameHitTest() && (request.active() || request.release()) && isRenderViewLayer()) {
    49494949            renderer().updateHitTestResult(result, downcast<RenderView>(renderer()).flipForWritingMode(hitTestLocation.point()));
    49504950            insideLayer = this;
     
    50745074    bool depthSortDescendants)
    50755075{
    5076     if (!isRootLayer())
     5076    if (!isRenderViewLayer())
    50775077        return nullptr;
    50785078
     
    58835883    // FIXME: Could eliminate the isDocumentElementRenderer() check if we fix background painting so that the RenderView
    58845884    // paints the root's background.
    5885     if (isRootLayer() || renderer().isDocumentElementRenderer())
     5885    if (isRenderViewLayer() || renderer().isDocumentElementRenderer())
    58865886        return true;
    58875887
     
    60366036        return LayoutRect();
    60376037
    6038     if (isRootLayer()) {
     6038    if (isRenderViewLayer()) {
    60396039        // The root layer is always just the size of the document.
    60406040        return renderer().view().unscaledDocumentRect();
     
    65866586        || renderer().isEmbeddedObject()
    65876587        || renderer().isRenderIFrame()
    6588         || (renderer().style().specifiesColumns() && !isRootLayer())
     6588        || (renderer().style().specifiesColumns() && !isRenderViewLayer())
    65896589        || renderer().isInFlowRenderFlowThread();
    65906590}
  • trunk/Source/WebCore/rendering/RenderLayer.h

    r220806 r221958  
    294294    void setInResizeMode(bool b) { m_inResizeMode = b; }
    295295
    296     bool isRootLayer() const { return m_isRootLayer; }
     296    bool isRenderViewLayer() const { return m_isRenderViewLayer; }
    297297
    298298    RenderLayerCompositor& compositor() const;
     
    761761    // Non-auto z-index always implies stacking context here, because StyleResolver::adjustRenderStyle already adjusts z-index
    762762    // based on positioning and other criteria.
    763     bool isStackingContext(const RenderStyle* style) const { return !style->hasAutoZIndex() || isRootLayer() || m_forcedStackingContext; }
     763    bool isStackingContext(const RenderStyle* style) const { return !style->hasAutoZIndex() || isRenderViewLayer() || m_forcedStackingContext; }
    764764
    765765    bool isDirtyStackingContainer() const { return m_zOrderListsDirty && isStackingContainer(); }
     
    10471047    // The bitfields are up here so they will fall into the padding from ScrollableArea on 64-bit.
    10481048
    1049     const bool m_isRootLayer : 1;
     1049    const bool m_isRenderViewLayer : 1;
    10501050    const bool m_forcedStackingContext : 1;
    10511051
  • trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

    r221813 r221958  
    210210    : m_owningLayer(layer)
    211211{
    212     if (layer.isRootLayer()) {
     212    if (layer.isRenderViewLayer()) {
    213213        m_isMainFrameRenderViewLayer = renderer().frame().isMainFrame();
    214214        m_isFrameLayerWithTiledBacking = renderer().page().chrome().client().shouldUseTiledBackingForFrameView(renderer().view().frameView());
     
    721721    PaintedContentsInfo contentsInfo(*this);
    722722
    723     if (!m_owningLayer.isRootLayer()) {
     723    if (!m_owningLayer.isRenderViewLayer()) {
    724724        bool didUpdateContentsRect = false;
    725725        updateDirectlyCompositedBoxDecorations(contentsInfo, didUpdateContentsRect);
     
    12211221    contentsInfo.setWantsSubpixelAntialiasedTextState(GraphicsLayer::supportsSubpixelAntialiasedLayerText());
    12221222
    1223     if (!m_owningLayer.isRootLayer()) {
     1223    if (!m_owningLayer.isRenderViewLayer()) {
    12241224        bool didUpdateContentsRect = false;
    12251225        updateDirectlyCompositedBoxDecorations(contentsInfo, didUpdateContentsRect);
     
    24032403        return false;
    24042404
    2405     if (m_owningLayer.isRootLayer()) {
     2405    if (m_owningLayer.isRenderViewLayer()) {
    24062406#if PLATFORM(IOS) || USE(COORDINATED_GRAPHICS)
    24072407        if (compositor().inForcedCompositingMode())
     
    25562556
    25572557    FrameView::PaintingState paintingState;
    2558     if (m_owningLayer.isRootLayer())
     2558    if (m_owningLayer.isRenderViewLayer())
    25592559        renderer().view().frameView().willPaintContents(context, paintDirtyRect, paintingState);
    25602560
     
    25662566        m_owningLayer.paintLayerContents(context, paintingInfo, paintFlags | RenderLayer::PaintLayerPaintingOverlayScrollbars);
    25672567
    2568     if (m_owningLayer.isRootLayer())
     2568    if (m_owningLayer.isRenderViewLayer())
    25692569        renderer().view().frameView().didPaintContents(context, paintDirtyRect, paintingState);
    25702570
  • trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

    r221845 r221958  
    799799
    800800    RenderLayerBacking* backing = layer.backing();
    801     if (requiresCompositingLayer(layer) || layer.isRootLayer()) {
     801    if (requiresCompositingLayer(layer) || layer.isRenderViewLayer()) {
    802802        ++m_obligateCompositedLayerCount;
    803803        m_obligatoryBackingStoreBytes += backing->backingStoreMemoryEstimate();
     
    956956{
    957957    // Needed for scroll bars.
    958     if (layer.isRootLayer())
     958    if (layer.isRenderViewLayer())
    959959        return true;
    960960
     
    10241024            layer.ensureBacking();
    10251025
    1026             if (layer.isRootLayer() && useCoordinatedScrollingForLayer(layer)) {
     1026            if (layer.isRenderViewLayer() && useCoordinatedScrollingForLayer(layer)) {
    10271027                updateScrollCoordinatedStatus(layer, { ScrollingNodeChangeFlags::Layer, ScrollingNodeChangeFlags::LayerGeometry });
    10281028                if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
     
    11541154    // The contents of this layer may be moving from a GraphicsLayer to the window,
    11551155    // so we need to make sure the window system synchronizes those changes on the screen.
    1156     if (compositedAncestor->isRootLayer())
     1156    if (compositedAncestor->isRenderViewLayer())
    11571157        m_renderView.frameView().setNeedsOneShotDrawingSynchronization();
    11581158}
     
    12191219void RenderLayerCompositor::addToOverlapMap(OverlapMap& overlapMap, const RenderLayer& layer, OverlapExtent& extent)
    12201220{
    1221     if (layer.isRootLayer())
     1221    if (layer.isRenderViewLayer())
    12221222        return;
    12231223
     
    12741274void RenderLayerCompositor::computeCompositingRequirementsForNamedFlowFixed(RenderLayer& layer, OverlapMap& overlapMap, CompositingState& childState, bool& layersChanged, bool& anyDescendantHas3DTransform)
    12751275{
    1276     if (!layer.isRootLayer())
     1276    if (!layer.isRenderViewLayer())
    12771277        return;
    12781278
     
    13221322    // Use the fact that we're composited as a hint to check for an animating transform.
    13231323    // FIXME: Maybe needsToBeComposited() should return a bitmask of reasons, to avoid the need to recompute things.
    1324     if (willBeComposited && !layer.isRootLayer())
     1324    if (willBeComposited && !layer.isRenderViewLayer())
    13251325        layerExtent.hasTransformAnimation = isRunningTransformAnimation(layer.renderer());
    13261326
     
    14271427    }
    14281428
    1429     if (layer.isRootLayer())
     1429    if (layer.isRenderViewLayer())
    14301430        computeCompositingRequirementsForNamedFlowFixed(layer, overlapMap, childState, layersChanged, anyDescendantHas3DTransform);
    14311431
    14321432    // If we just entered compositing mode, the root will have become composited (as long as accelerated compositing is enabled).
    1433     if (layer.isRootLayer()) {
     1433    if (layer.isRenderViewLayer()) {
    14341434        if (inCompositingMode() && m_hasAcceleratedCompositing)
    14351435            willBeComposited = true;
     
    14431443    // FIXME: When layerExtent has taken animation bounds into account, we also know that the bounds
    14441444    // include descendants, so we don't need to add them all to the overlap map.
    1445     if (childState.compositingAncestor && !childState.compositingAncestor->isRootLayer())
     1445    if (childState.compositingAncestor && !childState.compositingAncestor->isRenderViewLayer())
    14461446        addToOverlapMap(overlapMap, layer, layerExtent);
    14471447
     
    14981498#endif
    14991499
    1500     if (childState.compositingAncestor == &layer && !layer.isRootLayer())
     1500    if (childState.compositingAncestor == &layer && !layer.isRenderViewLayer())
    15011501        overlapMap.popCompositingContainer();
    15021502
     
    15041504    // to be composited, then we can drop out of compositing mode altogether. However, don't drop out of compositing mode
    15051505    // if there are composited layers that we didn't hit in our traversal (e.g. because of visibility:hidden).
    1506     if (layer.isRootLayer() && !childState.subtreeIsCompositing && !requiresCompositingLayer(layer) && !m_forceCompositingMode && !hasAnyAdditionalCompositedLayers(layer)) {
     1506    if (layer.isRenderViewLayer() && !childState.subtreeIsCompositing && !requiresCompositingLayer(layer) && !m_forceCompositingMode && !hasAnyAdditionalCompositedLayers(layer)) {
    15071507        // Don't drop out of compositing on iOS, because we may flash. See <rdar://problem/8348337>.
    15081508#if !PLATFORM(IOS)
     
    15841584void RenderLayerCompositor::rebuildCompositingLayerTreeForNamedFlowFixed(RenderLayer& layer, Vector<GraphicsLayer*>& childGraphicsLayersOfEnclosingLayer, int depth)
    15851585{
    1586     if (!layer.isRootLayer())
     1586    if (!layer.isRenderViewLayer())
    15871587        return;
    15881588
     
    16701670    }
    16711671
    1672     if (layer.isRootLayer())
     1672    if (layer.isRenderViewLayer())
    16731673        rebuildCompositingLayerTreeForNamedFlowFixed(layer, childList, depth + 1);
    16741674
     
    21632163        return false;
    21642164
    2165     return requiresCompositingLayer(layer, viewportConstrainedNotCompositedReason) || layer.mustCompositeForIndirectReasons() || (inCompositingMode() && layer.isRootLayer());
     2165    return requiresCompositingLayer(layer, viewportConstrainedNotCompositedReason) || layer.mustCompositeForIndirectReasons() || (inCompositingMode() && layer.isRenderViewLayer());
    21662166}
    21672167
     
    22172217        return true;
    22182218
    2219     if (layer.isRootLayer()
     2219    if (layer.isRenderViewLayer()
    22202220        || layer.transform() // note: excludes perspective and transformStyle3D.
    22212221        || requiresCompositingForAnimation(renderer)
     
    22292229        || requiresCompositingForPlugin(renderer)
    22302230        || requiresCompositingForOverflowScrolling(layer)
     2231#if PLATFORM(IOS)
     2232        || requiresCompositingForScrolling(layer)
     2233#endif
    22312234        || renderer.isTransparent()
    22322235        || renderer.hasMask()
    22332236        || renderer.hasReflection()
    22342237        || renderer.hasFilter()
    2235         || renderer.hasBackdropFilter()
    2236 #if PLATFORM(IOS)
    2237         || requiresCompositingForScrolling(layer)
    2238 #endif
    2239         )
     2238        || renderer.hasBackdropFilter())
    22402239        return true;
    22412240
     
    23462345    }
    23472346
    2348     if (inCompositingMode() && renderer.layer()->isRootLayer())
     2347    if (inCompositingMode() && renderer.layer()->isRenderViewLayer())
    23492348        reasons |= CompositingReason::Root;
    23502349
     
    27542753bool RenderLayerCompositor::useCoordinatedScrollingForLayer(const RenderLayer& layer) const
    27552754{
    2756     if (layer.isRootLayer() && hasCoordinatedScrolling())
     2755    if (layer.isRenderViewLayer() && hasCoordinatedScrolling())
    27572756        return true;
    27582757
     
    29232922bool RenderLayerCompositor::needsFixedRootBackgroundLayer(const RenderLayer& layer) const
    29242923{
    2925     if (!layer.isRootLayer())
     2924    if (!layer.isRenderViewLayer())
    29262925        return false;
    29272926
     
    38943893        return;
    38953894
    3896     bool isRootLayer = layer.isRootLayer();
    3897 
    3898     if (!layer.parent() && !isRootLayer)
     3895    bool isRenderViewLayer = layer.isRenderViewLayer();
     3896
     3897    if (!layer.parent() && !isRenderViewLayer)
    38993898        return;
    39003899
     
    39123911
    39133912        updateScrollCoordinationForThisFrame(parentDocumentHostingNodeID);
    3914         if (!(reasons & ViewportConstrained) && isRootLayer)
     3913        if (!(reasons & ViewportConstrained) && isRenderViewLayer)
    39153914            return;
    39163915    }
    39173916
    39183917    ScrollingNodeID parentNodeID = enclosingScrollingNodeID(layer, ExcludeSelf);
    3919     if (!parentNodeID && !isRootLayer)
     3918    if (!parentNodeID && !isRenderViewLayer)
    39203919        return;
    39213920
     
    39593958       
    39603959    if (reasons & Scrolling) {
    3961         if (isRootLayer)
     3960        if (isRenderViewLayer)
    39623961            updateScrollCoordinationForThisFrame(parentNodeID);
    39633962        else {
Note: See TracChangeset for help on using the changeset viewer.