Using Enum in place of bool for better code readability

Source/core/css/resolver/FontBuilder.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * 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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 84 matching lines @@
 {
     ASSERT(m_document && m_document->settings());
     if (!m_document || !m_document->settings())
         return;
 
     FontDescriptionChangeScope scope(this);
 
     scope.reset();
     setFontFamilyToStandard(scope.fontDescription(), m_document);
     scope.fontDescription().setKeywordSize(CSSValueMedium - CSSValueXxSmall + 1);
-    setSize(scope.fontDescription(), effectiveZoom, FontSize::fontSizeForKeyword(m_document, CSSValueMedium, false));
+    setSize(scope.fontDescription(), effectiveZoom, FontSize::fontSizeForKeyword(m_document, CSSValueMedium, NonFixedPitchFont));
 }
 
 void FontBuilder::inheritFrom(const FontDescription& fontDescription)
 {
     FontDescriptionChangeScope scope(this);
 
     scope.set(fontDescription);
 }
 
 void FontBuilder::didChangeFontParameters(bool changed)
@@ skipping 43 matching lines @@
 {
     FontDescriptionChangeScope scope(this);
 
     if (!value->isValueList())
         return;
 
     FontFamily& firstFamily = scope.fontDescription().firstFamily();
     FontFamily* currFamily = 0;
 
     // Before mapping in a new font-family property, we should reset the generic family.
-    bool oldFamilyUsedFixedDefaultSize = scope.fontDescription().useFixedDefaultSize();
+    FixedPitchFontType oldFixedPitchFontType = scope.fontDescription().fixedPitchFontType();
     scope.fontDescription().setGenericFamily(FontDescription::NoFamily);
 
     for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
         CSSValue* item = i.value();
         if (!item->isPrimitiveValue())
             continue;
         CSSPrimitiveValue* contentValue = toCSSPrimitiveValue(item);
         AtomicString face;
         Settings* settings = m_document->settings();
         if (contentValue->isString()) {
@@ skipping 45 matching lines @@
                 currFamily = newFamily.get();
             }
         }
     }
 
     // We can't call useFixedDefaultSize() until all new font families have been added
     // If currFamily is non-zero then we set at least one family on this description.
     if (!currFamily)
         return;
 
