Rename Repaint to Paint Invalidation Part 2

Source/core/frame/FrameView.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 76 matching lines @@
 
 using namespace HTMLNames;
 
 double FrameView::s_currentFrameTimeStamp = 0.0;
 bool FrameView::s_inPaintContents = false;
 
 // The maximum number of updateWidgets iterations that should be done before returning.
 static const unsigned maxUpdateWidgetsIterations = 2;
 static const double resourcePriorityUpdateDelayAfterScroll = 0.250;
 
-static RenderLayer::UpdateLayerPositionsFlags updateLayerPositionFlags(RenderLayer* layer, bool isRelayoutingSubtree, bool didFullRepaint)
+static RenderLayer::UpdateLayerPositionsFlags updateLayerPositionFlags(RenderLayer* layer, bool isRelayoutingSubtree, bool didFullPaintInvalidation)
 {
-    RenderLayer::UpdateLayerPositionsFlags flags = didFullRepaint ? RenderLayer::NeedsFullRepaintInBacking : RenderLayer::CheckForRepaint;
+    RenderLayer::UpdateLayerPositionsFlags flags = didFullPaintInvalidation ? RenderLayer::NeedsFullRepaintInBacking : RenderLayer::CheckForRepaint;
 
     if (isRelayoutingSubtree && (layer->isPaginated() || layer->enclosingPaginationLayer()))
         flags |= RenderLayer::UpdatePagination;
 
     return flags;
 }
 
 class FrameViewLayoutStateMaintainer {
     WTF_MAKE_NONCOPYABLE(FrameViewLayoutStateMaintainer);
 public:
@@ skipping 31 matching lines @@
     , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)
     , m_updateWidgetsTimer(this, &FrameView::updateWidgetsTimerFired)
     , m_isTransparent(false)
     , m_baseBackgroundColor(Color::white)
     , m_mediaType("screen")
     , m_overflowStatusDirty(true)
     , m_viewportRenderer(0)
     , m_wasScrolledByUser(false)
     , m_inProgrammaticScroll(false)
     , m_safeToPropagateScrollToParent(true)
-    , m_isTrackingRepaints(false)
+    , m_isTrackingPaintInvalidations(false)
     , m_scrollCorner(0)
     , m_shouldAutoSize(false)
     , m_inAutoSize(false)
     , m_didRunAutosize(false)
     , m_hasSoftwareFilters(false)
     , m_visibleContentScaleFactor(1)
     , m_inputEventsScaleFactorForEmulation(1)
     , m_layoutSizeFixedToFrameSize(true)
     , m_didScrollTimer(this, &FrameView::didScrollTimerFired)
 {
@@ skipping 52 matching lines @@
         ownerElement->setWidget(nullptr);
 }
 
 void FrameView::reset()
 {
     m_cannotBlitToWindow = false;
     m_isOverlapped = false;
     m_contentIsOpaque = false;
     m_hasPendingLayout = false;
     m_layoutSubtreeRoot = 0;
-    m_doFullRepaint = false;
+    m_doFullPaintInvalidation = false;
     m_layoutSchedulingEnabled = true;
     m_inPerformLayout = false;
     m_canInvalidatePaintDuringPerformLayout = false;
     m_inSynchronousPostLayout = false;
     m_layoutCount = 0;
     m_nestedLayoutCount = 0;
     m_postLayoutTasksTimer.stop();
     m_updateWidgetsTimer.stop();
     m_firstLayout = true;
     m_firstLayoutCallbackPending = false;
     m_wasScrolledByUser = false;
     m_safeToPropagateScrollToParent = true;
     m_lastViewportSize = IntSize();
     m_lastZoomFactor = 1.0f;
-    m_isTrackingRepaints = false;
-    m_trackedRepaintRects.clear();
+    m_isTrackingPaintInvalidations = false;
+    m_trackedPaintInvalidationRects.clear();
     m_lastPaintTime = 0;
     m_paintBehavior = PaintBehaviorNormal;
     m_isPainting = false;
     m_visuallyNonEmptyCharacterCount = 0;
     m_visuallyNonEmptyPixelCount = 0;
     m_isVisuallyNonEmpty = false;
     m_firstVisuallyNonEmptyLayoutCallbackPending = true;
     m_maintainScrollPositionAnchor = nullptr;
     m_viewportConstrainedObjects.clear();
 }
