Remove CSSFontSelector argument and member from CSSSegmentedFontFace

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 40 matching lines @@
     : public GarbageCollectedFinalized<LoadFontPromiseResolver>,
       public FontFace::LoadFontCallback {
   USING_GARBAGE_COLLECTED_MIXIN(LoadFontPromiseResolver);
 
  public:
   static LoadFontPromiseResolver* create(FontFaceArray faces,
                                          ScriptState* scriptState) {
     return new LoadFontPromiseResolver(faces, scriptState);
   }
 
-  void loadFonts();
+  void loadFonts(Document*);
   ScriptPromise promise() { return m_resolver->promise(); }
 
   void notifyLoaded(FontFace*) override;
   void notifyError(FontFace*) override;
 
   DECLARE_VIRTUAL_TRACE();
 
  private:
   LoadFontPromiseResolver(FontFaceArray faces, ScriptState* scriptState)
       : m_numLoading(faces.size()),
         m_errorOccured(false),
         m_resolver(ScriptPromiseResolver::create(scriptState)) {
     m_fontFaces.swap(faces);
   }
 
   HeapVector<Member<FontFace>> m_fontFaces;
   int m_numLoading;
   bool m_errorOccured;
   Member<ScriptPromiseResolver> m_resolver;
 };
 
-void LoadFontPromiseResolver::loadFonts() {
+void LoadFontPromiseResolver::loadFonts(Document* document) {
   if (!m_numLoading) {
     m_resolver->resolve(m_fontFaces);
     return;
   }
 
   for (size_t i = 0; i < m_fontFaces.size(); i++)
-    m_fontFaces[i]->loadWithCallback(this);
+    m_fontFaces[i]->loadWithCallback(document, this);
 }
 
 void LoadFontPromiseResolver::notifyLoaded(FontFace* fontFace) {
   m_numLoading--;
   if (m_numLoading || m_errorOccured)
     return;
 
   m_resolver->resolve(m_fontFaces);
 }
 
@@ skipping 31 matching lines @@
 }
 
 bool FontFaceSet::inActiveDocumentContext() const {
   ExecutionContext* context = getExecutionContext();
   return context && toDocument(context)->isActive();
 }
 
 void FontFaceSet::addFontFacesToFontFaceCache(CSSFontSelector* fontSelector) {
   FontFaceCache* fontFaceCache = document()->fontFaceCache();
   for (const auto& fontFace : m_nonCSSConnectedFaces)
-    fontFaceCache->addFontFace(fontSelector, fontFace, false);
+    fontFaceCache->addFontFace(fontFace, false);
 }
 
 const AtomicString& FontFaceSet::interfaceName() const {
   return EventTargetNames::FontFaceSet;
 }
 
 ExecutionContext* FontFaceSet::getExecutionContext() const {
   return SuspendableObject::getExecutionContext();
 }
 
@@ skipping 98 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);
+  document()->fontFaceCache()->addFontFace(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();
@@ skipping 113 matching lines @@
     CSSSegmentedFontFace* segmentedFontFace =
         fontFaceCache->get(font.getFontDescription(), f->family());
     if (segmentedFontFace)
       segmentedFontFace->match(text, faces);
   }
 
   LoadFontPromiseResolver* resolver =
       LoadFontPromiseResolver::create(faces, scriptState);
   ScriptPromise promise = resolver->promise();
   // After this, resolver->promise() may return null.
-  resolver->loadFonts();
+  resolver->loadFonts(document());
   return promise;
 }
 
 bool FontFaceSet::check(const String& fontString,
                         const String& text,
                         ExceptionState& exceptionState) {
   if (!inActiveDocumentContext())
     return false;
 
   Font font;
@@ skipping 151 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