| Index: Source/core/rendering/RenderTable.cpp
 | 
| diff --git a/Source/core/rendering/RenderTable.cpp b/Source/core/rendering/RenderTable.cpp
 | 
| index ea196ecff9541cf1a0fecb8bb2fba1e9ec3b6300..19947392e24e74a14ba0fbd2c5c63de0af50725e 100644
 | 
| --- a/Source/core/rendering/RenderTable.cpp
 | 
| +++ b/Source/core/rendering/RenderTable.cpp
 | 
| @@ -46,8 +46,6 @@
 | 
|  #include "core/rendering/style/StyleInheritedData.h"
 | 
|  #include "platform/graphics/GraphicsContextStateSaver.h"
 | 
|  
 | 
| -using namespace std;
 | 
| -
 | 
|  namespace WebCore {
 | 
|  
 | 
|  using namespace HTMLNames;
 | 
| @@ -275,30 +273,30 @@ void RenderTable::updateLogicalWidth()
 | 
|          LayoutUnit marginTotal = marginStart + marginEnd;
 | 
|  
 | 
|          // Subtract out our margins to get the available content width.
 | 
| -        LayoutUnit availableContentLogicalWidth = max<LayoutUnit>(0, containerWidthInInlineDirection - marginTotal);
 | 
| +        LayoutUnit availableContentLogicalWidth = std::max<LayoutUnit>(0, containerWidthInInlineDirection - marginTotal);
 | 
|          if (shrinkToAvoidFloats() && cb->containsFloats() && !hasPerpendicularContainingBlock)
 | 
|              availableContentLogicalWidth = shrinkLogicalWidthToAvoidFloats(marginStart, marginEnd, toRenderBlockFlow(cb));
 | 
|  
 | 
|          // Ensure we aren't bigger than our available width.
 | 
| -        setLogicalWidth(min<int>(availableContentLogicalWidth, maxPreferredLogicalWidth()));
 | 
| +        setLogicalWidth(std::min<int>(availableContentLogicalWidth, maxPreferredLogicalWidth()));
 | 
|      }
 | 
|  
 | 
|      // Ensure we aren't bigger than our max-width style.
 | 
|      Length styleMaxLogicalWidth = style()->logicalMaxWidth();
 | 
|      if ((styleMaxLogicalWidth.isSpecified() && !styleMaxLogicalWidth.isNegative()) || styleMaxLogicalWidth.isIntrinsic()) {
 | 
|          LayoutUnit computedMaxLogicalWidth = convertStyleLogicalWidthToComputedWidth(styleMaxLogicalWidth, availableLogicalWidth);
 | 
| -        setLogicalWidth(min<int>(logicalWidth(), computedMaxLogicalWidth));
 | 
| +        setLogicalWidth(std::min<int>(logicalWidth(), computedMaxLogicalWidth));
 | 
|      }
 | 
|  
 | 
|      // Ensure we aren't smaller than our min preferred width. This MUST be done after 'max-width' as
 | 
|      // we ignore it if it means we wouldn't accomodate our content.
 | 
| -    setLogicalWidth(max<int>(logicalWidth(), minPreferredLogicalWidth()));
 | 
| +    setLogicalWidth(std::max<int>(logicalWidth(), minPreferredLogicalWidth()));
 | 
|  
 | 
|       // Ensure we aren't smaller than our min-width style.
 | 
|      Length styleMinLogicalWidth = style()->logicalMinWidth();
 | 
|      if ((styleMinLogicalWidth.isSpecified() && !styleMinLogicalWidth.isNegative()) || styleMinLogicalWidth.isIntrinsic()) {
 | 
|          LayoutUnit computedMinLogicalWidth = convertStyleLogicalWidthToComputedWidth(styleMinLogicalWidth, availableLogicalWidth);
 | 
| -        setLogicalWidth(max<int>(logicalWidth(), computedMinLogicalWidth));
 | 
| +        setLogicalWidth(std::max<int>(logicalWidth(), computedMinLogicalWidth));
 | 
|      }
 | 
|  
 | 
|      // Finally, with our true width determined, compute our margins for real.
 | 
| @@ -349,7 +347,7 @@ LayoutUnit RenderTable::convertStyleLogicalHeightToComputedHeight(const Length&
 | 
|          computedLogicalHeight = computeIntrinsicLogicalContentHeightUsing(styleLogicalHeight, logicalHeight() - borderAndPadding, borderAndPadding);
 | 
|      else
 | 
|          ASSERT_NOT_REACHED();
 | 
| -    return max<LayoutUnit>(0, computedLogicalHeight);
 | 
| +    return std::max<LayoutUnit>(0, computedLogicalHeight);
 | 
|  }
 | 
|  
 | 
|  void RenderTable::layoutCaption(RenderTableCaption* caption)
 | 
| @@ -480,7 +478,7 @@ void RenderTable::layout()
 | 
|              }
 | 
|              if (logicalHeight() != oldTableLogicalTop) {
 | 
|                  sectionMoved = true;
 | 
| -                movedSectionLogicalTop = min(logicalHeight(), oldTableLogicalTop);
 | 
| +                movedSectionLogicalTop = std::min(logicalHeight(), oldTableLogicalTop);
 | 
|              }
 | 
|          }
 | 
|  
 | 
| @@ -501,13 +499,13 @@ void RenderTable::layout()
 | 
|          Length logicalMaxHeightLength = style()->logicalMaxHeight();
 | 
|          if (logicalMaxHeightLength.isIntrinsic() || (logicalMaxHeightLength.isSpecified() && !logicalMaxHeightLength.isNegative())) {
 | 
|              LayoutUnit computedMaxLogicalHeight = convertStyleLogicalHeightToComputedHeight(logicalMaxHeightLength);
 | 
| -            computedLogicalHeight = min(computedLogicalHeight, computedMaxLogicalHeight);
 | 
| +            computedLogicalHeight = std::min(computedLogicalHeight, computedMaxLogicalHeight);
 | 
|          }
 | 
|  
 | 
|          Length logicalMinHeightLength = style()->logicalMinHeight();
 | 
|          if (logicalMinHeightLength.isIntrinsic() || (logicalMinHeightLength.isSpecified() && !logicalMinHeightLength.isNegative())) {
 | 
|              LayoutUnit computedMinLogicalHeight = convertStyleLogicalHeightToComputedHeight(logicalMinHeightLength);
 | 
| -            computedLogicalHeight = max(computedLogicalHeight, computedMinLogicalHeight);
 | 
| +            computedLogicalHeight = std::max(computedLogicalHeight, computedMinLogicalHeight);
 | 
|          }
 | 
|  
 | 
|          distributeExtraLogicalHeight(floorToInt(computedLogicalHeight - totalSectionLogicalHeight));
 | 
| @@ -530,7 +528,7 @@ void RenderTable::layout()
 | 
|          while (section) {
 | 
|              if (!sectionMoved && section->logicalTop() != logicalHeight()) {
 | 
|                  sectionMoved = true;
 | 
| -                movedSectionLogicalTop = min(logicalHeight(), section->logicalTop()) + (style()->isHorizontalWritingMode() ? section->visualOverflowRect().y() : section->visualOverflowRect().x());
 | 
| +                movedSectionLogicalTop = std::min(logicalHeight(), section->logicalTop()) + (style()->isHorizontalWritingMode() ? section->visualOverflowRect().y() : section->visualOverflowRect().x());
 | 
|              }
 | 
|              section->setLogicalLocation(LayoutPoint(sectionLogicalLeft, logicalHeight()));
 | 
|  
 | 
| @@ -766,7 +764,7 @@ void RenderTable::computePreferredLogicalWidths()
 | 
|      m_tableLayout->applyPreferredLogicalWidthQuirks(m_minPreferredLogicalWidth, m_maxPreferredLogicalWidth);
 | 
|  
 | 
|      for (unsigned i = 0; i < m_captions.size(); i++)
 | 
| -        m_minPreferredLogicalWidth = max(m_minPreferredLogicalWidth, m_captions[i]->minPreferredLogicalWidth());
 | 
| +        m_minPreferredLogicalWidth = std::max(m_minPreferredLogicalWidth, m_captions[i]->minPreferredLogicalWidth());
 | 
|  
 | 
|      RenderStyle* styleToUse = style();
 | 
|      // FIXME: This should probably be checking for isSpecified since you should be able to use percentage or calc values for min-width.
 | 
| @@ -987,7 +985,7 @@ int RenderTable::calcBorderStart() const
 | 
|          if (columnAdjoiningBorder.style() == BHIDDEN)
 | 
|              return 0;
 | 
|          if (columnAdjoiningBorder.style() > BHIDDEN)
 | 
| -            borderWidth = max(borderWidth, columnAdjoiningBorder.width());
 | 
| +            borderWidth = std::max(borderWidth, columnAdjoiningBorder.width());
 | 
|          // FIXME: This logic doesn't properly account for the first column in the first column-group case.
 | 
|      }
 | 
|  
 | 
| @@ -997,7 +995,7 @@ int RenderTable::calcBorderStart() const
 | 
|              return 0;
 | 
|  
 | 
|          if (sectionAdjoiningBorder.style() > BHIDDEN)
 | 
| -            borderWidth = max(borderWidth, sectionAdjoiningBorder.width());
 | 
| +            borderWidth = std::max(borderWidth, sectionAdjoiningBorder.width());
 | 
|  
 | 