@@ skipping 100 matching lines @@
     if (!parent()) {
         if (HostWindow* window = hostWindow())
             window->invalidateContentsAndRootView(rect);
         return;
     }
 
     RenderPart* renderer = m_frame->ownerRenderer();
     if (!renderer)
         return;
 
-    IntRect repaintRect = rect;
-    repaintRect.move(renderer->borderLeft() + renderer->paddingLeft(),
+    IntRect paintInvalidationRect = rect;
+    paintInvalidationRect.move(renderer->borderLeft() + renderer->paddingLeft(),
                      renderer->borderTop() + renderer->paddingTop());
-    renderer->repaintRectangle(repaintRect);
+    renderer->repaintRectangle(paintInvalidationRect);
 }
 
 void FrameView::setFrameRect(const IntRect& newRect)
 {
     IntRect oldRect = frameRect();
     if (newRect == oldRect)
         return;
 
     // Autosized font sizes depend on the width of the viewing area.
     bool autosizerNeedsUpdating = false;
@@ skipping 428 matching lines @@
 
     // FIXME (crbug.com/256657): Do not do two layouts for text autosizing.
     rootForThisLayout->layout();
     gatherDebugLayoutRects(rootForThisLayout);
 
     ResourceLoadPriorityOptimizer::resourceLoadPriorityOptimizer()->updateAllImageResourcePriorities();
 
     TextAutosizer* textAutosizer = frame().document()->textAutosizer();
     bool autosized;
     {
-        AllowPaintInvalidationScope repaintAllowed(this);
+        AllowPaintInvalidationScope paintInvalidationAllowed(this);
         autosized = textAutosizer && textAutosizer->processSubtree(rootForThisLayout);
     }
 
     if (autosized && rootForThisLayout->needsLayout()) {
         TRACE_EVENT0("webkit", "2nd layout due to Text Autosizing");
         UseCounter::count(*frame().document(), UseCounter::TextAutosizingLayout);
         rootForThisLayout->layout();
         gatherDebugLayoutRects(rootForThisLayout);
     }
 
@@ skipping 99 matching lines @@
         calculateScrollbarModesForLayoutAndSetViewportRenderer(hMode, vMode);
 
         if (!inSubtreeLayout) {
             // Now set our scrollbar state for the layout.
             ScrollbarMode currentHMode = horizontalScrollbarMode();
             ScrollbarMode currentVMode = verticalScrollbarMode();
 
             if (m_firstLayout) {
                 setScrollbarsSuppressed(true);
 
-                m_doFullRepaint = true;
+                m_doFullPaintInvalidation = true;
                 m_firstLayout = false;
                 m_firstLayoutCallbackPending = true;
                 m_lastViewportSize = layoutSize(IncludeScrollbars);
                 m_lastZoomFactor = rootForThisLayout->style()->zoom();
 
                 // Set the initial vMode to AlwaysOn if we're auto.
                 if (vMode == ScrollbarAuto)
                     setVerticalScrollbarMode(ScrollbarAlwaysOn); // This causes a vertical scrollbar to appear.
                 // Set the initial hMode to AlwaysOff if we're auto.
                 if (hMode == ScrollbarAuto)
@@ skipping 11 matching lines @@
 
             if (oldSize != m_size && !m_firstLayout) {
                 RenderBox* rootRenderer = document->documentElement() ? document->documentElement()->renderBox() : 0;
                 RenderBox* bodyRenderer = rootRenderer && document->body() ? document->body()->renderBox() : 0;
                 if (bodyRenderer && bodyRenderer->stretchesToViewport())
                     bodyRenderer->setChildNeedsLayout();
                 else if (rootRenderer && rootRenderer->stretchesToViewport())
                     rootRenderer->setChildNeedsLayout();
             }
 
-            // We need to set m_doFullRepaint before triggering layout as RenderObject::checkForRepaint
-            // checks the boolean to disable local repaints.
-            m_doFullRepaint |= renderView()->shouldDoFullRepaintForNextLayout();
+            // We need to set m_doFullPaintInvalidation before triggering layout as RenderObject::checkForRepaint
+            // checks the boolean to disable local paint invalidations.
+            m_doFullPaintInvalidation |= renderView()->shouldDoFullRepaintForNextLayout();
         }
 
         layer = rootForThisLayout->enclosingLayer();
 
         performLayout(rootForThisLayout, inSubtreeLayout);
 
         m_layoutSubtreeRoot = 0;
     } // Reset m_layoutSchedulingEnabled to its previous value.
 
     if (!inSubtreeLayout && !toRenderView(rootForThisLayout)->document().printing())
         adjustViewSize();
 
-    layer->updateLayerPositionsAfterLayout(renderView()->layer(), updateLayerPositionFlags(layer, inSubtreeLayout, m_doFullRepaint));
+    layer->updateLayerPositionsAfterLayout(renderView()->layer(), updateLayerPositionFlags(layer, inSubtreeLayout, m_doFullPaintInvalidation));
     renderView()->compositor()->setNeedsCompositingUpdate(CompositingUpdateAfterLayout);
 
     m_layoutCount++;
 
     if (AXObjectCache* cache = rootForThisLayout->document().axObjectCache()) {
         const KURL& url = rootForThisLayout->document().url();
         if (url.isValid() && !url.isAboutBlankURL())
             cache->handleLayoutComplete(rootForThisLayout);
     }
     updateAnnotatedRegions();
 
     ASSERT(!rootForThisLayout->needsLayout());
 
     if (document->hasListenerType(Document::OVERFLOWCHANGED_LISTENER))
         updateOverflowStatus(layoutSize().width() < contentsWidth(), layoutSize().height() < contentsHeight());
 
     scheduleOrPerformPostLayoutTasks();
 
     TRACE_EVENT_END1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "Layout", "endData", InspectorLayoutEvent::endData(rootForThisLayout));
     // FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing.
     InspectorInstrumentation::didLayout(cookie, rootForThisLayout);
 
     m_nestedLayoutCount--;
     if (m_nestedLayoutCount)
         return;
 
     if (RuntimeEnabledFeatures::repaintAfterLayoutEnabled()) {
         invalidateTree(rootForThisLayout);
-    } else if (m_doFullRepaint) {
+    } else if (m_doFullPaintInvalidation) {
         // FIXME: This isn't really right, since the RenderView doesn't fully encompass
         // the visibleContentRect(). It just happens to work out most of the time,
         // since first layouts and printing don't have you scrolled anywhere.
         renderView()->repaint();
     }
 