-    if (scope.fontDescription().keywordSize() && scope.fontDescription().useFixedDefaultSize() != oldFamilyUsedFixedDefaultSize)
-        scope.fontDescription().setSpecifiedSize(FontSize::fontSizeForKeyword(m_document, CSSValueXxSmall + scope.fontDescription().keywordSize() - 1, !oldFamilyUsedFixedDefaultSize));
+    if (scope.fontDescription().keywordSize() && scope.fontDescription().fixedPitchFontType() != oldFixedPitchFontType) {
+        scope.fontDescription().setSpecifiedSize(FontSize::fontSizeForKeyword(m_document,
+        static_cast<CSSValueID>(CSSValueXxSmall + scope.fontDescription().keywordSize() - 1), scope.fontDescription().fixedPitchFontType()));
+    }
 }
 
 void FontBuilder::setFontSizeInitial()
 {
     FontDescriptionChangeScope scope(this);
 
-    float size = FontSize::fontSizeForKeyword(m_document, CSSValueMedium, scope.fontDescription().useFixedDefaultSize());
+    float size = FontSize::fontSizeForKeyword(m_document, CSSValueMedium, scope.fontDescription().fixedPitchFontType());
 
     if (size < 0)
         return;
 
     scope.fontDescription().setKeywordSize(CSSValueMedium - CSSValueXxSmall + 1);
     scope.fontDescription().setSpecifiedSize(size);
 }
 
 void FontBuilder::setFontSizeInherit(const FontDescription& parentFontDescription)
 {
@@ skipping 44 matching lines @@
     if (CSSValueID valueID = primitiveValue->getValueID()) {
         switch (valueID) {
         case CSSValueXxSmall:
         case CSSValueXSmall:
         case CSSValueSmall:
         case CSSValueMedium:
         case CSSValueLarge:
         case CSSValueXLarge:
         case CSSValueXxLarge:
         case CSSValueWebkitXxxLarge:
-            size = FontSize::fontSizeForKeyword(m_document, valueID, scope.fontDescription().useFixedDefaultSize());
+            size = FontSize::fontSizeForKeyword(m_document, valueID, scope.fontDescription().fixedPitchFontType());
             scope.fontDescription().setKeywordSize(valueID - CSSValueXxSmall + 1);
             break;
         case CSSValueLarger:
             size = largerFontSize(parentSize);
             break;
         case CSSValueSmaller:
             size = smallerFontSize(parentSize);
             break;
         default:
             return;
@@ skipping 272 matching lines @@
 }
 
 void FontBuilder::checkForGenericFamilyChange(RenderStyle* style, const RenderStyle* parentStyle)
 {
     FontDescriptionChangeScope scope(this);
 
     if (scope.fontDescription().isAbsoluteSize() || !parentStyle)
         return;
 
     const FontDescription& parentFontDescription = parentStyle->fontDescription();
-    if (scope.fontDescription().useFixedDefaultSize() == parentFontDescription.useFixedDefaultSize())
+    if (scope.fontDescription().fixedPitchFontType() == parentFontDescription.fixedPitchFontType())
         return;
 
     // For now, lump all families but monospace together.
     if (scope.fontDescription().genericFamily() != FontDescription::MonospaceFamily
         && parentFontDescription.genericFamily() != FontDescription::MonospaceFamily)
         return;
 
     // We know the parent is monospace or the child is monospace, and that font
     // size was unspecified. We want to scale our font size as appropriate.
     // If the font uses a keyword size, then we refetch from the table rather than
     // multiplying by our scale factor.
     float size;
     if (scope.fontDescription().keywordSize()) {
-        size = FontSize::fontSizeForKeyword(m_document, CSSValueXxSmall + scope.fontDescription().keywordSize() - 1, scope.fontDescription().useFixedDefaultSize());
+        size = FontSize::fontSizeForKeyword(m_document, static_cast<CSSValueID>(CSSValueXxSmall + scope.fontDescription().keywordSize() - 1), scope.fontDescription().fixedPitchFontType());
     } else {
         Settings* settings = m_document->settings();
         float fixedScaleFactor = (settings && settings->defaultFixedFontSize() && settings->defaultFontSize())
             ? static_cast<float>(settings->defaultFixedFontSize()) / settings->defaultFontSize()
             : 1;
-        size = parentFontDescription.useFixedDefaultSize() ?
+        size = parentFontDescription.fixedPitchFontType() == FixedPitchFont ?
             scope.fontDescription().specifiedSize() / fixedScaleFactor :
             scope.fontDescription().specifiedSize() * fixedScaleFactor;
     }
 
     setSize(scope.fontDescription(), style->effectiveZoom(), size);
 }
 
 void FontBuilder::updateComputedSize(RenderStyle* style, const RenderStyle* parentStyle)
 {
     FontDescriptionChangeScope scope(this);
@@ skipping 14 matching lines @@
     m_fontDirty = false;
 }
 
 void FontBuilder::createFontForDocument(PassRefPtrWillBeRawPtr<FontSelector> fontSelector, RenderStyle* documentStyle)
 {
     FontDescription fontDescription = FontDescription();
     fontDescription.setScript(localeToScriptCodeForFontSelection(documentStyle->locale()));
 
     setFontFamilyToStandard(fontDescription, m_document);
     fontDescription.setKeywordSize(CSSValueMedium - CSSValueXxSmall + 1);
-    int size = FontSize::fontSizeForKeyword(m_document, CSSValueMedium, false);
+    int size = FontSize::fontSizeForKeyword(m_document, CSSValueMedium, NonFixedPitchFont);
     fontDescription.setSpecifiedSize(size);
     fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(fontDescription, documentStyle->effectiveZoom(), size));
 
     FontOrientation fontOrientation;
     NonCJKGlyphOrientation glyphOrientation;
     getFontAndGlyphOrientation(documentStyle, fontOrientation, glyphOrientation);
     fontDescription.setOrientation(fontOrientation);
     fontDescription.setNonCJKGlyphOrientation(glyphOrientation);
     documentStyle->setFontDescription(fontDescription);
     documentStyle->font().update(fontSelector);
 }
 
 }