Changeset 17448 in webkit

Timestamp:

Oct 30, 2006 2:41:29 PM (17 years ago)

Author:

weinig

Message:

Reviewed by Mitz.

Fix for ​http://bugs.webkit.org/show_bug.cgi?id=11441
More rendering code cleaning

• WebCore.xcodeproj/project.pbxproj:
• rendering/RenderApplet.cpp: (WebCore::RenderApplet::RenderApplet): (WebCore::RenderApplet::createWidgetIfNecessary):
• rendering/RenderApplet.h:
• rendering/RenderArena.cpp: (WebCore::): (WebCore::RenderArena::RenderArena): (WebCore::RenderArena::allocate): (WebCore::RenderArena::free):
• rendering/RenderArena.h:
• rendering/RenderBR.cpp: (WebCore::RenderBR::RenderBR): (WebCore::RenderBR::baselinePosition): (WebCore::RenderBR::lineHeight): (WebCore::RenderBR::setStyle): (WebCore::RenderBR::caretMinOffset): (WebCore::RenderBR::positionForCoordinates): (WebCore::RenderBR::inlineBox):
• rendering/RenderBR.h:
• rendering/RenderBlock.cpp:
• rendering/RenderBlock.h: (WebCore::RenderBlock::maxTopMargin): (WebCore::RenderBlock::maxBottomMargin): (WebCore::RenderBlock::initMaxMarginValues): (WebCore::RenderBlock::containsFloats): (WebCore::RenderBlock::setHasMarkupTruncation): (WebCore::RenderBlock::BlockSelectionInfo::BlockSelectionInfo): (WebCore::RenderBlock::BlockSelectionInfo::block): (WebCore::RenderBlock::BlockSelectionInfo::state): (WebCore::RenderBlock::FloatingObject::FloatingObject): (WebCore::RenderBlock::CompactInfo::clear):
• rendering/RenderButton.cpp: (WebCore::RenderButton::removeChild): (WebCore::RenderButton::paintObject):
• rendering/RenderButton.h: (WebCore::RenderButton::renderName): (WebCore::RenderButton::removeLeftoverAnonymousBoxes):
• rendering/RenderContainer.cpp: (WebCore::RenderContainer::RenderContainer):
• rendering/RenderContainer.h: (WebCore::RenderContainer::firstChild): (WebCore::RenderContainer::lastChild): (WebCore::RenderContainer::calcMinMaxWidth):
• rendering/RenderCounter.cpp: (WebCore::RenderCounter::RenderCounter): (WebCore::toRoman): (WebCore::toHebrew): (WebCore::RenderCounter::calcMinMaxWidth):
• rendering/RenderCounter.h:
• rendering/RenderFieldset.cpp: (WebCore::RenderFieldset::paintBoxDecorations): (WebCore::RenderFieldset::paintBorderMinusLegend): (WebCore::RenderFieldset::setStyle):
• rendering/RenderFileUploadControl.cpp: (WebCore::RenderFileUploadControl::~RenderFileUploadControl): (WebCore::RenderFileUploadControl::setStyle): (WebCore::RenderFileUploadControl::paintObject): (WebCore::RenderFileUploadControl::calcMinMaxWidth):
• rendering/RenderFileUploadControl.h: (WebCore::RenderFileUploadControl::renderName):
• rendering/RenderFlexibleBox.h:
• rendering/RenderFlow.cpp:
• rendering/RenderFlow.h:
• rendering/RenderForeignObject.cpp: (WebCore::RenderForeignObject::RenderForeignObject): (WebCore::RenderForeignObject::paint): (WebCore::RenderForeignObject::computeAbsoluteRepaintRect): (WebCore::RenderForeignObject::layout): (WebCore::RenderForeignObject::nodeAtPoint):
• rendering/RenderForeignObject.h: (WebCore::RenderForeignObject::renderName):
• rendering/RenderFormElement.cpp: (WebCore::RenderFormElement::setStyle): (WebCore::RenderFormElement::layout): (WebCore::RenderFormElement::textAlignment):
• rendering/RenderFormElement.h:
• rendering/RenderFrame.cpp:
• rendering/RenderFrame.h: (WebCore::RenderFrame::element):
• rendering/RenderFrameSet.cpp:
• rendering/RenderFrameSet.h: (WebCore::RenderFrameSet::element):
• rendering/RenderHTMLCanvas.cpp: (WebCore::RenderHTMLCanvas::RenderHTMLCanvas): (WebCore::RenderHTMLCanvas::paint):
• rendering/RenderHTMLCanvas.h: (WebCore::RenderHTMLCanvas::renderName):
• rendering/RenderImage.cpp: (WebCore::RenderImage::RenderImage): (WebCore::RenderImage::setStyle): (WebCore::RenderImage::setContentObject): (WebCore::RenderImage::setCachedImage): (WebCore::RenderImage::imageChanged): (WebCore::RenderImage::paint): (WebCore::RenderImage::layout): (WebCore::RenderImage::updateAltText):
• rendering/RenderImage.h: (WebCore::RenderImage::element):
• rendering/RenderInline.cpp: (WebCore::RenderInline::RenderInline): (WebCore::RenderInline::~RenderInline): (WebCore::RenderInline::setStyle): (WebCore::RenderInline::addChildToFlow): (WebCore::RenderInline::cloneInline): (WebCore::RenderInline::splitInlines): (WebCore::RenderInline::splitFlow): (WebCore::RenderInline::paint): (WebCore::RenderInline::absoluteRects): (WebCore::RenderInline::calcMinMaxWidth): (WebCore::RenderInline::requiresLayer): (WebCore::RenderInline::width): (WebCore::RenderInline::height): (WebCore::RenderInline::renderName): (WebCore::RenderInline::nodeAtPoint): (WebCore::RenderInline::positionForCoordinates):
• rendering/RenderInline.h: (WebCore::RenderInline::layout):
• rendering/RenderLayer.cpp:
• rendering/RenderLayer.h: (WebCore::ClipRects::ClipRects): (WebCore::RenderLayer::nextSibling): (WebCore::RenderLayer::root): (WebCore::RenderLayer::setPos): (WebCore::RenderLayer::height): (WebCore::RenderLayer::relativePositionOffset):
• rendering/RenderLineEdit.cpp: (WebCore::RenderLineEdit::setStyle): (WebCore::RenderLineEdit::updateFromElement): (WebCore::RenderLineEdit::selectionStart): (WebCore::RenderLineEdit::selectionEnd): (WebCore::RenderLineEdit::setSelectionStart): (WebCore::RenderLineEdit::setSelectionEnd): (WebCore::RenderLineEdit::setSelectionRange):
• rendering/RenderLineEdit.h:
• rendering/RenderListBox.cpp:
• rendering/RenderListBox.h: (WebCore::RenderListBox::renderName):
• rendering/RenderListItem.cpp: (WebCore::RenderListItem::setStyle): (WebCore::getParentOfFirstLineBox): (WebCore::RenderListItem::updateMarkerLocation): (WebCore::RenderListItem::positionListMarker): (WebCore::RenderListItem::paint):
• rendering/RenderListItem.h:
• rendering/RenderListMarker.cpp:
• rendering/RenderListMarker.h: (WebCore::RenderListMarker::renderName): (WebCore::RenderListMarker::isListMarker):

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• WebCore.xcodeproj/project.pbxproj (modified) (2 diffs)
• rendering/RenderApplet.cpp (modified) (4 diffs)
• rendering/RenderApplet.h (modified) (2 diffs)
• rendering/RenderArena.cpp (modified) (9 diffs)
• rendering/RenderArena.h (modified) (2 diffs)
• rendering/RenderBR.cpp (modified) (6 diffs)
• rendering/RenderBR.h (modified) (2 diffs)
• rendering/RenderBlock.cpp (modified) (2 diffs)
• rendering/RenderBlock.h (modified) (22 diffs)
• rendering/RenderButton.cpp (modified) (3 diffs)
• rendering/RenderButton.h (modified) (4 diffs)
• rendering/RenderContainer.cpp (modified) (3 diffs)
• rendering/RenderContainer.h (modified) (4 diffs)
• rendering/RenderCounter.cpp (modified) (6 diffs)
• rendering/RenderCounter.h (modified) (2 diffs)
• rendering/RenderFieldset.cpp (modified) (5 diffs)
• rendering/RenderFileUploadControl.cpp (modified) (9 diffs)
• rendering/RenderFileUploadControl.h (modified) (3 diffs)
• rendering/RenderFlexibleBox.h (modified) (4 diffs)
• rendering/RenderFlow.cpp (modified) (3 diffs)
• rendering/RenderFlow.h (modified) (5 diffs)
• rendering/RenderForeignObject.cpp (modified) (6 diffs)
• rendering/RenderForeignObject.h (modified) (3 diffs)
• rendering/RenderFormElement.cpp (modified) (3 diffs)
• rendering/RenderFormElement.h (modified) (1 diff)
• rendering/RenderFrame.cpp (modified) (1 diff)
• rendering/RenderFrame.h (modified) (2 diffs)
• rendering/RenderFrameSet.cpp (modified) (3 diffs)
• rendering/RenderFrameSet.h (modified) (4 diffs)
• rendering/RenderHTMLCanvas.cpp (modified) (4 diffs)
• rendering/RenderHTMLCanvas.h (modified) (2 diffs)
• rendering/RenderImage.cpp (modified) (14 diffs)
• rendering/RenderImage.h (modified) (5 diffs)
• rendering/RenderInline.cpp (modified) (19 diffs)
• rendering/RenderInline.h (modified) (6 diffs)
• rendering/RenderLayer.cpp (modified) (3 diffs)
• rendering/RenderLayer.h (modified) (21 diffs)
• rendering/RenderLineEdit.cpp (modified) (7 diffs)
• rendering/RenderLineEdit.h (modified) (1 diff)
• rendering/RenderListBox.cpp (modified) (2 diffs)
• rendering/RenderListBox.h (modified) (5 diffs)
• rendering/RenderListItem.cpp (modified) (6 diffs)
• rendering/RenderListItem.h (modified) (4 diffs)
• rendering/RenderListMarker.cpp (modified) (1 diff)
• rendering/RenderListMarker.h (modified) (4 diffs)

trunk/WebCore/ChangeLog

@@ +1 @@
+2006-10-30  Sam Weinig  <sam.weinig@gmail.com>
+
+        Reviewed by Mitz.
+
+        Fix for http://bugs.webkit.org/show_bug.cgi?id=11441
+        More rendering code cleaning
+
+        * WebCore.xcodeproj/project.pbxproj:
+        * rendering/RenderApplet.cpp:
+        (WebCore::RenderApplet::RenderApplet):
+        (WebCore::RenderApplet::createWidgetIfNecessary):
+        * rendering/RenderApplet.h:
+        * rendering/RenderArena.cpp:
+        (WebCore::):
+        (WebCore::RenderArena::RenderArena):
+        (WebCore::RenderArena::allocate):
+        (WebCore::RenderArena::free):
+        * rendering/RenderArena.h:
+        * rendering/RenderBR.cpp:
+        (WebCore::RenderBR::RenderBR):
+        (WebCore::RenderBR::baselinePosition):
+        (WebCore::RenderBR::lineHeight):
+        (WebCore::RenderBR::setStyle):
+        (WebCore::RenderBR::caretMinOffset):
+        (WebCore::RenderBR::positionForCoordinates):
+        (WebCore::RenderBR::inlineBox):
+        * rendering/RenderBR.h:
+        * rendering/RenderBlock.cpp:
+        * rendering/RenderBlock.h:
+        (WebCore::RenderBlock::maxTopMargin):
+        (WebCore::RenderBlock::maxBottomMargin):
+        (WebCore::RenderBlock::initMaxMarginValues):
+        (WebCore::RenderBlock::containsFloats):
+        (WebCore::RenderBlock::setHasMarkupTruncation):
+        (WebCore::RenderBlock::BlockSelectionInfo::BlockSelectionInfo):
+        (WebCore::RenderBlock::BlockSelectionInfo::block):
+        (WebCore::RenderBlock::BlockSelectionInfo::state):
+        (WebCore::RenderBlock::FloatingObject::FloatingObject):
+        (WebCore::RenderBlock::CompactInfo::clear):
+        * rendering/RenderButton.cpp:
+        (WebCore::RenderButton::removeChild):
+        (WebCore::RenderButton::paintObject):
+        * rendering/RenderButton.h:
+        (WebCore::RenderButton::renderName):
+        (WebCore::RenderButton::removeLeftoverAnonymousBoxes):
+        * rendering/RenderContainer.cpp:
+        (WebCore::RenderContainer::RenderContainer):
+        * rendering/RenderContainer.h:
+        (WebCore::RenderContainer::firstChild):
+        (WebCore::RenderContainer::lastChild):
+        (WebCore::RenderContainer::calcMinMaxWidth):
+        * rendering/RenderCounter.cpp:
+        (WebCore::RenderCounter::RenderCounter):
+        (WebCore::toRoman):
+        (WebCore::toHebrew):
+        (WebCore::RenderCounter::calcMinMaxWidth):
+        * rendering/RenderCounter.h:
+        * rendering/RenderFieldset.cpp:
+        (WebCore::RenderFieldset::paintBoxDecorations):
+        (WebCore::RenderFieldset::paintBorderMinusLegend):
+        (WebCore::RenderFieldset::setStyle):
+        * rendering/RenderFileUploadControl.cpp:
+        (WebCore::RenderFileUploadControl::~RenderFileUploadControl):
+        (WebCore::RenderFileUploadControl::setStyle):
+        (WebCore::RenderFileUploadControl::paintObject):
+        (WebCore::RenderFileUploadControl::calcMinMaxWidth):
+        * rendering/RenderFileUploadControl.h:
+        (WebCore::RenderFileUploadControl::renderName):
+        * rendering/RenderFlexibleBox.h:
+        * rendering/RenderFlow.cpp:
+        * rendering/RenderFlow.h:
+        * rendering/RenderForeignObject.cpp:
+        (WebCore::RenderForeignObject::RenderForeignObject):
+        (WebCore::RenderForeignObject::paint):
+        (WebCore::RenderForeignObject::computeAbsoluteRepaintRect):
+        (WebCore::RenderForeignObject::layout):
+        (WebCore::RenderForeignObject::nodeAtPoint):
+        * rendering/RenderForeignObject.h:
+        (WebCore::RenderForeignObject::renderName):
+        * rendering/RenderFormElement.cpp:
+        (WebCore::RenderFormElement::setStyle):
+        (WebCore::RenderFormElement::layout):
+        (WebCore::RenderFormElement::textAlignment):
+        * rendering/RenderFormElement.h:
+        * rendering/RenderFrame.cpp:
+        * rendering/RenderFrame.h:
+        (WebCore::RenderFrame::element):
+        * rendering/RenderFrameSet.cpp:
+        * rendering/RenderFrameSet.h:
+        (WebCore::RenderFrameSet::element):
+        * rendering/RenderHTMLCanvas.cpp:
+        (WebCore::RenderHTMLCanvas::RenderHTMLCanvas):
+        (WebCore::RenderHTMLCanvas::paint):
+        * rendering/RenderHTMLCanvas.h:
+        (WebCore::RenderHTMLCanvas::renderName):
+        * rendering/RenderImage.cpp:
+        (WebCore::RenderImage::RenderImage):
+        (WebCore::RenderImage::setStyle):
+        (WebCore::RenderImage::setContentObject):
+        (WebCore::RenderImage::setCachedImage):
+        (WebCore::RenderImage::imageChanged):
+        (WebCore::RenderImage::paint):
+        (WebCore::RenderImage::layout):
+        (WebCore::RenderImage::updateAltText):
+        * rendering/RenderImage.h:
+        (WebCore::RenderImage::element):
+        * rendering/RenderInline.cpp:
+        (WebCore::RenderInline::RenderInline):
+        (WebCore::RenderInline::~RenderInline):
+        (WebCore::RenderInline::setStyle):
+        (WebCore::RenderInline::addChildToFlow):
+        (WebCore::RenderInline::cloneInline):
+        (WebCore::RenderInline::splitInlines):
+        (WebCore::RenderInline::splitFlow):
+        (WebCore::RenderInline::paint):
+        (WebCore::RenderInline::absoluteRects):
+        (WebCore::RenderInline::calcMinMaxWidth):
+        (WebCore::RenderInline::requiresLayer):
+        (WebCore::RenderInline::width):
+        (WebCore::RenderInline::height):
+        (WebCore::RenderInline::renderName):
+        (WebCore::RenderInline::nodeAtPoint):
+        (WebCore::RenderInline::positionForCoordinates):
+        * rendering/RenderInline.h:
+        (WebCore::RenderInline::layout):
+        * rendering/RenderLayer.cpp:
+        * rendering/RenderLayer.h:
+        (WebCore::ClipRects::ClipRects):
+        (WebCore::RenderLayer::nextSibling):
+        (WebCore::RenderLayer::root):
+        (WebCore::RenderLayer::setPos):
+        (WebCore::RenderLayer::height):
+        (WebCore::RenderLayer::relativePositionOffset):
+        * rendering/RenderLineEdit.cpp:
+        (WebCore::RenderLineEdit::setStyle):
+        (WebCore::RenderLineEdit::updateFromElement):
+        (WebCore::RenderLineEdit::selectionStart):
+        (WebCore::RenderLineEdit::selectionEnd):
+        (WebCore::RenderLineEdit::setSelectionStart):
+        (WebCore::RenderLineEdit::setSelectionEnd):
+        (WebCore::RenderLineEdit::setSelectionRange):
+        * rendering/RenderLineEdit.h:
+        * rendering/RenderListBox.cpp:
+        * rendering/RenderListBox.h:
+        (WebCore::RenderListBox::renderName):
+        * rendering/RenderListItem.cpp:
+        (WebCore::RenderListItem::setStyle):
+        (WebCore::getParentOfFirstLineBox):
+        (WebCore::RenderListItem::updateMarkerLocation):
+        (WebCore::RenderListItem::positionListMarker):
+        (WebCore::RenderListItem::paint):
+        * rendering/RenderListItem.h:
+        * rendering/RenderListMarker.cpp:
+        * rendering/RenderListMarker.h:
+        (WebCore::RenderListMarker::renderName):
+        (WebCore::RenderListMarker::isListMarker):
+
 2006-10-30  Timothy Hatcher  <timothy@apple.com>
 