-    m_doFullRepaint = false;
+    m_doFullPaintInvalidation = false;
 
 #ifndef NDEBUG
     // Post-layout assert that nobody was re-marked as needing layout during layout.
     document->renderView()->assertSubtreeIsLaidOut();
 #endif
 
     // FIXME: It should be not possible to remove the FrameView from the frame/page during layout
     // however m_inPerformLayout is not set for most of this function, so none of our RELEASE_ASSERTS
     // in LocalFrame/Page will fire. One of the post-layout tasks is disconnecting the LocalFrame from
     // the page in fast/frames/crash-remove-iframe-during-object-beforeload-2.html
     // necessitating this check here.
     // ASSERT(frame()->page());
     if (frame().page())
         frame().page()->chrome().client().layoutUpdated(m_frame.get());
 }
 
-// The plan is to move to compositor-queried repainting, in which case this
+// The plan is to move to compositor-queried paint invalidation, in which case this
 // method would setNeedsRedraw on the GraphicsLayers with invalidations and
 // let the compositor pick which to actually draw.
 // See http://crbug.com/306706
 void FrameView::invalidateTree(RenderObject* root)
 {
     ASSERT(RuntimeEnabledFeatures::repaintAfterLayoutEnabled());
     ASSERT(!root->needsLayout());
-    // We should only repaint for the outer most layout. This works as
-    // we continue to track repaint rects until this function is called.
+    // We should only invalidate paints for the outer most layout. This works as
+    // we continue to track paint invalidation rects until this function is called.
     ASSERT(!m_nestedLayoutCount);
 
-    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"), "FrameView::repaintTree",
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"), "FrameView::invalidateTree",
         "root", TRACE_STR_COPY(root->debugName().ascii().data()));
 
-    // FIXME: really, we're in the repaint phase here, and the compositing queries are legal.
+    // FIXME: really, we're in the paint invalidation phase here, and the compositing queries are legal.
     // Until those states are fully fledged, I'll just disable the ASSERTS.
     DisableCompositingQueryAsserts compositingQueryAssertsDisabler;
 
     RootLayoutStateScope rootLayoutStateScope(*root);
 
     root->invalidateTreeAfterLayout(*root->containerForRepaint());
 
