Revert of Move the FontFaceCache stored in CSSFontSelector to be stored in Document.

third_party/WebKit/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 118 matching lines @@
 
 Document* FontFaceSet::document() const {
   return toDocument(getExecutionContext());
 }
 
 bool FontFaceSet::inActiveDocumentContext() const {
   ExecutionContext* context = getExecutionContext();
   return context && toDocument(context)->isActive();
 }
 
-void FontFaceSet::addFontFacesToFontFaceCache(CSSFontSelector* fontSelector) {
-  FontFaceCache* fontFaceCache = document()->fontFaceCache();
+void FontFaceSet::addFontFacesToFontFaceCache(FontFaceCache* fontFaceCache,
+                                              CSSFontSelector* fontSelector) {
   for (const auto& fontFace : m_nonCSSConnectedFaces)
     fontFaceCache->addFontFace(fontSelector, fontFace, false);
 }
 
 const AtomicString& FontFaceSet::interfaceName() const {
   return EventTargetNames::FontFaceSet;
 }
 
 ExecutionContext* FontFaceSet::getExecutionContext() const {
   return SuspendableObject::getExecutionContext();
@@ skipping 100 matching lines @@
                                         ExceptionState&) {
   ASSERT(fontFace);
   if (!inActiveDocumentContext())
     return this;
   if (m_nonCSSConnectedFaces.contains(fontFace))
     return this;
   if (isCSSConnectedFontFace(fontFace))
     return this;
   CSSFontSelector* fontSelector = document()->styleEngine().fontSelector();
   m_nonCSSConnectedFaces.add(fontFace);
-  document()->fontFaceCache()->addFontFace(fontSelector, fontFace, false);
+  fontSelector->fontFaceCache()->addFontFace(fontSelector, fontFace, false);
   if (fontFace->loadStatus() == FontFace::Loading)
     addToLoadingFonts(fontFace);
   fontSelector->fontFaceInvalidated();
   return this;
 }
 
 void FontFaceSet::clearForBinding(ScriptState*, ExceptionState&) {
   if (!inActiveDocumentContext() || m_nonCSSConnectedFaces.isEmpty())
     return;
   CSSFontSelector* fontSelector = document()->styleEngine().fontSelector();
-  FontFaceCache* fontFaceCache = document()->fontFaceCache();
+  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::deleteForBinding(ScriptState*,
                                    FontFace* fontFace,
                                    ExceptionState&) {
   ASSERT(fontFace);
   if (!inActiveDocumentContext())
     return false;
   HeapListHashSet<Member<FontFace>>::iterator it =
       m_nonCSSConnectedFaces.find(fontFace);
   if (it != m_nonCSSConnectedFaces.end()) {
     m_nonCSSConnectedFaces.remove(it);
     CSSFontSelector* fontSelector = document()->styleEngine().fontSelector();
-    document()->fontFaceCache()->removeFontFace(fontFace, false);
+    fontSelector->fontFaceCache()->removeFontFace(fontFace, false);
     if (fontFace->loadStatus() == FontFace::Loading)
       removeFromLoadingFonts(fontFace);
     fontSelector->fontFaceInvalidated();
     return true;
   }
   return false;
 }
 
 bool FontFaceSet::hasForBinding(ScriptState*,
                                 FontFace* fontFace,
                                 ExceptionState&) const {
   ASSERT(fontFace);
   if (!inActiveDocumentContext())
     return false;
   return m_nonCSSConnectedFaces.contains(fontFace) ||
          isCSSConnectedFontFace(fontFace);
 }
 
 const HeapListHashSet<Member<FontFace>>& FontFaceSet::cssConnectedFontFaceList()
     const {
   Document* document = this->document();
   document->updateActiveStyle();
-  return document->fontFaceCache()->cssConnectedFontFaces();
+  return document->styleEngine()
+      .fontSelector()
+      ->fontFaceCache()
+      ->cssConnectedFontFaces();
 }
 
 bool FontFaceSet::isCSSConnectedFontFace(FontFace* fontFace) const {
   return cssConnectedFontFaceList().contains(fontFace);
 }
 
 size_t FontFaceSet::size() const {
   if (!inActiveDocumentContext())
     return m_nonCSSConnectedFaces.size();
   return cssConnectedFontFaceList().size() + m_nonCSSConnectedFaces.size();
@@ skipping 44 matching lines @@
   Font font;
   if (!resolveFontStyle(fontString, font)) {
     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()->fontFaceCache();
+  FontFaceCache* fontFaceCache =
+      document()->styleEngine().fontSelector()->fontFaceCache();
   FontFaceArray faces;
   for (const FontFamily* f = &font.getFontDescription().family(); f;
        f = f->next()) {
     CSSSegmentedFontFace* segmentedFontFace =
         fontFaceCache->get(font.getFontDescription(), f->family());
     if (segmentedFontFace)
       segmentedFontFace->match(text, faces);
   }
 
   LoadFontPromiseResolver* resolver =
@@ skipping 11 matching lines @@
     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();
-  FontFaceCache* fontFaceCache = document()->fontFaceCache();
+  FontFaceCache* fontFaceCache = fontSelector->fontFaceCache();
 
   bool hasLoadedFaces = false;
   for (const FontFamily* f = &font.getFontDescription().family(); f;
        f = f->next()) {
     CSSSegmentedFontFace* face =
         fontFaceCache->get(font.getFontDescription(), f->family());
     if (face) {
       if (!face->checkFont(text))
         return false;
       hasLoadedFaces = true;
@@ skipping 133 matching lines @@
   visitor->trace(m_failedFonts);
   visitor->trace(m_nonCSSConnectedFaces);
   visitor->trace(m_asyncRunner);
   EventTargetWithInlineData::trace(visitor);
   Supplement<Document>::trace(visitor);
   SuspendableObject::trace(visitor);
   FontFace::LoadFontCallback::trace(visitor);
 }
 
 }  // namespace blink