trunk/WebCore/WebCore.xcodeproj/project.pbxproj

@@ -8784 +8784 @@
                         isa = PBXGroup;
                         children = (
-                                ABB5419C0ACDDFE4002820EB /* RenderListBox.cpp */,
-                                ABB5419D0ACDDFE4002820EB /* RenderListBox.h */,
                                 A8CFF04B0A154F09000A4234 /* AutoTableLayout.cpp */,
                                 A8CFF0490A154F09000A4234 /* AutoTableLayout.h */,
@@ -8865 +8863 @@
                                 A8EA73BE0A1900E300A8EF5F /* RenderLineEdit.cpp */,
                                 A8EA73B10A1900E300A8EF5F /* RenderLineEdit.h */,
+                                ABB5419C0ACDDFE4002820EB /* RenderListBox.cpp */,
+                                ABB5419D0ACDDFE4002820EB /* RenderListBox.h */,
                                 A8EA7A480A191A5200A8EF5F /* RenderListItem.cpp */,
                                 A8EA7A4C0A191A5200A8EF5F /* RenderListItem.h */,

trunk/WebCore/rendering/RenderApplet.cpp

@@ -36 +36 @@
 
 RenderApplet::RenderApplet(HTMLAppletElement* applet, const HashMap<String, String>& args)
-    : RenderWidget(applet), m_args(args)
+    : RenderWidget(applet)
+    , m_args(args)
 {
     setInline(true);
@@ -75 +76 @@
     int height = style()->height().isFixed() ? style()->height().value() :
         m_height - borderTop() - borderBottom() - paddingTop() - paddingBottom();
-    for (Node* child = node()->firstChild(); child; child = child->nextSibling())
+    for (Node* child = node()->firstChild(); child; child = child->nextSibling()) {
         if (child->hasTagName(paramTag)) {
             HTMLParamElement* p = static_cast<HTMLParamElement*>(child);
@@ -81 +82 @@
                 m_args.set(p->name(), p->value());
         }
-    
+    }
+
     Frame* frame = document()->frame();
     ASSERT(frame);
@@ -100 +102 @@
 }
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderApplet.h

@@ -36 +36 @@
         RenderApplet(HTMLAppletElement*, const HashMap<String, String>& args);
         virtual ~RenderApplet();
+
         virtual const char* renderName() const { return "RenderApplet"; }
+
         virtual bool isApplet() const { return true; }
+
         virtual void layout();
         virtual int intrinsicWidth() const;
@@ -48 +51 @@
     };
 
-}
+} // namespace WebCore
 
-#endif
+#endif // RenderApplet_h

trunk/WebCore/rendering/RenderArena.cpp

@@ -37 +37 @@
 
 #include <assert.h>
+#include <stdlib.h>
 #include <string.h>
-#include <stdlib.h>
 
 #define ROUNDUP(x,y) ((((x)+((y)-1))/(y))*(y))
@@ -50 +50 @@
 
 typedef struct {
-    RenderArena *arena;
+    RenderArena* arena;
     size_t size;
     int signature;
@@ -57 +57 @@
 #endif
 
-RenderArena::RenderArena(unsigned int arenaSize)
+RenderArena::RenderArena(unsigned arenaSize)
 {
     // Initialize the arena pool
@@ -77 +77 @@
     // Use standard malloc so that memory debugging tools work.
     assert(this);
-    void *block = ::malloc(sizeof(RenderArenaDebugHeader) + size);
-    RenderArenaDebugHeader *header = (RenderArenaDebugHeader *)block;
+    void* block = ::malloc(sizeof(RenderArenaDebugHeader) + size);
+    RenderArenaDebugHeader* header = (RenderArenaDebugHeader*)block;
     header->arena = this;
     header->size = size;
@@ -91 +91 @@
     // Check recyclers first
     if (size < gMaxRecycledSize) {
-        const int   index = size >> 2;
-    
+        const int index = size >> 2;
+
         result = m_recyclers[index];
         if (result) {
@@ -100 +100 @@
         }
     }
-    
+
     if (!result) {
         // Allocate a new chunk from the arena
@@ -114 +114 @@
 #ifndef NDEBUG
     // Use standard free so that memory debugging tools work.
-    RenderArenaDebugHeader *header = (RenderArenaDebugHeader *)ptr - 1;
+    RenderArenaDebugHeader* header = (RenderArenaDebugHeader*)ptr - 1;
     assert(header->signature == signature);
     assert(header->size == size);
@@ -126 +126 @@
     // See if it's a size that we recycle
     if (size < gMaxRecycledSize) {
-        const int   index = size >> 2;
-        void*       currentTop = m_recyclers[index];
+        const int index = size >> 2;
+        void* currentTop = m_recyclers[index];
         m_recyclers[index] = ptr;
         *((void**)ptr) = currentTop;
@@ -134 +134 @@
 }
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderArena.h

@@ -33 +33 @@
  */
 
-#ifndef RENDERARENA_H
-#define RENDERARENA_H
+#ifndef RenderArena_h
+#define RenderArena_h
 
 #include "Arena.h"
@@ -44 +44 @@
 class RenderArena {
 public:
-   RenderArena(unsigned int arenaSize = 4096);
+    RenderArena(unsigned arenaSize = 4096);
     ~RenderArena();
 
-  // Memory management functions
-  void* allocate(size_t size);
-  void  free(size_t size, void* ptr);
+    // Memory management functions
+    void* allocate(size_t);
+    void free(size_t, void*);
 
 private:
-  // Underlying arena pool
-  ArenaPool m_pool;
+    // Underlying arena pool
+    ArenaPool m_pool;
 
-  // The recycler array is sparse with the indices being multiples of 4,
-  // i.e., 0, 4, 8, 12, 16, 20, ...
-  void*       m_recyclers[gMaxRecycledSize >> 2];
+    // The recycler array is sparse with the indices being multiples of 4,
+    // i.e., 0, 4, 8, 12, 16, 20, ...
+    void* m_recyclers[gMaxRecycledSize >> 2];
 };
 
-}
+} // namespace WebCore
 
-#endif
+#endif // RenderArena_h

trunk/WebCore/rendering/RenderBR.cpp

@@ -32 +32 @@
 
 RenderBR::RenderBR(Node* node)
-    : RenderText(node, new StringImpl("\n")), m_lineHeight(-1)
+    : RenderText(node, new StringImpl("\n"))
+    , m_lineHeight(-1)
 {
 }
@@ -49 +50 @@
 }
 
-short RenderBR::baselinePosition( bool firstLine, bool isRootLineBox) const
+short RenderBR::baselinePosition(bool firstLine, bool isRootLineBox) const
 {
     if (firstTextBox() && !firstTextBox()->isText())
@@ -76 +77 @@
         return lh.value();
     }
-    
+
     if (m_lineHeight == -1)
         m_lineHeight = RenderObject::lineHeight(false);
@@ -82 +83 @@
 }
 
-void RenderBR::setStyle(RenderStyle* _style)
+void RenderBR::setStyle(RenderStyle* newStyle)
 {
-    RenderText::setStyle(_style);
+    RenderText::setStyle(newStyle);
     m_lineHeight = -1;
 }
@@ -90 +91 @@
 int RenderBR::caretMinOffset() const 
 { 
-    return 0; 
+    return 0;
 }
 
@@ -103 +104 @@
 }
 
-VisiblePosition RenderBR::positionForCoordinates(int _x, int _y)
+VisiblePosition RenderBR::positionForCoordinates(int /*x*/, int /*y*/)
 {
     return VisiblePosition(element(), 0, DOWNSTREAM);
 }
 
-InlineBox *RenderBR::inlineBox(int offset, EAffinity affinity)
+InlineBox* RenderBR::inlineBox(int /*offset*/, EAffinity /*affinity*/)
 {
     return firstTextBox();
 }
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderBR.h

@@ -20 +20 @@
  *
  */
-#ifndef RENDER_BR_H
-#define RENDER_BR_H
+
+#ifndef RenderBR_h
+#define RenderBR_h
 
 #include "RenderText.h"
@@ -57 +58 @@
     virtual int caretMaxOffset() const;
     virtual unsigned caretMaxRenderedOffset() const;
-    
+
     virtual VisiblePosition positionForCoordinates(int x, int y);
 
-    virtual InlineBox* inlineBox(int offset, EAffinity affinity = UPSTREAM);
-    
+    virtual InlineBox* inlineBox(int offset, EAffinity = UPSTREAM);
+
 private:
     mutable short m_lineHeight;
-
 };
 
 } // namespace WebCore
 
-#endif // RENDER_BR_H
+#endif // RenderBR_h

trunk/WebCore/rendering/RenderBlock.cpp

@@ -29 +29 @@
 #include "Frame.h"
 #include "GraphicsContext.h"
+#include "HTMLNames.h"
+#include "HitTestResult.h"
 #include "InlineTextBox.h"
-#include "HitTestResult.h"
 #include "RenderTableCell.h"
 #include "RenderTextFragment.h"
+#include "RenderTheme.h"
+#include "RenderView.h"
 #include "SelectionController.h"
-#include "HTMLNames.h"
-#include "RenderView.h"
-#include "RenderTheme.h"
 #include "TextStream.h"
 
@@ -3681 +3681 @@
 
 } // namespace WebCore
-

trunk/WebCore/rendering/RenderBlock.h

@@ -22 +22 @@
  */
 
-#ifndef RenderBlock_H
-#define RenderBlock_H
+#ifndef RenderBlock_h
+#define RenderBlock_h
 
 #include "GapRects.h"
@@ -47 +47 @@
 
     // These two functions are overridden for inline-block.
-    virtual short lineHeight(bool b, bool isRootLineBox=false) const;
-    virtual short baselinePosition(bool b, bool isRootLineBox=false) const;
-    
+    virtual short lineHeight(bool firstLine, bool isRootLineBox = false) const;
+    virtual short baselinePosition(bool firstLine, bool isRootLineBox = false) const;
+
     virtual bool isRenderBlock() const { return true; }
     virtual bool isBlockFlow() const { return (!isInline() || isReplaced()) && !isTable(); }
     virtual bool isInlineFlow() const { return isInline() && !isReplaced(); }
     virtual bool isInlineBlockOrInlineTable() const { return isInline() && isReplaced(); }
-    
+
     virtual bool childrenInline() const { return m_childrenInline; }
     virtual void setChildrenInline(bool b) { m_childrenInline = b; }
@@ -62 +62 @@
     // of the block (e.g., a <div style="height:25px"> that has a 100px tall image inside
     // it would have an overflow height of borderTop() + paddingTop() + 100px.
-    virtual int overflowHeight(bool includeInterior=true) const;
-    virtual int overflowWidth(bool includeInterior=true) const;
-    virtual int overflowLeft(bool includeInterior=true) const;
-    virtual int overflowTop(bool includeInterior=true) const;
-    virtual IntRect overflowRect(bool includeInterior=true) const;
+    virtual int overflowHeight(bool includeInterior = true) const;
+    virtual int overflowWidth(bool includeInterior = true) const;
+    virtual int overflowLeft(bool includeInterior = true) const;
+    virtual int overflowTop(bool includeInterior = true) const;
+    virtual IntRect overflowRect(bool includeInterior = true) const;
     virtual void setOverflowHeight(int h) { m_overflowHeight = h; }
     virtual void setOverflowWidth(int w) { m_overflowWidth = w; }
-    
+
     virtual bool isSelfCollapsingBlock() const;
     virtual bool isTopMarginQuirk() const { return m_topMarginQuirk; }
     virtual bool isBottomMarginQuirk() const { return m_bottomMarginQuirk; }
 
