Return reference from styleEngine() accessor.

Source/core/css/FontFaceSet.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:
  *
  * 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 275 matching lines @@
     if (!fontFace) {
         exceptionState.throwTypeError("The argument is not a FontFace.");
         return;
     }
     if (m_nonCSSConnectedFaces.contains(fontFace))
         return;
     if (isCSSConnectedFontFace(fontFace)) {
         exceptionState.throwDOMException(InvalidModificationError, "Cannot add a CSS-connected FontFace.");
         return;
     }
-    CSSFontSelector* fontSelector = document()->styleEngine()->fontSelector();
+    CSSFontSelector* fontSelector = document()->styleEngine().fontSelector();
     m_nonCSSConnectedFaces.add(fontFace);
     fontSelector->fontFaceCache()->addFontFace(fontSelector, fontFace, false);
     if (fontFace->loadStatus() == FontFace::Loading)
         addToLoadingFonts(fontFace);
     fontSelector->fontFaceInvalidated();
 }
 
 void FontFaceSet::clear()
 {
     if (!inActiveDocumentContext() || m_nonCSSConnectedFaces.isEmpty())
         return;
-    CSSFontSelector* fontSelector = document()->styleEngine()->fontSelector();
+    CSSFontSelector* fontSelector = document()->styleEngine().fontSelector();
     FontFaceCache* fontFaceCache = fontSelector->fontFaceCache();
     for (const auto& fontFace : m_nonCSSConnectedFaces) {
         fontFaceCache->removeFontFace(fontFace.get(), false);
         if (fontFace->loadStatus() == FontFace::Loading)
             removeFromLoadingFonts(fontFace);
     }
     m_nonCSSConnectedFaces.clear();
     fontSelector->fontFaceInvalidated();
 }
 
 bool FontFaceSet::remove(FontFace* fontFace, ExceptionState& exceptionState)
 {
     if (!inActiveDocumentContext())
         return false;
     if (!fontFace) {
         exceptionState.throwTypeError("The argument is not a FontFace.");
         return false;
     }
     WillBeHeapListHashSet<RefPtrWillBeMember<FontFace> >::iterator it = m_nonCSSConnectedFaces.find(fontFace);
     if (it != m_nonCSSConnectedFaces.end()) {
         m_nonCSSConnectedFaces.remove(it);
-        CSSFontSelector* fontSelector = document()->styleEngine()->fontSelector();
+        CSSFontSelector* fontSelector = document()->styleEngine().fontSelector();
         fontSelector->fontFaceCache()->removeFontFace(fontFace, false);
         if (fontFace->loadStatus() == FontFace::Loading)
             removeFromLoadingFonts(fontFace);
         fontSelector->fontFaceInvalidated();
         return true;
     }
     if (isCSSConnectedFontFace(fontFace))
         exceptionState.throwDOMException(InvalidModificationError, "Cannot delete a CSS-connected FontFace.");
     return false;
 }
 
 bool FontFaceSet::has(FontFace* fontFace, ExceptionState& exceptionState) const
 {
     if (!inActiveDocumentContext())
         return false;
     if (!fontFace) {
         exceptionState.throwTypeError("The argument is not a FontFace.");
         return false;
     }
     return m_nonCSSConnectedFaces.contains(fontFace) || isCSSConnectedFontFace(fontFace);
 }
 
 const WillBeHeapListHashSet<RefPtrWillBeMember<FontFace> >& FontFaceSet::cssConnectedFontFaceList() const
 {
     Document* d = document();
     d->ensureStyleResolver(); // Flush pending style changes.
-    return d->styleEngine()->fontSelector()->fontFaceCache()->cssConnectedFontFaces();
+    return d->styleEngine().fontSelector()->fontFaceCache()->cssConnectedFontFaces();
 }
 
 bool FontFaceSet::isCSSConnectedFontFace(FontFace* fontFace) const
 {
     return cssConnectedFontFaceList().contains(fontFace);
 }
 
 void FontFaceSet::forEach(FontFaceSetForEachCallback* callback, const ScriptValue& thisArg) const
 {
     forEachInternal(callback, &thisArg);
@@ skipping 74 matching lines @@
         return ScriptPromise();
 
     Font font;
     if (!resolveFontStyle(fontString, font)) {
         RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
         ScriptPromise promise = resolver->promise();
         resolver->reject(DOMException::create(SyntaxError, "Could not resolve '" + fontString + "' as a font."));
         return promise;
     }
 
-    FontFaceCache* fontFaceCache = document()->styleEngine()->fontSelector()->fontFaceCache();
+    FontFaceCache* fontFaceCache = document()->styleEngine().fontSelector()->fontFaceCache();
     FontFaceArray faces;
     for (const FontFamily* f = &font.fontDescription().family(); f; f = f->next()) {
         CSSSegmentedFontFace* segmentedFontFace = fontFaceCache->get(font.fontDescription(), f->family());
         if (segmentedFontFace)
             segmentedFontFace->match(text, faces);
     }
 
     RefPtrWillBeRawPtr<LoadFontPromiseResolver> resolver = LoadFontPromiseResolver::create(faces, scriptState);
     ScriptPromise promise = resolver->promise();
     resolver->loadFonts(executionContext()); // After this, resolver->promise() may return null.
     return promise;
 }
 
 bool FontFaceSet::check(const String& fontString, const String& text, ExceptionState& exceptionState)
 {
     if (!inActiveDocumentContext())
         return false;
 
     Font font;
     if (!resolveFontStyle(fontString, font)) {
         exceptionState.throwDOMException(SyntaxError, "Could not resolve '" + fontString + "' as a font.");
         return false;
     }
 
-    CSSFontSelector* fontSelector = document()->styleEngine()->fontSelector();
+    CSSFontSelector* fontSelector = document()->styleEngine().fontSelector();
     FontFaceCache* fontFaceCache = fontSelector->fontFaceCache();
 
     bool hasLoadedFaces = false;
     for (const FontFamily* f = &font.fontDescription().family(); f; f = f->next()) {
         CSSSegmentedFontFace* face = fontFaceCache->get(font.fontDescription(), f->family());
         if (face) {
             if (!face->checkFont(text))
                 return false;
             hasLoadedFaces = true;
         }
@@ skipping 43 matching lines @@
         CSSPropertyValue(CSSPropertyFontStyle, *parsedStyle),
         CSSPropertyValue(CSSPropertyFontVariant, *parsedStyle),
         CSSPropertyValue(CSSPropertyFontWeight, *parsedStyle),
         CSSPropertyValue(CSSPropertyFontSize, *parsedStyle),
         CSSPropertyValue(CSSPropertyLineHeight, *parsedStyle),
     };
     StyleResolver& styleResolver = document()->ensureStyleResolver();
     styleResolver.applyPropertiesToStyle(properties, WTF_ARRAY_LENGTH(properties), style.get());
 
     font = style->font();
-    font.update(document()->styleEngine()->fontSelector());
+    font.update(document()->styleEngine().fontSelector());
     return true;
 }
 
 void FontFaceSet::FontLoadHistogram::updateStatus(FontFace* fontFace)
 {
     if (m_status == Reported)
         return;
     if (fontFace->hadBlankText())
         m_status = HadBlankText;
     else if (m_status == NoWebFonts)
@@ skipping 42 matching lines @@
     visitor->trace(m_loadedFonts);
     visitor->trace(m_failedFonts);
     visitor->trace(m_nonCSSConnectedFaces);
     DocumentSupplement::trace(visitor);
 #endif
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink