Ensure consistent document paint definiton between threads

RegisterMainThreadDocumentPaint definition now handles the case where
a definiton registered on the worklet thread is different from a
definiton on the main thread with the same name.  In this case,
the reference in document_definiton_map_ is set to null.

Bug: 948761
Change-Id: Ic969e2faf09c66013d79ab9ae8966befdf263432
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1662531
Commit-Queue: Adam Raine <asraine@google.com>
Reviewed-by: Xida Chen <xidachen@chromium.org>
Cr-Commit-Position: refs/heads/master@{#670104}

third_party/blink/renderer/modules/csspaint/document_paint_definition.cc

@@ -21,10 +21,25 @@ DocumentPaintDefinition::~DocumentPaintDefinition() = default;
 
 bool DocumentPaintDefinition::RegisterAdditionalPaintDefinition(
     const CSSPaintDefinition& other) {
-  if (alpha() != other.GetPaintRenderingContext2DSettings()->alpha() ||
-      NativeInvalidationProperties() != other.NativeInvalidationProperties() ||
-      CustomInvalidationProperties() != other.CustomInvalidationProperties() ||
-      InputArgumentTypes() != other.InputArgumentTypes())
+  if (other.NativeInvalidationProperties() != NativeInvalidationProperties() ||
+      other.CustomInvalidationProperties() != CustomInvalidationProperties() ||
+      other.InputArgumentTypes() != InputArgumentTypes() ||
+      other.GetPaintRenderingContext2DSettings()->alpha() != alpha())
+    return false;
+  registered_definitions_count_++;
+  return true;
+}
+
+bool DocumentPaintDefinition::RegisterAdditionalPaintDefinition(
+    const Vector<CSSPropertyID>& native_properties,
+    const Vector<String>& custom_properties,
+    const Vector<CSSSyntaxDescriptor>& input_argument_types,
+    bool alpha) {
+  if (native_properties != NativeInvalidationProperties() ||
+      !std::equal(custom_properties.begin(), custom_properties.end(),
+                  CustomInvalidationProperties().begin(),
+                  CustomInvalidationProperties().end()) ||
+      input_argument_types != InputArgumentTypes() || alpha != this->alpha())
     return false;
   registered_definitions_count_++;
   return true;

third_party/blink/renderer/modules/csspaint/document_paint_definition.h

@@ -43,6 +43,10 @@ class MODULES_EXPORT DocumentPaintDefinition {
   bool alpha() const { return alpha_; }
 
   bool RegisterAdditionalPaintDefinition(const CSSPaintDefinition&);
+  bool RegisterAdditionalPaintDefinition(const Vector<CSSPropertyID>&,
+                                         const Vector<String>&,
+                                         const Vector<CSSSyntaxDescriptor>&,
+                                         bool alpha);
 
   unsigned GetRegisteredDefinitionCount() const {
     return registered_definitions_count_;

third_party/blink/renderer/modules/csspaint/paint_worklet.cc

@@ -164,8 +164,15 @@ void PaintWorklet::RegisterCSSPaintDefinition(const String& name,
     // Notify the generator ready only when register paint is called the
     // second time with the same |name| (i.e. there is already a document
     // definition associated with |name|
+    //
+    // We are looking for kNumGlobalScopesPerThread number of definitions
+    // regiserered from RegisterCSSPaintDefinition and one extra definition from
+    // RegisterMainThreadDocumentPaintDefinition if OffMainThreadCSSPaintEnabled
+    // is true.
     if (existing_document_definition->GetRegisteredDefinitionCount() ==
-        PaintWorklet::kNumGlobalScopesPerThread)
+                RuntimeEnabledFeatures::OffMainThreadCSSPaintEnabled()
+            ? kNumGlobalScopesPerThread + 1
+            : kNumGlobalScopesPerThread)
       pending_generator_registry_->NotifyGeneratorReady(name);
   } else {
     auto document_definition = std::make_unique<DocumentPaintDefinition>(
@@ -183,18 +190,38 @@ void PaintWorklet::RegisterMainThreadDocumentPaintDefinition(
     Vector<String> custom_properties,
     Vector<CSSSyntaxDescriptor> input_argument_types,
     double alpha) {
-  // Because this method is called cross-thread, |custom_properties| cannot be
-  // an AtomicString. Instead, convert to AtomicString now that we are on the
-  // main thread.
-  Vector<AtomicString> new_custom_properties;
-  new_custom_properties.ReserveInitialCapacity(custom_properties.size());
-  for (const String& property : custom_properties)
-    new_custom_properties.push_back(AtomicString(property));
-  auto definition = std::make_unique<DocumentPaintDefinition>(
-      std::move(native_properties), std::move(new_custom_properties),
-      std::move(input_argument_types), alpha);
-  document_definition_map_.insert(name, std::move(definition));
-  pending_generator_registry_->NotifyGeneratorReady(name);
+  if (document_definition_map_.Contains(name)) {
+    DocumentPaintDefinition* document_definition =
+        document_definition_map_.at(name);
+    if (!document_definition)
+      return;
+    if (!document_definition->RegisterAdditionalPaintDefinition(
+            native_properties, custom_properties, input_argument_types,
+            alpha)) {
+      document_definition_map_.Set(name, nullptr);
+      return;
+    }
+  } else {
+    // Because this method is called cross-thread, |custom_properties| cannot be
+    // an AtomicString. Instead, convert to AtomicString now that we are on the
+    // main thread.
+    Vector<AtomicString> new_custom_properties;
+    new_custom_properties.ReserveInitialCapacity(custom_properties.size());
+    for (const String& property : custom_properties)
+      new_custom_properties.push_back(AtomicString(property));
+    auto document_definition = std::make_unique<DocumentPaintDefinition>(
+        std::move(native_properties), std::move(new_custom_properties),
+        std::move(input_argument_types), alpha);
+    document_definition_map_.insert(name, std::move(document_definition));
+  }
+  DocumentPaintDefinition* document_definition =
+      document_definition_map_.at(name);
+  // We are looking for kNumGlobalScopesPerThread number of definitions
+  // registered from RegisterCSSPaintDefinition and one extra definition from
+  // RegisterMainThreadDocumentPaintDefinition
+  if (document_definition->GetRegisteredDefinitionCount() ==
+      kNumGlobalScopesPerThread + 1)
+    pending_generator_registry_->NotifyGeneratorReady(name);
 }
 
 bool PaintWorklet::NeedsToCreateGlobalScope() {