-    virtual int maxTopMargin(bool positive) const {
-        if (positive)
-            return m_maxTopPosMargin;
-        else
-            return m_maxTopNegMargin;
-    }
-    virtual int maxBottomMargin(bool positive) const {
-        if (positive)
-            return m_maxBottomPosMargin;
-        else
-            return m_maxBottomNegMargin;
-    }
-
-    void initMaxMarginValues() {
+    virtual int maxTopMargin(bool positive) const { return positive ? m_maxTopPosMargin : m_maxTopNegMargin; }
+    virtual int maxBottomMargin(bool positive) const { return positive ? m_maxBottomPosMargin : m_maxBottomNegMargin; }
+
+    void initMaxMarginValues()
+    {
         if (m_marginTop >= 0) {
             m_maxTopPosMargin = m_marginTop;
@@ -127 +118 @@
     // Called to lay out the legend for a fieldset.
     virtual RenderObject* layoutLegend(bool relayoutChildren) { return 0; };
-    
+
     // the implementation of the following functions is in bidi.cpp
     void bidiReorderLine(const BidiIterator& start, const BidiIterator& end, BidiState& bidi);
@@ -137 +128 @@
                         const BidiIterator& endLineStart, const BidiStatus& endLineStatus, BidiContext* endLineContext,
                         RootInlineBox*& endLine, int& endYPos, int& repaintBottom, int& repaintTop);
-    int skipWhitespace(BidiIterator& , BidiState &);
-    BidiIterator findNextLineBreak(BidiIterator& start, BidiState &info );
+    int skipWhitespace(BidiIterator&, BidiState&);
+    BidiIterator findNextLineBreak(BidiIterator& start, BidiState& info);
     RootInlineBox* constructLine(const BidiIterator& start, const BidiIterator& end);
     InlineFlowBox* createLineBoxes(RenderObject*);
@@ -148 +139 @@
     void checkLinesForTextOverflow();
     // end bidi.cpp functions
+
+    virtual void paint(PaintInfo&, int tx, int ty);
+    virtual void paintObject(PaintInfo&, int tx, int ty);
+    void paintFloats(PaintInfo&, int tx, int ty, bool paintSelection = false);
+    void paintChildren(PaintInfo&, int tx, int ty);
+    void paintEllipsisBoxes(PaintInfo&, int tx, int ty);
+    void paintSelection(PaintInfo&, int tx, int ty);
+    void paintCaret(PaintInfo&, CaretType);
     
-    virtual void paint(PaintInfo& i, int tx, int ty);
-    virtual void paintObject(PaintInfo& i, int tx, int ty);
-    void paintFloats(PaintInfo& i, int _tx, int _ty, bool paintSelection = false);
-    void paintChildren(PaintInfo& i, int _tx, int _ty);
-    void paintEllipsisBoxes(PaintInfo& i, int _tx, int _ty);
-    void paintSelection(PaintInfo& i, int _tx, int _ty);
-    void paintCaret(PaintInfo& i, CaretType);
-    
-    void insertFloatingObject(RenderObject *o);
-    void removeFloatingObject(RenderObject *o);
+    void insertFloatingObject(RenderObject*);
+    void removeFloatingObject(RenderObject*);
     void setPaintsFloatingObject(RenderObject*, bool);
 
@@ -164 +155 @@
     void positionNewFloats();
     void clearFloats();
-    int getClearDelta(RenderObject *child);
+    int getClearDelta(RenderObject* child);
     virtual void markAllDescendantsWithFloatsForLayout(RenderObject* floatToRemove = 0);
     void markPositionedObjectsForLayout();
@@ -171 +162 @@
     // is empty. However, layoutInlineChildren() relies on the current behavior.
     // http://bugzilla.opendarwin.org/show_bug.cgi?id=7395#c3
-    virtual bool containsFloats() { return m_floatingObjects!=0; }
-    virtual bool containsFloat(RenderObject* o);
+    virtual bool containsFloats() { return m_floatingObjects; }
+    virtual bool containsFloat(RenderObject*);
 
     virtual bool hasOverhangingFloats() { return floatBottom() > m_height; }
@@ -185 +176 @@
 
     virtual int lineWidth(int y) const;
-    virtual int lowestPosition(bool includeOverflowInterior=true, bool includeSelf=true) const;
-    virtual int rightmostPosition(bool includeOverflowInterior=true, bool includeSelf=true) const;
-    virtual int leftmostPosition(bool includeOverflowInterior=true, bool includeSelf=true) const;
+    virtual int lowestPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;
+    virtual int rightmostPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;
+    virtual int leftmostPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;
 
     int rightOffset() const;
-    int rightRelOffset(int y, int fixedOffset, bool applyTextIndent = true,
-                       int *heightRemaining = 0) const;
+    int rightRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int* heightRemaining = 0) const;
     int rightOffset(int y) const { return rightRelOffset(y, rightOffset(), true); }
 
     int leftOffset() const;
-    int leftRelOffset(int y, int fixedOffset, bool applyTextIndent = true,
-                      int *heightRemaining = 0) const;
+    int leftRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int* heightRemaining = 0) const;
     int leftOffset(int y) const { return leftRelOffset(y, leftOffset(), true); }
 
-    virtual bool nodeAtPoint(HitTestResult&, int x, int y, int tx, int ty, HitTestAction hitTestAction);
+    virtual bool nodeAtPoint(HitTestResult&, int x, int y, int tx, int ty, HitTestAction);
 
     virtual bool isPointInScrollbar(HitTestResult&, int x, int y, int tx, int ty);
@@ -219 +208 @@
     virtual RenderBlock* firstLineBlock() const;
     virtual void updateFirstLetter();
-    
+
     bool inRootBlockContext() const;
 
-    void setHasMarkupTruncation(bool b=true) { m_hasMarkupTruncation = b; }
+    void setHasMarkupTruncation(bool b = true) { m_hasMarkupTruncation = b; }
     bool hasMarkupTruncation() const { return m_hasMarkupTruncation; }
 
@@ -234 +223 @@
         SelectionState m_state;
 
-        BlockSelectionInfo() { m_block = 0; m_state = SelectionNone; }
-        BlockSelectionInfo(RenderBlock* b) { 
-            m_block = b;
-            m_state = m_block->selectionState();
-            m_rects = m_block->selectionGapRects();
+        BlockSelectionInfo()
+            : m_block(0)
+            , m_state(SelectionNone)
+        {
         }
-        
+
+        BlockSelectionInfo(RenderBlock* b)
+            : m_block(b)
+            , m_rects(b->selectionGapRects())
+            , m_state(b->selectionState())
+        { 
+        }
+
+        RenderBlock* block() const { return m_block; }
         GapRects rects() const { return m_rects; }
         SelectionState state() const { return m_state; }
-        RenderBlock* block() const { return m_block; }
     };
-    
+
     virtual IntRect selectionRect() { return selectionGapRects(); }
     GapRects selectionGapRects();
     virtual bool shouldPaintSelectionGaps() const;
     bool isSelectionRoot() const;
-    GapRects fillSelectionGaps(RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty, 
-                               int& lastTop, int& lastLeft, int& lastRight, const PaintInfo* i = 0);
+    GapRects fillSelectionGaps(RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty,
+                               int& lastTop, int& lastLeft, int& lastRight, const PaintInfo* = 0);
     GapRects fillInlineSelectionGaps(RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty,
-                                     int& lastTop, int& lastLeft, int& lastRight, const PaintInfo* i);
+                                     int& lastTop, int& lastLeft, int& lastRight, const PaintInfo*);
     GapRects fillBlockSelectionGaps(RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty,
-                                    int& lastTop, int& lastLeft, int& lastRight, const PaintInfo* i);
-    IntRect fillVerticalSelectionGap(int lastTop, int lastLeft, int lastRight,
-                                   int bottomY, RenderBlock* rootBlock, int blockX, int blockY, const PaintInfo* i);
-    IntRect fillLeftSelectionGap(RenderObject* selObj, int xPos, int yPos, int height, RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty, const PaintInfo* i);
-    IntRect fillRightSelectionGap(RenderObject* selObj, int xPos, int yPos, int height, RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty, const PaintInfo* i);
-    IntRect fillHorizontalSelectionGap(RenderObject* selObj, int xPos, int yPos, int width, int height, const PaintInfo* i);
-
-    void getHorizontalSelectionGapInfo(SelectionState state, bool& leftGap, bool& rightGap);
+                                    int& lastTop, int& lastLeft, int& lastRight, const PaintInfo*);
+    IntRect fillVerticalSelectionGap(int lastTop, int lastLeft, int lastRight, int bottomY, RenderBlock* rootBlock,
+                                     int blockX, int blockY, const PaintInfo*);
+    IntRect fillLeftSelectionGap(RenderObject* selObj, int xPos, int yPos, int height, RenderBlock* rootBlock, 
+                                 int blockX, int blockY, int tx, int ty, const PaintInfo*);
+    IntRect fillRightSelectionGap(RenderObject* selObj, int xPos, int yPos, int height, RenderBlock* rootBlock,
+                                  int blockX, int blockY, int tx, int ty, const PaintInfo*);
+    IntRect fillHorizontalSelectionGap(RenderObject* selObj, int xPos, int yPos, int width, int height, const PaintInfo*);
+
+    void getHorizontalSelectionGapInfo(SelectionState, bool& leftGap, bool& rightGap);
     int leftSelectionOffset(RenderBlock* rootBlock, int y);
     int rightSelectionOffset(RenderBlock* rootBlock, int y);
 
 #ifndef NDEBUG
-    virtual void dump(TextStream *stream, DeprecatedString ind = "") const;
+    virtual void dump(TextStream*, DeprecatedString ind = "") const;
 #endif
 
     // Helper methods for computing line counts and heights for line counts.
-    RootInlineBox* lineAtIndex(int i);
+    RootInlineBox* lineAtIndex(int);
     int lineCount();
-    int heightForLineCount(int l);
+    int heightForLineCount(int);
     void clearTruncation();
 
@@ -281 +278 @@
 
 private:
-    Position positionForBox(InlineBox *box, bool start=true) const;
-    Position positionForRenderer(RenderObject *renderer, bool start=true) const;
+    Position positionForBox(InlineBox*, bool start = true) const;
+    Position positionForRenderer(RenderObject*, bool start = true) const;
         
 protected:
@@ -291 +288 @@
         };
 
-        FloatingObject(Type type) {
-            node = 0;
-            startY = 0;
-            endY = 0;
-            m_type = type;
-            left = 0;
-            width = 0;
-            noPaint = false;
+        FloatingObject(Type type)
+            : node(0)
+            , startY(0)
+            , endY(0)
+            , left(0)
+            , width(0)
+            , m_type(type)
+            , noPaint(false)
+        {
         }
-        
+
         Type type() { return static_cast<Type>(m_type); }
 
@@ -311 +309 @@
         bool noPaint : 1;
     };
-    
+
     // The following helper functions and structs are used by layoutBlockChildren.
     class CompactInfo {
         // A compact child that needs to be collapsed into the margin of the following block.
         RenderObject* m_compact;
-        
+
         // The block with the open margin that the compact child is going to place itself within.
         RenderObject* m_block;
@@ -324 +322 @@
         RenderObject* block() const { return m_block; }
         bool matches(RenderObject* child) const { return m_compact && m_block == child; }
-        
-        void clear() { set(0, 0);  }
+
+        void clear() { set(0, 0); }
         void set(RenderObject* c, RenderObject* b) { m_compact = c; m_block = b; }
-        
+
         CompactInfo() { clear(); }
     };
@@ -336 +334 @@
         bool m_canCollapseTopWithChildren : 1;
         bool m_canCollapseBottomWithChildren : 1;
-        
+
         // Whether or not we are a quirky container, i.e., do we collapse away top and bottom
         // margins in our container.  Table cells and the body are the common examples. We
@@ -354 +352 @@
         // we track it in this variable.
         bool m_selfCollapsingBlockClearedFloat : 1;
-    
+
         // These variables are used to detect quirky margins that we need to collapse away (in table cells
         // and in the body element).
@@ -367 +365 @@
     public:
         MarginInfo(RenderBlock* b, int top, int bottom);
-        
+
         void setAtTopOfBlock(bool b) { m_atTopOfBlock = b; }
         void setAtBottomOfBlock(bool b) { m_atBottomOfBlock = b; }
@@ -396 +394 @@
         int margin() const { return m_posMargin - m_negMargin; }
     };
-    
-    void adjustPositionedBlock(RenderObject* child, const MarginInfo& marginInfo);
-    void adjustFloatingBlock(const MarginInfo& marginInfo);
-    RenderObject* handleSpecialChild(RenderObject* child, const MarginInfo& marginInfo, CompactInfo& compactInfo, bool& handled);
-    RenderObject* handleFloatingChild(RenderObject* child, const MarginInfo& marginInfo, bool& handled);
-    RenderObject* handlePositionedChild(RenderObject* child, const MarginInfo& marginInfo, bool& handled);
-    RenderObject* handleCompactChild(RenderObject* child, CompactInfo& compactInfo, bool& handled);
+
+    void adjustPositionedBlock(RenderObject* child, const MarginInfo&);
+    void adjustFloatingBlock(const MarginInfo&);
+    RenderObject* handleSpecialChild(RenderObject* child, const MarginInfo&, CompactInfo&, bool& handled);
+    RenderObject* handleFloatingChild(RenderObject* child, const MarginInfo&, bool& handled);
+    RenderObject* handlePositionedChild(RenderObject* child, const MarginInfo&, bool& handled);
+    RenderObject* handleCompactChild(RenderObject* child, CompactInfo&, bool& handled);
     RenderObject* handleRunInChild(RenderObject* child, bool& handled);
-    void collapseMargins(RenderObject* child, MarginInfo& marginInfo, int yPosEstimate);
-    void clearFloatsIfNeeded(RenderObject* child, MarginInfo& marginInfo, int oldTopPosMargin, int oldTopNegMargin);
-    void insertCompactIfNeeded(RenderObject* child, CompactInfo& compactInfo);
-    int estimateVerticalPosition(RenderObject* child, const MarginInfo& info);
+    void collapseMargins(RenderObject* child, MarginInfo&, int yPosEstimate);
+    void clearFloatsIfNeeded(RenderObject* child, MarginInfo&, int oldTopPosMargin, int oldTopNegMargin);
+    void insertCompactIfNeeded(RenderObject* child, CompactInfo&);
+    int estimateVerticalPosition(RenderObject* child, const MarginInfo&);
     void determineHorizontalPosition(RenderObject* child);
-    void handleBottomOfBlock(int top, int bottom, MarginInfo& marginInfo);
-    void setCollapsedBottomMargin(const MarginInfo& marginInfo);
+    void handleBottomOfBlock(int top, int bottom, MarginInfo&);
+    void setCollapsedBottomMargin(const MarginInfo&);
     // End helper functions and structs used by layoutBlockChildren.
 
@@ -416 +414 @@
     DeprecatedPtrList<FloatingObject>* m_floatingObjects;
     DeprecatedPtrList<RenderObject>* m_positionedObjects;
-    
+
     bool m_childrenInline : 1;
     bool m_firstLine : 1;
@@ -432 +430 @@
     // How much content overflows out of our block vertically or horizontally (all we support
     // for now is spillage out of the bottom and the right, which are the common cases).
-    // XXX Generalize to work with top and left as well.
+    // FIXME: Generalize to work with top and left as well.
     int m_overflowHeight;
     int m_overflowWidth;
-    
+
     // Left and top overflow.  Does not affect scrolling dimensions, but we do at least use it
     // when dirty rect checking and hit testing.
     int m_overflowLeft;
     int m_overflowTop;
-    
+
     // full width of a tab character
     int m_tabWidth;
@@ -447 +445 @@
 } // namespace WebCore
 
-#endif // RenderBlock_H
+#endif // RenderBlock_h

trunk/WebCore/rendering/RenderButton.cpp

@@ -27 +27 @@
 #include "GraphicsContext.h"
 #include "HTMLInputElement.h"
+#include "HTMLNames.h"
 #include "RenderText.h"
-#include "HTMLNames.h"
 
 namespace WebCore {
@@ -59 +59 @@
         RenderFlexibleBox::removeChild(oldChild);
         m_inner = 0;
-    }
-    else
+    } else
         m_inner->removeChild(oldChild);
 }
@@ -110 +109 @@
 }
 
