Adds FontFaceSetForWorkers

Bug: 722511
Change-Id: I4a8f5eb5c5a4bae215690979f737bbdfb446a449
Reviewed-on: https://chromium-review.googlesource.com/726341Reviewed-by: Justin Novosad <junov@chromium.org>
Reviewed-by: Kunihiko Sakamoto <ksakamoto@chromium.org>
Commit-Queue: Fernando Serboncini <fserb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#512873}

third_party/WebKit/Source/core/css/BUILD.gn

@@ -198,6 +198,8 @@ blink_core_sources("css") {
     "FontFaceSetDocument.h",
     "FontFaceSetLoadEvent.cpp",
     "FontFaceSetLoadEvent.h",
+    "FontFaceSetWorker.cpp",
+    "FontFaceSetWorker.h",
     "FontFaceSource.cpp",
     "FontFaceSource.h",
     "FontSize.cpp",

third_party/WebKit/Source/core/css/CSSFontFace.cpp

@@ -30,8 +30,10 @@
 #include "core/css/CSSFontSelector.h"
 #include "core/css/CSSSegmentedFontFace.h"
 #include "core/css/FontFaceSetDocument.h"
+#include "core/css/FontFaceSetWorker.h"
 #include "core/css/RemoteFontFaceSource.h"
 #include "core/frame/UseCounter.h"
+#include "core/workers/WorkerGlobalScope.h"
 #include "platform/fonts/FontDescription.h"
 #include "platform/fonts/SimpleFontData.h"
 
@@ -185,12 +187,20 @@ void CSSFontFace::SetLoadStatus(FontFace::LoadStatusType new_status) {
   else
     font_face_->SetLoadStatus(new_status);
 
-  if (!segmented_font_face_ || !font_face_->GetExecutionContext() ||
-      !font_face_->GetExecutionContext()->IsDocument())
+  if (!segmented_font_face_ || !font_face_->GetExecutionContext())
     return;
-  Document* document = ToDocument(font_face_->GetExecutionContext());
-  if (document && new_status == FontFace::kLoading)
-    FontFaceSetDocument::From(*document)->BeginFontLoading(font_face_);
+
+  if (font_face_->GetExecutionContext()->IsDocument()) {
+    Document* document = ToDocument(font_face_->GetExecutionContext());
+    if (new_status == FontFace::kLoading)
+      FontFaceSetDocument::From(*document)->BeginFontLoading(font_face_);
+  }
+  if (font_face_->GetExecutionContext()->IsWorkerGlobalScope()) {
+    WorkerGlobalScope* scope =
+        ToWorkerGlobalScope(font_face_->GetExecutionContext());
+    if (new_status == FontFace::kLoading)
+      FontFaceSetWorker::From(*scope)->BeginFontLoading(font_face_);
+  }
 }
 
 void CSSFontFace::Trace(blink::Visitor* visitor) {

third_party/WebKit/Source/core/css/CSSFontSelector.h

@@ -60,7 +60,7 @@ class CORE_EXPORT CSSFontSelector : public FontSelector {
                     const AtomicString& family_name,
                     const FontDataForRangeSet&) override;
   bool IsPlatformFamilyMatchAvailable(const FontDescription&,
-                                      const AtomicString& family);
+                                      const AtomicString& family) override;
 
   void FontFaceInvalidated() override;
 
@@ -71,7 +71,7 @@ class CORE_EXPORT CSSFontSelector : public FontSelector {
   void UnregisterForInvalidationCallbacks(FontSelectorClient*) override;
 
   ExecutionContext* GetExecutionContext() const override { return document_; }
-  FontFaceCache* GetFontFaceCache() { return &font_face_cache_; }
+  FontFaceCache* GetFontFaceCache() override { return &font_face_cache_; }
 
   const GenericFontFamilySettings& GetGenericFontFamilySettings() const {
     return generic_font_family_settings_;

third_party/WebKit/Source/core/css/FontFaceSet.cpp

@@ -4,8 +4,306 @@
 
 #include "core/css/FontFaceSet.h"
 
+#include "core/css/FontFaceCache.h"
+#include "core/css/FontFaceSetLoadEvent.h"
+#include "platform/fonts/Font.h"
+
 namespace blink {
 
+void FontFaceSet::Suspend() {
+  async_runner_->Suspend();
+}
+
+void FontFaceSet::Resume() {
+  async_runner_->Resume();
+}
+
+void FontFaceSet::ContextDestroyed(ExecutionContext*) {
+  async_runner_->Stop();
+}
+
+void FontFaceSet::HandlePendingEventsAndPromisesSoon() {
+  // async_runner_ will be automatically stopped on destruction.
+  async_runner_->RunAsync();
+}
+
+void FontFaceSet::HandlePendingEventsAndPromises() {
+  FireLoadingEvent();
+  FireDoneEventIfPossible();
+}
+
+void FontFaceSet::FireLoadingEvent() {
+  if (should_fire_loading_event_) {
+    should_fire_loading_event_ = false;
+    DispatchEvent(
+        FontFaceSetLoadEvent::CreateForFontFaces(EventTypeNames::loading));
+  }
+}
+
+FontFaceSet* FontFaceSet::addForBinding(ScriptState*,
+                                        FontFace* font_face,
+                                        ExceptionState&) {
+  DCHECK(font_face);
+  if (!InActiveContext())
+    return this;
+  if (non_css_connected_faces_.Contains(font_face))
+    return this;
+  if (IsCSSConnectedFontFace(font_face))
+    return this;
+  FontSelector* font_selector = GetFontSelector();
+  non_css_connected_faces_.insert(font_face);
+  font_selector->GetFontFaceCache()->AddFontFace(font_face, false);
+  if (font_face->LoadStatus() == FontFace::kLoading)
+    AddToLoadingFonts(font_face);
+  font_selector->FontFaceInvalidated();
+  return this;
+}
+
+void FontFaceSet::clearForBinding(ScriptState*, ExceptionState&) {
+  if (!InActiveContext() || non_css_connected_faces_.IsEmpty())
+    return;
+  FontSelector* font_selector = GetFontSelector();
+  FontFaceCache* font_face_cache = font_selector->GetFontFaceCache();
+  for (const auto& font_face : non_css_connected_faces_) {
+    font_face_cache->RemoveFontFace(font_face.Get(), false);
+    if (font_face->LoadStatus() == FontFace::kLoading)
+      RemoveFromLoadingFonts(font_face);
+  }
+  non_css_connected_faces_.clear();
+  font_selector->FontFaceInvalidated();
+}
+
+bool FontFaceSet::deleteForBinding(ScriptState*,
+                                   FontFace* font_face,
+                                   ExceptionState&) {
+  DCHECK(font_face);
+  if (!InActiveContext())
+    return false;
+  HeapListHashSet<Member<FontFace>>::iterator it =
+      non_css_connected_faces_.find(font_face);
+  if (it != non_css_connected_faces_.end()) {
+    non_css_connected_faces_.erase(it);
+    FontSelector* font_selector = GetFontSelector();
+    font_selector->GetFontFaceCache()->RemoveFontFace(font_face, false);
+    if (font_face->LoadStatus() == FontFace::kLoading)
+      RemoveFromLoadingFonts(font_face);
+    font_selector->FontFaceInvalidated();
+    return true;
+  }
+  return false;
+}
+
+bool FontFaceSet::hasForBinding(ScriptState*,
+                                FontFace* font_face,
+                                ExceptionState&) const {
+  DCHECK(font_face);
+  if (!InActiveContext())
+    return false;
+  return non_css_connected_faces_.Contains(font_face) ||
+         IsCSSConnectedFontFace(font_face);
+}
+
+void FontFaceSet::Trace(blink::Visitor* visitor) {
+  visitor->Trace(non_css_connected_faces_);
+  visitor->Trace(loading_fonts_);
+  visitor->Trace(loaded_fonts_);
+  visitor->Trace(failed_fonts_);
+  visitor->Trace(ready_);
+  visitor->Trace(async_runner_);
+  SuspendableObject::Trace(visitor);
+  EventTargetWithInlineData::Trace(visitor);
+  FontFace::LoadFontCallback::Trace(visitor);
+}
+
+size_t FontFaceSet::size() const {
+  if (!InActiveContext())
+    return non_css_connected_faces_.size();
+  return CSSConnectedFontFaceList().size() + non_css_connected_faces_.size();
+}
+
+void FontFaceSet::AddFontFacesToFontFaceCache(FontFaceCache* font_face_cache) {
+  for (const auto& font_face : non_css_connected_faces_)
+    font_face_cache->AddFontFace(font_face, false);
+}
+
+void FontFaceSet::AddToLoadingFonts(FontFace* font_face) {
+  if (!is_loading_) {
+    is_loading_ = true;
+    should_fire_loading_event_ = true;
+    if (ready_->GetState() != ReadyProperty::kPending)
+      ready_->Reset();
+    HandlePendingEventsAndPromisesSoon();
+  }
+  loading_fonts_.insert(font_face);
+  font_face->AddCallback(this);
+}
+
+void FontFaceSet::RemoveFromLoadingFonts(FontFace* font_face) {
+  loading_fonts_.erase(font_face);
+  if (loading_fonts_.IsEmpty())
+    HandlePendingEventsAndPromisesSoon();
+}
+
+void FontFaceSet::LoadFontPromiseResolver::LoadFonts() {
+  if (!num_loading_) {
+    resolver_->Resolve(font_faces_);
+    return;
+  }
+
+  for (size_t i = 0; i < font_faces_.size(); i++)
+    font_faces_[i]->LoadWithCallback(this);
+}
+
+ScriptPromise FontFaceSet::load(ScriptState* script_state,
+                                const String& font_string,
+                                const String& text) {
+  if (!InActiveContext())
+    return ScriptPromise();
+
+  Font font;
+  if (!ResolveFontStyle(font_string, font)) {
+    ScriptPromiseResolver* resolver =
+        ScriptPromiseResolver::Create(script_state);
+    ScriptPromise promise = resolver->Promise();
+    resolver->Reject(DOMException::Create(
+        kSyntaxError, "Could not resolve '" + font_string + "' as a font."));
+    return promise;
+  }
+
+  FontFaceCache* font_face_cache = GetFontSelector()->GetFontFaceCache();
+  FontFaceArray faces;
+  for (const FontFamily* f = &font.GetFontDescription().Family(); f;
+       f = f->Next()) {
+    CSSSegmentedFontFace* segmented_font_face =
+        font_face_cache->Get(font.GetFontDescription(), f->Family());
+    if (segmented_font_face)
+      segmented_font_face->Match(text, faces);
+  }
+
+  LoadFontPromiseResolver* resolver =
+      LoadFontPromiseResolver::Create(faces, script_state);
+  ScriptPromise promise = resolver->Promise();
+  // After this, resolver->promise() may return null.
+  resolver->LoadFonts();
+  return promise;
+}
+
+bool FontFaceSet::check(const String& font_string,
+                        const String& text,
+                        ExceptionState& exception_state) {
+  if (!InActiveContext())
+    return false;
+
+  Font font;
+  if (!ResolveFontStyle(font_string, font)) {
+    exception_state.ThrowDOMException(
+        kSyntaxError, "Could not resolve '" + font_string + "' as a font.");
+    return false;
+  }
+
+  FontSelector* font_selector = GetFontSelector();
+  FontFaceCache* font_face_cache = font_selector->GetFontFaceCache();
+
+  bool has_loaded_faces = false;
+  for (const FontFamily* f = &font.GetFontDescription().Family(); f;
+       f = f->Next()) {
+    CSSSegmentedFontFace* face =
+        font_face_cache->Get(font.GetFontDescription(), f->Family());
+    if (face) {
+      if (!face->CheckFont(text))
+        return false;
+      has_loaded_faces = true;
+    }
+  }
+  if (has_loaded_faces)
+    return true;
+  for (const FontFamily* f = &font.GetFontDescription().Family(); f;
+       f = f->Next()) {
+    if (font_selector->IsPlatformFamilyMatchAvailable(font.GetFontDescription(),
+                                                      f->Family()))
+      return true;
+  }
+  return false;
+}
+
+void FontFaceSet::FireDoneEvent() {
+  if (is_loading_) {
+    FontFaceSetLoadEvent* done_event = nullptr;
+    FontFaceSetLoadEvent* error_event = nullptr;
+    done_event = FontFaceSetLoadEvent::CreateForFontFaces(
+        EventTypeNames::loadingdone, loaded_fonts_);
+    loaded_fonts_.clear();
+    if (!failed_fonts_.IsEmpty()) {
+      error_event = FontFaceSetLoadEvent::CreateForFontFaces(
+          EventTypeNames::loadingerror, failed_fonts_);
+      failed_fonts_.clear();
+    }
+    is_loading_ = false;
+    DispatchEvent(done_event);
+    if (error_event)
+      DispatchEvent(error_event);
+  }
+
+  if (ready_->GetState() == ReadyProperty::kPending)
+    ready_->Resolve(this);
+}
+
+bool FontFaceSet::ShouldSignalReady() const {
+  if (!loading_fonts_.IsEmpty())
+    return false;
+  return is_loading_ || ready_->GetState() == ReadyProperty::kPending;
+}
+
+void FontFaceSet::LoadFontPromiseResolver::NotifyLoaded(FontFace* font_face) {
+  num_loading_--;
+  if (num_loading_ || error_occured_)
+    return;
+
+  resolver_->Resolve(font_faces_);
+}
+
+void FontFaceSet::LoadFontPromiseResolver::NotifyError(FontFace* font_face) {
+  num_loading_--;
+  if (!error_occured_) {
+    error_occured_ = true;
+    resolver_->Reject(font_face->GetError());
+  }
+}
+
+void FontFaceSet::LoadFontPromiseResolver::Trace(blink::Visitor* visitor) {
+  visitor->Trace(font_faces_);
+  visitor->Trace(resolver_);
+  LoadFontCallback::Trace(visitor);
+}
+
+bool FontFaceSet::IterationSource::Next(ScriptState*,
+                                        Member<FontFace>& key,
+                                        Member<FontFace>& value,
+                                        ExceptionState&) {
+  if (font_faces_.size() <= index_)
+    return false;
+  key = value = font_faces_[index_++];
+  return true;
+}
 
+FontFaceSetIterable::IterationSource* FontFaceSet::StartIteration(
+    ScriptState*,
+    ExceptionState&) {
+  // Setlike should iterate each item in insertion order, and items should
+  // be keep on up to date. But since blink does not have a way to hook up CSS
+  // modification, take a snapshot here, and make it ordered as follows.
+  HeapVector<Member<FontFace>> font_faces;
+  if (InActiveContext()) {
+    const HeapListHashSet<Member<FontFace>>& css_connected_faces =
+        CSSConnectedFontFaceList();
+    font_faces.ReserveInitialCapacity(css_connected_faces.size() +
+                                      non_css_connected_faces_.size());
+    for (const auto& font_face : css_connected_faces)
+      font_faces.push_back(font_face);
+    for (const auto& font_face : non_css_connected_faces_)
+      font_faces.push_back(font_face);
+  }
+  return new IterationSource(font_faces);
+}
 
 }  // namespace blink

third_party/WebKit/Source/core/css/FontFaceSet.h

+
 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
@@ -7,10 +8,14 @@
 
 #include "bindings/core/v8/Iterable.h"
 #include "bindings/core/v8/ScriptPromise.h"
+#include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/css/FontFace.h"
+#include "core/dom/SuspendableObject.h"
 #include "core/dom/events/EventListener.h"
 #include "core/dom/events/EventTarget.h"
+#include "platform/AsyncMethodRunner.h"
 #include "platform/bindings/ScriptWrappable.h"
+#include "platform/fonts/FontSelector.h"
 
 // Mac OS X 10.6 SDK defines check() macro that interferes with our check()
 // method
@@ -20,55 +25,94 @@
 
 namespace blink {
 
+class FontFaceCache;
+
 using FontFaceSetIterable = SetlikeIterable<Member<FontFace>>;
 
 class CORE_EXPORT FontFaceSet : public EventTargetWithInlineData,
-                                public FontFaceSetIterable {
+                                public SuspendableObject,
+                                public FontFaceSetIterable,
+                                public FontFace::LoadFontCallback {
   DEFINE_WRAPPERTYPEINFO();
   WTF_MAKE_NONCOPYABLE(FontFaceSet);
 
  public:
-  FontFaceSet() {}
+  FontFaceSet(ExecutionContext& context)
+      : SuspendableObject(&context),
+        is_loading_(false),
+        should_fire_loading_event_(false),
+        ready_(new ReadyProperty(GetExecutionContext(),
+                                 this,
+                                 ReadyProperty::kReady)),
+        async_runner_(AsyncMethodRunner<FontFaceSet>::Create(
+            this,
+            &FontFaceSet::HandlePendingEventsAndPromises)) {}
   ~FontFaceSet() {}
 
   DEFINE_ATTRIBUTE_EVENT_LISTENER(loading);
   DEFINE_ATTRIBUTE_EVENT_LISTENER(loadingdone);
   DEFINE_ATTRIBUTE_EVENT_LISTENER(loadingerror);
 
-  virtual bool check(const String& font,
-                     const String& text,
-                     ExceptionState&) = 0;
-  virtual ScriptPromise load(ScriptState*,
-                             const String& font,
-                             const String& text) = 0;
+  bool check(const String& font, const String& text, ExceptionState&);
+  ScriptPromise load(ScriptState*, const String& font, const String& text);
   virtual ScriptPromise ready(ScriptState*) = 0;
 
-  virtual ExecutionContext* GetExecutionContext() const = 0;
+  ExecutionContext* GetExecutionContext() const {
+    return SuspendableObject::GetExecutionContext();
+  }
+
   const AtomicString& InterfaceName() const {
     return EventTargetNames::FontFaceSet;
   }
 
-  virtual FontFaceSet* addForBinding(ScriptState*,
-                                     FontFace*,
-                                     ExceptionState&) = 0;
-  virtual void clearForBinding(ScriptState*, ExceptionState&) = 0;
-  virtual bool deleteForBinding(ScriptState*, FontFace*, ExceptionState&) = 0;
-  virtual bool hasForBinding(ScriptState*,
-                             FontFace*,
-                             ExceptionState&) const = 0;
+  FontFaceSet* addForBinding(ScriptState*, FontFace*, ExceptionState&);
+  void clearForBinding(ScriptState*, ExceptionState&);
+  bool deleteForBinding(ScriptState*, FontFace*, ExceptionState&);
+  bool hasForBinding(ScriptState*, FontFace*, ExceptionState&) const;
 
-  virtual size_t size() const = 0;
+  void AddFontFacesToFontFaceCache(FontFaceCache*);
+
+  // SuspendableObject
+  void Suspend() override;
+  void Resume() override;
+  void ContextDestroyed(ExecutionContext*) override;
+
+  size_t size() const;
   virtual AtomicString status() const = 0;
 
-  virtual void Trace(blink::Visitor* visitor) {
-    EventTargetWithInlineData::Trace(visitor);
-  }
+  virtual void Trace(blink::Visitor*);
 
  protected:
-  // Iterable overrides.
-  virtual FontFaceSetIterable::IterationSource* StartIteration(
-      ScriptState*,
-      ExceptionState&) = 0;
+  virtual bool ResolveFontStyle(const String&, Font&) = 0;
+  virtual bool InActiveContext() const = 0;
+  virtual FontSelector* GetFontSelector() const = 0;
+  virtual const HeapListHashSet<Member<FontFace>>& CSSConnectedFontFaceList()
+      const = 0;
+  bool IsCSSConnectedFontFace(FontFace* font_face) const {
+    return CSSConnectedFontFaceList().Contains(font_face);
+  }
+
+  virtual void FireDoneEventIfPossible() = 0;
+
+  void AddToLoadingFonts(FontFace*);
+  void RemoveFromLoadingFonts(FontFace*);
+  void HandlePendingEventsAndPromisesSoon();
+  bool ShouldSignalReady() const;
+  void FireDoneEvent();
+
+  using ReadyProperty = ScriptPromiseProperty<Member<FontFaceSet>,
+                                              Member<FontFaceSet>,
+                                              Member<DOMException>>;
+
+  bool is_loading_;
+  bool should_fire_loading_event_;
+  HeapListHashSet<Member<FontFace>> non_css_connected_faces_;
+  HeapHashSet<Member<FontFace>> loading_fonts_;
+  FontFaceArray loaded_fonts_;
+  FontFaceArray failed_fonts_;
+  Member<ReadyProperty> ready_;
+
+  Member<AsyncMethodRunner<FontFaceSet>> async_runner_;
 
   class IterationSource final : public FontFaceSetIterable::IterationSource {
    public:
@@ -88,6 +132,47 @@ class CORE_EXPORT FontFaceSet : public EventTargetWithInlineData,
     size_t index_;
     HeapVector<Member<FontFace>> font_faces_;
   };
+
+  class LoadFontPromiseResolver final
+      : public GarbageCollectedFinalized<LoadFontPromiseResolver>,
+        public FontFace::LoadFontCallback {
+    USING_GARBAGE_COLLECTED_MIXIN(LoadFontPromiseResolver);
+
+   public:
+    static LoadFontPromiseResolver* Create(FontFaceArray faces,
+                                           ScriptState* script_state) {
+      return new LoadFontPromiseResolver(faces, script_state);
+    }
+
+    void LoadFonts();
+    ScriptPromise Promise() { return resolver_->Promise(); }
+
+    void NotifyLoaded(FontFace*) override;
+    void NotifyError(FontFace*) override;
+
+    void Trace(blink::Visitor*);
+
+   private:
+    LoadFontPromiseResolver(FontFaceArray faces, ScriptState* script_state)
+        : num_loading_(faces.size()),
+          error_occured_(false),
+          resolver_(ScriptPromiseResolver::Create(script_state)) {
+      font_faces_.swap(faces);
+    }
+
+    HeapVector<Member<FontFace>> font_faces_;
+    int num_loading_;
+    bool error_occured_;
+    Member<ScriptPromiseResolver> resolver_;
+  };
+
+ private:
+  FontFaceSetIterable::IterationSource* StartIteration(
+      ScriptState*,
+      ExceptionState&) override;
+
+  void HandlePendingEventsAndPromises();
+  void FireLoadingEvent();
 };
 
 }  // namespace blink

third_party/WebKit/Source/core/css/FontFaceSet.idl

@@ -32,11 +32,12 @@
 
 enum FontFaceSetLoadStatus { "loading", "loaded" };
 
-// TODO(foolip): This interface should be [Exposed=Window,Worker] and should
-// have a constructor, and thus not have [NoInterfaceObject].
+// TODO(foolip): This interface should have a constructor and thos not have
+// [NoInterfaceObject]
 [
     DependentLifetime,
-    NoInterfaceObject
+    NoInterfaceObject,
+    Exposed(Window StableBlinkFeatures, Worker ExperimentalCanvasFeatures)
 ] interface FontFaceSet : EventTarget {
     setlike<FontFace>;
 

third_party/WebKit/Source/core/css/FontFaceSetDocument.h

@@ -28,8 +28,10 @@
 
 #include "bindings/core/v8/Iterable.h"
 #include "bindings/core/v8/ScriptPromise.h"
+#include "core/css/CSSFontSelector.h"
 #include "core/css/FontFace.h"
 #include "core/css/FontFaceSet.h"
+#include "core/css/StyleEngine.h"
 #include "core/dom/Document.h"
 #include "core/dom/SuspendableObject.h"
 #include "core/dom/events/EventListener.h"
@@ -39,46 +41,22 @@
 #include "platform/wtf/Allocator.h"
 #include "platform/wtf/Vector.h"
 
-// Mac OS X 10.6 SDK defines check() macro that interferes with our check()
-// method
-#ifdef check
-#undef check
-#endif
-
 namespace blink {
 
-class ExceptionState;
 class Font;
-class FontFaceCache;
-class ExecutionContext;
-
-class CORE_EXPORT FontFaceSetDocument final
-    : public FontFaceSet,
-      public Supplement<Document>,
-      public SuspendableObject,
-      public FontFace::LoadFontCallback {
+
+class CORE_EXPORT FontFaceSetDocument final : public FontFaceSet,
+                                              public Supplement<Document> {
   USING_GARBAGE_COLLECTED_MIXIN(FontFaceSetDocument);
   WTF_MAKE_NONCOPYABLE(FontFaceSetDocument);
 
  public:
   ~FontFaceSetDocument() override;
 
-  bool check(const String& font, const String& text, ExceptionState&) override;
-  ScriptPromise load(ScriptState*,
-                     const String& font,
-                     const String& text) override;
   ScriptPromise ready(ScriptState*) override;
 
-  FontFaceSet* addForBinding(ScriptState*, FontFace*, ExceptionState&) override;
-  void clearForBinding(ScriptState*, ExceptionState&) override;
-  bool deleteForBinding(ScriptState*, FontFace*, ExceptionState&) override;
-  bool hasForBinding(ScriptState*, FontFace*, ExceptionState&) const override;
-
-  size_t size() const override;
   AtomicString status() const override;
 
-  ExecutionContext* GetExecutionContext() const override;
-
   Document* GetDocument() const;
 
   void DidLayout();
@@ -90,31 +68,34 @@ class CORE_EXPORT FontFaceSetDocument final
 
   size_t ApproximateBlankCharacterCount() const;
 
-  // SuspendableObject
-  void Suspend() override;
-  void Resume() override;
-  void ContextDestroyed(ExecutionContext*) override;
-
   static FontFaceSetDocument* From(Document&);
   static void DidLayout(Document&);
   static size_t ApproximateBlankCharacterCount(Document&);
 
   static const char* SupplementName() { return "FontFaceSetDocument"; }
 
-  void AddFontFacesToFontFaceCache(FontFaceCache*);
-
   virtual void Trace(blink::Visitor*);
   virtual void TraceWrappers(const ScriptWrappableVisitor*) const;
 
- private:
-  FontFaceSetIterable::IterationSource* StartIteration(
-      ScriptState*,
-      ExceptionState&) override;
+ protected:
+  bool InActiveContext() const override;
+  FontSelector* GetFontSelector() const override {
+    return GetDocument()->GetStyleEngine().GetFontSelector();
+  }
+
+  bool ResolveFontStyle(const String&, Font&) override;
 
+ private:
   static FontFaceSetDocument* Create(Document& document) {
     return new FontFaceSetDocument(document);
   }
 
+  explicit FontFaceSetDocument(Document&);
+
+  void FireDoneEventIfPossible() override;
+  const HeapListHashSet<Member<FontFace>>& CSSConnectedFontFaceList()
+      const override;
+
   class FontLoadHistogram {
     DISALLOW_NEW();
 
@@ -130,35 +111,6 @@ class CORE_EXPORT FontFaceSetDocument final
     int count_;
     bool recorded_;
   };
-
-  explicit FontFaceSetDocument(Document&);
-
-  bool InActiveDocumentContext() const;
-  void AddToLoadingFonts(FontFace*);
-  void RemoveFromLoadingFonts(FontFace*);
-  void FireLoadingEvent();
-  void FireDoneEventIfPossible();
-  bool ResolveFontStyle(const String&, Font&);
-  void HandlePendingEventsAndPromisesSoon();
-  void HandlePendingEventsAndPromises();
-  const HeapListHashSet<Member<FontFace>>& CssConnectedFontFaceList() const;
-  bool IsCSSConnectedFontFace(FontFace*) const;
-  bool ShouldSignalReady() const;
-
-  using ReadyProperty = ScriptPromiseProperty<Member<FontFaceSetDocument>,
-                                              Member<FontFaceSetDocument>,
-                                              Member<DOMException>>;
-
-  HeapHashSet<Member<FontFace>> loading_fonts_;
-  bool should_fire_loading_event_;
-  bool is_loading_;
-  Member<ReadyProperty> ready_;
-  FontFaceArray loaded_fonts_;
-  FontFaceArray failed_fonts_;
-  HeapListHashSet<Member<FontFace>> non_css_connected_faces_;
-
-  Member<AsyncMethodRunner<FontFaceSetDocument>> async_runner_;
-
   FontLoadHistogram histogram_;
 };
 

third_party/WebKit/Source/core/css/FontFaceSetWorker.cpp

+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "core/css/FontFaceSetWorker.h"
+
+#include "bindings/core/v8/Dictionary.h"
+#include "bindings/core/v8/ScriptPromiseResolver.h"
+#include "core/css/CSSSegmentedFontFace.h"
+#include "core/css/FontFaceCache.h"
+#include "core/css/FontFaceSetLoadEvent.h"
+#include "core/css/OffscreenFontSelector.h"
+#include "core/css/StylePropertySet.h"
+#include "core/css/parser/CSSParser.h"
+#include "core/css/resolver/FontStyleResolver.h"
+#include "core/css/resolver/StyleResolver.h"
+#include "core/frame/LocalFrame.h"
+#include "core/frame/LocalFrameView.h"
+#include "core/style/ComputedStyle.h"
+#include "platform/bindings/ScriptState.h"
+
+namespace blink {
+
+static const int kDefaultFontSize = 10;
+static const char kDefaultFontFamily[] = "sans-serif";
+
+FontFaceSetWorker::FontFaceSetWorker(WorkerGlobalScope& worker)
+    : FontFaceSet(worker), Supplement<WorkerGlobalScope>(worker) {
+  SuspendIfNeeded();
+}
+
+FontFaceSetWorker::~FontFaceSetWorker() {}
+
+WorkerGlobalScope* FontFaceSetWorker::GetWorker() const {
+  return ToWorkerGlobalScope(GetExecutionContext());
+}
+
+AtomicString FontFaceSetWorker::status() const {
+  DEFINE_STATIC_LOCAL(AtomicString, loading, ("loading"));
+  DEFINE_STATIC_LOCAL(AtomicString, loaded, ("loaded"));
+  return is_loading_ ? loading : loaded;
+}
+
+void FontFaceSetWorker::BeginFontLoading(FontFace* font_face) {
+  AddToLoadingFonts(font_face);
+}
+
+void FontFaceSetWorker::NotifyLoaded(FontFace* font_face) {
+  loaded_fonts_.push_back(font_face);
+  RemoveFromLoadingFonts(font_face);
+}
+
+void FontFaceSetWorker::NotifyError(FontFace* font_face) {
+  failed_fonts_.push_back(font_face);
+  RemoveFromLoadingFonts(font_face);
+}
+
+ScriptPromise FontFaceSetWorker::ready(ScriptState* script_state) {
+  return ready_->Promise(script_state->World());
+}
+
+void FontFaceSetWorker::FireDoneEventIfPossible() {
+  if (should_fire_loading_event_)
+    return;
+  if (!ShouldSignalReady())
+    return;
+
+  FireDoneEvent();
+}
+
+bool FontFaceSetWorker::ResolveFontStyle(const String& font_string,
+                                         Font& font) {
+  if (font_string.IsEmpty())
+    return false;
+
+  // Interpret fontString in the same way as the 'font' attribute of
+  // CanvasRenderingContext2D.
+  MutableStylePropertySet* parsed_style =
+      MutableStylePropertySet::Create(kHTMLStandardMode);
+  CSSParser::ParseValue(parsed_style, CSSPropertyFont, font_string, true);
+  if (parsed_style->IsEmpty())
+    return false;
+
+  String font_value = parsed_style->GetPropertyValue(CSSPropertyFont);
+  if (font_value == "inherit" || font_value == "initial")
+    return false;
+
+  FontFamily font_family;
+  font_family.SetFamily(kDefaultFontFamily);
+
+  FontDescription default_font_description;
+  default_font_description.SetFamily(font_family);
+  default_font_description.SetSpecifiedSize(kDefaultFontSize);
+  default_font_description.SetComputedSize(kDefaultFontSize);
+
+  FontDescription description = FontStyleResolver::ComputeFont(
+      *parsed_style, GetWorker()->GetFontSelector());
+
+  font = Font(description);
+  font.Update(GetWorker()->GetFontSelector());
+
+  return true;
+}
+
+FontFaceSetWorker* FontFaceSetWorker::From(WorkerGlobalScope& worker) {
+  FontFaceSetWorker* fonts = static_cast<FontFaceSetWorker*>(
+      Supplement<WorkerGlobalScope>::From(worker, SupplementName()));
+  if (!fonts) {
+    fonts = FontFaceSetWorker::Create(worker);
+    Supplement<WorkerGlobalScope>::ProvideTo(worker, SupplementName(), fonts);
+  }
+
+  return fonts;
+}
+
+void FontFaceSetWorker::Trace(Visitor* visitor) {
+  Supplement<WorkerGlobalScope>::Trace(visitor);
+  FontFaceSet::Trace(visitor);
+}
+
+}  // namespace blink

third_party/WebKit/Source/core/css/FontFaceSetWorker.h

+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FontFaceSetWorker_h
+#define FontFaceSetWorker_h
+
+#include "bindings/core/v8/Iterable.h"
+#include "bindings/core/v8/ScriptPromise.h"
+#include "core/css/FontFace.h"
+#include "core/css/FontFaceSet.h"
+#include "core/css/OffscreenFontSelector.h"
+#include "core/dom/SuspendableObject.h"
+#include "core/workers/WorkerGlobalScope.h"
+#include "platform/AsyncMethodRunner.h"
+#include "platform/heap/Handle.h"
+#include "platform/wtf/Allocator.h"
+#include "platform/wtf/Vector.h"
+
+namespace blink {
+
+class Font;
+
+class CORE_EXPORT FontFaceSetWorker final
+    : public FontFaceSet,
+      public Supplement<WorkerGlobalScope> {
+  USING_GARBAGE_COLLECTED_MIXIN(FontFaceSetWorker);
+  WTF_MAKE_NONCOPYABLE(FontFaceSetWorker);
+
+ public:
+  ~FontFaceSetWorker() override;
+
+  ScriptPromise ready(ScriptState*) override;
+
+  AtomicString status() const override;
+
+  WorkerGlobalScope* GetWorker() const;
+
+  // FontFace::LoadFontCallback
+  void NotifyLoaded(FontFace*) override;
+  void NotifyError(FontFace*) override;
+
+  void BeginFontLoading(FontFace*);
+
+  static FontFaceSetWorker* From(WorkerGlobalScope&);
+
+  static const char* SupplementName() { return "FontFaceSetWorker"; }
+
+  void Trace(Visitor*) override;
+
+ protected:
+  bool InActiveContext() const override { return true; }
+  FontSelector* GetFontSelector() const override {
+    return GetWorker()->GetFontSelector();
+  }
+  // For workers, this is always an empty list.
+  const HeapListHashSet<Member<FontFace>>& CSSConnectedFontFaceList()
+      const override {
+    DCHECK(
+        GetFontSelector()->GetFontFaceCache()->CssConnectedFontFaces().size() ==
+        0);
+    return GetFontSelector()->GetFontFaceCache()->CssConnectedFontFaces();
+  }
+
+  bool ResolveFontStyle(const String&, Font&) override;
+
+ private:
+  static FontFaceSetWorker* Create(WorkerGlobalScope& worker) {
+    return new FontFaceSetWorker(worker);
+  }
+
+  explicit FontFaceSetWorker(WorkerGlobalScope&);
+
+  void FireDoneEventIfPossible() override;
+};
+
+}  // namespace blink
+
+#endif  // FontFaceSetWorker_h

third_party/WebKit/Source/core/css/OffscreenFontSelector.h

@@ -51,10 +51,11 @@ class CORE_EXPORT OffscreenFontSelector : public FontSelector {
 
   void UpdateGenericFontFamilySettings(const GenericFontFamilySettings&);
 
-  FontFaceCache* GetFontFaceCache() { return &font_face_cache_; }
+  FontFaceCache* GetFontFaceCache() override { return &font_face_cache_; }
 
-  bool IsPlatformFamilyMatchAvailable(const FontDescription&,
-                                      const AtomicString& passed_family);
+  bool IsPlatformFamilyMatchAvailable(
+      const FontDescription&,
+      const AtomicString& passed_family) override;
 
   ExecutionContext* GetExecutionContext() const override {
     return execution_context_;

third_party/WebKit/Source/platform/fonts/FontSelector.h

@@ -38,6 +38,7 @@ namespace blink {
 class ExecutionContext;
 class FontData;
 class FontDescription;
+class FontFaceCache;
 class FontSelectorClient;
 class GenericFontFamilySettings;
 
@@ -67,6 +68,12 @@ class PLATFORM_EXPORT FontSelector : public FontCacheClient {
 
   virtual ExecutionContext* GetExecutionContext() const = 0;
 
+  virtual FontFaceCache* GetFontFaceCache() = 0;
+
+  virtual bool IsPlatformFamilyMatchAvailable(
+      const FontDescription&,
+      const AtomicString& passed_family) = 0;
+
  protected:
   static AtomicString FamilyNameFromSettings(
       const GenericFontFamilySettings&,

third_party/WebKit/Source/platform/testing/FontTestHelpers.cpp

@@ -53,11 +53,18 @@ class TestFontSelector : public FontSelector {
   unsigned Version() const override { return 0; }
   void FontCacheInvalidated() override {}
   void ReportNotDefGlyph() const override {}
-  ExecutionContext* GetExecutionContext() const { return nullptr; }
+  ExecutionContext* GetExecutionContext() const override { return nullptr; }
+  FontFaceCache* GetFontFaceCache() override { return nullptr; }
 
   void RegisterForInvalidationCallbacks(FontSelectorClient*) override {}
   void UnregisterForInvalidationCallbacks(FontSelectorClient*) override {}
 
+  bool IsPlatformFamilyMatchAvailable(
+      const FontDescription&,
+      const AtomicString& passed_family) override {
+    return false;
+  }
+
  private:
   TestFontSelector(scoped_refptr<FontCustomPlatformData> custom_platform_data)
       : custom_platform_data_(std::move(custom_platform_data)) {