-    // Repaint the frameviews scrollbars if needed
+    // Invalidate the paint of the frameviews scrollbars if needed
     if (hasVerticalBarDamage())
         invalidateRect(verticalBarDamage());
     if (hasHorizontalBarDamage())
         invalidateRect(horizontalBarDamage());
     resetScrollbarDamage();
 }
 
 DocumentLifecycle& FrameView::lifecycle() const
 {
     return m_frame->document()->lifecycle();
@@ skipping 301 matching lines @@
         if (FrameView* view = child->view())
             view->scrollContentsIfNeededRecursive();
     }
 }
 
 void FrameView::scrollContentsIfNeeded()
 {
     bool didScroll = !pendingScrollDelta().isZero();
     ScrollView::scrollContentsIfNeeded();
     if (didScroll)
-        updateFixedElementRepaintRectsAfterScroll();
+        updateFixedElementPaintInvalidationRectsAfterScroll();
 }
 
 bool FrameView::scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect)
 {
     if (!m_viewportConstrainedObjects || m_viewportConstrainedObjects->isEmpty()) {
         hostWindow()->scroll(scrollDelta, rectToScroll, clipRect);
         return true;
     }
 
     const bool isCompositedContentLayer = contentsInCompositedLayer();
 
     // Get the rects of the fixed objects visible in the rectToScroll
     Region regionToUpdate;
     ViewportConstrainedObjectSet::const_iterator end = m_viewportConstrainedObjects->end();
     for (ViewportConstrainedObjectSet::const_iterator it = m_viewportConstrainedObjects->begin(); it != end; ++it) {
         RenderObject* renderer = *it;
         // m_viewportConstrainedObjects should not contain non-viewport constrained objects.
         ASSERT(renderer->style()->hasViewportConstrainedPosition());
 
         // Fixed items should always have layers.
         ASSERT(renderer->hasLayer());
         RenderLayer* layer = toRenderBoxModelObject(renderer)->layer();
 
         // Layers that paint into their ancestor or into a grouped backing will still need
-        // to apply a repaint invalidation. If the layer paints into its own backing, then
-        // it does not need repainting just to scroll.
+        // to apply a paint invalidation. If the layer paints into its own backing, then
+        // it does not need paint invalidation just to scroll.
         if (layer->compositingState() == PaintsIntoOwnBacking)
             continue;
 
         if (layer->viewportConstrainedNotCompositedReason() == RenderLayer::NotCompositedForBoundsOutOfView
             || layer->viewportConstrainedNotCompositedReason() == RenderLayer::NotCompositedForNoVisibleContent) {
             // Don't invalidate for invisible fixed layers.
             continue;
         }
 
         if (layer->hasAncestorWithFilterOutsets()) {
             // If the fixed layer has a blur/drop-shadow filter applied on at least one of its parents, we cannot
             // scroll using the fast path, otherwise the outsets of the filter will be moved around the page.
             return false;
         }
 
         IntRect updateRect = pixelSnappedIntRect(layer->repainter().repaintRectIncludingNonCompositingDescendants());
 
         RenderLayer* enclosingCompositingLayer = layer->enclosingCompositingLayer(ExcludeSelf);
         if (enclosingCompositingLayer && !enclosingCompositingLayer->renderer()->isRenderView()) {
             // If the fixed-position layer is contained by a composited layer that is not its containing block,
             // then we have to invalidate that enclosing layer, not the RenderView.
             // FIXME: Why do we need to issue this invalidation? Won't the fixed position element just scroll
             //        with the enclosing layer.
             updateRect.moveBy(scrollPosition());
             IntRect previousRect = updateRect;
             previousRect.move(scrollDelta);
             updateRect.unite(previousRect);
             enclosingCompositingLayer->repainter().setBackingNeedsRepaintInRect(updateRect);
         } else {
-            // Coalesce the repaints that will be issued to the renderView.
+            // Coalesce the paint invalidations that will be issued to the renderView.
             updateRect = contentsToRootView(updateRect);
-            if (!isCompositedContentLayer && clipsRepaints())
+            if (!isCompositedContentLayer && clipsPaintInvalidations())
                 updateRect.intersect(rectToScroll);
             if (!updateRect.isEmpty())
                 regionToUpdate.unite(updateRect);
         }
     }
 
     // 1) scroll
     hostWindow()->scroll(scrollDelta, rectToScroll, clipRect);
 
     // 2) update the area of fixed objects that has been invalidated
     Vector<IntRect> subRectsToUpdate = regionToUpdate.rects();
     size_t viewportConstrainedObjectsCount = subRectsToUpdate.size();
     for (size_t i = 0; i < viewportConstrainedObjectsCount; ++i) {
         IntRect updateRect = subRectsToUpdate[i];
         IntRect scrolledRect = updateRect;
         scrolledRect.move(-scrollDelta);
         updateRect.unite(scrolledRect);
         if (isCompositedContentLayer) {
             updateRect = rootViewToContents(updateRect);
             ASSERT(renderView());
             renderView()->layer()->repainter().setBackingNeedsRepaintInRect(updateRect);
             continue;
         }
-        if (clipsRepaints())
+        if (clipsPaintInvalidations())
             updateRect.intersect(rectToScroll);
         hostWindow()->invalidateContentsAndRootView(updateRect);
     }
 
     return true;
 }
 
 void FrameView::scrollContentsSlowPath(const IntRect& updateRect)
 {
     if (contentsInCompositedLayer()) {
@@ skipping 27 matching lines @@
 
 void FrameView::restoreScrollbar()
 {
     setScrollbarsSuppressed(false);
 }
 
 bool FrameView::scrollToFragment(const KURL& url)
 {
     // If our URL has no ref, then we have no place we need to jump to.
     // OTOH If CSS target was set previously, we want to set it to 0, recalc
-    // and possibly repaint because :target pseudo class may have been
+    // and possibly paint invalidation because :target pseudo class may have been
     // set (see bug 11321).
     if (!url.hasFragmentIdentifier() && !m_frame->document()->cssTarget())
         return false;
 
     String fragmentIdentifier = url.fragmentIdentifier();
     if (scrollToAnchor(fragmentIdentifier))
         return true;
 
     // Try again after decoding the ref, based on the document's encoding.
     if (m_frame->document()->encoding().isValid())
@@ skipping 173 matching lines @@
         if (RenderView* renderView = this->renderView())
             renderView->layer()->updateLayerPositionsAfterDocumentScroll();
     }
 
     // Compositing layers may change after scrolling.
     // FIXME: Maybe no longer needed after we land squashing and kill overlap testing?
     if (RenderView* renderView = this->renderView())
         renderView->compositor()->setNeedsCompositingUpdate(CompositingUpdateOnScroll);
 }
 
-void FrameView::updateFixedElementRepaintRectsAfterScroll()
+void FrameView::updateFixedElementPaintInvalidationRectsAfterScroll()
 {
     if (!hasViewportConstrainedObjects())
         return;
 
-    // Update the repaint rects for fixed elements after scrolling and invalidation to reflect
+    // Update the paint invalidation rects for fixed elements after scrolling and invalidation to reflect
     // the new scroll position.
     ViewportConstrainedObjectSet::const_iterator end = m_viewportConstrainedObjects->end();
     for (ViewportConstrainedObjectSet::const_iterator it = m_viewportConstrainedObjects->begin(); it != end; ++it) {
         RenderObject* renderer = *it;
         // m_viewportConstrainedObjects should not contain non-viewport constrained objects.
         ASSERT(renderer->style()->hasViewportConstrainedPosition());
 
         // Fixed items should always have layers.
         ASSERT(renderer->hasLayer());
 
@@ skipping 26 matching lines @@
 }
 
 HostWindow* FrameView::hostWindow() const
 {
     Page* page = frame().page();
     if (!page)
         return 0;
     return &page->chrome();
 }
 
-void FrameView::repaintContentRectangle(const IntRect& r)
+void FrameView::contentRectangleForPaintInvalidation(const IntRect& r)
 {
-    ASSERT(repaintAllowed());
+    ASSERT(paintInvalidationIsAllowed());
     ASSERT(!m_frame->owner());
 
-    if (m_isTrackingRepaints) {
-        IntRect repaintRect = r;
-        repaintRect.move(-scrollOffset());
-        m_trackedRepaintRects.append(repaintRect);
-        // FIXME: http://crbug.com/368518. Eventually, repaintContentRectangle
+    if (m_isTrackingPaintInvalidations) {
+        IntRect paintInvalidationRect = r;
+        paintInvalidationRect.move(-scrollOffset());
+        m_trackedPaintInvalidationRects.append(paintInvalidationRect);
+        // FIXME: http://crbug.com/368518. Eventually, invalidateContentRectangleForPaint
         // is going away entirely once all layout tests are FCM. In the short
-        // term, no code should be tracking non-composited FrameView repaints.
+        // term, no code should be tracking non-composited FrameView paint invalidations.
         RELEASE_ASSERT_NOT_REACHED();
     }
 
-    ScrollView::repaintContentRectangle(r);
+    ScrollView::contentRectangleForPaintInvalidation(r);
 }
 
 void FrameView::contentsResized()
 {
     if (m_frame->isMainFrame() && m_frame->document()) {
         if (FastTextAutosizer* textAutosizer = m_frame->document()->fastTextAutosizer())
             textAutosizer->updatePageInfoInAllFrames();
     }
 
     ScrollView::contentsResized();
@@ skipping 1328 matching lines @@
                        -renderer->borderTop() - renderer->paddingTop());
             return point;
         }
 
         return Widget::convertFromContainingView(parentPoint);
     }
 
     return parentPoint;
 }
 
-void FrameView::setTracksRepaints(bool trackRepaints)
+void FrameView::setTracksPaintInvalidations(bool trackPaintInvalidations)
 {
-    if (trackRepaints == m_isTrackingRepaints)
+    if (trackPaintInvalidations == m_isTrackingPaintInvalidations)
         return;
 
     for (LocalFrame* frame = m_frame->tree().top(); frame; frame = frame->tree().traverseNext()) {
         if (RenderView* renderView = frame->contentRenderer())
-            renderView->compositor()->setTracksRepaints(trackRepaints);
+            renderView->compositor()->setTracksRepaints(trackPaintInvalidations);
     }
 
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"),
-        "FrameView::setTracksRepaints", "enabled", trackRepaints);
+        "FrameView::setTracksPaintInvalidations", "enabled", trackPaintInvalidations);
 
-    resetTrackedRepaints();
-    m_isTrackingRepaints = trackRepaints;
+    resetTrackedPaintInvalidations();
+    m_isTrackingPaintInvalidations = trackPaintInvalidations;
 }
 
-void FrameView::resetTrackedRepaints()
+void FrameView::resetTrackedPaintInvalidations()
 {
-    m_trackedRepaintRects.clear();
+    m_trackedPaintInvalidationRects.clear();
     if (RenderView* renderView = this->renderView())
         renderView->compositor()->resetTrackedRepaintRects();
 }
 