-void RenderButton::paintObject(PaintInfo& i, int _tx, int _ty)
+void RenderButton::paintObject(PaintInfo& paintInfo, int tx, int ty)
 {
     // Push a clip.
-    if (m_inner && i.phase == PaintPhaseForeground) {
-        IntRect clipRect(_tx + borderLeft(), _ty + borderTop(),
+    if (m_inner && paintInfo.phase == PaintPhaseForeground) {
+        IntRect clipRect(tx + borderLeft(), ty + borderTop(),
             width() - borderLeft() - borderRight(), height() - borderBottom() - borderTop());
         if (clipRect.width() == 0 || clipRect.height() == 0)
             return;
-        i.p->save();
-        i.p->clip(clipRect);
+        paintInfo.p->save();
+        paintInfo.p->clip(clipRect);
     }
-    
+
     // Paint the children.
-    RenderBlock::paintObject(i, _tx, _ty);
-    
+    RenderBlock::paintObject(paintInfo, tx, ty);
+
     // Pop the clip.
-    if (m_inner && i.phase == PaintPhaseForeground)
-        i.p->restore();
+    if (m_inner && paintInfo.phase == PaintPhaseForeground)
+        paintInfo.p->restore();
 }
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderButton.h

@@ -21 +21 @@
  */
 
-#ifndef RenderButton_H
-#define RenderButton_H
+#ifndef RenderButton_h
+#define RenderButton_h
 
 #include "RenderFlexibleBox.h"
@@ -31 +31 @@
 // For inputs, they will also generate an anonymous RenderText and keep its style and content up
 // to date as the button changes.
-class RenderButton : public RenderFlexibleBox
-{
+class RenderButton : public RenderFlexibleBox {
 public:
     RenderButton(Node*);
 
+    virtual const char* renderName() const { return "RenderButton"; }
+
     virtual void addChild(RenderObject* newChild, RenderObject *beforeChild = 0);
-    virtual void removeChild(RenderObject* oldChild);
-    virtual void removeLeftoverAnonymousBoxes() {}
+    virtual void removeChild(RenderObject*);
+    virtual void removeLeftoverAnonymousBoxes() { }
     virtual bool createsAnonymousWrapper() const { return true; }
 
@@ -50 +51 @@
     void setText(const String&);
 
-    virtual const char* renderName() const { return "RenderButton"; }
-
 protected:
     virtual bool hasLineIfEmpty() const { return true; }
@@ -59 +58 @@
 };
 
-}
+} // namespace WebCore
 
-#endif
+#endif // RenderButton_h

trunk/WebCore/rendering/RenderContainer.cpp

@@ -29 +29 @@
 #include "RenderContainer.h"
 
-#include "htmlediting.h"
+#include "AXObjectCache.h"
+#include "Document.h"
 #include "RenderCounter.h"
+#include "RenderImage.h"
 #include "RenderListItem.h"
 #include "RenderTable.h"
 #include "RenderTextFragment.h"
-#include "RenderImage.h"
 #include "RenderView.h"
-#include "Document.h"
-
-// For accessibility
-#include "AXObjectCache.h" 
+#include "htmlediting.h"
 
 namespace WebCore {
@@ -45 +43 @@
 RenderContainer::RenderContainer(Node* node)
     : RenderBox(node)
-{
-    m_first = 0;
-    m_last = 0;
-}
-
+    , m_first(0)
+    , m_last(0)
+{
+}
 
 RenderContainer::~RenderContainer()
@@ -640 +637 @@
 #undef DEBUG_LAYOUT
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderContainer.h

@@ -21 +21 @@
  */
 
-#ifndef RenderContainer_H
-#define RenderContainer_H
+#ifndef RenderContainer_h
+#define RenderContainer_h
 
 #include "RenderBox.h"
@@ -33 +33 @@
  * Base class for rendering objects that can have children
  */
-class RenderContainer : public RenderBox
-{
+class RenderContainer : public RenderBox {
 public:
     RenderContainer(Node*);
     virtual ~RenderContainer();
 
-    RenderObject *firstChild() const { return m_first; }
-    RenderObject *lastChild() const { return m_last; }
+    RenderObject* firstChild() const { return m_first; }
+    RenderObject* lastChild() const { return m_last; }
 
     virtual bool canHaveChildren() const;
-    virtual void addChild(RenderObject *newChild, RenderObject *beforeChild = 0);
-    virtual void removeChild(RenderObject *oldChild);
+    virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);
+    virtual void removeChild(RenderObject*);
 
     virtual void destroy();
     void destroyLeftoverChildren();
-    
-    virtual RenderObject* removeChildNode(RenderObject* child);
-    virtual void appendChildNode(RenderObject* child);
+
+    virtual RenderObject* removeChildNode(RenderObject*);
+    virtual void appendChildNode(RenderObject*);
     virtual void insertChildNode(RenderObject* child, RenderObject* before);
 
     virtual void layout();
-    virtual void calcMinMaxWidth() { setMinMaxKnown( true ); }
+    virtual void calcMinMaxWidth() { setMinMaxKnown(true); }
 
     virtual void removeLeftoverAnonymousBoxes();
@@ -63 +62 @@
 
     virtual VisiblePosition positionForCoordinates(int x, int y);
-    
+
     virtual void lineBoxRects(Vector<IntRect>&);
 
@@ -70 +69 @@
     void setLastChild(RenderObject* last) { m_last = last; }
 
-protected:
-    RenderObject *m_first;
-    RenderObject *m_last;
+    RenderObject* m_first;
+    RenderObject* m_last;
 };
 
-}
-#endif
+} // namespace WebCore
+
+#endif // RenderContainer_h

trunk/WebCore/rendering/RenderCounter.cpp

@@ -35 +35 @@
 
 RenderCounter::RenderCounter(Node* node, CounterData* counter)
-    : RenderText(node, 0), m_counter(counter), m_counterNode(0)
+    : RenderText(node, 0)
+    , m_counter(counter)
+    , m_counterNode(0)
 {
 }
@@ -58 +60 @@
     do {
         int num = number % 10;
-        if (num % 5 < 4)
+        if (num % 5 < 4) {
             for (int i = num % 5; i > 0; i--)
                 roman.insert(&digits[d], 1, 0);
+        }
         if (num >= 4 && num <= 8)
             roman.insert(&digits[d + 1], 1, 0);
@@ -95 +98 @@
     if (number < 1)
         return String::number(number);
-    
+
     static const UChar tenDigit[] = {1497, 1499, 1500, 1502, 1504, 1505, 1506, 1508, 1510};
 
@@ -218 +221 @@
     if (m_counterNode->isReset())
         value = m_counterNode->value();
-    
+
     int total = value;
     if (m_counterNode->parent())
         total = m_counterNode->parent()->total();
-    
+
     m_item = convertValueToType(value, total, m_counter->listStyle());
 
@@ -231 +234 @@
             value = counter->count() ? counter->count() : 1;
             total = counter->parent()->total();
-            m_item = convertValueToType(value, total, m_counter->listStyle()) 
-                + m_counter->separator() + m_item;
+            m_item = convertValueToType(value, total, m_counter->listStyle()) + m_counter->separator() + m_item;
             counter = counter->parent();
             first = false;
@@ -239 +241 @@
 
     str = new StringImpl(m_item.characters(), m_item.length());
-    
+
     RenderText::calcMinMaxWidth();
 }

trunk/WebCore/rendering/RenderCounter.h

@@ -21 +21 @@
  *
  */
-#ifndef RENDER_COUNTER_H_
-#define RENDER_COUNTER_H_
+#ifndef RenderCounter_h
+#define RenderCounter_h
 
 #include "RenderText.h"
 
 namespace WebCore {
-    class CounterNode;
 
-// -----------------------------------------------------------------------------
+class CounterNode;
 
 class RenderCounter : public RenderText {
-
 public:
     RenderCounter(Node*, CounterData*);
-    
+
     virtual const char* renderName() const { return "RenderCounter"; }
 
     virtual bool isCounter() const { return true; }
+
     virtual void layout();
     virtual void calcMinMaxWidth();
@@ -50 +49 @@
 };
 
-} //namespace
+} // namespace WebCore
 
-#endif
+#endif // RenderCounter_h

trunk/WebCore/rendering/RenderFieldset.cpp

@@ -71 +71 @@
 }
 
-void RenderFieldset::paintBoxDecorations(PaintInfo& i, int _tx, int _ty)
+void RenderFieldset::paintBoxDecorations(PaintInfo& paintInfo, int tx, int ty)
 {
     int w = width();
@@ -77 +77 @@
     RenderObject* legend = findLegend();
     if (!legend)
-        return RenderBlock::paintBoxDecorations(i, _tx, _ty);
+        return RenderBlock::paintBoxDecorations(paintInfo, tx, ty);
 
-    int yOff = (legend->yPos() > 0) ? 0 : (legend->height()-borderTop())/2;
+    int yOff = (legend->yPos() > 0) ? 0 : (legend->height() - borderTop()) / 2;
     h -= yOff;
-    _ty += yOff - borderTopExtra();
+    ty += yOff - borderTopExtra();
 
-    int my = max(_ty, i.r.y());
-    int end = min(i.r.bottom(),  _ty + h);
+    int my = max(ty, paintInfo.r.y());
+    int end = min(paintInfo.r.bottom(), ty + h);
     int mh = end - my;
 
-    paintBackground(i.p, style()->backgroundColor(), style()->backgroundLayers(), my, mh, _tx, _ty, w, h);
+    paintBackground(paintInfo.p, style()->backgroundColor(), style()->backgroundLayers(), my, mh, tx, ty, w, h);
 
     if (style()->hasBorder())
-        paintBorderMinusLegend(i.p, _tx, _ty, w, h, style(), legend->xPos(), legend->width());
+        paintBorderMinusLegend(paintInfo.p, tx, ty, w, h, style(), legend->xPos(), legend->width());
 }
 
-void RenderFieldset::paintBorderMinusLegend(GraphicsContext* p, int _tx, int _ty, int w, int h,
+void RenderFieldset::paintBorderMinusLegend(GraphicsContext* graphicsContext, int tx, int ty, int w, int h,
                                             const RenderStyle* style, int lx, int lw)
 {
@@ -111 +111 @@
 
     if (render_t) {
-        drawBorder(p, _tx, _ty, _tx + lx, _ty +  style->borderTopWidth(), BSTop, tc, style->color(), ts,
-                   (render_l && (ls == DOTTED || ls == DASHED || ls == DOUBLE)?style->borderLeftWidth():0), 0);
-        drawBorder(p, _tx+lx+lw, _ty, _tx + w, _ty +  style->borderTopWidth(), BSTop, tc, style->color(), ts,
-                   0, (render_r && (rs == DOTTED || rs == DASHED || rs == DOUBLE)?style->borderRightWidth():0));
+        drawBorder(graphicsContext, tx, ty, tx + lx, ty + style->borderTopWidth(), BSTop, tc, style->color(), ts,
+                   (render_l && (ls == DOTTED || ls == DASHED || ls == DOUBLE) ? style->borderLeftWidth() : 0), 0);
+        drawBorder(graphicsContext, tx + lx + lw, ty, tx + w, ty + style->borderTopWidth(), BSTop, tc, style->color(), ts,
+                   0, (render_r && (rs == DOTTED || rs == DASHED || rs == DOUBLE) ? style->borderRightWidth() : 0));
     }
 
     if (render_b)
-        drawBorder(p, _tx, _ty + h - style->borderBottomWidth(), _tx + w, _ty + h, BSBottom, bc, style->color(), bs,
-                   (render_l && (ls == DOTTED || ls == DASHED || ls == DOUBLE)?style->borderLeftWidth():0),
-                   (render_r && (rs == DOTTED || rs == DASHED || rs == DOUBLE)?style->borderRightWidth():0));
+        drawBorder(graphicsContext, tx, ty + h - style->borderBottomWidth(), tx + w, ty + h, BSBottom, bc, style->color(), bs,
+                   (render_l && (ls == DOTTED || ls == DASHED || ls == DOUBLE) ? style->borderLeftWidth() : 0),
+                   (render_r && (rs == DOTTED || rs == DASHED || rs == DOUBLE) ? style->borderRightWidth() : 0));
 
     if (render_l) {
@@ -135 +135 @@
             (bs == DOTTED || bs == DASHED || bs == SOLID || bs == INSET);
 
-        drawBorder(p, _tx, _ty, _tx + style->borderLeftWidth(), _ty + h, BSLeft, lc, style->color(), ls,
-                   ignore_top?0:style->borderTopWidth(),
-                   ignore_bottom?0:style->borderBottomWidth());
+        drawBorder(graphicsContext, tx, ty, tx + style->borderLeftWidth(), ty + h, BSLeft, lc, style->color(), ls,
+                   ignore_top ? 0 : style->borderTopWidth(), ignore_bottom ? 0 : style->borderBottomWidth());
     }
 
@@ -153 +152 @@
             (bs == DOTTED || bs == DASHED || bs == SOLID || bs == INSET);
 
-        drawBorder(p, _tx + w - style->borderRightWidth(), _ty, _tx + w, _ty + h, BSRight, rc, style->color(), rs,
-                   ignore_top?0:style->borderTopWidth(),
-                   ignore_bottom?0:style->borderBottomWidth());
+        drawBorder(graphicsContext, tx + w - style->borderRightWidth(), ty, tx + w, ty + h, BSRight, rc, style->color(), rs,
+                   ignore_top ? 0 : style->borderTopWidth(), ignore_bottom ? 0 : style->borderBottomWidth());
     }
 }
 
-void RenderFieldset::setStyle(RenderStyle* _style)
+void RenderFieldset::setStyle(RenderStyle* newStyle)
 {
-    RenderBlock::setStyle(_style);
+    RenderBlock::setStyle(newStyle);
 
     // WinIE renders fieldsets with display:inline like they're inline-blocks.  For us,

trunk/WebCore/rendering/RenderFileUploadControl.cpp

@@ -59 +59 @@
     
 private:
-        Node* m_shadowParent;    
+    Node* m_shadowParent;    
 };
 
@@ -73 +73 @@
     if (m_button)
         m_button->detach();
-    if (m_fileChooser) {
+    if (m_fileChooser)
         m_fileChooser->disconnectUploadControl();
-    }
-}
-
-void RenderFileUploadControl::setStyle(RenderStyle* s)
+}
+
+void RenderFileUploadControl::setStyle(RenderStyle* newStyle)
 {
     // Force text-align to match the direction
-    if (s->direction() == LTR)
-        s->setTextAlign(LEFT);
+    if (newStyle->direction() == LTR)
+        newStyle->setTextAlign(LEFT);
     else
-        s->setTextAlign(RIGHT);
-    
-    RenderBlock::setStyle(s);
+        newStyle->setTextAlign(RIGHT);
+
+    RenderBlock::setStyle(newStyle);
     if (m_button)
-        m_button->renderer()->setStyle(createButtonStyle(s));
+        m_button->renderer()->setStyle(createButtonStyle(newStyle));
 
     setReplaced(isInline());
@@ -141 +140 @@
 }
 
-void RenderFileUploadControl::paintObject(PaintInfo& i, int tx, int ty)
+void RenderFileUploadControl::paintObject(PaintInfo& paintInfo, int tx, int ty)
 {
     // Push a clip.
-    if (i.phase == PaintPhaseForeground || i.phase == PaintPhaseChildBlockBackgrounds) {
+    if (paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseChildBlockBackgrounds) {
         IntRect clipRect(tx + borderLeft(), ty + borderTop(),
                          width() - borderLeft() - borderRight(), height() - borderBottom() - borderTop());
         if (clipRect.width() == 0 || clipRect.height() == 0)
             return;
-        i.p->save();
-        i.p->clip(clipRect);
-    }
-    
-    if (i.phase == PaintPhaseForeground) {
+        paintInfo.p->save();
+        paintInfo.p->clip(clipRect);
+    }
+
+    if (paintInfo.phase == PaintPhaseForeground) {
         const String& displayedFilename = m_fileChooser->basenameForWidth(maxFilenameWidth());
         TextRun textRun(displayedFilename.characters(), displayedFilename.length());
-        
+
         // Determine where the filename should be placed
         int contentLeft = tx + borderLeft() + paddingLeft();
@@ -168 +167 @@
         RenderButton* buttonRenderer = static_cast<RenderButton*>(m_button->renderer());
         int textY = buttonRenderer->absoluteBoundingBoxRect().y() + buttonRenderer->marginTop() + buttonRenderer->borderTop() + buttonRenderer->paddingTop() + buttonRenderer->baselinePosition(true, false);
-        
-        i.p->setFont(style()->font());
-        i.p->setPen(style()->color());
-        
+
+        paintInfo.p->setFont(style()->font());
+        paintInfo.p->setPen(style()->color());
+
         // Draw the filename
-        i.p->drawText(textRun, IntPoint(textX, textY));
-        
+        paintInfo.p->drawText(textRun, IntPoint(textX, textY));
+
         if (m_fileChooser->icon()) {
             // Determine where the icon should be placed
@@ -183 +182 @@
             else
                 iconX = contentLeft + contentWidth() - m_button->renderer()->width() - afterButtonSpacing - iconWidth;
-            
+
             // Draw the file icon
-            m_fileChooser->icon()->paint(i.p, IntRect(iconX, iconY, iconWidth, iconHeight));
+            m_fileChooser->icon()->paint(paintInfo.p, IntRect(iconX, iconY, iconWidth, iconHeight));
         }
     }
-    
+
     // Paint the children.
-    RenderBlock::paintObject(i, tx, ty);
-    
+    RenderBlock::paintObject(paintInfo, tx, ty);
+
     // Pop the clip.
-    if (i.phase == PaintPhaseForeground || i.phase == PaintPhaseChildBlockBackgrounds)
-        i.p->restore();
+    if (paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseChildBlockBackgrounds)
+        paintInfo.p->restore();
 }
 
@@ -201 +200 @@
     m_minWidth = 0;
     m_maxWidth = 0;
-    
+
     if (style()->width().isFixed() && style()->width().value() > 0)
         m_minWidth = m_maxWidth = calcContentBoxWidth(style()->width().value());
@@ -211 +210 @@
         m_maxWidth = (int)ceilf(charWidth * defaultWidthNumChars);
     }
-    
+
     if (style()->minWidth().isFixed() && style()->minWidth().value() > 0) {
         m_maxWidth = max(m_maxWidth, calcContentBoxWidth(style()->minWidth().value()));
@@ -219 +218 @@
     else
         m_minWidth = m_maxWidth;
-    
+
     if (style()->maxWidth().isFixed() && style()->maxWidth().value() != undefinedLength) {
         m_maxWidth = min(m_maxWidth, calcContentBoxWidth(style()->maxWidth().value()));
         m_minWidth = min(m_minWidth, calcContentBoxWidth(style()->maxWidth().value()));
     }
-    
+
     int toAdd = paddingLeft() + paddingRight() + borderLeft() + borderRight();
     m_minWidth += toAdd;
     m_maxWidth += toAdd;
-    
+
     setMinMaxKnown();
 }
@@ -244 +243 @@
 }
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderFileUploadControl.h

@@ -19 +19 @@
  */
 
-#ifndef RenderFileUploadControl_H
-#define RenderFileUploadControl_H
-
-#include "RenderBlock.h"
+#ifndef RenderFileUploadControl_h
+#define RenderFileUploadControl_h
 
 #include "FileChooser.h"
 #include "HTMLInputElement.h"
+#include "RenderBlock.h"
 #include "Shared.h"
 
@@ -42 +41 @@
     ~RenderFileUploadControl();
 
+    virtual const char* renderName() const { return "RenderFileUploadControl"; }
+
     virtual void setStyle(RenderStyle*);
     virtual void updateFromElement();
@@ -51 +52 @@
     void valueChanged();
 
-    virtual const char* renderName() const { return "RenderFileUploadControl"; }
-
 protected:
     int maxFilenameWidth();
     RenderStyle* createButtonStyle(RenderStyle* parentStyle = 0);
-    
+
     RefPtr<HTMLFileUploadInnerButtonElement> m_button;
     RefPtr<FileChooser> m_fileChooser;
 };
 
-}
+} // namespace WebCore
 
-#endif
+#endif // RenderFileUploadControl_h

trunk/WebCore/rendering/RenderFlexibleBox.h

@@ -21 +21 @@
  */
 
-#ifndef RenderFlexibleBox_H
-#define RenderFlexibleBox_H
+#ifndef RenderFlexibleBox_h
+#define RenderFlexibleBox_h
 
 #include "RenderBlock.h"
@@ -32 +32 @@
     RenderFlexibleBox(Node*);
     virtual ~RenderFlexibleBox();
+
+    virtual const char* renderName() const;
 
     virtual void calcMinMaxWidth();
@@ -46 +48 @@
     virtual bool isFlexingChildren() const { return m_flexingChildren; }
     virtual bool isStretchingChildren() const { return m_stretchingChildren; }
-
-    virtual const char* renderName() const;
 
     void placeChild(RenderObject* child, int x, int y);
@@ -64 +64 @@
 } // namespace WebCore
 
-#endif // RenderFlexibleBox_H
+#endif // RenderFlexibleBox_h

trunk/WebCore/rendering/RenderFlow.cpp

@@ -21 +21 @@
  * Boston, MA 02111-1307, USA.
  */
-// -------------------------------------------------------------------------
 
 #include "config.h"
@@ -28 +27 @@
 #include "Document.h"
 #include "GraphicsContext.h"
+#include "HTMLNames.h"
 #include "InlineTextBox.h"
-#include "HTMLNames.h"
 #include "RenderArena.h"
+#include "RenderInline.h"
 #include "RenderView.h"
-#include "RenderInline.h"
 
 using namespace std;
@@ -800 +799 @@
 }
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderFlow.h

@@ -23 +23 @@
  */
 
-#ifndef RenderFlow_H
-#define RenderFlow_H
+#ifndef RenderFlow_h
+#define RenderFlow_h
 
 #include "RenderContainer.h"
@@ -53 +53 @@
     void setContinuation(RenderFlow* c) { m_continuation = c; }
     RenderFlow* continuationBefore(RenderObject* beforeChild);
-    
+
     void addChildWithContinuation(RenderObject* newChild, RenderObject* beforeChild);
     virtual void addChildToFlow(RenderObject* newChild, RenderObject* beforeChild) = 0;
-    virtual void addChild(RenderObject *newChild, RenderObject *beforeChild = 0);
+    virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);
 
-    static RenderFlow* createAnonymousFlow(Document* doc, RenderStyle* style);
+    static RenderFlow* createAnonymousFlow(Document*, RenderStyle*);
 
-    void extractLineBox(InlineFlowBox* lineBox);
-    void attachLineBox(InlineFlowBox* lineBox);
-    void removeLineBox(InlineFlowBox* lineBox);
+    void extractLineBox(InlineFlowBox*);
+    void attachLineBox(InlineFlowBox*);
+    void removeLineBox(InlineFlowBox*);
     void deleteLineBoxes();
     virtual void destroy();
 
     virtual void dirtyLinesFromChangedChild(RenderObject* child);
-    
-    virtual short lineHeight(bool firstLine, bool isRootLineBox=false) const;
-    
+
+    virtual short lineHeight(bool firstLine, bool isRootLineBox = false) const;
+
     InlineFlowBox* firstLineBox() const { return m_firstLineBox; }
     InlineFlowBox* lastLineBox() const { return m_lastLineBox; }
@@ -75 +75 @@
     virtual InlineBox* createInlineBox(bool makePlaceHolderBox, bool isRootLineBox, bool isOnlyRun=false);
     virtual void dirtyLineBoxes(bool fullLayout, bool isRootLineBox = false);
-    
-    void paintLines(PaintInfo&, int _tx, int _ty);
+
+    void paintLines(PaintInfo&, int tx, int ty);
     bool hitTestLines(HitTestResult&, int x, int y, int tx, int ty, HitTestAction);
 
     virtual IntRect getAbsoluteRepaintRect();
-    
-    virtual int lowestPosition(bool includeOverflowInterior=true, bool includeSelf=true) const;
-    virtual int rightmostPosition(bool includeOverflowInterior=true, bool includeSelf=true) const;
-    virtual int leftmostPosition(bool includeOverflowInterior=true, bool includeSelf=true) const;
-    
-    virtual IntRect caretRect(int offset, EAffinity affinity = UPSTREAM, int *extraWidthToEndOfLine = 0);
 
-    virtual void addFocusRingRects(GraphicsContext*, int _tx, int _ty);
-    void paintOutlineForLine(GraphicsContext*, int tx, int ty, const IntRect &prevLine, const IntRect &thisLine, const IntRect &nextLine);
+    virtual int lowestPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;
+    virtual int rightmostPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;
+    virtual int leftmostPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;
+
+    virtual IntRect caretRect(int offset, EAffinity = UPSTREAM, int* extraWidthToEndOfLine = 0);
+
+    virtual void addFocusRingRects(GraphicsContext*, int tx, int ty);
+    void paintOutlineForLine(GraphicsContext*, int tx, int ty, const IntRect& prevLine, const IntRect& thisLine, const IntRect& nextLine);
     void paintOutline(GraphicsContext*, int tx, int ty);
 
@@ -103 +103 @@
     InlineFlowBox* m_firstLineBox;
     InlineFlowBox* m_lastLineBox;
-    
+
     mutable short m_lineHeight;
 };
@@ -109 +109 @@
 } // namespace WebCore
 
-#endif // RenderFlow_H
+#endif // RenderFlow_h

trunk/WebCore/rendering/RenderForeignObject.cpp

@@ -22 +22 @@
 
 #include "config.h"
+
 #ifdef SVG_SUPPORT
+
 #include "RenderForeignObject.h"
 
 #include "GraphicsContext.h"
 #include "KRenderingDevice.h"
+#include "SVGForeignObjectElement.h"
 #include "SVGLength.h"
-#include "SVGForeignObjectElement.h"
 
 namespace WebCore {
 
-RenderForeignObject::RenderForeignObject(SVGForeignObjectElement *node) 
+RenderForeignObject::RenderForeignObject(SVGForeignObjectElement* node) 
     : RenderBlock(node)
 {
@@ -48 +50 @@
         return;
 
-    KRenderingDevice *device = renderingDevice();
+    KRenderingDevice* device = renderingDevice();
     KRenderingDeviceContext* context = device->currentContext();
     bool shouldPopContext = false;
@@ -77 +79 @@
     if (opacity < 1.0f)
         paintInfo.p->endTransparencyLayer();
-    
+
     if (shouldPopContext) {
         device->popContext();
@@ -90 +92 @@
     AffineTransform transform = translationForAttributes() * localTransform();
     r = transform.mapRect(r);
-    
+
     RenderBlock::computeAbsoluteRepaintRect(r, f);
 }
@@ -115 +117 @@
     if (checkForRepaint)
         repaintAfterLayoutIfNeeded(oldBounds, oldBounds);
-    
+
     setNeedsLayout(false);
 }
@@ -125 +127 @@
     double localX, localY;
     totalTransform.invert().map(x, y, &localX, &localY);
-    return RenderBlock::nodeAtPoint(result, (int)localX, (int)localY, tx, ty, hitTestAction);
+    return RenderBlock::nodeAtPoint(result, static_cast<int>(localX), static_cast<int>(localY), tx, ty, hitTestAction);
 }
 
-}
+} // namespace WebCore
 
 #endif // SVG_SUPPORT

trunk/WebCore/rendering/RenderForeignObject.h

@@ -21 +21 @@
  */
 
-#ifndef RenderForeignObject_H
-#define RenderForeignObject_H
+#ifndef RenderForeignObject_h
+#define RenderForeignObject_h
 #ifdef SVG_SUPPORT
 
+#include "AffineTransform.h"
 #include "RenderBlock.h"
-#include "AffineTransform.h"
 
 namespace WebCore {
@@ -32 +32 @@
 class SVGForeignObjectElement;
 
-class RenderForeignObject : public RenderBlock
-{
+class RenderForeignObject : public RenderBlock {
 public:
-    RenderForeignObject(SVGForeignObjectElement *node);
-    
-    virtual const char *renderName() const { return "RenderForeignObject"; }
-    virtual void paint(PaintInfo& paintInfo, int parentX, int parentY);
-    
+    RenderForeignObject(SVGForeignObjectElement*);
+
+    virtual const char* renderName() const { return "RenderForeignObject"; }
+
+    virtual void paint(PaintInfo&, int parentX, int parentY);
+
     virtual AffineTransform localTransform() const { return m_transform; }
     virtual void setLocalTransform(const AffineTransform& transform) { m_transform = transform; }
-    
-    virtual void computeAbsoluteRepaintRect(IntRect& r, bool f);
+
+    virtual void computeAbsoluteRepaintRect(IntRect&, bool fixed);
     virtual bool requiresLayer();
     virtual void layout();
@@ -51 +51 @@
  private:
     AffineTransform translationForAttributes();
+
     AffineTransform m_transform;
     IntRect m_absoluteBounds;
 };
 
-}
+} // namespace WebCore
 
 #endif // SVG_SUPPORT
-#endif
+#endif // RenderForeignObject_h

trunk/WebCore/rendering/RenderFormElement.cpp

@@ -51 +51 @@
 }
 
-void RenderFormElement::setStyle(RenderStyle* s)
+void RenderFormElement::setStyle(RenderStyle* newStyle)
 {
-    RenderWidget::setStyle(s);
+    RenderWidget::setStyle(newStyle);
 
     // Do not paint a background or border for Aqua form elements
@@ -76 +76 @@
     calcWidth();
     calcHeight();
-    
+
     setNeedsLayout(false);
 }
@@ -106 +106 @@
             return style()->direction() == RTL ? AlignRight : AlignLeft;
     }
-    ASSERT(false); // Should never be reached.
+    ASSERT_NOT_REACHED();
     return AlignLeft;
 }

trunk/WebCore/rendering/RenderFormElement.h

@@ -27 +27 @@
 #define RenderFormElement_h
 
+#include "GraphicsTypes.h"
 #include "RenderWidget.h"
