Changed CSSParser::parseFontFaceDescriptor to return a const CSSValue*

third_party/WebKit/Source/core/css/FontFace.cpp

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 45 matching lines @@
 #include "core/dom/StyleEngine.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "platform/FontFamilyNames.h"
 #include "platform/Histogram.h"
 #include "platform/SharedBuffer.h"
 
 namespace blink {
 
-static CSSValue* parseCSSValue(const Document* document, const String& value, CSSPropertyID propertyID)
+static const CSSValue* parseCSSValue(const Document* document, const String& value, CSSPropertyID propertyID)
 {
     CSSParserContext context(*document, UseCounter::getFrom(document));
     return CSSParser::parseFontFaceDescriptor(propertyID, value, context);
 }
 
 FontFace* FontFace::create(ExecutionContext* context, const AtomicString& family, StringOrArrayBufferOrArrayBufferView& source, const FontFaceDescriptors& descriptors)
 {
     if (source.isString())
         return create(context, family, source.getAsString(), descriptors);
     if (source.isArrayBuffer())
         return create(context, family, source.getAsArrayBuffer(), descriptors);
     if (source.isArrayBufferView())
         return create(context, family, source.getAsArrayBufferView(), descriptors);
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 FontFace* FontFace::create(ExecutionContext* context, const AtomicString& family, const String& source, const FontFaceDescriptors& descriptors)
 {
     FontFace* fontFace = new FontFace(context, family, descriptors);
 
-    CSSValue* src = parseCSSValue(toDocument(context), source, CSSPropertySrc);
+    const CSSValue* src = parseCSSValue(toDocument(context), source, CSSPropertySrc);
     if (!src || !src->isValueList())
         fontFace->setError(DOMException::create(SyntaxError, "The source provided ('" + source + "') could not be parsed as a value list."));
 
     fontFace->initCSSFontFace(toDocument(context), src);
     return fontFace;
 }
 
 FontFace* FontFace::create(ExecutionContext* context, const AtomicString& family, DOMArrayBuffer* source, const FontFaceDescriptors& descriptors)
 {
     FontFace* fontFace = new FontFace(context, family, descriptors);
@@ skipping 122 matching lines @@
     setPropertyFromString(toDocument(context), s, CSSPropertyFontVariant, &exceptionState);
 }
 
 void FontFace::setFeatureSettings(ExecutionContext* context, const String& s, ExceptionState& exceptionState)
 {
     setPropertyFromString(toDocument(context), s, CSSPropertyFontFeatureSettings, &exceptionState);
 }
 
 void FontFace::setPropertyFromString(const Document* document, const String& s, CSSPropertyID propertyID, ExceptionState* exceptionState)
 {
-    CSSValue* value = parseCSSValue(document, s, propertyID);
+    const CSSValue* value = parseCSSValue(document, s, propertyID);
     if (value && setPropertyValue(value, propertyID))
         return;
 
     String message = "Failed to set '" + s + "' as a property value.";
     if (exceptionState)
         exceptionState->throwDOMException(SyntaxError, message);
     else
         setError(DOMException::create(SyntaxError, message));
 }
 
 bool FontFace::setPropertyFromStyle(const StylePropertySet& properties, CSSPropertyID propertyID)
 {
     return setPropertyValue(properties.getPropertyCSSValue(propertyID), propertyID);
 }
 
-bool FontFace::setPropertyValue(CSSValue* value, CSSPropertyID propertyID)
+bool FontFace::setPropertyValue(const CSSValue* value, CSSPropertyID propertyID)
 {
     switch (propertyID) {
     case CSSPropertyFontStyle:
         m_style = value;
         break;
     case CSSPropertyFontWeight:
         m_weight = value;
         break;
     case CSSPropertyFontStretch:
         m_stretch = value;
@@ skipping 245 matching lines @@
     return FontTraits(style, weight, stretch);
 }
 
 size_t FontFace::approximateBlankCharacterCount() const
 {
     if (m_status == Loading)
         return m_cssFontFace->approximateBlankCharacterCount();
     return 0;
 }
 
-static FontDisplay CSSValueToFontDisplay(CSSValue* value)
+static FontDisplay CSSValueToFontDisplay(const CSSValue* value)
 {
     if (value && value->isPrimitiveValue()) {
         switch (toCSSPrimitiveValue(value)->getValueID()) {
         case CSSValueAuto:
             return FontDisplayAuto;
         case CSSValueBlock:
             return FontDisplayBlock;
         case CSSValueSwap:
             return FontDisplaySwap;
         case CSSValueFallback:
             return FontDisplayFallback;
         case CSSValueOptional:
             return FontDisplayOptional;
         default:
             break;
         }
     }
     return FontDisplayAuto;
 }
 
-static CSSFontFace* createCSSFontFace(FontFace* fontFace, CSSValue* unicodeRange)
+static CSSFontFace* createCSSFontFace(FontFace* fontFace, const CSSValue* unicodeRange)
 {
     Vector<UnicodeRange> ranges;
-    if (CSSValueList* rangeList = toCSSValueList(unicodeRange)) {
+    if (const CSSValueList* rangeList = toCSSValueList(unicodeRange)) {
         unsigned numRanges = rangeList->length();
         for (unsigned i = 0; i < numRanges; i++) {
             const CSSUnicodeRangeValue& range = toCSSUnicodeRangeValue(rangeList->item(i));
             ranges.append(UnicodeRange(range.from(), range.to()));
         }
     }
 
     return new CSSFontFace(fontFace, ranges);
 }
 
-void FontFace::initCSSFontFace(Document* document, CSSValue* src)
+void FontFace::initCSSFontFace(Document* document, const CSSValue* src)
 {
     m_cssFontFace = createCSSFontFace(this, m_unicodeRange.get());
     if (m_error)
         return;
 
     // Each item in the src property's list is a single CSSFontFaceSource. Put them all into a CSSFontFace.
     ASSERT(src);
     ASSERT(src->isValueList());
-    CSSValueList* srcList = toCSSValueList(src);
+    const CSSValueList* srcList = toCSSValueList(src);
     int srcLength = srcList->length();
 
     for (int i = 0; i < srcLength; i++) {
         // An item in the list either specifies a string (local font name) or a URL (remote font to download).
         const CSSFontFaceSrcValue& item = toCSSFontFaceSrcValue(srcList->item(i));
         CSSFontFaceSource* source = nullptr;
 
         if (!item.isLocal()) {
             const Settings* settings = document ? document->settings() : nullptr;
             bool allowDownloading = settings && settings->downloadableBinaryFontsEnabled();
@@ skipping 53 matching lines @@
 {
     return m_cssFontFace->hadBlankText();
 }
 
 bool FontFace::hasPendingActivity() const
 {
     return m_status == Loading && getExecutionContext() && !getExecutionContext()->activeDOMObjectsAreStopped();
 }
 
 } // namespace blink