-String FrameView::trackedRepaintRectsAsText() const
+String FrameView::trackedPaintInvalidationRectsAsText() const
 {
     TextStream ts;
-    if (!m_trackedRepaintRects.isEmpty()) {
+    if (!m_trackedPaintInvalidationRects.isEmpty()) {
         ts << "(repaint rects\n";
-        for (size_t i = 0; i < m_trackedRepaintRects.size(); ++i)
-            ts << "  (rect " << m_trackedRepaintRects[i].x() << " " << m_trackedRepaintRects[i].y() << " " << m_trackedRepaintRects[i].width() << " " << m_trackedRepaintRects[i].height() << ")\n";
+        for (size_t i = 0; i < m_trackedPaintInvalidationRects.size(); ++i)
+            ts << "  (rect " << m_trackedPaintInvalidationRects[i].x() << " " << m_trackedPaintInvalidationRects[i].y() << " " << m_trackedPaintInvalidationRects[i].width() << " " << m_trackedPaintInvalidationRects[i].height() << ")\n";
         ts << ")\n";
     }
     return ts.release();
 }
 
 void FrameView::addResizerArea(RenderBox& resizerBox)
 {
     if (!m_resizerAreas)
         m_resizerAreas = adoptPtr(new ResizerAreaSet);
     m_resizerAreas->add(&resizerBox);
@@ skipping 114 matching lines @@
 void FrameView::willRemoveScrollbar(Scrollbar* scrollbar, ScrollbarOrientation orientation)
 {
     ScrollableArea::willRemoveScrollbar(scrollbar, orientation);
     if (AXObjectCache* cache = axObjectCache()) {
         cache->remove(scrollbar);
         cache->handleScrollbarUpdate(this);
     }
 }
 
 } // namespace WebCore