-#include "GraphicsTypes.h"
 
 namespace WebCore {

trunk/WebCore/rendering/RenderFrame.cpp

@@ -23 +23 @@
  *
  */
+
 #include "config.h"
 #include "RenderFrame.h"

trunk/WebCore/rendering/RenderFrame.h

@@ -23 +23 @@
  */
 
-#ifndef RenderFrame_H
-#define RenderFrame_H
+#ifndef RenderFrame_h
+#define RenderFrame_h
 
+#include "HTMLFrameElement.h"
 #include "RenderPart.h"
-#include "HTMLFrameElement.h"
 
 namespace WebCore {
 
-class RenderFrame : public RenderPart
-{
+class RenderFrame : public RenderPart {
 public:
     RenderFrame(HTMLFrameElement*);
@@ -38 +37 @@
     virtual const char* renderName() const { return "RenderFrame"; }
 
-    HTMLFrameElement* element() const
-        { return static_cast<HTMLFrameElement*>(RenderPart::element()); }
+    HTMLFrameElement* element() const { return static_cast<HTMLFrameElement*>(RenderPart::element()); }
 
     virtual void viewCleared();
 };
 
-}
+} // namespace WebCore
 
-#endif
+#endif // RenderFrame_h

trunk/WebCore/rendering/RenderFrameSet.cpp

@@ -23 +23 @@
  *
  */
+
 #include "config.h"
 #include "RenderFrameSet.h"
@@ -32 +33 @@
 #include "HTMLFrameSetElement.h"
 #include "HTMLNames.h"
-#include "TextStream.h"
+#include "HitTestResult.h"
 #include "MouseEvent.h"
-#include "HitTestResult.h"
 #include "RenderFrame.h"
 #include "RenderView.h"
+#include "TextStream.h"
 
 namespace WebCore {
@@ -558 +559 @@
 #endif
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderFrameSet.h

@@ -23 +23 @@
  */
 
-#ifndef RenderFrameSet_H
-#define RenderFrameSet_H
+#ifndef RenderFrameSet_h
+#define RenderFrameSet_h
 
+#include "HTMLFrameSetElement.h"
 #include "RenderContainer.h"
-#include "HTMLFrameSetElement.h"
-
 
 namespace WebCore {
@@ -35 +34 @@
 class MouseEvent;
 
-class RenderFrameSet : public RenderContainer
-{
+class RenderFrameSet : public RenderContainer {
     friend class HTMLFrameSetElement;
 public:
@@ -57 +55 @@
     virtual bool nodeAtPoint(HitTestResult&, int x, int y, int tx, int ty, HitTestAction);
 
-    HTMLFrameSetElement* element() const
-        { return static_cast<HTMLFrameSetElement*>(RenderContainer::element()); }
+    HTMLFrameSetElement* element() const { return static_cast<HTMLFrameSetElement*>(RenderContainer::element()); }
 
 #ifndef NDEBUG
@@ -82 +79 @@
 };
 
-}
+} // namespace WebCore
 
-#endif
+#endif // RenderFrameSet_h

trunk/WebCore/rendering/RenderHTMLCanvas.cpp

@@ -36 +36 @@
 using namespace HTMLNames;
 
-RenderHTMLCanvas::RenderHTMLCanvas(Node* n)
-    : RenderReplaced(n)
+RenderHTMLCanvas::RenderHTMLCanvas(Node* node)
+    : RenderReplaced(node)
 {
 }
 
-const char* RenderHTMLCanvas::renderName() const
+void RenderHTMLCanvas::paint(PaintInfo& paintInfo, int tx, int ty)
 {
-    return "RenderHTMLCanvas";
-}
-
-void RenderHTMLCanvas::paint(PaintInfo& i, int tx, int ty)
-{
-    if (!shouldPaint(i, tx, ty))
+    if (!shouldPaint(paintInfo, tx, ty))
         return;
 
@@ -54 +49 @@
     int y = ty + m_y;
 
-    if (shouldPaintBackgroundOrBorder() && (i.phase == PaintPhaseForeground || i.phase == PaintPhaseSelection)) 
-        paintBoxDecorations(i, x, y);
+    if (shouldPaintBackgroundOrBorder() && (paintInfo.phase == PaintPhaseForeground || paintInfo.phase == PaintPhaseSelection)) 
+        paintBoxDecorations(paintInfo, x, y);
 
-    if ((i.phase == PaintPhaseOutline || i.phase == PaintPhaseSelfOutline) && style()->outlineWidth() && style()->visibility() == VISIBLE)
-        paintOutline(i.p, x, y, width(), height(), style());
-    
-    if (i.phase != PaintPhaseForeground && i.phase != PaintPhaseSelection)
+    if ((paintInfo.phase == PaintPhaseOutline || paintInfo.phase == PaintPhaseSelfOutline) && style()->outlineWidth() && style()->visibility() == VISIBLE)
+        paintOutline(paintInfo.p, x, y, width(), height(), style());
+
+    if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection)
         return;
 
-    if (!shouldPaintWithinRoot(i))
+    if (!shouldPaintWithinRoot(paintInfo))
         return;
 
     bool drawSelectionTint = selectionState() != SelectionNone && !document()->printing();
-    if (i.phase == PaintPhaseSelection) {
+    if (paintInfo.phase == PaintPhaseSelection) {
         if (selectionState() == SelectionNone)
             return;
@@ -74 +69 @@
 
     if (element() && element()->hasTagName(canvasTag))
-        static_cast<HTMLCanvasElement*>(element())->paint(i.p,
+        static_cast<HTMLCanvasElement*>(element())->paint(paintInfo.p,
             IntRect(x + borderLeft() + paddingLeft(), y + borderTop() + paddingTop(), contentWidth(), contentHeight()));
 
     if (drawSelectionTint)
-        i.p->fillRect(selectionRect(), selectionBackgroundColor());
+        paintInfo.p->fillRect(selectionRect(), selectionBackgroundColor());
 }
 
@@ -98 +93 @@
 }
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderHTMLCanvas.h

@@ -24 +24 @@
  */
 
-#ifndef RenderHTMLCanvas_H
-#define RenderHTMLCanvas_H
+#ifndef RenderHTMLCanvas_h
+#define RenderHTMLCanvas_h
 
 #include "RenderReplaced.h"
@@ -34 +34 @@
     public:
         RenderHTMLCanvas(Node*);
-        virtual const char* renderName() const;
+
+        virtual const char* renderName() const { return "RenderHTMLCanvas"; }
+
         virtual void paint(PaintInfo&, int tx, int ty);
         virtual void layout();
     };
 
-} //namespace
+} // namespace WebCore
 
-#endif
+#endif // RenderHTMLCanvas_h

trunk/WebCore/rendering/RenderImage.cpp

@@ -45 +45 @@
 using namespace HTMLNames;
 
-RenderImage::RenderImage(Node* n)
-    : RenderReplaced(n)
+RenderImage::RenderImage(Node* node)
+    : RenderReplaced(node)
     , m_cachedImage(0)
+    , m_isAnonymousImage(0)
 {
     m_selectionState = SelectionNone;
     setIntrinsicWidth(0);
     setIntrinsicHeight(0);
-    m_isAnonymousImage = 0;
     updateAltText();
 }
@@ -62 +62 @@
 }
 