|          if (const RenderTableCell* adjoiningStartCell = topNonEmptySection->firstRowCellAdjoiningTableStart()) {
 | 
|              // FIXME: Make this work with perpendicular and flipped cells.
 | 
| @@ -1010,9 +1008,9 @@ int RenderTable::calcBorderStart() const
 | 
|                  return 0;
 | 
|  
 | 
|              if (startCellAdjoiningBorder.style() > BHIDDEN)
 | 
| -                borderWidth = max(borderWidth, startCellAdjoiningBorder.width());
 | 
| +                borderWidth = std::max(borderWidth, startCellAdjoiningBorder.width());
 | 
|              if (firstRowAdjoiningBorder.style() > BHIDDEN)
 | 
| -                borderWidth = max(borderWidth, firstRowAdjoiningBorder.width());
 | 
| +                borderWidth = std::max(borderWidth, firstRowAdjoiningBorder.width());
 | 
|          }
 | 
|      }
 | 
|      return (borderWidth + (style()->isLeftToRightDirection() ? 0 : 1)) / 2;
 | 
| @@ -1042,7 +1040,7 @@ int RenderTable::calcBorderEnd() const
 | 
|          if (columnAdjoiningBorder.style() == BHIDDEN)
 | 
|              return 0;
 | 
|          if (columnAdjoiningBorder.style() > BHIDDEN)
 | 
| -            borderWidth = max(borderWidth, columnAdjoiningBorder.width());
 | 
| +            borderWidth = std::max(borderWidth, columnAdjoiningBorder.width());
 | 
|          // FIXME: This logic doesn't properly account for the last column in the last column-group case.
 | 
|      }
 | 
|  
 | 
| @@ -1052,7 +1050,7 @@ int RenderTable::calcBorderEnd() const
 | 
|              return 0;
 | 
|  
 | 
|          if (sectionAdjoiningBorder.style() > BHIDDEN)
 | 
| -            borderWidth = max(borderWidth, sectionAdjoiningBorder.width());
 | 
| +            borderWidth = std::max(borderWidth, sectionAdjoiningBorder.width());
 | 
|  
 | 
|          if (const RenderTableCell* adjoiningEndCell = topNonEmptySection->firstRowCellAdjoiningTableEnd()) {
 | 
|              // FIXME: Make this work with perpendicular and flipped cells.
 | 
| @@ -1065,9 +1063,9 @@ int RenderTable::calcBorderEnd() const
 | 
|                  return 0;
 | 
|  
 | 
|              if (endCellAdjoiningBorder.style() > BHIDDEN)
 | 
| -                borderWidth = max(borderWidth, endCellAdjoiningBorder.width());
 | 
| +                borderWidth = std::max(borderWidth, endCellAdjoiningBorder.width());
 | 
|              if (firstRowAdjoiningBorder.style() > BHIDDEN)
 | 
| -                borderWidth = max(borderWidth, firstRowAdjoiningBorder.width());
 | 
| +                borderWidth = std::max(borderWidth, firstRowAdjoiningBorder.width());
 | 
|          }
 | 
|      }
 | 
|      return (borderWidth + (style()->isLeftToRightDirection() ? 1 : 0)) / 2;
 | 
| @@ -1112,7 +1110,7 @@ int RenderTable::outerBorderBefore() const
 | 
|      if (tb.style() == BHIDDEN)
 | 
|          return 0;
 | 
|      if (tb.style() > BHIDDEN)
 | 
| -        borderWidth = max<int>(borderWidth, tb.width() / 2);
 | 
| +        borderWidth = std::max<int>(borderWidth, tb.width() / 2);
 | 
|      return borderWidth;
 | 
|  }
 | 
|  
 | 
| @@ -1131,7 +1129,7 @@ int RenderTable::outerBorderAfter() const
 | 
|      if (tb.style() == BHIDDEN)
 | 
|          return 0;
 | 
|      if (tb.style() > BHIDDEN)
 | 
| -        borderWidth = max<int>(borderWidth, (tb.width() + 1) / 2);
 | 
| +        borderWidth = std::max<int>(borderWidth, (tb.width() + 1) / 2);
 | 
|      return borderWidth;
 | 
|  }
 | 
|  
 | 
| @@ -1154,7 +1152,7 @@ int RenderTable::outerBorderStart() const
 | 
|          if (sw < 0)
 | 
|              continue;
 | 
|          allHidden = false;
 | 
| -        borderWidth = max(borderWidth, sw);
 | 
| +        borderWidth = std::max(borderWidth, sw);
 | 
|      }
 | 
|      if (allHidden)
 | 
|          return 0;
 | 
| @@ -1181,7 +1179,7 @@ int RenderTable::outerBorderEnd() const
 | 
|          if (sw < 0)
 | 
|              continue;
 | 
|          allHidden = false;
 | 
| -        borderWidth = max(borderWidth, sw);
 | 
| +        borderWidth = std::max(borderWidth, sw);
 | 
|      }
 | 
|      if (allHidden)
 | 
|          return 0;
 | 
| 
 |