Worklet: Lazily create PaintWorkletGlobalScopes

third_party/WebKit/Source/modules/csspaint/PaintWorklet.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/PaintWorklet.h"
 
 #include "bindings/core/v8/V8BindingForCore.h"
 #include "core/dom/Document.h"
 #include "core/frame/LocalFrame.h"
 #include "modules/csspaint/PaintWorkletGlobalScope.h"
 
 namespace blink {
 
 // static
 PaintWorklet* PaintWorklet::Create(LocalFrame* frame) {
   return new PaintWorklet(frame);
 }
 
 PaintWorklet::PaintWorklet(LocalFrame* frame)
     : MainThreadWorklet(frame),
-      global_scope_proxy_(
-          WTF::MakeUnique<PaintWorkletGlobalScopeProxy>(frame)) {}
+      pending_generator_registry_(new PaintWorkletPendingGeneratorRegistry) {}
 
 PaintWorklet::~PaintWorklet() = default;
 
-WorkletGlobalScopeProxy* PaintWorklet::GetWorkletGlobalScopeProxy() const {
-  return global_scope_proxy_.get();
-}
+CSSPaintDefinition* PaintWorklet::FindDefinition(const String& name) {
+  if (GetProxies().IsEmpty())
+    return nullptr;
 
-CSSPaintDefinition* PaintWorklet::FindDefinition(const String& name) {
-  return global_scope_proxy_->FindDefinition(name);
+  // TODO(nhiroki): Support the case where there are multiple global scopes.

[ikilpatrick, 2017/05/10 03:47:44]

so what we'll want to do for paint is basically switch global scopes every N
frames for the moment. (N ~= say 60). It may make sense to remove FindDefinition
here? Thoughts?

[nhiroki, 2017/05/10 09:01:32]

I'm a bit confused. Does it mean to remove PaintWorklet::FindDefinition() call
in CSSPaintImageGeneratorImpl::Create() and always add a newly created generator
into the pending registry? If so, how/when do we associate the pending generator
with an existing CSSPaintDefinition?

Or, does it mean to remove a CSSPaintDefinition returned from FindDefinition()
from WorkletGlobalScope's DefinitionMap?

[ikilpatrick, 2017/05/24 03:47:07]

Ah sorry, we'll have to work on this a bit more, the CSS Paint API actually has
two types of registeries/definitions to deal with this, a:
DocumentPaintRegistry
PaintWorkletGlobalScopeRegistry

The document one is used for the pending generator case, i.e. the document wants
to see what input properties it should invalidate on etc.

The worklet GS one is used for the invoking paint, etc upon.

We can refactor this later.

[nhiroki, 2017/05/24 05:12:21]

Acknowledged. Thank you for the clarification.

+  DCHECK_EQ(1u, GetProxies().size());
+  PaintWorkletGlobalScopeProxy* proxy =
+      PaintWorkletGlobalScopeProxy::From(GetProxies().begin()->get());
+  return proxy->FindDefinition(name);
 }
 
 void PaintWorklet::AddPendingGenerator(const String& name,
                                        CSSPaintImageGeneratorImpl* generator) {
-  return global_scope_proxy_->AddPendingGenerator(name, generator);
+  if (GetProxies().IsEmpty()) {
+    pending_generator_registry_->AddPendingGenerator(name, generator);
+    return;
+  }
+
+  // TODO(nhiroki): Support the case where there are multiple global scopes.
+  DCHECK_EQ(1u, GetProxies().size());
+  PaintWorkletGlobalScopeProxy* proxy =
+      PaintWorkletGlobalScopeProxy::From(GetProxies().begin()->get());
+  return proxy->AddPendingGenerator(name, generator);
 }
 
 DEFINE_TRACE(PaintWorklet) {
+  visitor->Trace(pending_generator_registry_);
   MainThreadWorklet::Trace(visitor);
 }
 
+bool PaintWorklet::NeedsToCreateGlobalScope() {
+  // "The user agent must have, and select from at least two
+  // PaintWorkletGlobalScopes in the worklet's WorkletGlobalScopes list, unless
+  // the user agent is under memory constraints."
+  // https://drafts.css-houdini.org/css-paint-api-1/#drawing-an-image
+  // TODO(nhiroki): In the current impl, we create only one global scope. We
+  // should create at least two global scopes as the spec.
+  return GetProxies().IsEmpty();
+}
+
+std::unique_ptr<WorkletGlobalScopeProxy> PaintWorklet::CreateGlobalScope() {
+  auto proxy = WTF::MakeUnique<PaintWorkletGlobalScopeProxy>(frame_);
+  if (GetProxies().IsEmpty()) {
+    proxy->global_scope()->SetPendingGeneratorRegistry(
+        pending_generator_registry_);
+    pending_generator_registry_ = nullptr;
+  }
+  return proxy;
+}
+
 }  // namespace blink