-void RenderImage::setStyle(RenderStyle* _style)
-{
-    RenderReplaced::setStyle(_style);
-    
+void RenderImage::setStyle(RenderStyle* newStyle)
+{
+    RenderReplaced::setStyle(newStyle);
     setShouldPaintBackgroundOrBorder(true);
 }
 
-void RenderImage::setContentObject(CachedResource* co)
-{
-    if (co && m_cachedImage != co) {
+void RenderImage::setContentObject(CachedResource* cachedResource)
+{
+    if (cachedResource && m_cachedImage != cachedResource) {
         if (m_cachedImage)
             m_cachedImage->deref(this);
-        m_cachedImage = static_cast<CachedImage*>(co);
+        m_cachedImage = static_cast<CachedImage*>(cachedResource);
         if (m_cachedImage)
             m_cachedImage->ref(this);
@@ -84 +83 @@
     if (isAnonymousImage())
         return;
-    
+
     if (m_cachedImage != newImage) {
         if (m_cachedImage)
@@ -96 +95 @@
 }
 
-void RenderImage::imageChanged(CachedImage* o)
+void RenderImage::imageChanged(CachedImage* newImage)
 {
     if (documentBeingDestroyed())
         return;
 
-    if (o != m_cachedImage) {
-        RenderReplaced::imageChanged(o);
-        return;
-    }
-
-    bool iwchanged = false;
-
-    if (o->isErrorImage()) {
-        int iw = o->image()->width() + 4;
-        int ih = o->image()->height() + 4;
+    if (newImage != m_cachedImage) {
+        RenderReplaced::imageChanged(newImage);
+        return;
+    }
+
+    bool imageSizeChanged = false;
+
+    if (newImage->isErrorImage()) {
+        int imageWidth = newImage->image()->width() + 4;
+        int imageHeight = newImage->image()->height() + 4;
 
         // we have an alt and the user meant it (its not a text we invented)
         if (!m_altText.isEmpty()) {
             const Font& font = style()->font();
-            iw = max(iw, min(font.width(TextRun(m_altText.characters(), m_altText.length())), 1024));
-            ih = max(ih, min(font.height(), 256));
-        }
-
-        if (iw != intrinsicWidth()) {
-            setIntrinsicWidth(iw);
-            iwchanged = true;
-        }
-        if (ih != intrinsicHeight()) {
-            setIntrinsicHeight(ih);
-            iwchanged = true;
-        }
-    }
-
-    bool needlayout = false;
+            imageWidth = max(imageWidth, min(font.width(TextRun(m_altText.characters(), m_altText.length())), 1024));
+            imageHeight = max(imageHeight, min(font.height(), 256));
+        }
+
+        if (imageWidth != intrinsicWidth()) {
+            setIntrinsicWidth(imageWidth);
+            imageSizeChanged = true;
+        }
+        if (imageHeight != intrinsicHeight()) {
+            setIntrinsicHeight(imageHeight);
+            imageSizeChanged = true;
+        }
+    }
+
+    bool ensureLayout = false;
 
     // Image dimensions have been changed, see what needs to be done
-    if ((o->imageSize().width() != intrinsicWidth() || o->imageSize().height() != intrinsicHeight() || iwchanged)) {
-        if(!o->isErrorImage()) {
-            setIntrinsicWidth(o->imageSize().width());
-            setIntrinsicHeight(o->imageSize().height());
+    if (newImage->imageSize().width() != intrinsicWidth() || newImage->imageSize().height() != intrinsicHeight() || imageSizeChanged) {
+        if (!newImage->isErrorImage()) {
+            setIntrinsicWidth(newImage->imageSize().width());
+            setIntrinsicHeight(newImage->imageSize().height());
         }
 
@@ -148 +147 @@
             calcHeight();
     
-            if(iwchanged || m_width != oldwidth || m_height != oldheight)
-                needlayout = true;
-    
+            if (imageSizeChanged || m_width != oldwidth || m_height != oldheight)
+                ensureLayout = true;
+
             m_width = oldwidth;
             m_height = oldheight;
@@ -156 +155 @@
     }
 
-    if (needlayout) {
+    if (ensureLayout) {
         if (!selfNeedsLayout())
             setNeedsLayout(true);
         if (minMaxKnown())
             setMinMaxKnown(false);
-    }
-    else
+    } else
         // FIXME: We always just do a complete repaint, since we always pass in the full image
         // rect at the moment anyway.
-        repaintRectangle(IntRect(borderLeft()+paddingLeft(), borderTop()+paddingTop(), contentWidth(), contentHeight()));
+        repaintRectangle(IntRect(borderLeft() + paddingLeft(), borderTop() + paddingTop(), contentWidth(), contentHeight()));
 }
 
@@ -177 +175 @@
 }
 
-void RenderImage::paint(PaintInfo& i, int _tx, int _ty)
-{
-    if (!shouldPaint(i, _tx, _ty)) return;
-
-    _tx += m_x;
-    _ty += m_y;
+void RenderImage::paint(PaintInfo& paintInfo, int tx, int ty)
+{
+    if (!shouldPaint(paintInfo, tx, ty))
+        return;
+
+    tx += m_x;
+    ty += m_y;
         
-    if (shouldPaintBackgroundOrBorder() && i.phase != PaintPhaseOutline && i.phase != PaintPhaseSelfOutline) 
-        paintBoxDecorations(i, _tx, _ty);
-
-    GraphicsContext* p = i.p;
-    
-    if ((i.phase == PaintPhaseOutline || i.phase == PaintPhaseSelfOutline) && style()->outlineWidth() && style()->visibility() == VISIBLE)
-        paintOutline(p, _tx, _ty, width(), height(), style());
-    
-    if (i.phase != PaintPhaseForeground && i.phase != PaintPhaseSelection)
-        return;
-
-    if (!shouldPaintWithinRoot(i))
+    if (shouldPaintBackgroundOrBorder() && paintInfo.phase != PaintPhaseOutline && paintInfo.phase != PaintPhaseSelfOutline) 
+        paintBoxDecorations(paintInfo, tx, ty);
+
+    GraphicsContext* p = paintInfo.p;
+
+    if ((paintInfo.phase == PaintPhaseOutline || paintInfo.phase == PaintPhaseSelfOutline) && style()->outlineWidth() && style()->visibility() == VISIBLE)
+        paintOutline(p, tx, ty, width(), height(), style());
+
+    if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection)
+        return;
+
+    if (!shouldPaintWithinRoot(paintInfo))
         return;
         
     bool isPrinting = document()->printing();
     bool drawSelectionTint = isSelected() && !isPrinting;
-    if (i.phase == PaintPhaseSelection) {
+    if (paintInfo.phase == PaintPhaseSelection) {
         if (selectionState() == SelectionNone)
             return;
@@ -217 +216 @@
 
     if (!m_cachedImage || image()->isNull() || errorOccurred()) {
-        if (i.phase == PaintPhaseSelection)
+        if (paintInfo.phase == PaintPhaseSelection)
             return;
 
@@ -224 +223 @@
                 p->setPen(Color::lightGray);
                 p->setFillColor(Color::transparent);
-                p->drawRect(IntRect(_tx + leftBorder + leftPad, _ty + topBorder + topPad, cWidth, cHeight));
+                p->drawRect(IntRect(tx + leftBorder + leftPad, ty + topBorder + topPad, cWidth, cHeight));
             }
-            
+
             bool errorPictureDrawn = false;
-            int imageX = 0, imageY = 0;
+            int imageX = 0;
+            int imageY = 0;
             int usableWidth = cWidth;
             int usableHeight = cHeight;
-            
+
             if (errorOccurred() && !image()->isNull() && (usableWidth >= image()->width()) && (usableHeight >= image()->height())) {
                 // Center the error image, accounting for border and padding.
-                int centerX = (usableWidth - image()->width())/2;
+                int centerX = (usableWidth - image()->width()) / 2;
                 if (centerX < 0)
                     centerX = 0;
-                int centerY = (usableHeight - image()->height())/2;
+                int centerY = (usableHeight - image()->height()) / 2;
                 if (centerY < 0)
                     centerY = 0;
                 imageX = leftBorder + leftPad + centerX;
                 imageY = topBorder + topPad + centerY;
-                p->drawImage(image(), IntPoint(_tx + imageX, _ty + imageY));
+                p->drawImage(image(), IntPoint(tx + imageX, ty + imageY));
                 errorPictureDrawn = true;
             }
-            
+
             if (!m_altText.isEmpty()) {
                 DeprecatedString text = m_altText.deprecatedString();
@@ -251 +251 @@
                 p->setFont(style()->font());
                 p->setPen(style()->color());
-                int ax = _tx + leftBorder + leftPad;
-                int ay = _ty + topBorder + topPad;
+                int ax = tx + leftBorder + leftPad;
+                int ay = ty + topBorder + topPad;
                 const Font& font = style()->font();
                 int ascent = font.ascent();
@@ -269 +269 @@
     } else if (m_cachedImage) {
 #if PLATFORM(MAC)
-        if (style()->highlight() != nullAtom && !i.p->paintingDisabled())
-            paintCustomHighlight(_tx - m_x, _ty - m_y, style()->highlight(), true);
+        if (style()->highlight() != nullAtom && !paintInfo.p->paintingDisabled())
+            paintCustomHighlight(tx - m_x, ty - m_y, style()->highlight(), true);
 #endif
 
-        IntRect rect(IntPoint(_tx + leftBorder + leftPad, _ty + topBorder + topPad), IntSize(cWidth, cHeight));
-        
+        IntRect rect(IntPoint(tx + leftBorder + leftPad, ty + topBorder + topPad), IntSize(cWidth, cHeight));
+
         HTMLImageElement* imageElt = (element() && element()->hasTagName(imgTag)) ? static_cast<HTMLImageElement*>(element()) : 0;
         CompositeOperator compositeOperator = imageElt ? imageElt->compositeOperator() : CompositeSourceOver;
@@ -287 +287 @@
 {
     ASSERT(needsLayout());
-    ASSERT( minMaxKnown() );
+    ASSERT(minMaxKnown());
 
     IntRect oldBounds;
@@ -335 +335 @@
     if (!element())
         return;
-        
+
     if (element()->hasTagName(inputTag))
         m_altText = static_cast<HTMLInputElement*>(element())->altText();
@@ -436 +436 @@
 }
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderImage.h

@@ -25 +25 @@
  */
 
-#ifndef RENDER_IMAGE_H
-#define RENDER_IMAGE_H
+#ifndef RenderImage_h
+#define RenderImage_h
 
 #include "CachedImage.h"
@@ -37 +37 @@
 class HTMLMapElement;
 
-class RenderImage : public RenderReplaced
-{
+class RenderImage : public RenderReplaced {
 public:
     RenderImage(Node*);
@@ -52 +51 @@
 
     virtual void imageChanged(CachedImage*);
-    
+
     // don't even think about making this method virtual!
-    HTMLElement* element() const
-        { return static_cast<HTMLElement*>(RenderReplaced::element()); }
+    HTMLElement* element() const { return static_cast<HTMLElement*>(RenderReplaced::element()); }
 
     // hook to keep RendeObject::m_inline() up to date
-    virtual void setStyle(RenderStyle *style);
+    virtual void setStyle(RenderStyle*);
     void updateAltText();
-    
+
     void setIsAnonymousImage(bool anon) { m_isAnonymousImage = anon; }
     bool isAnonymousImage() { return m_isAnonymousImage; }
-    
+
     void setCachedImage(CachedImage*);
     CachedImage* cachedImage() const { return m_cachedImage; }
-    
+
     Image* image() { return m_cachedImage ? m_cachedImage->image() : nullImage(); }
 
     virtual bool nodeAtPoint(HitTestResult&, int x, int y, int tx, int ty, HitTestAction);
-    
+
     virtual int calcReplacedWidth() const;
     virtual int calcReplacedHeight() const;
@@ -81 +79 @@
     // Called to set generated content images (e.g., :before/:after generated images).
     void setContentObject(CachedResource*);
-    
+
     bool errorOccurred() const { return m_cachedImage && m_cachedImage->isErrorImage(); }
-    
+
     HTMLMapElement* imageMap();
 
@@ -104 +102 @@
 };
 
-} //namespace
+} // namespace WebCore
 
-#endif
+#endif // RenderImage_h

trunk/WebCore/rendering/RenderInline.cpp

@@ -34 +34 @@
 
 RenderInline::RenderInline(Node* node)
-:RenderFlow(node), m_isContinuation(false)
-{}
+    : RenderFlow(node)
+    , m_isContinuation(false)
+{
+}
 
 RenderInline::~RenderInline()
-{}
-
-void RenderInline::setStyle(RenderStyle* _style)
-{
-    RenderFlow::setStyle(_style);
+{
+}
+
+void RenderInline::setStyle(RenderStyle* newStyle)
+{
+    RenderFlow::setStyle(newStyle);
     setInline(true);
 
@@ -63 +66 @@
 
     m_lineHeight = -1;
-    
+
     // Update pseudos for :before and :after now.
     updatePseudoChild(RenderStyle::BEFORE);
@@ -85 +88 @@
         // |newChild|.  We then make that block box a continuation of this inline.  We take all of
         // the children after |beforeChild| and put them in a clone of this object.
-        RenderStyle *newStyle = new (renderArena()) RenderStyle();
+        RenderStyle* newStyle = new (renderArena()) RenderStyle();
         newStyle->inheritFrom(style());
         newStyle->setDisplay(BLOCK);
 
-        RenderBlock *newBox = new (renderArena()) RenderBlock(document() /* anonymous box */);
+        RenderBlock* newBox = new (renderArena()) RenderBlock(document() /* anonymous box */);
         newBox->setStyle(newStyle);
         RenderFlow* oldContinuation = continuation();
@@ -102 +105 @@
             beforeChild = 0; // We destroyed the last child, so now we need to update our insertion
                              // point to be 0.  It's just a straight append now.
-        
+
         splitFlow(beforeChild, newBox, newChild, oldContinuation);
         return;
@@ -114 +117 @@
 RenderInline* RenderInline::cloneInline(RenderFlow* src)
 {
-    RenderInline *o = new (src->renderArena()) RenderInline(src->element());
+    RenderInline* o = new (src->renderArena()) RenderInline(src->element());
     o->m_isContinuation = true;
     o->setStyle(src->style());
@@ -127 +130 @@
     RenderInline* clone = cloneInline(this);
     clone->setContinuation(oldCont);
-    
+
     // Now take all of the children from beforeChild to the end and remove
     // them from |this| and place them in the clone.
@@ -163 +166 @@
         // content gets properly destroyed.
         curr->updatePseudoChild(RenderStyle::AFTER);
-        
+
         // Now we need to take all of the children starting from the first child
         // *after* currChild and append them all to the clone.
@@ -209 +212 @@
 
     RenderBlock* post = block->createAnonymousBlock();
-    
+
     RenderObject* boxFirst = madeNewBeforeBlock ? block->firstChild() : pre->nextSibling();
     if (madeNewBeforeBlock)
@@ -219 +222 @@
     if (madeNewBeforeBlock) {
         RenderObject* o = boxFirst;
-        while (o)
-        {
+        while (o) {
             RenderObject* no = o;
             o = no->nextSibling();
@@ -240 +242 @@
     // to wrap itself in additional boxes (e.g., table construction).
     newBlockBox->addChildToFlow(newChild, 0);
-    
+
     // Always just do a full layout in order to ensure that line boxes (especially wrappers for images)
     // get deleted properly.  Because objects moves from the pre block into the post block, we want to
@@ -249 +251 @@
 }
 
-void RenderInline::paint(PaintInfo& i, int _tx, int _ty)
-{
-    paintLines(i, _tx, _ty);
+void RenderInline::paint(PaintInfo& paintInfo, int tx, int ty)
+{
+    paintLines(paintInfo, tx, ty);
 }
 
@@ -258 +260 @@
     for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox())
         rects.append(IntRect(tx + curr->xPos(), ty + curr->yPos(), curr->width(), curr->height()));
-    
-    for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling())
+
+    for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (!curr->isText())
             curr->absoluteRects(rects, tx + curr->xPos(), ty + curr->yPos());
-    
+    }
+
     if (continuation())
         continuation()->absoluteRects(rects, 
@@ -271 +274 @@
 void RenderInline::calcMinMaxWidth()
 {
-    ASSERT( !minMaxKnown() );
-
-#ifdef DEBUG_LAYOUT
-    kdDebug( 6040 ) << renderName() << "(RenderInline)::calcMinMaxWidth() this=" << this << endl;
-#endif
+    ASSERT(!minMaxKnown());
 
     // Irrelevant, since some enclosing block will actually measure us and our children.
@@ -284 +283 @@
 }
 
-bool RenderInline::requiresLayer() {
+bool RenderInline::requiresLayer()
+{
     return isRoot() || isRelPositioned() || style()->opacity() < 1.0f;
 }
@@ -299 +299 @@
             rightSide = curr->xPos() + curr->width();
     }
-    
+
     return rightSide - leftSide;
 }
@@ -305 +305 @@
 int RenderInline::height() const
 {
-    int h = 0;
     if (firstLineBox())
-        h = lastLineBox()->yPos() + lastLineBox()->height() - firstLineBox()->yPos();
-    return h;
+        return lastLineBox()->yPos() + lastLineBox()->height() - firstLineBox()->yPos();
+    return 0;
 }
 
@@ -327 +326 @@
 }
 
-const char *RenderInline::renderName() const
+const char* RenderInline::renderName() const
 {
     if (isRelPositioned())
@@ -336 +335 @@
 }
 
-bool RenderInline::nodeAtPoint(HitTestResult& result, int _x, int _y, int _tx, int _ty,
-                               HitTestAction hitTestAction)
-{
-    return hitTestLines(result, _x, _y, _tx, _ty, hitTestAction);
+bool RenderInline::nodeAtPoint(HitTestResult& result, int x, int y, int tx, int ty, HitTestAction hitTestAction)
+{
+    return hitTestLines(result, x, y, tx, ty, hitTestAction);
 }
 
 VisiblePosition RenderInline::positionForCoordinates(int x, int y)
 {
-    for (RenderObject *c = continuation(); c; c = c->continuation()) {
+    for (RenderObject* c = continuation(); c; c = c->continuation()) {
         if (c->isInline() || c->firstChild())
             return c->positionForCoordinates(x, y);
@@ -352 +350 @@
 }
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderInline.h

@@ -23 +23 @@
  */
 
-#ifndef RENDER_INLINE_H
-#define RENDER_INLINE_H
+#ifndef RenderInline_h
+#define RenderInline_h
 
 #include "RenderFlow.h"
 
 namespace WebCore {
-    class Position;
-}
 
-namespace WebCore {
+class Position;
 
-class RenderInline : public RenderFlow
-{
+class RenderInline : public RenderFlow {
 public:
     RenderInline(Node*);
     virtual ~RenderInline();
 
-    virtual const char *renderName() const;
+    virtual const char* renderName() const;
 
     virtual bool isRenderInline() const { return true; }
@@ -47 +44 @@
 
     virtual bool isInlineContinuation() const;
-    
+
     virtual void addChildToFlow(RenderObject* newChild, RenderObject* beforeChild);
     void splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock, RenderBlock* middleBlock,
@@ -53 +50 @@
     void splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
                    RenderObject* newChild, RenderFlow* oldCont);
-    
+
     virtual void setStyle(RenderStyle*);
 
-    virtual void layout() {} // Do nothing for layout()
-    
+    virtual void layout() { } // Do nothing for layout()
+
     virtual void paint(PaintInfo&, int tx, int ty);
 
-    virtual bool nodeAtPoint(HitTestResult&, int _x, int _y, int _tx, int _ty, HitTestAction);
-    
+    virtual bool nodeAtPoint(HitTestResult&, int x, int y, int tx, int ty, HitTestAction);
+
     virtual void calcMinMaxWidth();
 
@@ -69 +66 @@
     virtual int width() const;
     virtual int height() const;
-    
+
     // used to calculate offsetWidth/Height.  Overridden by inlines (RenderFlow) to return
     // the remaining width on a given line (and the height of a single line).
@@ -78 +75 @@
 
     virtual VisiblePosition positionForCoordinates(int x, int y);
-    
+
 protected:
     static RenderInline* cloneInline(RenderFlow* src);
@@ -86 +83 @@
 };
 
-} // namespace
+} // namespace WebCore
 
-#endif
-
+#endif // RenderInline_h

trunk/WebCore/rendering/RenderLayer.cpp

@@ -57 +57 @@
 #include "OverflowEvent.h"
 #include "PlatformMouseEvent.h"
+#include "PlatformScrollBar.h" 
 #include "RenderArena.h"
 #include "RenderInline.h"
@@ -62 +63 @@
 #include "RenderView.h"
 #include "SelectionController.h"
-#include "PlatformScrollBar.h" 
 
 #ifdef SVG_SUPPORT
@@ -2313 +2313 @@
 }
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderLayer.h

@@ -42 +42 @@
  */
 
-#ifndef render_layer_h
-#define render_layer_h
+#ifndef RenderLayer_h
+#define RenderLayer_h
 
 #include "RenderObject.h"
+#include "ScrollBar.h"
 #include "Timer.h"
-#include "ScrollBar.h"
 
 namespace WebCore {
@@ -53 +53 @@
 class CachedResource;
 class HitTestResult;
-class RenderView;
+class PlatformScrollbar;
 class RenderFrameSet;
 class RenderObject;
@@ -59 +59 @@
 class RenderTable;
 class RenderText;
-class PlatformScrollbar;
+class RenderView;
 
 class ClipRects {
 public:
-    ClipRects(const IntRect& r) :m_overflowClipRect(r), m_fixedClipRect(r), m_posClipRect(r), m_refCnt(0) {}
+    ClipRects(const IntRect& r)
+        : m_overflowClipRect(r)
+        , m_fixedClipRect(r)
+        , m_posClipRect(r)
+        , m_refCnt(0)
+    {
+    }
+
     ClipRects(const IntRect& o, const IntRect& f, const IntRect& p)
-      :m_overflowClipRect(o), m_fixedClipRect(f), m_posClipRect(p), m_refCnt(0) {}
+        : m_overflowClipRect(o)
+        , m_fixedClipRect(f)
+        , m_posClipRect(p)
+        , m_refCnt(0)
+    {
+    }
 
     const IntRect& overflowClipRect() { return m_overflowClipRect; }
@@ -73 +85 @@
     void ref() { m_refCnt++; }
     void deref(RenderArena* renderArena) { if (--m_refCnt == 0) destroy(renderArena); }
-    
-    void destroy(RenderArena* renderArena);
+
+    void destroy(RenderArena*);
 
     // Overloaded new operator.
-    void* operator new(size_t sz, RenderArena* renderArena) throw();    
+    void* operator new(size_t, RenderArena*) throw();
 
     // Overridden to prevent the normal delete from being called.
-    void operator delete(void* ptr, size_t sz);
+    void operator delete(void*, size_t);
         
 private:
     // The normal operator new is disallowed on all render objects.
-    void* operator new(size_t sz) throw();
+    void* operator new(size_t) throw();
 
 private:
@@ -93 +105 @@
 };
 
+
+// FIXME: move this to its own file
 // This class handles the auto-scrolling of layers with overflow: marquee.
-class Marquee
-{
+class Marquee {
 public:
     Marquee(RenderLayer*);
@@ -101 +114 @@
     int speed() const { return m_speed; }
     int marqueeSpeed() const;
+
     EMarqueeDirection reverseDirection() const { return static_cast<EMarqueeDirection>(-direction()); }
     EMarqueeDirection direction() const;
@@ -109 +123 @@
 
     EWhiteSpace whiteSpace() { return static_cast<EWhiteSpace>(m_whiteSpace); }
-    
-    int computePosition(EMarqueeDirection dir, bool stopAtClientEdge);
+
+    int computePosition(EMarqueeDirection, bool stopAtClientEdge);
 
     void setEnd(int end) { m_end = end; }
@@ -163 +177 @@
     static const ScrollAlignment gAlignTopAlways;
     static const ScrollAlignment gAlignBottomAlways;
-    
+
     static ScrollBehavior getVisibleBehavior(const ScrollAlignment& s) { return s.m_rectVisible; }
     static ScrollBehavior getPartialBehavior(const ScrollAlignment& s) { return s.m_rectPartial; }
     static ScrollBehavior getHiddenBehavior(const ScrollAlignment& s) { return s.m_rectHidden; }
-    
+
     RenderLayer(RenderObject*);
     ~RenderLayer();
-    
+
     RenderObject* renderer() const { return m_object; }
     RenderLayer* parent() const { return m_parent; }
     RenderLayer* previousSibling() const { return m_previous; }
     RenderLayer* nextSibling() const { return m_next; }
-
     RenderLayer* firstChild() const { return m_first; }
     RenderLayer* lastChild() const { return m_last; }
@@ -186 +199 @@
 
     void repaintIncludingDescendants();
-    
+
     void styleChanged();
-    
+
     Marquee* marquee() const { return m_marquee; }
     void suspendMarquees();
 
     bool isOverflowOnly() const { return m_isOverflowOnly; }
-    
+
     bool isTransparent() const;
     RenderLayer* transparentAncestor();
     void beginTransparencyLayers(GraphicsContext*, const IntRect&);
-    
-    const RenderLayer* root() const {
+
+    const RenderLayer* root() const
+    {
         const RenderLayer* curr = this;
-        while (curr->parent()) curr = curr->parent();
+        while (curr->parent())
+            curr = curr->parent();
         return curr;
     }
@@ -206 +221 @@
     int xPos() const { return m_x; }
     int yPos() const { return m_y; }
-    int width() const { return m_width; }
-    int height() const { return m_height; }
-
-    void setWidth(int w) { m_width = w; }
-    void setHeight(int h) { m_height = h; }
-
-    int scrollWidth();
-    int scrollHeight();
-    
-    void setPos( int xPos, int yPos ) {
+    void setPos(int xPos, int yPos)
+    {
         m_x = xPos;
         m_y = yPos;
     }
+
+    int width() const { return m_width; }
+    int height() const { return m_height; }
+    void setWidth(int w) { m_width = w; }
+    void setHeight(int h) { m_height = h; }
+
+    int scrollWidth();
+    int scrollHeight();
 
     // Scrolling methods for layers that can scroll their overflow.
@@ -228 +243 @@
     void scrollToXOffset(int x) { scrollToOffset(x, m_scrollY); }
     void scrollToYOffset(int y) { scrollToOffset(m_scrollX + m_scrollOriginX, y); }
-    void scrollRectToVisible(const IntRect &r, const ScrollAlignment& alignX = gAlignCenterIfNeeded, const ScrollAlignment& alignY = gAlignCenterIfNeeded);
-    IntRect getRectToExpose(const IntRect &visibleRect,  const IntRect &exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);    
+    void scrollRectToVisible(const IntRect&, const ScrollAlignment& alignX = gAlignCenterIfNeeded, const ScrollAlignment& alignY = gAlignCenterIfNeeded);
+
+    IntRect getRectToExpose(const IntRect& visibleRect, const IntRect& exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);    
+
     void setHasHorizontalScrollbar(bool);
     void setHasVerticalScrollbar(bool);
+
     PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation);
     void destroyScrollbar(ScrollbarOrientation);
+
     Scrollbar* horizontalScrollbar() { return m_hBar.get(); }
     Scrollbar* verticalScrollbar() { return m_vBar.get(); }
+
     PlatformScrollbar* horizontaScrollbarWidget() const;
     PlatformScrollbar* verticalScrollbarWidget() const;
+
     int verticalScrollbarWidth() const;
     int horizontalScrollbarHeight() const;
+
     void positionOverflowControls();
     bool isPointInResizeControl(const IntPoint&);
     IntSize offsetFromResizeCorner(const IntPoint&) const;
+
     void paintOverflowControls(GraphicsContext*, int tx, int ty, const IntRect& damageRect);
+
     void updateScrollInfoAfterLayout();
-    bool scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier=1.0);
+
+    bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1.0f);
     void autoscroll();
+
     void resize(const PlatformMouseEvent&, const IntSize&);
     bool inResizeMode() const { return m_inResizeMode; }
@@ -252 +278 @@
     
     void updateLayerPosition();
-    void updateLayerPositions(bool doFullRepaint = false, bool checkForRepaint=true);
+    void updateLayerPositions(bool doFullRepaint = false, bool checkForRepaint = true);
     void checkForRepaintOnResize();
-    void relativePositionOffset(int& relX, int& relY) {
-        relX += m_relX; relY += m_relY;
-    }
-     
+
+    void relativePositionOffset(int& relX, int& relY) { relX += m_relX; relY += m_relY; }
+
     void clearClipRects();
     void clearClipRect();
@@ -270 +295 @@
     Vector<RenderLayer*>* posZOrderList() const { return m_posZOrderList; }
     Vector<RenderLayer*>* negZOrderList() const { return m_negZOrderList; }
-    
+
     void dirtyOverflowList();
     void updateOverflowList();
     Vector<RenderLayer*>* overflowList() const { return m_overflowList; }
-    
+
     bool hasVisibleContent() const { return m_hasVisibleContent; }
-    void setHasVisibleContent(bool b);
+    void setHasVisibleContent(bool);
     void dirtyVisibleContentStatus();
 
@@ -282 +307 @@
     // the <html> layer and the root layer).
     RenderLayer* enclosingPositionedAncestor() const;
-    
+
     void convertToLayerCoords(const RenderLayer* ancestorLayer, int& x, int& y) const;
-    
+
     bool hasAutoZIndex() const { return renderer()->style()->hasAutoZIndex(); }
     int zIndex() const { return renderer()->style()->zIndex(); }
@@ -311 +336 @@
 
     void updateHoverActiveState(HitTestResult&);
-    
+
     IntRect repaintRect() const { return m_repaintRect; }
 
-    void destroy(RenderArena* renderArena);
+    void destroy(RenderArena*);
 
      // Overloaded new operator.  Derived classes must override operator new
     // in order to allocate out of the RenderArena.
-    void* operator new(size_t sz, RenderArena* renderArena) throw();    
+    void* operator new(size_t, RenderArena*) throw();
 
     // Overridden to prevent the normal delete from being called.
-    void operator delete(void* ptr, size_t sz);
+    void operator delete(void*, size_t);
 
 private:
     // The normal operator new is disallowed on all render objects.
-    void* operator new(size_t sz) throw();
+    void* operator new(size_t) throw();
 
 private:
@@ -337 +362 @@
 
     void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const IntRect& paintDirtyRect,
-        bool haveTransparency, PaintRestriction, RenderObject* paintingRoot);
+                    bool haveTransparency, PaintRestriction, RenderObject* paintingRoot);
     RenderLayer* hitTestLayer(RenderLayer* rootLayer, HitTestResult&, const IntRect& hitTestRect);
     void computeScrollDimensions(bool* needHBar = 0, bool* needVBar = 0);
@@ -347 +372 @@
 
     void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);
-    
+
     void childVisibilityChanged(bool newVisibility);
     void dirtyVisibleDescendantStatus();
     void updateVisibilityStatus();
-        
+
 protected:   
     RenderObject* m_object;
-    
+
     RenderLayer* m_parent;
     RenderLayer* m_previous;
     RenderLayer* m_next;
-
     RenderLayer* m_first;
     RenderLayer* m_last;
@@ -378 +402 @@
     int m_width;
     int m_height;
-    
+
     // Our scroll offsets if the view is scrolled.
     int m_scrollX;
@@ -384 +408 @@
     int m_scrollOriginX;
     int m_scrollLeftOverflow;
-    
+
     // The width/height of our scrolled area.
     int m_scrollWidth;
     int m_scrollHeight;
-    
+
     // For layers with overflow, we have a pair of scrollbars.
     RefPtr<Scrollbar> m_hBar;
     RefPtr<Scrollbar> m_vBar;
-    
+
     // Keeps track of whether the layer is currently resizing, so events can cause resizing to start and stop.
     bool m_inResizeMode;
@@ -402 +426 @@
     Vector<RenderLayer*>* m_posZOrderList;
     Vector<RenderLayer*>* m_negZOrderList;
-    
+
     // This list contains our overflow child layers.
     Vector<RenderLayer*>* m_overflowList;
@@ -426 +450 @@
     bool m_visibleDescendantStatusDirty : 1;
     bool m_hasVisibleDescendant : 1;
-    
+
     Marquee* m_marquee; // Used by layers with overflow:marquee
 };
 
-} // namespace
-
-#endif
+} // namespace WebCore
+
+#endif // RenderLayer_h

trunk/WebCore/rendering/RenderLineEdit.cpp

@@ -111 +111 @@
 }
 
-void RenderLineEdit::setStyle(RenderStyle *s)
-{
-    RenderFormElement::setStyle(s);
+void RenderLineEdit::setStyle(RenderStyle* newStyle)
+{
+    RenderFormElement::setStyle(newStyle);
 
     TextField* w = static_cast<TextField*>(widget());
@@ -150 +150 @@
 
     w->setReadOnly(e->isReadOnlyControl());
-    
+
     // Handle updating the search attributes.
     w->setPlaceholderString(e->getAttribute(placeholderAttr).deprecatedString());
@@ -183 +183 @@
 int RenderLineEdit::selectionStart()
 {
-    TextField *lineEdit = static_cast<TextField *>(m_widget);
+    TextField* lineEdit = static_cast<TextField*>(m_widget);
     int start = lineEdit->selectionStart();
     if (start == -1)
@@ -192 +192 @@
 int RenderLineEdit::selectionEnd()
 {
-    TextField *lineEdit = static_cast<TextField *>(m_widget);
+    TextField* lineEdit = static_cast<TextField*>(m_widget);
     int start = lineEdit->selectionStart();
     if (start == -1)
         return lineEdit->cursorPosition();
-    return start + (int)lineEdit->selectedText().length();
+    return start + static_cast<int>(lineEdit->selectedText().length());
 }
 
@@ -203 +203 @@
     int realStart = max(start, 0);
     int length = max(selectionEnd() - realStart, 0);
-    static_cast<TextField *>(m_widget)->setSelection(realStart, length);
+    static_cast<TextField*>(m_widget)->setSelection(realStart, length);
 }
 
@@ -215 +215 @@
         length = 0;
     }
-    static_cast<TextField *>(m_widget)->setSelection(start, length);
+    static_cast<TextField*>(m_widget)->setSelection(start, length);
 }
 
@@ -236 +236 @@
     int realStart = max(start, 0);
     int length = max(end - realStart, 0);
-    static_cast<TextField *>(m_widget)->setSelection(realStart, length);
+    static_cast<TextField*>(m_widget)->setSelection(realStart, length);
 }
 

trunk/WebCore/rendering/RenderLineEdit.h

@@ -50 +50 @@
         void setSelectionStart(int);
         void setSelectionEnd(int);
-        
+
         bool isEdited() const;
         void setEdited(bool);

trunk/WebCore/rendering/RenderListBox.cpp

@@ -30 +30 @@
 #include "GraphicsContext.h"
 #include "HTMLNames.h"
+#include "HTMLOptGroupElement.h"
 #include "HTMLOptionElement.h"
-#include "HTMLOptGroupElement.h"
 #include "HTMLSelectElement.h"
 #include "HitTestResult.h"
@@ -434 +434 @@
 }
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderListBox.h

@@ -21 +21 @@
  */
 
-#ifndef RenderListBox_H
-#define RenderListBox_H
+#ifndef RenderListBox_h
+#define RenderListBox_h
 
 #include "RenderBlock.h"
@@ -36 +36 @@
     ~RenderListBox();
 
+    virtual const char* renderName() const { return "RenderListBox"; }
+
     virtual bool isListBox() const { return true; }
 
@@ -43 +45 @@
 
     virtual bool canHaveChildren() const { return false; }
-    virtual const char* renderName() const { return "RenderListBox"; }
+
     virtual void paintObject(PaintInfo&, int tx, int ty);
     virtual bool isPointInScrollbar(HitTestResult&, int x, int y, int tx, int ty);
 
-    virtual bool scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier=1.0);
+    virtual bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1.0f);
 
     virtual void calcMinMaxWidth();
-    virtual short baselinePosition(bool, bool isRootLineBox) const;
+    virtual short baselinePosition(bool firstLine, bool isRootLineBox) const;
     virtual void calcHeight();
     void setOptionsChanged(bool c) { m_optionsChanged = c; }
     void valueChanged(unsigned listIndex);
-    
+
     // ScrollbarClient interface.
     virtual void valueChanged(Scrollbar*);
@@ -60 +62 @@
 
     HTMLOptionElement* optionAtPoint(int x, int y);
-    
+
     bool scrollToRevealElementAtListIndex(int index);
-    
+
     virtual bool shouldAutoscroll() const { return numItems() > size(); }
     virtual void autoscroll();
 
 private:
+    int size() const;
+    int numItems() const;
+    IntRect itemBoundingBoxRect(int tx, int ty, int index);
+    void paintScrollbar(PaintInfo&);
+    void paintItemForeground(PaintInfo&, int tx, int ty, int listIndex);
+    void paintItemBackground(PaintInfo&, int tx, int ty, int listIndex);
+
     bool m_optionsChanged;
     int m_optionsWidth;
@@ -73 +82 @@
     int m_indexOffset;
     bool m_selectionChanged;
-    
-    int size() const;
-    int numItems() const;
-    IntRect itemBoundingBoxRect(int tx, int ty, int index);
-    void paintScrollbar(PaintInfo&);
-    void paintItemForeground(PaintInfo&, int tx, int ty, int listIndex);
-    void paintItemBackground(PaintInfo&, int tx, int ty, int listIndex);
-    
+
     Scrollbar* m_vBar;
 };
 
-}
+} // namepace WebCore
 
