Remove unused parameter from FontFace::loadWithCallback()

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(ExecutionContext*);
+  void loadFonts();
   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(ExecutionContext* context) {
+void LoadFontPromiseResolver::loadFonts() {
   if (!m_numLoading) {
     m_resolver->resolve(m_fontFaces);
     return;
   }
 
   for (size_t i = 0; i < m_fontFaces.size(); i++)
-    m_fontFaces[i]->loadWithCallback(this, context);
+    m_fontFaces[i]->loadWithCallback(this);
 }
 
 void LoadFontPromiseResolver::notifyLoaded(FontFace* fontFace) {
   m_numLoading--;
   if (m_numLoading || m_errorOccured)
     return;
 
   m_resolver->resolve(m_fontFaces);
 }
 
@@ skipping 288 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(getExecutionContext());
+  resolver->loadFonts();
   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