Dispatch slotchange events in "notify mutation observers" steps

third_party/WebKit/Source/core/dom/MutationObserver.cpp

 /*
  * Copyright (C) 2011 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 19 matching lines @@
 
 #include "core/dom/MutationObserver.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/Microtask.h"
 #include "core/dom/MutationCallback.h"
 #include "core/dom/MutationObserverInit.h"
 #include "core/dom/MutationObserverRegistration.h"
 #include "core/dom/MutationRecord.h"
 #include "core/dom/Node.h"
+#include "core/html/HTMLSlotElement.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include <algorithm>
 
 namespace blink {
 
 static unsigned s_observerPriority = 0;
 
 struct MutationObserver::ObserverLessThan {
   bool operator()(const Member<MutationObserver>& lhs,
                   const Member<MutationObserver>& rhs) {
@@ skipping 114 matching lines @@
   DCHECK(m_registrations.contains(registration));
   m_registrations.remove(registration);
 }
 
 static MutationObserverSet& activeMutationObservers() {
   DEFINE_STATIC_LOCAL(MutationObserverSet, activeObservers,
                       (new MutationObserverSet));
   return activeObservers;
 }
 
+using SlotChangeList = HeapVector<Member<HTMLSlotElement>>;
+
+// TODO(hayato): We should have a SlotChangeList for each unit of related
+// similar-origin browsing context.
+// https://html.spec.whatwg.org/multipage/browsers.html#unit-of-related-similar-origin-browsing-contexts
+static SlotChangeList& activeSlotChangeList() {
+  DEFINE_STATIC_LOCAL(SlotChangeList, slotChangeList, (new SlotChangeList));

[tkent, 2017/01/11 11:24:17]

I'm afraid static strong references to HTMLSlotElements can cause memory leak. 
Is this safe?

[hayato, 2017/01/12 03:47:41]

The content of |slotlist| is always cleared at the timing of microtask. Thus, I
do not think memory leak would happen.

Rather, I had a concern about using HeapVector in a function static variable.
Does Oilpan trace it?
It looks existing code, e.g. activeMutationObservers(), uses
HeapHashSet<Member<MutationObserver>>, in a function static local. Thus, I
thought it is okay.

[tkent, 2017/01/12 06:24:35]

Is the microtask guaranteed to be executed?  Is v8::Isolate::TearDown() never
called when its microtask queue is not empty?
It's ok.  DEFINE_STATIC_LOCAL uses Persistent<T> internally for Oilpan objects.

+  return slotChangeList;
+}
+
 static MutationObserverSet& suspendedMutationObservers() {
   DEFINE_STATIC_LOCAL(MutationObserverSet, suspendedObservers,
                       (new MutationObserverSet));
   return suspendedObservers;
 }
 
+static void ensureEnqueueMicrotask() {
+  if (activeMutationObservers().isEmpty() && activeSlotChangeList().isEmpty())
+    Microtask::enqueueMicrotask(WTF::bind(&MutationObserver::deliverMutations));
+}
+
+void MutationObserver::enqueueSlotChange(HTMLSlotElement& slot) {
+  DCHECK(isMainThread());
+  ensureEnqueueMicrotask();
+  activeSlotChangeList().push_back(&slot);
+}
+
 static void activateObserver(MutationObserver* observer) {
-  if (activeMutationObservers().isEmpty())
-    Microtask::enqueueMicrotask(WTF::bind(&MutationObserver::deliverMutations));
-
+  ensureEnqueueMicrotask();
   activeMutationObservers().add(observer);
 }
 
 void MutationObserver::enqueueMutationRecord(MutationRecord* mutation) {
   DCHECK(isMainThread());
   m_records.push_back(mutation);
   activateObserver(this);
   InspectorInstrumentation::asyncTaskScheduled(
       m_callback->getExecutionContext(), mutation->type(), mutation);
 }
@@ skipping 56 matching lines @@
   copyToVector(suspendedMutationObservers(), suspended);
   for (const auto& observer : suspended) {
     if (!observer->shouldBeSuspended()) {
       suspendedMutationObservers().remove(observer);
       activateObserver(observer);
     }
   }
 }
 
 void MutationObserver::deliverMutations() {
+  // These steps are defined in DOM Standard's "notify mutation observers".
+  // https://dom.spec.whatwg.org/#notify-mutation-observers
   DCHECK(isMainThread());
+
   MutationObserverVector observers;
   copyToVector(activeMutationObservers(), observers);
   activeMutationObservers().clear();
+
+  SlotChangeList slots;
+  copyToVector(activeSlotChangeList(), slots);

[tkent, 2017/01/11 11:24:17]

slots.swap(activeSlotChangeList()) should work.

[hayato, 2017/01/12 03:47:41]

Done

+  activeSlotChangeList().clear();
+  for (const auto& slot : slots)
+    slot->clearSlotChangeEventEnqueued();
+
   std::sort(observers.begin(), observers.end(), ObserverLessThan());
   for (const auto& observer : observers) {
     if (observer->shouldBeSuspended())
       suspendedMutationObservers().add(observer);
     else
       observer->deliver();
   }
+  for (const auto& slot : slots)
+    slot->dispatchSlotChangeEvent();
 }
 
 DEFINE_TRACE(MutationObserver) {
   visitor->trace(m_callback);
   visitor->trace(m_records);
   visitor->trace(m_registrations);
   visitor->trace(m_callback);
 }
 
 }  // namespace blink