Implement interfaces in PaintInfo and make it a class.

Source/core/rendering/RenderFlowThread.cpp

 /*
  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above
  *    copyright notice, this list of conditions and the following
  *    disclaimer.
@@ skipping 249 matching lines @@
 LayoutRect RenderFlowThread::computeRegionClippingRect(const LayoutPoint& offset, const LayoutRect& flowThreadPortionRect, const LayoutRect& flowThreadPortionOverflowRect) const
 {
     LayoutRect regionClippingRect(offset + (flowThreadPortionOverflowRect.location() - flowThreadPortionRect.location()), flowThreadPortionOverflowRect.size());
     if (style()->isFlippedBlocksWritingMode())
         regionClippingRect.move(flowThreadPortionRect.size() - flowThreadPortionOverflowRect.size());
     return regionClippingRect;
 }
 
 void RenderFlowThread::paintFlowThreadPortionInRegion(PaintInfo& paintInfo, RenderRegion* region, const LayoutRect& flowThreadPortionRect, const LayoutRect& flowThreadPortionOverflowRect, const LayoutPoint& paintOffset) const
 {
-    GraphicsContext* context = paintInfo.context;
+    GraphicsContext* context = paintInfo.getContext();
     if (!context)
         return;
 
     // RenderFlowThread should start painting its content in a position that is offset
     // from the region rect's current position. The amount of offset is equal to the location of
     // the flow thread portion in the flow thread's local coordinates.
     // Note that we have to pixel snap the location at which we're going to paint, since this is necessary
     // to minimize the amount of incorrect snapping that would otherwise occur.
     // If we tried to paint by applying a non-integral translation, then all the
     // layout code that attempted to pixel snap would be incorrect.
     IntPoint adjustedPaintOffset;
     LayoutPoint portionLocation;
     if (style()->isFlippedBlocksWritingMode()) {
         LayoutRect flippedFlowThreadPortionRect(flowThreadPortionRect);
         flipForWritingMode(flippedFlowThreadPortionRect);
         portionLocation = flippedFlowThreadPortionRect.location();
     } else
         portionLocation = flowThreadPortionRect.location();
     adjustedPaintOffset = roundedIntPoint(paintOffset - portionLocation);
 
     // The clipping rect for the region is set up by assuming the flowThreadPortionRect is going to paint offset from adjustedPaintOffset.
     // Remember that we pixel snapped and moved the paintOffset and stored the snapped result in adjustedPaintOffset. Now we add back in
     // the flowThreadPortionRect's location to get the spot where we expect the portion to actually paint. This can be non-integral and
     // that's ok. We then pixel snap the resulting clipping rect to account for snapping that will occur when the flow thread paints.
     IntRect regionClippingRect = pixelSnappedIntRect(computeRegionClippingRect(adjustedPaintOffset + portionLocation, flowThreadPortionRect, flowThreadPortionOverflowRect));
 
     PaintInfo info(paintInfo);
-    info.rect.intersect(regionClippingRect);
+    info.getRect().intersect(regionClippingRect);
 
-    if (!info.rect.isEmpty()) {
+    if (!info.getRect().isEmpty()) {
         context->save();
 
         context->clip(regionClippingRect);
 
         context->translate(adjustedPaintOffset.x(), adjustedPaintOffset.y());
-        info.rect.moveBy(-adjustedPaintOffset);
+        info.getRect().moveBy(-adjustedPaintOffset);
 
-        layer()->paint(context, info.rect, 0, 0, region, RenderLayer::PaintLayerTemporaryClipRects);
+        layer()->paint(context, info.getRect(), 0, 0, region, RenderLayer::PaintLayerTemporaryClipRects);
 
         context->restore();
     }
 }
 
 bool RenderFlowThread::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
 {
     if (hitTestAction == HitTestBlockBackground)
         return false;
     return RenderBlock::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, hitTestAction);
@@ skipping 724 matching lines @@
 {
     if (!m_renderFlowThread)
         return;
     RenderView* view = m_renderFlowThread->view();
     ASSERT(view->flowThreadController()->currentRenderFlowThread() == m_renderFlowThread);
     view->flowThreadController()->setCurrentRenderFlowThread(m_previousRenderFlowThread);
 }
 
 
 } // namespace WebCore