Changeset 142647 in webkit


Ignore:
Timestamp:
Feb 12, 2013 11:35:01 AM (11 years ago)
Author:
esprehn@chromium.org
Message:

rootRenderer in FrameView is really RenderView
​https://bugs.webkit.org/show_bug.cgi?id=109510

Reviewed by Eric Seidel.

The global function rootRenderer(FrameView*) is really just a way
to get the RenderView from the Frame so replace it with a renderView()
method and replace usage of the word "root" with renderView so it's
obvious the root we're talking about is the renderView. This is an
important distinction to make since we also have rootRenderer in the code
for the documentElement()'s renderer and we also have a "layout root" which
is entirely different.

No new tests, just refactoring.

  • page/FrameView.cpp:

(WebCore::FrameView::rootRenderer): Removed.
(WebCore::FrameView::setFrameRect):
(WebCore::FrameView::adjustViewSize):
(WebCore::FrameView::updateCompositingLayersAfterStyleChange):
(WebCore::FrameView::updateCompositingLayersAfterLayout):
(WebCore::FrameView::clearBackingStores):
(WebCore::FrameView::restoreBackingStores):
(WebCore::FrameView::usesCompositedScrolling):
(WebCore::FrameView::layerForHorizontalScrollbar):
(WebCore::FrameView::layerForVerticalScrollbar):
(WebCore::FrameView::layerForScrollCorner):
(WebCore::FrameView::tiledBacking):
(WebCore::FrameView::scrollLayerID):
(WebCore::FrameView::layerForOverhangAreas):
(WebCore::FrameView::flushCompositingStateForThisFrame):
(WebCore::FrameView::hasCompositedContent):
(WebCore::FrameView::enterCompositingMode):
(WebCore::FrameView::isSoftwareRenderable):
(WebCore::FrameView::didMoveOnscreen):
(WebCore::FrameView::willMoveOffscreen):
(WebCore::FrameView::layout):
(WebCore::FrameView::embeddedContentBox):
(WebCore::FrameView::contentsInCompositedLayer):
(WebCore::FrameView::scrollContentsFastPath):
(WebCore::FrameView::scrollContentsSlowPath):
(WebCore::FrameView::maintainScrollPositionAtAnchor):
(WebCore::FrameView::scrollPositionChanged):
(WebCore::FrameView::repaintFixedElementsAfterScrolling):
(WebCore::FrameView::updateFixedElementsAfterScrolling):
(WebCore::FrameView::visibleContentsResized):
(WebCore::FrameView::scheduleRelayoutOfSubtree):
(WebCore::FrameView::needsLayout):
(WebCore::FrameView::setNeedsLayout):
(WebCore::FrameView::performPostLayoutTasks):
(WebCore::FrameView::updateControlTints):
(WebCore::FrameView::paintContents):
(WebCore::FrameView::forceLayoutForPagination):
(WebCore::FrameView::adjustPageHeightDeprecated):
(WebCore::FrameView::resetTrackedRepaints):
(WebCore::FrameView::isVerticalDocument):
(WebCore::FrameView::isFlippedDocument):

  • page/FrameView.h:

(WebCore::FrameView::renderView): Added.

Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r142646 r142647  
     12013-02-12  Elliott Sprehn  <esprehn@chromium.org>
     2
     3        rootRenderer in FrameView is really RenderView
     4        https://bugs.webkit.org/show_bug.cgi?id=109510
     5
     6        Reviewed by Eric Seidel.
     7
     8        The global function rootRenderer(FrameView*) is really just a way
     9        to get the RenderView from the Frame so replace it with a renderView()
     10        method and replace usage of the word "root" with renderView so it's
     11        obvious the root we're talking about is the renderView. This is an
     12        important distinction to make since we also have rootRenderer in the code
     13        for the documentElement()'s renderer and we also have a "layout root" which
     14        is entirely different.
     15
     16        No new tests, just refactoring.
     17
     18        * page/FrameView.cpp:
     19        (WebCore::FrameView::rootRenderer): Removed.
     20        (WebCore::FrameView::setFrameRect):
     21        (WebCore::FrameView::adjustViewSize):
     22        (WebCore::FrameView::updateCompositingLayersAfterStyleChange):
     23        (WebCore::FrameView::updateCompositingLayersAfterLayout):
     24        (WebCore::FrameView::clearBackingStores):
     25        (WebCore::FrameView::restoreBackingStores):
     26        (WebCore::FrameView::usesCompositedScrolling):
     27        (WebCore::FrameView::layerForHorizontalScrollbar):
     28        (WebCore::FrameView::layerForVerticalScrollbar):
     29        (WebCore::FrameView::layerForScrollCorner):
     30        (WebCore::FrameView::tiledBacking):
     31        (WebCore::FrameView::scrollLayerID):
     32        (WebCore::FrameView::layerForOverhangAreas):
     33        (WebCore::FrameView::flushCompositingStateForThisFrame):
     34        (WebCore::FrameView::hasCompositedContent):
     35        (WebCore::FrameView::enterCompositingMode):
     36        (WebCore::FrameView::isSoftwareRenderable):
     37        (WebCore::FrameView::didMoveOnscreen):
     38        (WebCore::FrameView::willMoveOffscreen):
     39        (WebCore::FrameView::layout):
     40        (WebCore::FrameView::embeddedContentBox):
     41        (WebCore::FrameView::contentsInCompositedLayer):
     42        (WebCore::FrameView::scrollContentsFastPath):
     43        (WebCore::FrameView::scrollContentsSlowPath):
     44        (WebCore::FrameView::maintainScrollPositionAtAnchor):
     45        (WebCore::FrameView::scrollPositionChanged):
     46        (WebCore::FrameView::repaintFixedElementsAfterScrolling):
     47        (WebCore::FrameView::updateFixedElementsAfterScrolling):
     48        (WebCore::FrameView::visibleContentsResized):
     49        (WebCore::FrameView::scheduleRelayoutOfSubtree):
     50        (WebCore::FrameView::needsLayout):
     51        (WebCore::FrameView::setNeedsLayout):
     52        (WebCore::FrameView::performPostLayoutTasks):
     53        (WebCore::FrameView::updateControlTints):
     54        (WebCore::FrameView::paintContents):
     55        (WebCore::FrameView::forceLayoutForPagination):
     56        (WebCore::FrameView::adjustPageHeightDeprecated):
     57        (WebCore::FrameView::resetTrackedRepaints):
     58        (WebCore::FrameView::isVerticalDocument):
     59        (WebCore::FrameView::isFlippedDocument):
     60        * page/FrameView.h:
     61        (WebCore::FrameView::renderView): Added.
     62
    1632013-02-12  Tomas Popela  <tpopela@redhat.com>
    264

  • trunk/Source/WebCore/page/FrameView.cpp

    r142638 r142647  
    125125static const unsigned maxUpdateWidgetsIterations = 2;
    126126
    127 static inline RenderView* rootRenderer(const FrameView* view)
    128 {
    129     return view->frame() ? view->frame()->contentRenderer() : 0;
    130 }
    131 
    132127static RenderLayer::UpdateLayerPositionsFlags updateLayerPositionFlags(RenderLayer* layer, bool isRelayoutingSubtree, bool didFullRepaint)
    133128{
    … …  
    455450
    456451#if USE(ACCELERATED_COMPOSITING)
    457     if (RenderView* root = rootRenderer(this)) {
    458         if (root->usesCompositing())
    459             root->compositor()->frameViewDidChangeSize();
     452    if (RenderView* renderView = this->renderView()) {
     453        if (renderView->usesCompositing())
     454            renderView->compositor()->frameViewDidChangeSize();
    460455    }
    461456#endif
    … …  
    574569void FrameView::adjustViewSize()
    575570{
    576     RenderView* root = rootRenderer(this);
    577     if (!root)
     571    RenderView* renderView = this->renderView();
     572    if (!renderView)
    578573        return;
    579574
    580575    ASSERT(m_frame->view() == this);
    581576
    582     const IntRect rect = root->documentRect();
     577    const IntRect rect = renderView->documentRect();
    583578    const IntSize& size = rect.size();
    584579    ScrollView::setScrollOrigin(IntPoint(-rect.x(), -rect.y()), !m_frame->document()->printing(), size == contentsSize());
    … …  
    725720void FrameView::updateCompositingLayersAfterStyleChange()
    726721{
    727     RenderView* root = rootRenderer(this);
    728     if (!root)
     722    RenderView* renderView = this->renderView();
     723    if (!renderView)
    729724        return;
    730725
    731726    // If we expect to update compositing after an incipient layout, don't do so here.
    732     if (m_doingPreLayoutStyleUpdate || layoutPending() || root->needsLayout())
     727    if (m_doingPreLayoutStyleUpdate || layoutPending() || renderView->needsLayout())
    733728        return;
    734729
    735730    // This call will make sure the cached hasAcceleratedCompositing is updated from the pref
    736     root->compositor()->cacheAcceleratedCompositingFlags();
    737     root->compositor()->updateCompositingLayers(CompositingUpdateAfterStyleChange);
     731    renderView->compositor()->cacheAcceleratedCompositingFlags();
     732    renderView->compositor()->updateCompositingLayers(CompositingUpdateAfterStyleChange);
    738733}
    739734
    740735void FrameView::updateCompositingLayersAfterLayout()
    741736{
    742     RenderView* root = rootRenderer(this);
    743     if (!root)
     737    RenderView* renderView = this->renderView();
     738    if (!renderView)
    744739        return;
    745740
    746741    // This call will make sure the cached hasAcceleratedCompositing is updated from the pref
    747     root->compositor()->cacheAcceleratedCompositingFlags();
    748     root->compositor()->updateCompositingLayers(CompositingUpdateAfterLayout);
     742    renderView->compositor()->cacheAcceleratedCompositingFlags();
     743    renderView->compositor()->updateCompositingLayers(CompositingUpdateAfterLayout);
    749744}
    750745
    751746void FrameView::clearBackingStores()
    752747{
    753     RenderView* root = rootRenderer(this);
    754     if (!root)
    755         return;
    756 
    757     RenderLayerCompositor* compositor = root->compositor();
     748    RenderView* renderView = this->renderView();
     749    if (!renderView)
     750        return;
     751
     752    RenderLayerCompositor* compositor = renderView->compositor();
    758753    ASSERT(compositor->inCompositingMode());
    759754    compositor->enableCompositingMode(false);
    … …  
    763758void FrameView::restoreBackingStores()
    764759{
    765     RenderView* root = rootRenderer(this);
    766     if (!root)
    767         return;
    768 
    769     RenderLayerCompositor* compositor = root->compositor();
     760    RenderView* renderView = this->renderView();
     761    if (!renderView)
     762        return;
     763
     764    RenderLayerCompositor* compositor = renderView->compositor();
    770765    compositor->enableCompositingMode(true);
    771766    compositor->updateCompositingLayers(CompositingUpdateAfterLayout);
    … …  
    774769bool FrameView::usesCompositedScrolling() const
    775770{
    776     if (m_frame->settings() && m_frame->settings()->compositedScrollingForFramesEnabled()) {
    777         RenderView* root = rootRenderer(this);
    778         return root && root->compositor()->inForcedCompositingMode();
    779     }
     771    RenderView* renderView = this->renderView();
     772    if (!renderView)
     773        return false;
     774    if (m_frame->settings() && m_frame->settings()->compositedScrollingForFramesEnabled())
     775        return renderView->compositor()->inForcedCompositingMode();
    780776    return false;
    781777}
    … …  
    783779GraphicsLayer* FrameView::layerForHorizontalScrollbar() const
    784780{
    785     RenderView* root = rootRenderer(this);
    786     if (!root)
     781    RenderView* renderView = this->renderView();
     782    if (!renderView)
    787783        return 0;
    788     return root->compositor()->layerForHorizontalScrollbar();
     784    return renderView->compositor()->layerForHorizontalScrollbar();
    789785}
    790786
    791787GraphicsLayer* FrameView::layerForVerticalScrollbar() const
    792788{
    793     RenderView* root = rootRenderer(this);
    794     if (!root)
     789    RenderView* renderView = this->renderView();
     790    if (!renderView)
    795791        return 0;
    796     return root->compositor()->layerForVerticalScrollbar();
     792    return renderView->compositor()->layerForVerticalScrollbar();
    797793}
    798794
    799795GraphicsLayer* FrameView::layerForScrollCorner() const
    800796{
    801     RenderView* root = rootRenderer(this);
    802     if (!root)
     797    RenderView* renderView = this->renderView();
     798    if (!renderView)
    803799        return 0;
    804     return root->compositor()->layerForScrollCorner();
     800    return renderView->compositor()->layerForScrollCorner();
    805801}
    806802
    807803TiledBacking* FrameView::tiledBacking()
    808804{
    809     RenderView* root = rootRenderer(this);
    810     if (!root)
     805    RenderView* renderView = this->renderView();
     806    if (!renderView)
    811807        return 0;
    812808
    813     RenderLayerBacking* backing = root->layer()->backing();
     809    RenderLayerBacking* backing = renderView->layer()->backing();
    814810    if (!backing)
    815811        return 0;
    … …  
    820816uint64_t FrameView::scrollLayerID() const
    821817{
    822     RenderView* root = rootRenderer(this);
    823     if (!root)
     818    RenderView* renderView = this->renderView();
     819    if (!renderView)
    824820        return 0;
    825821
    826     RenderLayerBacking* backing = root->layer()->backing();
     822    RenderLayerBacking* backing = renderView->layer()->backing();
    827823    if (!backing)
    828824        return 0;
    … …  
    834830GraphicsLayer* FrameView::layerForOverhangAreas() const
    835831{
    836     RenderView* root = rootRenderer(this);
    837     if (!root)
     832    RenderView* renderView = this->renderView();
     833    if (!renderView)
    838834        return 0;
    839     return root->compositor()->layerForOverhangAreas();
     835    return renderView->compositor()->layerForOverhangAreas();
    840836}
    841837#endif
    … …  
    843839bool FrameView::flushCompositingStateForThisFrame(Frame* rootFrameForFlush)
    844840{
    845     RenderView* root = rootRenderer(this);
    846     if (!root)
     841    RenderView* renderView = this->renderView();
     842    if (!renderView)
    847843        return true; // We don't want to keep trying to update layers if we have no renderer.
    848844
    … …  
    858854    flushDeferredRepaints();
    859855
    860     root->compositor()->flushPendingLayerChanges(rootFrameForFlush == m_frame);
     856    renderView->compositor()->flushPendingLayerChanges(rootFrameForFlush == m_frame);
    861857
    862858    return true;
    … …  
    875871{
    876872#if USE(ACCELERATED_COMPOSITING)
    877     if (RenderView* root = rootRenderer(this))
    878         return root->compositor()->inCompositingMode();
     873    if (RenderView* renderView = this->renderView())
     874        return renderView->compositor()->inCompositingMode();
    879875#endif
    880876    return false;
    … …  
    916912{
    917913#if USE(ACCELERATED_COMPOSITING)
    918     if (RenderView* root = rootRenderer(this)) {
    919         root->compositor()->enableCompositingMode();
     914    if (RenderView* renderView = this->renderView()) {
     915        renderView->compositor()->enableCompositingMode();
    920916        if (!needsLayout())
    921             root->compositor()->scheduleCompositingLayerUpdate();
     917            renderView->compositor()->scheduleCompositingLayerUpdate();
    922918    }
    923919#endif
    … …  
    955951{
    956952#if USE(ACCELERATED_COMPOSITING)
    957     RenderView* root = rootRenderer(this);
    958     if (!root)
    959         return true;
    960 
    961     return !root->compositor()->has3DContent();
     953    RenderView* renderView = this->renderView();
     954    return !renderView || !renderView->compositor()->has3DContent();
    962955#else
    963956    return true;
    … …  
    967960void FrameView::didMoveOnscreen()
    968961{
    969     if (RenderView* root = rootRenderer(this))
    970         root->didMoveOnscreen();
     962    if (RenderView* renderView = this->renderView())
     963        renderView->didMoveOnscreen();
    971964    contentAreaDidShow();
    972965}
    … …  
    974967void FrameView::willMoveOffscreen()
    975968{
    976     if (RenderView* root = rootRenderer(this))
    977         root->willMoveOffscreen();
     969    if (RenderView* renderView = this->renderView())
     970        renderView->willMoveOffscreen();
    978971    contentAreaDidHide();
    979972}
    … …  
    12461239                                 // to work out most of the time, since first layouts and printing don't have you scrolled anywhere.
    12471240
    1248     layer->updateLayerPositionsAfterLayout(rootRenderer(this)->layer(), updateLayerPositionFlags(layer, subtree, m_doFullRepaint));
     1241    layer->updateLayerPositionsAfterLayout(renderView()->layer(), updateLayerPositionFlags(layer, subtree, m_doFullRepaint));
    12491242
    12501243    endDeferredRepaints();
    … …  
    12751268        if (!m_inSynchronousPostLayout) {
    12761269            if (inChildFrameLayoutWithFrameFlattening) {
    1277                 if (RenderView* root = rootRenderer(this))
    1278                     root->updateWidgetPositions();
     1270                if (RenderView* renderView = this->renderView())
     1271                    renderView->updateWidgetPositions();
    12791272            } else {
    12801273                m_inSynchronousPostLayout = true;
    … …  
    13161309{
    13171310#if ENABLE(SVG)
    1318     RenderView* root = rootRenderer(this);
    1319     if (!root)
     1311    RenderView* renderView = this->renderView();
     1312    if (!renderView)
    13201313        return 0;
    13211314
    1322     RenderObject* rootChild = root->firstChild();
    1323     if (!rootChild || !rootChild->isBox())
     1315    RenderObject* firstChild = renderView->firstChild();
     1316    if (!firstChild || !firstChild->isBox())
    13241317        return 0;
    13251318
    13261319    // Curently only embedded SVG documents participate in the size-negotiation logic.
    1327     if (rootChild->isSVGRoot())
    1328         return toRenderBox(rootChild);
     1320    if (firstChild->isSVGRoot())
     1321        return toRenderBox(firstChild);
    13291322#endif
    13301323
    … …  
    14281421{
    14291422#if USE(ACCELERATED_COMPOSITING)
    1430     RenderView* root = rootRenderer(this);
    1431     if (root && root->isComposited()) {
    1432         GraphicsLayer* layer = root->layer()->backing()->graphicsLayer();
     1423    RenderView* renderView = this->renderView();
     1424    if (renderView && renderView->isComposited()) {
     1425        GraphicsLayer* layer = renderView->layer()->backing()->graphicsLayer();
    14331426        if (layer && layer->drawsContent())
    14341427            return true;
    … …  
    15871580        if (isCompositedContentLayer) {
    15881581            updateRect = rootViewToContents(updateRect);
    1589             RenderView* root = rootRenderer(this);
    1590             ASSERT(root);
    1591             root->layer()->setBackingNeedsRepaintInRect(updateRect);
     1582            ASSERT(renderView());
     1583            renderView()->layer()->setBackingNeedsRepaintInRect(updateRect);
    15921584            continue;
    15931585        }
    … …  
    16051597#if USE(ACCELERATED_COMPOSITING)
    16061598    if (contentsInCompositedLayer()) {
    1607         RenderView* root = rootRenderer(this);
    1608         ASSERT(root);
    1609 
    16101599        IntRect updateRect = visibleContentRect();
    16111600
    … …  
    16141603        updateRect.scale(1 / m_frame->frameScaleFactor());
    16151604
    1616         root->layer()->setBackingNeedsRepaintInRect(updateRect);
     1605        ASSERT(renderView());
     1606        renderView()->layer()->setBackingNeedsRepaintInRect(updateRect);
    16171607    }
    16181608    if (RenderPart* frameRenderer = m_frame->ownerRenderer()) {
    … …  
    17571747    m_frame->document()->updateStyleIfNeeded();
    17581748    // Only do a layout if changes have occurred that make it necessary.
    1759     RenderView* root = rootRenderer(this);
    1760     if (root && root->needsLayout())
     1749    RenderView* renderView = this->renderView();
     1750    if (renderView && renderView->needsLayout())
    17611751        layout();
    17621752    else
    … …  
    18511841
    18521842#if USE(ACCELERATED_COMPOSITING)
    1853     if (RenderView* root = rootRenderer(this)) {
    1854         if (root->usesCompositing())
    1855             root->compositor()->frameViewDidScroll();
     1843    if (RenderView* renderView = this->renderView()) {
     1844        if (renderView->usesCompositing())
     1845            renderView->compositor()->frameViewDidScroll();
    18561846    }
    18571847#endif
    … …  
    18631853    // but only if we're not inside of layout.
    18641854    if (!m_nestedLayoutCount && hasViewportConstrainedObjects()) {
    1865         if (RenderView* root = rootRenderer(this)) {
    1866             root->updateWidgetPositions();
    1867             root->layer()->updateLayerPositionsAfterDocumentScroll();
     1855        if (RenderView* renderView = this->renderView()) {
     1856            renderView->updateWidgetPositions();
     1857            renderView->layer()->updateLayerPositionsAfterDocumentScroll();
    18681858        }
    18691859    }
    … …  
    19061896
    19071897    if (m_nestedLayoutCount <= 1 && hasViewportConstrainedObjects()) {
    1908         if (RenderView* root = rootRenderer(this))
    1909             root->compositor()->updateCompositingLayers(CompositingUpdateOnScroll);
     1898        if (RenderView* renderView = this->renderView())
     1899            renderView->compositor()->updateCompositingLayers(CompositingUpdateOnScroll);
    19101900    }
    19111901#endif
    … …  
    20392029
    20402030#if USE(ACCELERATED_COMPOSITING)
    2041     if (RenderView* root = rootRenderer(this)) {
    2042         if (root->usesCompositing())
    2043             root->compositor()->frameViewDidChangeSize();
     2031    if (RenderView* renderView = this->renderView()) {
     2032        if (renderView->usesCompositing())
     2033            renderView->compositor()->frameViewDidChangeSize();
    20442034    }
    20452035#endif
    … …  
    22582248    ASSERT(m_frame->view() == this);
    22592249
    2260     RenderView* root = rootRenderer(this);
    2261     if (root && root->needsLayout()) {
     2250    RenderView* renderView = this->renderView();
     2251    if (renderView && renderView->needsLayout()) {
    22622252        if (relayoutRoot)
    22632253            relayoutRoot->markContainingBlocksForLayout(false);
    … …  
    23092299        return false;
    23102300
    2311     RenderView* root = rootRenderer(this);
     2301    RenderView* renderView = this->renderView();
    23122302    return layoutPending()
    2313         || (root && root->needsLayout())
     2303        || (renderView && renderView->needsLayout())
    23142304        || m_layoutRoot
    23152305        || (m_deferSetNeedsLayouts && m_setNeedsLayoutWasDeferred);
    … …  
    23232313    }
    23242314
    2325     if (RenderView* root = rootRenderer(this))
    2326         root->setNeedsLayout(true);
     2315    if (RenderView* renderView = this->renderView())
     2316        renderView->setNeedsLayout(true);
    23272317}
    23282318
    … …  
    25682558    m_frame->loader()->client()->dispatchDidLayout();
    25692559
    2570     RenderView* root = rootRenderer(this);
    2571     if (root)
    2572         root->updateWidgetPositions();
     2560    RenderView* renderView = this->renderView();
     2561    if (renderView)
     2562        renderView->updateWidgetPositions();
    25732563   
    25742564    for (unsigned i = 0; i < maxUpdateWidgetsIterations; i++) {
    … …  
    25832573
    25842574#if USE(ACCELERATED_COMPOSITING)
    2585     if (RenderView* root = rootRenderer(this)) {
    2586         if (root->usesCompositing())
    2587             root->compositor()->frameViewDidLayout();
    2588     }
     2575    if (renderView && renderView->usesCompositing())
     2576        renderView->compositor()->frameViewDidLayout();
    25892577#endif
    25902578
    … …  
    25932581    m_actionScheduler->resume();
    25942582
    2595     if (root && !root->printing()) {
     2583    if (renderView && !renderView->printing()) {
    25962584        IntSize currentSize;
    25972585        if (useFixedLayout() && !fixedLayoutSize().isEmpty() && delegatesScrolling())
    … …  
    25992587        else
    26002588            currentSize = visibleContentRect(true /*includeScrollbars*/).size();
    2601         float currentZoomFactor = root->style()->zoom();
     2589        float currentZoomFactor = renderView->style()->zoom();
    26022590        bool resized = !m_firstLayout && (currentSize != m_lastViewportSize || currentZoomFactor != m_lastZoomFactor);
    26032591        m_lastViewportSize = currentSize;
    … …  
    32403228        return;
    32413229
    3242     RenderView* root = rootRenderer(this);
    3243     if ((root && root->theme()->supportsControlTints()) || hasCustomScrollbars())
     3230    RenderView* renderView = this->renderView();
     3231    if ((renderView && renderView->theme()->supportsControlTints()) || hasCustomScrollbars())
    32443232        paintControlTints();
    32453233}
    … …  
    32993287#endif
    33003288
    3301     RenderView* root = rootRenderer(this);
    3302     if (!root) {
     3289    RenderView* renderView = this->renderView();
     3290    if (!renderView) {
    33033291        LOG_ERROR("called FrameView::paint with nil renderer");
    33043292        return;
    … …  
    33433331    // m_nodeToDraw is used to draw only one element (and its descendants)
    33443332    RenderObject* eltRenderer = m_nodeToDraw ? m_nodeToDraw->renderer() : 0;
    3345     RenderLayer* rootLayer = root->layer();
     3333    RenderLayer* rootLayer = renderView->layer();
    33463334
    33473335#ifndef NDEBUG
    … …  
    35173505    // Dumping externalRepresentation(m_frame->renderer()).ascii() is a good trick to see
    35183506    // the state of things before and after the layout
    3519     if (RenderView* root = rootRenderer(this)) {
    3520         float pageLogicalWidth = root->style()->isHorizontalWritingMode() ? pageSize.width() : pageSize.height();
    3521         float pageLogicalHeight = root->style()->isHorizontalWritingMode() ? pageSize.height() : pageSize.width();
     3507    if (RenderView* renderView = this->renderView()) {
     3508        float pageLogicalWidth = renderView->style()->isHorizontalWritingMode() ? pageSize.width() : pageSize.height();
     3509        float pageLogicalHeight = renderView->style()->isHorizontalWritingMode() ? pageSize.height() : pageSize.width();
    35223510
    35233511        LayoutUnit flooredPageLogicalWidth = static_cast<LayoutUnit>(pageLogicalWidth);
    35243512        LayoutUnit flooredPageLogicalHeight = static_cast<LayoutUnit>(pageLogicalHeight);
    3525         root->setLogicalWidth(flooredPageLogicalWidth);
    3526         root->setPageLogicalHeight(flooredPageLogicalHeight);
    3527         root->setNeedsLayoutAndPrefWidthsRecalc();
     3513        renderView->setLogicalWidth(flooredPageLogicalWidth);
     3514        renderView->setPageLogicalHeight(flooredPageLogicalHeight);
     3515        renderView->setNeedsLayoutAndPrefWidthsRecalc();
    35283516        forceLayout();
    35293517
    … …  
    35323520        // FIXME: We are assuming a shrink-to-fit printing implementation.  A cropping
    35333521        // implementation should not do this!
    3534         bool horizontalWritingMode = root->style()->isHorizontalWritingMode();
    3535         const LayoutRect& documentRect = root->documentRect();
     3522        bool horizontalWritingMode = renderView->style()->isHorizontalWritingMode();
     3523        const LayoutRect& documentRect = renderView->documentRect();
    35363524        LayoutUnit docLogicalWidth = horizontalWritingMode ? documentRect.width() : documentRect.height();
    35373525        if (docLogicalWidth > pageLogicalWidth) {
    … …  
    35443532            flooredPageLogicalWidth = static_cast<LayoutUnit>(pageLogicalWidth);
    35453533            flooredPageLogicalHeight = static_cast<LayoutUnit>(pageLogicalHeight);
    3546             root->setLogicalWidth(flooredPageLogicalWidth);
    3547             root->setPageLogicalHeight(flooredPageLogicalHeight);
    3548             root->setNeedsLayoutAndPrefWidthsRecalc();
     3534            renderView->setLogicalWidth(flooredPageLogicalWidth);
     3535            renderView->setPageLogicalHeight(flooredPageLogicalHeight);
     3536            renderView->setNeedsLayoutAndPrefWidthsRecalc();
    35493537            forceLayout();
    35503538
    3551             const LayoutRect& updatedDocumentRect = root->documentRect();
     3539            const LayoutRect& updatedDocumentRect = renderView->documentRect();
    35523540            LayoutUnit docLogicalHeight = horizontalWritingMode ? updatedDocumentRect.height() : updatedDocumentRect.width();
    35533541            LayoutUnit docLogicalTop = horizontalWritingMode ? updatedDocumentRect.y() : updatedDocumentRect.x();
    35543542            LayoutUnit docLogicalRight = horizontalWritingMode ? updatedDocumentRect.maxX() : updatedDocumentRect.maxY();
    35553543            LayoutUnit clippedLogicalLeft = 0;
    3556             if (!root->style()->isLeftToRightDirection())
     3544            if (!renderView->style()->isLeftToRightDirection())
    35573545                clippedLogicalLeft = docLogicalRight - pageLogicalWidth;
    35583546            LayoutRect overflow(clippedLogicalLeft, docLogicalTop, pageLogicalWidth, docLogicalHeight);
    … …  
    35603548            if (!horizontalWritingMode)
    35613549                overflow = overflow.transposedRect();
    3562             root->clearLayoutOverflow();
    3563             root->addLayoutOverflow(overflow); // This is how we clip in case we overflow again.
     3550            renderView->clearLayoutOverflow();
     3551            renderView->addLayoutOverflow(overflow); // This is how we clip in case we overflow again.
    35643552        }
    35653553    }
    … …  
    35713559void FrameView::adjustPageHeightDeprecated(float *newBottom, float oldTop, float oldBottom, float /*bottomLimit*/)
    35723560{
    3573     if (RenderView* root = rootRenderer(this)) {
    3574         // Use a context with painting disabled.
    3575         GraphicsContext context((PlatformGraphicsContext*)0);
    3576         root->setTruncatedAt(static_cast<int>(floorf(oldBottom)));
    3577         IntRect dirtyRect(0, static_cast<int>(floorf(oldTop)), root->layoutOverflowRect().maxX(), static_cast<int>(ceilf(oldBottom - oldTop)));
    3578         root->setPrintRect(dirtyRect);
    3579         root->layer()->paint(&context, dirtyRect);
    3580         *newBottom = root->bestTruncatedAt();
    3581         if (*newBottom == 0)
    3582             *newBottom = oldBottom;
    3583         root->setPrintRect(IntRect());
    3584     } else
     3561    RenderView* renderView = this->renderView();
     3562    if (!renderView) {
    35853563        *newBottom = oldBottom;
     3564        return;
     3565
     3566    }
     3567    // Use a context with painting disabled.
     3568    GraphicsContext context((PlatformGraphicsContext*)0);
     3569    renderView->setTruncatedAt(static_cast<int>(floorf(oldBottom)));
     3570    IntRect dirtyRect(0, static_cast<int>(floorf(oldTop)), renderView->layoutOverflowRect().maxX(), static_cast<int>(ceilf(oldBottom - oldTop)));
     3571    renderView->setPrintRect(dirtyRect);
     3572    renderView->layer()->paint(&context, dirtyRect);
     3573    *newBottom = renderView->bestTruncatedAt();
     3574    if (!*newBottom)
     3575        *newBottom = oldBottom;
     3576    renderView->setPrintRect(IntRect());
    35863577}
    35873578
    … …  
    37723763    m_trackedRepaintRects.clear();
    37733764#if USE(ACCELERATED_COMPOSITING)
    3774     if (RenderView* root = rootRenderer(this)) {
    3775         RenderLayerCompositor* compositor = root->compositor();
    3776         compositor->resetTrackedRepaintRects();
    3777     }
     3765    if (RenderView* renderView = this->renderView())
     3766        renderView->compositor()->resetTrackedRepaintRects();
    37783767#endif
    37793768}
    … …  
    38703859bool FrameView::isVerticalDocument() const
    38713860{
    3872     RenderView* root = rootRenderer(this);
    3873     if (!root)
     3861    RenderView* renderView = this->renderView();
     3862    if (!renderView)
    38743863        return true;
    38753864
    3876     return root->style()->isHorizontalWritingMode();
     3865    return renderView->style()->isHorizontalWritingMode();
    38773866}
    38783867
    38793868bool FrameView::isFlippedDocument() const
    38803869{
    3881     RenderView* root = rootRenderer(this);
    3882     if (!root)
     3870    RenderView* renderView = this->renderView();
     3871    if (!renderView)
    38833872        return false;
    38843873
    3885     return root->style()->isFlippedBlocksWritingMode();
     3874    return renderView->style()->isFlippedBlocksWritingMode();
    38863875}
    38873876

  • trunk/Source/WebCore/page/FrameView.h

    r141053 r142647  
    3939namespace WebCore {
    4040
    41 class Color;
    4241class Element;
    4342class Event;
    4443class FloatSize;
    45 class Frame;
    4644class FrameActionScheduler;
    4745class KURL;
    … …  
    7977    Frame* frame() const { return m_frame.get(); }
    8078    void clearFrame();
     79
     80    RenderView* renderView() const { return m_frame ? m_frame->contentRenderer() : 0; }
    8181
    8282    int mapFromLayoutToCSSUnits(LayoutUnit);
Note: See TracChangeset for help on using the changeset viewer.