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

third_party/WebKit/Source/core/html/shadow/DateTimeEditElement.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 73 matching lines @@
 DateTimeEditBuilder::DateTimeEditBuilder(DateTimeEditElement& element, const DateTimeEditElement::LayoutParameters& layoutParameters, const DateComponents& dateValue)
     : m_editElement(&element)
     , m_dateValue(dateValue)
     , m_parameters(layoutParameters)
     , m_dayRange(1, 31)
     , m_hour23Range(0, 23)
     , m_minuteRange(0, 59)
     , m_secondRange(0, 59)
     , m_millisecondRange(0, 999)
 {
-    if (m_dateValue.type() == DateComponents::Date || m_dateValue.type() == DateComponents::DateTimeLocal) {
-        if (m_parameters.minimum.type() != DateComponents::Invalid
-            && m_parameters.maximum.type() != DateComponents::Invalid
+    if (m_dateValue.getType() == DateComponents::Date || m_dateValue.getType() == DateComponents::DateTimeLocal) {
+        if (m_parameters.minimum.getType() != DateComponents::Invalid
+            && m_parameters.maximum.getType() != DateComponents::Invalid
             && m_parameters.minimum.fullYear() == m_parameters.maximum.fullYear()
             && m_parameters.minimum.month() == m_parameters.maximum.month()
             && m_parameters.minimum.monthDay() <= m_parameters.maximum.monthDay()) {
             m_dayRange.minimum = m_parameters.minimum.monthDay();
             m_dayRange.maximum = m_parameters.maximum.monthDay();
         }
     }
 
-    if (m_dateValue.type() == DateComponents::Time || m_dayRange.isSingleton()) {
-        if (m_parameters.minimum.type() != DateComponents::Invalid
-            && m_parameters.maximum.type() != DateComponents::Invalid
+    if (m_dateValue.getType() == DateComponents::Time || m_dayRange.isSingleton()) {
+        if (m_parameters.minimum.getType() != DateComponents::Invalid
+            && m_parameters.maximum.getType() != DateComponents::Invalid
             && m_parameters.minimum.hour() <= m_parameters.maximum.hour()) {
             m_hour23Range.minimum = m_parameters.minimum.hour();
             m_hour23Range.maximum = m_parameters.maximum.hour();
         }
     }
 
     if (m_hour23Range.isSingleton() && m_parameters.minimum.minute() <= m_parameters.maximum.minute()) {
         m_minuteRange.minimum = m_parameters.minimum.minute();
         m_minuteRange.maximum = m_parameters.maximum.minute();
     }
@@ skipping 89 matching lines @@
         if (shouldMinuteFieldDisabled()) {
             field->setValueAsDate(m_dateValue);
             field->setDisabled();
         }
         return;
     }
 
     case DateTimeFormat::FieldTypeMonth: // Fallthrough.
     case DateTimeFormat::FieldTypeMonthStandAlone: {
         int minMonth = 0, maxMonth = 11;
-        if (m_parameters.minimum.type() != DateComponents::Invalid
-            && m_parameters.maximum.type() != DateComponents::Invalid
+        if (m_parameters.minimum.getType() != DateComponents::Invalid
+            && m_parameters.maximum.getType() != DateComponents::Invalid
             && m_parameters.minimum.fullYear() == m_parameters.maximum.fullYear()
             && m_parameters.minimum.month() <= m_parameters.maximum.month()) {
             minMonth = m_parameters.minimum.month();
             maxMonth = m_parameters.maximum.month();
         }
         RefPtrWillBeRawPtr<DateTimeFieldElement> field;
         switch (count) {
         case countForNarrowMonth: // Fallthrough.
         case countForAbbreviatedMonth:
             field = DateTimeSymbolicMonthFieldElement::create(document, editElement(), fieldType == DateTimeFormat::FieldTypeMonth ? m_parameters.locale.shortMonthLabels() : m_parameters.locale.shortStandAloneMonthLabels(), minMonth, maxMonth);
             break;
         case countForFullMonth:
             field = DateTimeSymbolicMonthFieldElement::create(document, editElement(), fieldType == DateTimeFormat::FieldTypeMonth ? m_parameters.locale.monthLabels() : m_parameters.locale.standAloneMonthLabels(), minMonth, maxMonth);
             break;
         default:
             field = DateTimeMonthFieldElement::create(document, editElement(), m_parameters.placeholderForMonth, DateTimeNumericFieldElement::Range(minMonth + 1, maxMonth + 1));
             break;
         }
         editElement().addField(field);
-        if (minMonth == maxMonth && minMonth == m_dateValue.month() && m_dateValue.type() != DateComponents::Month) {
+        if (minMonth == maxMonth && minMonth == m_dateValue.month() && m_dateValue.getType() != DateComponents::Month) {
             field->setValueAsDate(m_dateValue);
             field->setDisabled();
         }
         return;
     }
 
     case DateTimeFormat::FieldTypePeriod: {
         RefPtrWillBeRawPtr<DateTimeFieldElement> field = DateTimeAMPMFieldElement::create(document, editElement(), m_parameters.locale.timeAMPMLabels());
         editElement().addField(field);
         if (shouldAMPMFieldDisabled()) {
@@ skipping 25 matching lines @@
         editElement().addField(field);
         if (shouldMillisecondFieldDisabled()) {
             field->setValueAsDate(m_dateValue);
             field->setDisabled();
         }
         return;
     }
 
     case DateTimeFormat::FieldTypeWeekOfYear: {
         DateTimeNumericFieldElement::Range range(DateComponents::minimumWeekNumber, DateComponents::maximumWeekNumber);
-        if (m_parameters.minimum.type() != DateComponents::Invalid
-            && m_parameters.maximum.type() != DateComponents::Invalid
+        if (m_parameters.minimum.getType() != DateComponents::Invalid
+            && m_parameters.maximum.getType() != DateComponents::Invalid
             && m_parameters.minimum.fullYear() == m_parameters.maximum.fullYear()
             && m_parameters.minimum.week() <= m_parameters.maximum.week()) {
             range.minimum = m_parameters.minimum.week();
             range.maximum = m_parameters.maximum.week();
         }
         editElement().addField(DateTimeWeekFieldElement::create(document, editElement(), range));
         return;
     }
 
     case DateTimeFormat::FieldTypeYear: {
         DateTimeYearFieldElement::Parameters yearParams;
-        if (m_parameters.minimum.type() == DateComponents::Invalid) {
+        if (m_parameters.minimum.getType() == DateComponents::Invalid) {
             yearParams.minimumYear = DateComponents::minimumYear();
             yearParams.minIsSpecified = false;
         } else {
             yearParams.minimumYear = m_parameters.minimum.fullYear();
             yearParams.minIsSpecified = true;
         }
-        if (m_parameters.maximum.type() == DateComponents::Invalid) {
+        if (m_parameters.maximum.getType() == DateComponents::Invalid) {
             yearParams.maximumYear = DateComponents::maximumYear();
             yearParams.maxIsSpecified = false;
         } else {
             yearParams.maximumYear = m_parameters.maximum.fullYear();
             yearParams.maxIsSpecified = true;
         }
         if (yearParams.minimumYear > yearParams.maximumYear) {
             std::swap(yearParams.minimumYear, yearParams.maximumYear);
             std::swap(yearParams.minIsSpecified, yearParams.maxIsSpecified);
         }
@@ skipping 14 matching lines @@
 
 bool DateTimeEditBuilder::shouldAMPMFieldDisabled() const
 {
     return shouldHourFieldDisabled()
         || (m_hour23Range.minimum < 12 && m_hour23Range.maximum < 12 && m_dateValue.hour() < 12)
         || (m_hour23Range.minimum >= 12 && m_hour23Range.maximum >= 12 && m_dateValue.hour() >= 12);
 }
 
 bool DateTimeEditBuilder::shouldDayOfMonthFieldDisabled() const
 {
-    return m_dayRange.isSingleton() && m_dayRange.minimum == m_dateValue.monthDay() && m_dateValue.type() != DateComponents::Date;
+    return m_dayRange.isSingleton() && m_dayRange.minimum == m_dateValue.monthDay() && m_dateValue.getType() != DateComponents::Date;
 }
 
 bool DateTimeEditBuilder::shouldHourFieldDisabled() const
 {
     if (m_hour23Range.isSingleton() && m_hour23Range.minimum == m_dateValue.hour()
         && !(shouldMinuteFieldDisabled() && shouldSecondFieldDisabled() && shouldMillisecondFieldDisabled()))
         return true;
 
-    if (m_dateValue.type() == DateComponents::Time)
+    if (m_dateValue.getType() == DateComponents::Time)
         return false;
-    ASSERT(m_dateValue.type() == DateComponents::DateTimeLocal);
+    ASSERT(m_dateValue.getType() == DateComponents::DateTimeLocal);
 
     if (shouldDayOfMonthFieldDisabled()) {
         ASSERT(m_parameters.minimum.fullYear() == m_parameters.maximum.fullYear());
         ASSERT(m_parameters.minimum.month() == m_parameters.maximum.month());
         return false;
     }
 
     const Decimal decimalMsPerDay(static_cast<int>(msPerDay));
     Decimal hourPartOfMinimum = (stepRange().stepBase().abs().remainder(decimalMsPerDay) / static_cast<int>(msPerHour)).floor();
     return hourPartOfMinimum == m_dateValue.hour() && stepRange().step().remainder(decimalMsPerDay).isZero();
@@ skipping 23 matching lines @@
     if (m_secondRange.isSingleton() && m_secondRange.minimum == m_dateValue.second())
         return true;
 
     const Decimal decimalMsPerMinute(static_cast<int>(msPerMinute));
     Decimal secondPartOfMinimum = (stepRange().stepBase().abs().remainder(decimalMsPerMinute) / static_cast<int>(msPerSecond)).floor();
     return secondPartOfMinimum == m_dateValue.second() && stepRange().step().remainder(decimalMsPerMinute).isZero();
 }
 
 bool DateTimeEditBuilder::shouldYearFieldDisabled() const
 {
-    return m_parameters.minimum.type() != DateComponents::Invalid
-        && m_parameters.maximum.type() != DateComponents::Invalid
+    return m_parameters.minimum.getType() != DateComponents::Invalid
+        && m_parameters.maximum.getType() != DateComponents::Invalid
         && m_parameters.minimum.fullYear() == m_parameters.maximum.fullYear()
         && m_parameters.minimum.fullYear() == m_dateValue.fullYear();
 }
 
 void DateTimeEditBuilder::visitLiteral(const String& text)
 {
     DEFINE_STATIC_LOCAL(AtomicString, textPseudoId, ("-webkit-datetime-edit-text", AtomicString::ConstructFromLiteral));
     ASSERT(text.length());
     RefPtrWillBeRawPtr<HTMLDivElement> element = HTMLDivElement::create(editElement().document());
     element->setShadowPseudoId(textPseudoId);
@@ skipping 357 matching lines @@
         m_fields[fieldIndex]->setEmptyValue(DateTimeFieldElement::DispatchNoEvent);
 }
 
 bool DateTimeEditElement::hasFocusedField()
 {
     return focusedFieldIndex() != invalidFieldIndex;
 }
 
 void DateTimeEditElement::setOnlyYearMonthDay(const DateComponents& date)
 {
-    ASSERT(date.type() == DateComponents::Date);
+    ASSERT(date.getType() == DateComponents::Date);
 
     if (!m_editControlOwner)
         return;
 
     DateTimeFieldsState dateTimeFieldsState = valueAsDateTimeFieldsState();
     dateTimeFieldsState.setYear(date.fullYear());
     dateTimeFieldsState.setMonth(date.month() + 1);
     dateTimeFieldsState.setDayOfMonth(date.monthDay());
     setValueAsDateTimeFieldsState(dateTimeFieldsState);
     m_editControlOwner->editControlValueChanged();
@@ skipping 30 matching lines @@
 {
     DateTimeFieldsState dateTimeFieldsState;
     for (size_t fieldIndex = 0; fieldIndex < m_fields.size(); ++fieldIndex)
         m_fields[fieldIndex]->populateDateTimeFieldsState(dateTimeFieldsState);
     return dateTimeFieldsState;
 }
 
 } // namespace blink
 
 #endif