Worklet: Lazily create PaintWorkletGlobalScopes

third_party/WebKit/Source/modules/csspaint/PaintWorkletGlobalScope.cpp

 // Copyright 2016 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 "modules/csspaint/PaintWorkletGlobalScope.h"
 
 #include "bindings/core/v8/IDLTypes.h"
 #include "bindings/core/v8/NativeValueTraitsImpl.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
 #include "core/CSSPropertyNames.h"
 #include "core/css/CSSSyntaxDescriptor.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/inspector/MainThreadDebugger.h"
 #include "modules/csspaint/CSSPaintDefinition.h"
 #include "modules/csspaint/CSSPaintImageGeneratorImpl.h"
 #include "platform/bindings/V8BindingMacros.h"
 
 namespace blink {
 
 // static
 PaintWorkletGlobalScope* PaintWorkletGlobalScope::Create(
     LocalFrame* frame,
     const KURL& url,
     const String& user_agent,
     PassRefPtr<SecurityOrigin> security_origin,
-    v8::Isolate* isolate) {
+    v8::Isolate* isolate,
+    PaintWorkletPendingGeneratorRegistry* pending_generator_registry) {
   PaintWorkletGlobalScope* paint_worklet_global_scope =
       new PaintWorkletGlobalScope(frame, url, user_agent,
-                                  std::move(security_origin), isolate);
+                                  std::move(security_origin), isolate,
+                                  pending_generator_registry);
   paint_worklet_global_scope->ScriptController()->InitializeContextIfNeeded();
   MainThreadDebugger::Instance()->ContextCreated(
       paint_worklet_global_scope->ScriptController()->GetScriptState(),
       paint_worklet_global_scope->GetFrame(),
       paint_worklet_global_scope->GetSecurityOrigin());
   return paint_worklet_global_scope;
 }
 
 PaintWorkletGlobalScope::PaintWorkletGlobalScope(
     LocalFrame* frame,
     const KURL& url,
     const String& user_agent,
     PassRefPtr<SecurityOrigin> security_origin,
-    v8::Isolate* isolate)
+    v8::Isolate* isolate,
+    PaintWorkletPendingGeneratorRegistry* pending_generator_registry)
     : MainThreadWorkletGlobalScope(frame,
                                    url,
                                    user_agent,
                                    std::move(security_origin),
-                                   isolate) {}
+                                   isolate),
+      pending_generator_registry_(pending_generator_registry) {}
 
 PaintWorkletGlobalScope::~PaintWorkletGlobalScope() {}
 
 void PaintWorkletGlobalScope::Dispose() {
   MainThreadDebugger::Instance()->ContextWillBeDestroyed(
       ScriptController()->GetScriptState());
+
   // Explicitly clear the paint defininitions to break a reference cycle
   // between them and this global scope.
   paint_definitions_.clear();
 
+  pending_generator_registry_ = nullptr;
   WorkletGlobalScope::Dispose();
 }
 
 void PaintWorkletGlobalScope::registerPaint(const String& name,
                                             const ScriptValue& ctor_value,
                                             ExceptionState& exception_state) {
   if (paint_definitions_.Contains(name)) {
     exception_state.ThrowDOMException(
         kNotSupportedError,
         "A class with name:'" + name + "' is already registered.");
@@ skipping 117 matching lines @@
     return;
   }
 
   v8::Local<v8::Function> paint = v8::Local<v8::Function>::Cast(paint_value);
 
   CSSPaintDefinition* definition = CSSPaintDefinition::Create(
       ScriptController()->GetScriptState(), constructor, paint,
       native_invalidation_properties, custom_invalidation_properties,
       input_argument_types, has_alpha);
   paint_definitions_.Set(name, definition);
-
-  // Set the definition on any pending generators.
-  GeneratorHashSet* set = pending_generators_.at(name);
-  if (set) {
-    for (const auto& generator : *set) {
-      if (generator) {
-        generator->SetDefinition(definition);
-      }
-    }
-  }
-  pending_generators_.erase(name);
+  pending_generator_registry_->SetDefinition(name, definition);
 }
 
 CSSPaintDefinition* PaintWorkletGlobalScope::FindDefinition(
     const String& name) {
   return paint_definitions_.at(name);
 }
 
-void PaintWorkletGlobalScope::AddPendingGenerator(
-    const String& name,
-    CSSPaintImageGeneratorImpl* generator) {
-  Member<GeneratorHashSet>& set =
-      pending_generators_.insert(name, nullptr).stored_value->value;
-  if (!set)
-    set = new GeneratorHashSet;
-  set->insert(generator);
-}
-
 DEFINE_TRACE(PaintWorkletGlobalScope) {
   visitor->Trace(paint_definitions_);
-  visitor->Trace(pending_generators_);
+  visitor->Trace(pending_generator_registry_);
   MainThreadWorkletGlobalScope::Trace(visitor);
 }
 
 }  // namespace blink