Convert global MutationObserver data to per-agent

Convert the global MutationObserver data, active_mutation_observers, suspended_mutation_observers, and active_slot_change_list to per agent.

Introduces the MutationObserverNotifier class which is created for every WindowAgent.
MutationObserverNotifier now manages active_mutation_observers, suspended_mutation_observers, and active_slot_change_list.

Also the Document's agent is now set using the ContextDocument frame's WindowAgentFactory.
This is because some Documents such as those created with DOMImplementation.createHTMLDocument do not have a frame.
Some Documents created in unit tests have neither a ContextDocument nor a frame so we assign a new WindowAgent.
In theory agent's are tied to ExecutionContexts, and these Documents that do not have an ExecutionContext should not have their own WindowAgent.

Bug: 961186
Change-Id: Ie36a64791a3e1b424bcbf248b083fdf1bf5d465d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1655412
Commit-Queue: Keishi Hattori <keishi@chromium.org>
Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: Kouhei Ueno <kouhei@chromium.org>
Reviewed-by: Yuta Kitamura <yutak@chromium.org>
Reviewed-by: Hayato Ito <hayato@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#669571}

third_party/blink/renderer/core/dom/BUILD.gn

@@ -170,6 +170,8 @@ blink_core_sources("dom") {
     "mutation_observer.h",
     "mutation_observer_interest_group.cc",
     "mutation_observer_interest_group.h",
+    "mutation_observer_notifier.cc",
+    "mutation_observer_notifier.h",
     "mutation_observer_registration.cc",
     "mutation_observer_registration.h",
     "mutation_record.cc",

third_party/blink/renderer/core/dom/document.cc

@@ -115,6 +115,7 @@
 #include "third_party/blink/renderer/core/dom/layout_tree_builder_traversal.h"
 #include "third_party/blink/renderer/core/dom/live_node_list.h"
 #include "third_party/blink/renderer/core/dom/mutation_observer.h"
+#include "third_party/blink/renderer/core/dom/mutation_observer_notifier.h"
 #include "third_party/blink/renderer/core/dom/node_child_removal_tracker.h"
 #include "third_party/blink/renderer/core/dom/node_computed_style.h"
 #include "third_party/blink/renderer/core/dom/node_iterator.h"
@@ -745,20 +746,28 @@ Document::Document(const DocumentInit& initializer,
   }
 
   InitSecurityContext(initializer);
-  if (frame_) {
+  if (frame_)
     frame_->Client()->DidSetFramePolicyHeaders(GetSandboxFlags(), {});
 
+  Document* context_document = ContextDocument();
+  if (context_document) {
+    Frame* context_document_frame = context_document->GetFrame();
+    CHECK(context_document_frame);
     bool has_potential_universal_access_privilege = false;
-    if (Settings* settings = GetSettings()) {
+    if (Settings* settings = context_document_frame->GetSettings()) {
       // TODO(keishi): Also check if AllowUniversalAccessFromFileURLs might
       // dynamically change.
       if (!settings->GetWebSecurityEnabled() ||
           settings->GetAllowUniversalAccessFromFileURLs())
         has_potential_universal_access_privilege = true;
     }
-    SetAgent(frame_->window_agent_factory().GetAgentForOrigin(
+    SetAgent(context_document_frame->window_agent_factory().GetAgentForOrigin(
         has_potential_universal_access_privilege, GetIsolate(),
         GetSecurityOrigin()));
+  } else {
+    // ContextDocument is null only for Documents created in unit tests.
+    // In that case, use a throw away WindowAgent.
+    SetAgent(MakeGarbageCollected<WindowAgent>(GetIsolate()));
   }
 
   InitDNSPrefetch();
@@ -6916,7 +6925,7 @@ void Document::TasksWereUnpaused() {
   if (scripted_animation_controller_)
     scripted_animation_controller_->Unpause();
 
-  MutationObserver::ResumeSuspendedObservers();
+  GetAgent().GetMutationObserverNotifier().ResumeSuspendedObservers();
   if (dom_window_)
     DOMWindowPerformance::performance(*dom_window_)->ResumeSuspendedObservers();
 }
@@ -7895,6 +7904,10 @@ LazyLoadImageObserver& Document::EnsureLazyLoadImageObserver() {
   return *lazy_load_image_observer_;
 }
 
+WindowAgent& Document::GetAgent() {
+  return *static_cast<WindowAgent*>(ExecutionContext::GetAgent());
+}
+
 void Document::CountPotentialFeaturePolicyViolation(
     mojom::FeaturePolicyFeature feature) const {
   size_t index = static_cast<size_t>(feature);

third_party/blink/renderer/core/dom/document.h

@@ -99,6 +99,7 @@ class CanvasFontCache;
 class ChromeClient;
 class Comment;
 class ComputedAccessibleNode;
+class WindowAgent;
 class ComputedStyle;
 class ConsoleMessage;
 class ContextFeatures;
@@ -1478,6 +1479,9 @@ class CORE_EXPORT Document : public ContainerNode,
 
   LazyLoadImageObserver& EnsureLazyLoadImageObserver();
 
+  // Agent may be null for Documents created in unit tests.
+  WindowAgent& GetAgent();
+
   // TODO(binji): See http://crbug.com/798572. This implementation shares the
   // same agent cluster ID for any one document. The proper implementation of
   // this function must follow the rules described here:

third_party/blink/renderer/core/dom/mutation_observer.cc

@@ -36,10 +36,12 @@
 #include "third_party/blink/renderer/bindings/core/v8/v8_mutation_callback.h"
 #include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/dom/mutation_observer_init.h"
+#include "third_party/blink/renderer/core/dom/mutation_observer_notifier.h"
 #include "third_party/blink/renderer/core/dom/mutation_observer_registration.h"
 #include "third_party/blink/renderer/core/dom/mutation_record.h"
 #include "third_party/blink/renderer/core/dom/node.h"
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"
+#include "third_party/blink/renderer/core/execution_context/window_agent.h"
 #include "third_party/blink/renderer/core/html/html_slot_element.h"
 #include "third_party/blink/renderer/core/probe/core_probes.h"
 #include "third_party/blink/renderer/platform/bindings/exception_state.h"
@@ -83,15 +85,6 @@ class MutationObserver::V8DelegateImpl final
   Member<V8MutationCallback> callback_;
 };
 
-static unsigned g_observer_priority = 0;
-
-struct MutationObserver::ObserverLessThan {
-  bool operator()(const Member<MutationObserver>& lhs,
-                  const Member<MutationObserver>& rhs) {
-    return lhs->priority_ < rhs->priority_;
-  }
-};
-
 MutationObserver* MutationObserver::Create(Delegate* delegate) {
   DCHECK(IsMainThread());
   return MakeGarbageCollected<MutationObserver>(delegate->GetExecutionContext(),
@@ -108,9 +101,12 @@ MutationObserver* MutationObserver::Create(ScriptState* script_state,
 
 MutationObserver::MutationObserver(ExecutionContext* execution_context,
                                    Delegate* delegate)
-    : ContextClient(execution_context),
-      delegate_(delegate),
-      priority_(g_observer_priority++) {}
+    : ContextClient(execution_context), delegate_(delegate) {
+  priority_ = GetDocument()
+                  ->GetAgent()
+                  .GetMutationObserverNotifier()
+                  .NextObserverPriority();
+}
 
 MutationObserver::~MutationObserver() {
   CancelInspectorAsyncTasks();
@@ -221,66 +217,35 @@ void MutationObserver::ObservationEnded(
   registrations_.erase(registration);
 }
 
-static MutationObserverSet& ActiveMutationObservers() {
-  DEFINE_STATIC_LOCAL(Persistent<MutationObserverSet>, active_observers,
-                      (MakeGarbageCollected<MutationObserverSet>()));
-  return *active_observers;
-}
-
-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/C/#unit-of-related-similar-origin-browsing-contexts
-static SlotChangeList& ActiveSlotChangeList() {
-  DEFINE_STATIC_LOCAL(Persistent<SlotChangeList>, slot_change_list,
-                      (MakeGarbageCollected<SlotChangeList>()));
-  return *slot_change_list;
-}
-
-static MutationObserverSet& SuspendedMutationObservers() {
-  DEFINE_STATIC_LOCAL(Persistent<MutationObserverSet>, suspended_observers,
-                      (MakeGarbageCollected<MutationObserverSet>()));
-  return *suspended_observers;
-}
-
-static void EnsureEnqueueMicrotask() {
-  if (ActiveMutationObservers().IsEmpty() && ActiveSlotChangeList().IsEmpty())
-    Microtask::EnqueueMicrotask(WTF::Bind(&MutationObserver::DeliverMutations));
-}
-
+// static
 void MutationObserver::EnqueueSlotChange(HTMLSlotElement& slot) {
   DCHECK(IsMainThread());
-  EnsureEnqueueMicrotask();
-  ActiveSlotChangeList().push_back(&slot);
+  slot.GetDocument().GetAgent().GetMutationObserverNotifier().EnqueueSlotChange(
+      slot);
 }
 
+// static
 void MutationObserver::CleanSlotChangeList(Document& document) {
-  SlotChangeList kept;
-  kept.ReserveCapacity(ActiveSlotChangeList().size());
-  for (auto& slot : ActiveSlotChangeList()) {
-    if (slot->GetDocument() != document)
-      kept.push_back(slot);
-  }
-  ActiveSlotChangeList().swap(kept);
+  document.GetAgent().GetMutationObserverNotifier().CleanSlotChangeList(
+      document);
 }
 
-static void ActivateObserver(MutationObserver* observer) {
-  EnsureEnqueueMicrotask();
-  ActiveMutationObservers().insert(observer);
+void MutationObserver::Activate() {
+  GetDocument()->GetAgent().GetMutationObserverNotifier().ActivateObserver(
+      this);
 }
 
 void MutationObserver::EnqueueMutationRecord(MutationRecord* mutation) {
   DCHECK(IsMainThread());
   records_.push_back(mutation);
-  ActivateObserver(this);
+  Activate();
   probe::AsyncTaskScheduled(delegate_->GetExecutionContext(), mutation->type(),
                             mutation);
 }
 
 void MutationObserver::SetHasTransientRegistration() {
   DCHECK(IsMainThread());
-  ActivateObserver(this);
+  Activate();
 }
 
 HeapHashSet<Member<Node>> MutationObserver::GetObservedNodes() const {
@@ -326,52 +291,6 @@ void MutationObserver::Deliver() {
   delegate_->Deliver(records, *this);
 }
 
-void MutationObserver::ResumeSuspendedObservers() {
-  DCHECK(IsMainThread());
-  if (SuspendedMutationObservers().IsEmpty())
-    return;
-
-  MutationObserverVector suspended;
-  CopyToVector(SuspendedMutationObservers(), suspended);
-  for (const auto& observer : suspended) {
-    if (!observer->ShouldBeSuspended()) {
-      SuspendedMutationObservers().erase(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;
-  slots.swap(ActiveSlotChangeList());
-  for (const auto& slot : slots)
-    slot->ClearSlotChangeEventEnqueued();
-
-  std::sort(observers.begin(), observers.end(), ObserverLessThan());
-  for (const auto& observer : observers) {
-    if (!observer->GetExecutionContext()) {
-      // The observer's execution context is already gone, as active observers
-      // intentionally do not hold their execution context. Do nothing then.
-      continue;
-    }
-
-    if (observer->ShouldBeSuspended())
-      SuspendedMutationObservers().insert(observer);
-    else
-      observer->Deliver();
-  }
-  for (const auto& slot : slots)
-    slot->DispatchSlotChangeEvent();
-}
-
 void MutationObserver::Trace(Visitor* visitor) {
   visitor->Trace(delegate_);
   visitor->Trace(records_);

third_party/blink/renderer/core/dom/mutation_observer.h

@@ -56,10 +56,8 @@ class Node;
 class ScriptState;
 class V8MutationCallback;
 
-using MutationObserverSet = HeapHashSet<Member<MutationObserver>>;
 using MutationObserverRegistrationSet =
     HeapHashSet<WeakMember<MutationObserverRegistration>>;
-using MutationObserverVector = HeapVector<Member<MutationObserver>>;
 using MutationRecordVector = HeapVector<Member<MutationRecord>>;
 
 class CORE_EXPORT MutationObserver final
@@ -94,8 +92,6 @@ class CORE_EXPORT MutationObserver final
 
   static MutationObserver* Create(Delegate*);
   static MutationObserver* Create(ScriptState*, V8MutationCallback*);
-  static void ResumeSuspendedObservers();
-  static void DeliverMutations();
   static void EnqueueSlotChange(HTMLSlotElement&);
   static void CleanSlotChangeList(Document&);
 
@@ -118,12 +114,14 @@ class CORE_EXPORT MutationObserver final
   EAGERLY_FINALIZE();
   void Trace(Visitor*) override;
 
- private:
-  struct ObserverLessThan;
-
+  // Methods to be used by MutationObserverNotifier
   void Deliver();
   bool ShouldBeSuspended() const;
   void CancelInspectorAsyncTasks();
+  unsigned priority() { return priority_; }
+
+ private:
+  void Activate();
 
   Member<Delegate> delegate_;
   HeapVector<Member<MutationRecord>> records_;

third_party/blink/renderer/core/dom/mutation_observer_notifier.cc

+// Copyright 2019 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 "third_party/blink/renderer/core/dom/mutation_observer_notifier.h"
+
+#include "third_party/blink/renderer/core/dom/mutation_observer.h"
+#include "third_party/blink/renderer/core/html/html_slot_element.h"
+#include "third_party/blink/renderer/platform/bindings/microtask.h"
+
+namespace blink {
+
+MutationObserverNotifier::MutationObserverNotifier() {}
+
+void MutationObserverNotifier::EnqueueSlotChange(HTMLSlotElement& slot) {
+  EnqueueMicrotaskIfNecessary();
+  active_slot_change_list_.push_back(&slot);
+}
+
+void MutationObserverNotifier::CleanSlotChangeList(Document& document) {
+  SlotChangeList kept;
+  kept.ReserveCapacity(active_slot_change_list_.size());
+  for (auto& slot : active_slot_change_list_) {
+    if (slot->GetDocument() != document)
+      kept.push_back(slot);
+  }
+  active_slot_change_list_.swap(kept);
+}
+
+void MutationObserverNotifier::ActivateObserver(MutationObserver* observer) {
+  EnqueueMicrotaskIfNecessary();
+  active_mutation_observers_.insert(observer);
+}
+
+void MutationObserverNotifier::EnqueueMicrotaskIfNecessary() {
+  if (microtask_enqueued_) {
+    return;
+  }
+
+  // If this is called before inserting the observer or slot, they should both
+  // be empty.
+  DCHECK(active_mutation_observers_.IsEmpty());
+  DCHECK(active_slot_change_list_.IsEmpty());
+
+  microtask_enqueued_ = true;
+  Microtask::EnqueueMicrotask(WTF::Bind(
+      &MutationObserverNotifier::DeliverMutations, WrapPersistent(this)));
+}
+
+struct MutationObserverNotifier::ObserverLessThan {
+  bool operator()(const Member<MutationObserver>& lhs,
+                  const Member<MutationObserver>& rhs) {
+    return lhs->priority() < rhs->priority();
+  }
+};
+
+void MutationObserverNotifier::DeliverMutations() {
+  // These steps are defined in DOM Standard's "notify mutation observers".
+  // https://dom.spec.whatwg.org/#notify-mutation-observers
+  DCHECK(IsMainThread());
+
+  microtask_enqueued_ = false;
+
+  MutationObserverVector observers;
+  CopyToVector(active_mutation_observers_, observers);
+  active_mutation_observers_.clear();
+
+  SlotChangeList slots;
+  slots.swap(active_slot_change_list_);
+  for (const auto& slot : slots)
+    slot->ClearSlotChangeEventEnqueued();
+
+  std::sort(observers.begin(), observers.end(), ObserverLessThan());
+  for (const auto& observer : observers) {
+    if (!observer->GetExecutionContext()) {
+      // The observer's execution context is already gone, as active observers
+      // intentionally do not hold their execution context. Do nothing then.
+      continue;
+    }
+
+    if (observer->ShouldBeSuspended())
+      suspended_mutation_observers_.insert(observer);
+    else
+      observer->Deliver();
+  }
+  for (const auto& slot : slots)
+    slot->DispatchSlotChangeEvent();
+}
+
+void MutationObserverNotifier::ResumeSuspendedObservers() {
+  DCHECK(IsMainThread());
+  if (suspended_mutation_observers_.IsEmpty())
+    return;
+
+  MutationObserverVector suspended;
+  CopyToVector(suspended_mutation_observers_, suspended);
+  for (const auto& observer : suspended) {
+    if (!observer->ShouldBeSuspended()) {
+      suspended_mutation_observers_.erase(observer);
+      ActivateObserver(observer);
+    }
+  }
+}
+
+unsigned MutationObserverNotifier::NextObserverPriority() {
+  return ++last_observer_priority_;
+}
+
+void MutationObserverNotifier::Trace(Visitor* visitor) {
+  visitor->Trace(active_mutation_observers_);
+  visitor->Trace(suspended_mutation_observers_);
+  visitor->Trace(active_slot_change_list_);
+}
+
+}  // namespace blink

third_party/blink/renderer/core/dom/mutation_observer_notifier.h

+// Copyright 2019 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 THIRD_PARTY_BLINK_RENDERER_CORE_DOM_MUTATION_OBSERVER_NOTIFIER_H_
+#define THIRD_PARTY_BLINK_RENDERER_CORE_DOM_MUTATION_OBSERVER_NOTIFIER_H_
+
+#include "third_party/blink/renderer/platform/heap/handle.h"
+
+namespace blink {
+
+class Document;
+class MutationObserver;
+class HTMLSlotElement;
+
+// In charge of mutation observer related state that should be managed per
+// WindowAgent.
+class MutationObserverNotifier final
+    : public GarbageCollectedFinalized<MutationObserverNotifier> {
+ public:
+  MutationObserverNotifier();
+
+  void Trace(Visitor*);
+
+  void EnqueueSlotChange(HTMLSlotElement&);
+  void CleanSlotChangeList(Document&);
+  void ActivateObserver(MutationObserver*);
+  void ResumeSuspendedObservers();
+  // Returns the priority that should be assigned to the next MutationObserver.
+  unsigned NextObserverPriority();
+
+  // Callback called to deliver the accumulated mutations.
+  void DeliverMutations();
+
+ private:
+  struct ObserverLessThan;
+
+  // Schedules the DeliverMutations() callback if necessary.
+  void EnqueueMicrotaskIfNecessary();
+
+  using MutationObserverSet = HeapHashSet<Member<MutationObserver>>;
+  using SlotChangeList = HeapVector<Member<HTMLSlotElement>>;
+  using MutationObserverVector = HeapVector<Member<MutationObserver>>;
+
+  bool microtask_enqueued_ = false;
+  MutationObserverSet active_mutation_observers_;
+  MutationObserverSet suspended_mutation_observers_;
+  SlotChangeList active_slot_change_list_;
+  unsigned last_observer_priority_ = 0;
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_CORE_DOM_MUTATION_OBSERVER_NOTIFIER_H_

third_party/blink/renderer/core/execution_context/window_agent.cc

@@ -3,18 +3,21 @@
 // found in the LICENSE file.
 
 #include "third_party/blink/renderer/core/execution_context/window_agent.h"
-#include "third_party/blink/renderer/core/dom/mutation_observer.h"
-#include "third_party/blink/renderer/core/html/custom/custom_element_reaction_stack.h"
-#include "third_party/blink/renderer/platform/scheduler/public/event_loop.h"
+
+#include "third_party/blink/renderer/core/dom/mutation_observer_notifier.h"
 
 namespace blink {
 
-WindowAgent::WindowAgent(v8::Isolate* isolate) : Agent(isolate) {}
+WindowAgent::WindowAgent(v8::Isolate* isolate)
+    : Agent(isolate),
+      mutation_observer_notifier_(
+          MakeGarbageCollected<MutationObserverNotifier>()) {}
 
 WindowAgent::~WindowAgent() = default;
 
 void WindowAgent::Trace(Visitor* visitor) {
   Agent::Trace(visitor);
+  visitor->Trace(mutation_observer_notifier_);
 }
 
 }  // namespace blink

third_party/blink/renderer/core/execution_context/window_agent.h

@@ -6,7 +6,6 @@
 #define THIRD_PARTY_BLINK_RENDERER_CORE_EXECUTION_CONTEXT_WINDOW_AGENT_H_
 
 #include "third_party/blink/renderer/core/execution_context/agent.h"
-#include "third_party/blink/renderer/platform/heap/heap.h"
 
 namespace v8 {
 class Isolate;
@@ -14,6 +13,8 @@ class Isolate;
 
 namespace blink {
 
+class MutationObserverNotifier;
+
 // This corresponds to similar-origin window agent, that is shared by a group
 // of Documents that are mutually reachable and have the same-site origins.
 // https://html.spec.whatwg.org/C#similar-origin-window-agent
@@ -29,10 +30,16 @@ class WindowAgent final : public Agent {
 
   void Trace(blink::Visitor*) override;
 
+  MutationObserverNotifier& GetMutationObserverNotifier() {
+    return *mutation_observer_notifier_;
+  }
+
  private:
+  // For MutationObserver.
+  Member<MutationObserverNotifier> mutation_observer_notifier_;
+
   // TODO(tzik): Move per-agent data here with the correct granularity.
-  // E.g. ActiveMutationObservers and CustomElementReactionStack should move
-  // here.
+  // E.g. CustomElementReactionStack should move here.
 };
 
 }  // namespace blink