Move FontFaceSet.{check,load}'s argument default into IDL file

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 413 matching lines @@
     }
 
     if (!m_readyResolvers.isEmpty()) {
         Vector<OwnPtr<FontsReadyPromiseResolver> > resolvers;
         m_readyResolvers.swap(resolvers);
         for (size_t index = 0; index < resolvers.size(); ++index)
             resolvers[index]->resolve(this);
     }
 }
 
-static const String& nullToSpace(const String& s)
-{
-    DEFINE_STATIC_LOCAL(String, space, (" "));
-    return s.isNull() ? space : s;
-}
-
 ScriptPromise FontFaceSet::load(ScriptState* scriptState, const String& fontString, const String& text)
 {
     if (!inActiveDocumentContext())
         return ScriptPromise();
 
     Font font;
     if (!resolveFontStyle(fontString, font)) {
         RefPtr<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();
     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(nullToSpace(text), faces);
+            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();
     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(nullToSpace(text)))
+            if (!face->checkFont(text))
                 return false;
             hasLoadedFaces = true;
         }
     }
     if (hasLoadedFaces)
         return true;
     for (const FontFamily* f = &font.fontDescription().family(); f; f = f->next()) {
         if (fontSelector->isPlatformFontAvailable(font.fontDescription(), f->family()))
             return true;
     }
@@ skipping 97 matching lines @@
     visitor->trace(m_loadingFonts);
     visitor->trace(m_loadedFonts);
     visitor->trace(m_failedFonts);
     visitor->trace(m_nonCSSConnectedFaces);
     DocumentSupplement::trace(visitor);
     EventTargetWithInlineData::trace(visitor);
 }
 #endif
 
 } // namespace blink