Rename enums/functions that collide in chromium style in platform/

third_party/WebKit/Source/platform/Length.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller ( mueller@kde.org )
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 84 matching lines @@
     , m_type(Calculated)
     , m_isFloat(false)
 {
     m_intValue = calcHandles().insert(calc);
 }
 
 Length Length::blendMixedTypes(const Length& from, double progress, ValueRange range) const
 {
     ASSERT(from.isSpecified());
     ASSERT(isSpecified());
-    PixelsAndPercent fromPixelsAndPercent = from.pixelsAndPercent();
-    PixelsAndPercent toPixelsAndPercent = pixelsAndPercent();
+    PixelsAndPercent fromPixelsAndPercent = from.getPixelsAndPercent();
+    PixelsAndPercent toPixelsAndPercent = getPixelsAndPercent();
     const float pixels = blink::blend(fromPixelsAndPercent.pixels, toPixelsAndPercent.pixels, progress);
     const float percent = blink::blend(fromPixelsAndPercent.percent, toPixelsAndPercent.percent, progress);
     return Length(CalculationValue::create(PixelsAndPercent(pixels, percent), range));
 }
 
-PixelsAndPercent Length::pixelsAndPercent() const
+PixelsAndPercent Length::getPixelsAndPercent() const
 {
     switch (type()) {
     case Fixed:
         return PixelsAndPercent(value(), 0);
     case Percent:
         return PixelsAndPercent(0, value());
     case Calculated:
-        return calculationValue().pixelsAndPercent();
+        return getCalculationValue().getPixelsAndPercent();
     default:
         ASSERT_NOT_REACHED();
         return PixelsAndPercent(0, 0);
     }
 }
 
 Length Length::subtractFromOneHundredPercent() const
 {
-    PixelsAndPercent result = pixelsAndPercent();
+    PixelsAndPercent result = getPixelsAndPercent();
     result.pixels = -result.pixels;
     result.percent = 100 - result.percent;
     if (result.pixels && result.percent)
         return Length(CalculationValue::create(result, ValueRangeAll));
     if (result.percent)
         return Length(result.percent, Percent);
     return Length(result.pixels, Fixed);
 }
 
 Length Length::zoom(double factor) const
 {
     switch (type()) {
     case Fixed:
         return Length(getFloatValue() * factor, Fixed);
     case Calculated: {
-        PixelsAndPercent result = pixelsAndPercent();
+        PixelsAndPercent result = getPixelsAndPercent();
         result.pixels *= factor;
-        return Length(CalculationValue::create(result, calculationValue().valueRange()));
+        return Length(CalculationValue::create(result, getCalculationValue().getValueRange()));
     }
     default:
         return *this;
     }
 }
 
-CalculationValue& Length::calculationValue() const
+CalculationValue& Length::getCalculationValue() const
 {
     ASSERT(isCalculated());
     return calcHandles().get(calculationHandle());
 }
 
 void Length::incrementCalculatedRef() const
 {
     ASSERT(isCalculated());
-    calculationValue().ref();
+    getCalculationValue().ref();
 }
 
 void Length::decrementCalculatedRef() const
 {
     ASSERT(isCalculated());
     calcHandles().decrementRef(calculationHandle());
 }
 
 float Length::nonNanCalculatedValue(LayoutUnit maxValue) const
 {
     ASSERT(isCalculated());
-    float result = calculationValue().evaluate(maxValue.toFloat());
+    float result = getCalculationValue().evaluate(maxValue.toFloat());
     if (std::isnan(result))
         return 0;
     return result;
 }
 
 bool Length::isCalculatedEqual(const Length& o) const
 {
-    return isCalculated() && (&calculationValue() == &o.calculationValue() || calculationValue() == o.calculationValue());
+    return isCalculated() && (&getCalculationValue() == &o.getCalculationValue() || getCalculationValue() == o.getCalculationValue());
 }
 
 struct SameSizeAsLength {
     int32_t value;
     int32_t metaData;
 };
 static_assert(sizeof(Length) == sizeof(SameSizeAsLength), "length should stay small");
 
 } // namespace blink