-#endif
+#endif // RenderListBox_h

trunk/WebCore/rendering/RenderListItem.cpp

@@ -48 +48 @@
 }
 
-void RenderListItem::setStyle(RenderStyle* _style)
-{
-    RenderBlock::setStyle(_style);
+void RenderListItem::setStyle(RenderStyle* newStyle)
+{
+    RenderBlock::setStyle(newStyle);
 
     if (style()->listStyleType() != LNONE ||
@@ -143 +143 @@
     if (!firstChild)
         return 0;
-        
+
     for (RenderObject* currChild = firstChild; currChild; currChild = currChild->nextSibling()) {
         if (currChild == marker)
             continue;
-            
+
         if (currChild->isInline())
             return curr;
-        
+
         if (currChild->isFloating() || currChild->isPositioned())
             continue;
-            
+
         if (currChild->isTable() || !currChild->isRenderBlock())
             break;
-        
+
         if (currChild->style()->htmlHacks() && currChild->element() &&
             (currChild->element()->hasTagName(ulTag)|| currChild->element()->hasTagName(olTag)))
             break;
-            
+
         RenderObject* lineBox = getParentOfFirstLineBox(currChild, marker);
         if (lineBox)
             return lineBox;
     }
-    
+
     return 0;
 }
@@ -192 +192 @@
                 lineBoxParent = this;
         }
-        
+
         if (markerPar != lineBoxParent || !m_marker->minMaxKnown()) {
             m_marker->remove();
@@ -232 +232 @@
             xOffset += o->xPos();
         }
-        
+
         RootInlineBox* root = m_marker->inlineBoxWrapper()->root();
         if (style()->direction() == LTR) {
@@ -254 +254 @@
 }
 
-void RenderListItem::paint(PaintInfo& i, int _tx, int _ty)
+void RenderListItem::paint(PaintInfo& paintInfo, int tx, int ty)
 {
     if (!m_height)
         return;
 
-    RenderBlock::paint(i, _tx, _ty);
+    RenderBlock::paint(paintInfo, tx, ty);
 }
 
@@ -267 +267 @@
 }
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderListItem.h

@@ -23 +23 @@
  */
 
-#ifndef RenderListItem_H
-#define RenderListItem_H
+#ifndef RenderListItem_h
+#define RenderListItem_h
 
 #include "RenderBlock.h"
@@ -32 +32 @@
 class RenderListMarker;
 
-class RenderListItem : public RenderBlock
-{
+class RenderListItem : public RenderBlock {
 public:
     RenderListItem(Node*);
+
+    virtual const char* renderName() const { return "RenderListItem"; }
+
+    virtual bool isListItem() const { return true; }
     
     virtual void destroy();
 
-    virtual const char* renderName() const { return "RenderListItem"; }
-
     virtual void setStyle(RenderStyle*);
 
-    virtual bool isListItem() const { return true; }
-    
     int value() const { return m_value; }
     void setValue(int v) { m_predefVal = v; }
@@ -58 +57 @@
     virtual void positionListMarker();
     void updateMarkerLocation();
-    
+
     void setNotInList(bool notInList) { m_notInList = notInList; }
     bool notInList() const { return m_notInList; }
@@ -71 +70 @@
 };
 
+} // namespace WebCore
 
-} //namespace
-
-#endif
+#endif // RenderListItem_h

trunk/WebCore/rendering/RenderListMarker.cpp

@@ -522 +522 @@
 }
 
-}
+} // namespace WebCore

trunk/WebCore/rendering/RenderListMarker.h

@@ -23 +23 @@
  */
 
-#ifndef RenderListMarker_H
-#define RenderListMarker_H
+#ifndef RenderListMarker_h
+#define RenderListMarker_h
 
 #include "DeprecatedString.h"
@@ -36 +36 @@
      This class always has to be a direct child of a RenderListItem!
 */
-class RenderListMarker : public RenderBox
-{
+class RenderListMarker : public RenderBox {
 public:
     RenderListMarker(Document*);
     ~RenderListMarker();
 
+    virtual const char* renderName() const { return "RenderListMarker"; }
+
+    virtual bool isListMarker() const { return true; }
+
     virtual void setStyle(RenderStyle*);
 
-    virtual const char* renderName() const { return "RenderListMarker"; }
+    virtual void paint(PaintInfo&, int xoff, int yoff);
+
     // so the marker gets to layout itself. Only needed for
     // list-style-position: inside
-
-    virtual void paint(PaintInfo&, int xoff, int yoff);
     virtual void layout();
     virtual void calcMinMaxWidth();
@@ -58 +60 @@
     virtual InlineBox* createInlineBox(bool, bool, bool);
 
-    virtual short lineHeight(bool b, bool isRootLineBox=false) const;
-    virtual short baselinePosition(bool b, bool isRootLineBox=false) const;
+    virtual short lineHeight(bool firstLine, bool isRootLineBox = false) const;
+    virtual short baselinePosition(bool firstLine, bool isRootLineBox = false) const;
 
-    virtual bool isListMarker() const { return true; }
-    
     CachedImage* listImage() const { return m_listImage; }
-    
+
     RenderListItem* listItem() { return m_listItem; }
     void setListItem(RenderListItem* listItem) { m_listItem = listItem; }
-    
+
     const DeprecatedString& text() const { return m_item; }
 
     bool isInside() const;
-    
+
     IntRect getRelativeMarkerRect();
-    
+
     virtual SelectionState selectionState() const { return m_selectionState; }
     virtual void setSelectionState(SelectionState);
@@ -86 +86 @@
 };
 
-} //namespace
+} // namespace WebCore
 
-#endif
+#endif // RenderListMarker_h