summaryrefslogtreecommitdiffstats
path: root/dom/base
diff options
context:
space:
mode:
Diffstat (limited to 'dom/base')
-rw-r--r--dom/base/ResizeObserver.cpp304
-rw-r--r--dom/base/ResizeObserver.h254
-rw-r--r--dom/base/ResizeObserverController.cpp234
-rw-r--r--dom/base/ResizeObserverController.h129
-rw-r--r--dom/base/WindowNamedPropertiesHandler.h2
-rw-r--r--dom/base/crashtests/1251361.html33
-rw-r--r--dom/base/crashtests/371466-1.xhtml24
-rw-r--r--dom/base/crashtests/535926-1.html28
-rwxr-xr-xdom/base/moz.build4
-rw-r--r--dom/base/nsAttrValue.h4
-rw-r--r--dom/base/nsContentUtils.cpp16
-rw-r--r--dom/base/nsContentUtils.h8
-rw-r--r--dom/base/nsDocument.cpp28
-rw-r--r--dom/base/nsDocument.h8
-rw-r--r--dom/base/nsGkAtomList.h1
-rw-r--r--dom/base/nsGlobalWindow.cpp4
-rw-r--r--dom/base/nsIDocument.h5
-rw-r--r--dom/base/nsJSEnvironment.cpp2
-rw-r--r--dom/base/test/test_bug840098.html2
-rw-r--r--dom/base/test/test_caretPositionFromPoint.html2
-rw-r--r--dom/base/test/test_mutationobservers.html913
21 files changed, 996 insertions, 1009 deletions
diff --git a/dom/base/ResizeObserver.cpp b/dom/base/ResizeObserver.cpp
new file mode 100644
index 000000000..37d940c2b
--- /dev/null
+++ b/dom/base/ResizeObserver.cpp
@@ -0,0 +1,304 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/ResizeObserver.h"
+
+#include "mozilla/dom/DOMRect.h"
+#include "nsContentUtils.h"
+#include "nsIFrame.h"
+#include "nsSVGUtils.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ResizeObserver)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(ResizeObserver)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(ResizeObserver)
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(ResizeObserver)
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(ResizeObserver)
+ NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(ResizeObserver)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mOwner)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mCallback)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mObservationMap)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(ResizeObserver)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOwner)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCallback)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mObservationMap)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+already_AddRefed<ResizeObserver>
+ResizeObserver::Constructor(const GlobalObject& aGlobal,
+ ResizeObserverCallback& aCb,
+ ErrorResult& aRv)
+{
+ nsCOMPtr<nsPIDOMWindowInner> window =
+ do_QueryInterface(aGlobal.GetAsSupports());
+
+ if (!window) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ nsCOMPtr<nsIDocument> document = window->GetExtantDoc();
+
+ if (!document) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ RefPtr<ResizeObserver> observer = new ResizeObserver(window.forget(), aCb);
+ document->AddResizeObserver(observer);
+
+ return observer.forget();
+}
+
+void
+ResizeObserver::Observe(Element* aTarget,
+ ErrorResult& aRv)
+{
+ if (!aTarget) {
+ aRv.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
+ return;
+ }
+
+ RefPtr<ResizeObservation> observation;
+
+ if (!mObservationMap.Get(aTarget, getter_AddRefs(observation))) {
+ observation = new ResizeObservation(this, aTarget);
+
+ mObservationMap.Put(aTarget, observation);
+ mObservationList.insertBack(observation);
+
+ // Per the spec, we need to trigger notification in event loop that
+ // contains ResizeObserver observe call even when resize/reflow does
+ // not happen.
+ aTarget->OwnerDoc()->ScheduleResizeObserversNotification();
+ }
+}
+
+void
+ResizeObserver::Unobserve(Element* aTarget,
+ ErrorResult& aRv)
+{
+ if (!aTarget) {
+ aRv.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
+ return;
+ }
+
+ RefPtr<ResizeObservation> observation;
+
+ if (mObservationMap.Get(aTarget, getter_AddRefs(observation))) {
+ mObservationMap.Remove(aTarget);
+
+ MOZ_ASSERT(!mObservationList.isEmpty(),
+ "If ResizeObservation found for an element, observation list "
+ "must be not empty.");
+
+ observation->remove();
+ }
+}
+
+void
+ResizeObserver::Disconnect()
+{
+ mObservationMap.Clear();
+ mObservationList.clear();
+ mActiveTargets.Clear();
+}
+
+void
+ResizeObserver::GatherActiveObservations(uint32_t aDepth)
+{
+ mActiveTargets.Clear();
+ mHasSkippedTargets = false;
+
+ for (auto observation : mObservationList) {
+ if (observation->IsActive()) {
+ uint32_t targetDepth =
+ nsContentUtils::GetNodeDepth(observation->Target());
+
+ if (targetDepth > aDepth) {
+ mActiveTargets.AppendElement(observation);
+ } else {
+ mHasSkippedTargets = true;
+ }
+ }
+ }
+}
+
+bool
+ResizeObserver::HasActiveObservations() const
+{
+ return !mActiveTargets.IsEmpty();
+}
+
+bool
+ResizeObserver::HasSkippedObservations() const
+{
+ return mHasSkippedTargets;
+}
+
+uint32_t
+ResizeObserver::BroadcastActiveObservations()
+{
+ uint32_t shallowestTargetDepth = UINT32_MAX;
+
+ if (HasActiveObservations()) {
+ Sequence<OwningNonNull<ResizeObserverEntry>> entries;
+
+ for (auto observation : mActiveTargets) {
+ RefPtr<ResizeObserverEntry> entry =
+ new ResizeObserverEntry(this, observation->Target());
+
+ nsRect rect = observation->GetTargetRect();
+ entry->SetContentRect(rect);
+
+ if (!entries.AppendElement(entry.forget(), fallible)) {
+ // Out of memory.
+ break;
+ }
+
+ // Sync the broadcast size of observation so the next size inspection
+ // will be based on the updated size from last delivered observations.
+ observation->UpdateBroadcastSize(rect);
+
+ uint32_t targetDepth =
+ nsContentUtils::GetNodeDepth(observation->Target());
+
+ if (targetDepth < shallowestTargetDepth) {
+ shallowestTargetDepth = targetDepth;
+ }
+ }
+
+ mCallback->Call(this, entries, *this);
+ mActiveTargets.Clear();
+ mHasSkippedTargets = false;
+ }
+
+ return shallowestTargetDepth;
+}
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ResizeObserverEntry)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(ResizeObserverEntry)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(ResizeObserverEntry)
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ResizeObserverEntry,
+ mTarget, mContentRect,
+ mOwner)
+
+already_AddRefed<ResizeObserverEntry>
+ResizeObserverEntry::Constructor(const GlobalObject& aGlobal,
+ Element* aTarget,
+ ErrorResult& aRv)
+{
+ RefPtr<ResizeObserverEntry> observerEntry =
+ new ResizeObserverEntry(aGlobal.GetAsSupports(), aTarget);
+ return observerEntry.forget();
+}
+
+void
+ResizeObserverEntry::SetContentRect(nsRect aRect)
+{
+ RefPtr<DOMRect> contentRect = new DOMRect(mTarget);
+ nsIFrame* frame = mTarget->GetPrimaryFrame();
+
+ if (frame) {
+ nsMargin padding = frame->GetUsedPadding();
+
+ // Per the spec, we need to include padding in contentRect of
+ // ResizeObserverEntry.
+ aRect.x = padding.left;
+ aRect.y = padding.top;
+ }
+
+ contentRect->SetLayoutRect(aRect);
+ mContentRect = contentRect.forget();
+}
+
+ResizeObserverEntry::~ResizeObserverEntry()
+{
+}
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ResizeObservation)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(ResizeObservation)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(ResizeObservation)
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ResizeObservation,
+ mTarget, mOwner)
+
+already_AddRefed<ResizeObservation>
+ResizeObservation::Constructor(const GlobalObject& aGlobal,
+ Element* aTarget,
+ ErrorResult& aRv)
+{
+ RefPtr<ResizeObservation> observation =
+ new ResizeObservation(aGlobal.GetAsSupports(), aTarget);
+ return observation.forget();
+}
+
+bool
+ResizeObservation::IsActive() const
+{
+ nsRect rect = GetTargetRect();
+ return (rect.width != mBroadcastWidth || rect.height != mBroadcastHeight);
+}
+
+void
+ResizeObservation::UpdateBroadcastSize(nsRect aRect)
+{
+ mBroadcastWidth = aRect.width;
+ mBroadcastHeight = aRect.height;
+}
+
+nsRect
+ResizeObservation::GetTargetRect() const
+{
+ nsRect rect;
+ nsIFrame* frame = mTarget->GetPrimaryFrame();
+
+ if (frame) {
+ if (mTarget->IsSVGElement()) {
+ gfxRect bbox = nsSVGUtils::GetBBox(frame);
+ rect.width = NSFloatPixelsToAppUnits(bbox.width, AppUnitsPerCSSPixel());
+ rect.height = NSFloatPixelsToAppUnits(bbox.height, AppUnitsPerCSSPixel());
+ } else {
+ // Per the spec, non-replaced inline Elements will always have an empty
+ // content rect.
+ if (frame->IsFrameOfType(nsIFrame::eReplaced) ||
+ !frame->IsFrameOfType(nsIFrame::eLineParticipant)) {
+ rect = frame->GetContentRectRelativeToSelf();
+ }
+ }
+ }
+
+ return rect;
+}
+
+ResizeObservation::~ResizeObservation()
+{
+}
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/base/ResizeObserver.h b/dom/base/ResizeObserver.h
new file mode 100644
index 000000000..2f56c580f
--- /dev/null
+++ b/dom/base/ResizeObserver.h
@@ -0,0 +1,254 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_ResizeObserver_h
+#define mozilla_dom_ResizeObserver_h
+
+#include "mozilla/dom/ResizeObserverBinding.h"
+
+namespace mozilla {
+namespace dom {
+
+/**
+ * ResizeObserver interfaces and algorithms are based on
+ * https://wicg.github.io/ResizeObserver/#api
+ */
+class ResizeObserver final
+ : public nsISupports
+ , public nsWrapperCache
+{
+public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ResizeObserver)
+
+ ResizeObserver(already_AddRefed<nsPIDOMWindowInner>&& aOwner,
+ ResizeObserverCallback& aCb)
+ : mOwner(aOwner)
+ , mCallback(&aCb)
+ {
+ MOZ_ASSERT(mOwner, "Need a non-null owner window");
+ }
+
+ static already_AddRefed<ResizeObserver>
+ Constructor(const GlobalObject& aGlobal,
+ ResizeObserverCallback& aCb,
+ ErrorResult& aRv);
+
+ JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override
+ {
+ return ResizeObserverBinding::Wrap(aCx, this, aGivenProto);
+ }
+
+ nsISupports* GetParentObject() const
+ {
+ return mOwner;
+ }
+
+ void Observe(Element* aTarget, ErrorResult& aRv);
+
+ void Unobserve(Element* aTarget, ErrorResult& aRv);
+
+ void Disconnect();
+
+ /*
+ * Gather all observations which have an observed target with size changed
+ * since last BroadcastActiveObservations() in this ResizeObserver.
+ * An observation will be skipped if the depth of its observed target is less
+ * or equal than aDepth. All gathered observations will be added to
+ * mActiveTargets.
+ */
+ void GatherActiveObservations(uint32_t aDepth);
+
+ /*
+ * Returns whether this ResizeObserver has any active observations
+ * since last GatherActiveObservations().
+ */
+ bool HasActiveObservations() const;
+
+ /*
+ * Returns whether this ResizeObserver has any skipped observations
+ * since last GatherActiveObservations().
+ */
+ bool HasSkippedObservations() const;
+
+ /*
+ * Deliver the callback function in JavaScript for all active observations
+ * and pass the sequence of ResizeObserverEntry so JavaScript can access them.
+ * The broadcast size of observations will be updated and mActiveTargets will
+ * be cleared. It also returns the shallowest depth of elements from active
+ * observations or UINT32_MAX if there is no any active observations.
+ */
+ uint32_t BroadcastActiveObservations();
+
+protected:
+ ~ResizeObserver()
+ {
+ mObservationList.clear();
+ }
+
+ nsCOMPtr<nsPIDOMWindowInner> mOwner;
+ RefPtr<ResizeObserverCallback> mCallback;
+ nsTArray<RefPtr<ResizeObservation>> mActiveTargets;
+ bool mHasSkippedTargets;
+
+ // Combination of HashTable and LinkedList so we can iterate through
+ // the elements of HashTable in order of insertion time.
+ // Will be nice if we have our own data structure for this in the future.
+ nsRefPtrHashtable<nsPtrHashKey<Element>, ResizeObservation> mObservationMap;
+ LinkedList<ResizeObservation> mObservationList;
+};
+
+/**
+ * ResizeObserverEntry is the entry that contains the information for observed
+ * elements. This object is the one that visible to JavaScript in callback
+ * function that is fired by ResizeObserver.
+ */
+class ResizeObserverEntry final
+ : public nsISupports
+ , public nsWrapperCache
+{
+public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ResizeObserverEntry)
+
+ ResizeObserverEntry(nsISupports* aOwner, Element* aTarget)
+ : mOwner(aOwner)
+ , mTarget(aTarget)
+ {
+ MOZ_ASSERT(mOwner, "Need a non-null owner");
+ MOZ_ASSERT(mTarget, "Need a non-null target element");
+ }
+
+ static already_AddRefed<ResizeObserverEntry>
+ Constructor(const GlobalObject& aGlobal,
+ Element* aTarget,
+ ErrorResult& aRv);
+
+ JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override
+ {
+ return ResizeObserverEntryBinding::Wrap(aCx, this,
+ aGivenProto);
+ }
+
+ nsISupports* GetParentObject() const
+ {
+ return mOwner;
+ }
+
+ Element* Target() const
+ {
+ return mTarget;
+ }
+
+ /*
+ * Returns the DOMRectReadOnly of target's content rect so it can be
+ * accessed from JavaScript in callback function of ResizeObserver.
+ */
+ DOMRectReadOnly* GetContentRect() const
+ {
+ return mContentRect;
+ }
+
+ void SetContentRect(nsRect aRect);
+
+protected:
+ ~ResizeObserverEntry();
+
+ nsCOMPtr<nsISupports> mOwner;
+ nsCOMPtr<Element> mTarget;
+ RefPtr<DOMRectReadOnly> mContentRect;
+};
+
+/**
+ * We use ResizeObservation to store and sync the size information of one
+ * observed element so we can decide whether an observation should be fired
+ * or not.
+ */
+class ResizeObservation final
+ : public nsISupports
+ , public nsWrapperCache
+ , public LinkedListElement<ResizeObservation>
+{
+public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ResizeObservation)
+
+ ResizeObservation(nsISupports* aOwner, Element* aTarget)
+ : mOwner(aOwner)
+ , mTarget(aTarget)
+ , mBroadcastWidth(0)
+ , mBroadcastHeight(0)
+ {
+ MOZ_ASSERT(mOwner, "Need a non-null owner");
+ MOZ_ASSERT(mTarget, "Need a non-null target element");
+ }
+
+ static already_AddRefed<ResizeObservation>
+ Constructor(const GlobalObject& aGlobal,
+ Element* aTarget,
+ ErrorResult& aRv);
+
+ JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override
+ {
+ return ResizeObservationBinding::Wrap(aCx, this, aGivenProto);
+ }
+
+ nsISupports* GetParentObject() const
+ {
+ return mOwner;
+ }
+
+ Element* Target() const
+ {
+ return mTarget;
+ }
+
+ nscoord BroadcastWidth() const
+ {
+ return mBroadcastWidth;
+ }
+
+ nscoord BroadcastHeight() const
+ {
+ return mBroadcastHeight;
+ }
+
+ /*
+ * Returns whether the observed target element size differs from current
+ * BroadcastWidth and BroadcastHeight
+ */
+ bool IsActive() const;
+
+ /*
+ * Update current BroadcastWidth and BroadcastHeight with size from aRect.
+ */
+ void UpdateBroadcastSize(nsRect aRect);
+
+ /*
+ * Returns the target's rect in the form of nsRect.
+ * If the target is SVG, width and height are determined from bounding box.
+ */
+ nsRect GetTargetRect() const;
+
+protected:
+ ~ResizeObservation();
+
+ nsCOMPtr<nsISupports> mOwner;
+ nsCOMPtr<Element> mTarget;
+
+ // Broadcast width and broadcast height are the latest recorded size
+ // of observed target.
+ nscoord mBroadcastWidth;
+ nscoord mBroadcastHeight;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_ResizeObserver_h
+
diff --git a/dom/base/ResizeObserverController.cpp b/dom/base/ResizeObserverController.cpp
new file mode 100644
index 000000000..924bba10d
--- /dev/null
+++ b/dom/base/ResizeObserverController.cpp
@@ -0,0 +1,234 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/ResizeObserverController.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/ErrorEvent.h"
+#include "nsIPresShell.h"
+#include "nsPresContext.h"
+
+namespace mozilla {
+namespace dom {
+
+void
+ResizeObserverNotificationHelper::WillRefresh(TimeStamp aTime)
+{
+ MOZ_ASSERT(mOwner, "Why is mOwner already dead when this RefreshObserver is still registered?");
+ if (mOwner) {
+ mOwner->Notify();
+ }
+}
+
+nsRefreshDriver*
+ResizeObserverNotificationHelper::GetRefreshDriver() const
+{
+ nsIPresShell* presShell = mOwner->GetShell();
+ if (MOZ_UNLIKELY(!presShell)) {
+ return nullptr;
+ }
+
+ nsPresContext* presContext = presShell->GetPresContext();
+ if (MOZ_UNLIKELY(!presContext)) {
+ return nullptr;
+ }
+
+ return presContext->RefreshDriver();
+}
+
+void
+ResizeObserverNotificationHelper::Register()
+{
+ if (mRegistered) {
+ return;
+ }
+
+ nsRefreshDriver* refreshDriver = GetRefreshDriver();
+ if (!refreshDriver) {
+ // We maybe navigating away from this page or currently in an iframe with
+ // display: none. Just abort the Register(), no need to do notification.
+ return;
+ }
+
+ refreshDriver->AddRefreshObserver(this, Flush_Display);
+ mRegistered = true;
+}
+
+void
+ResizeObserverNotificationHelper::Unregister()
+{
+ if (!mRegistered) {
+ return;
+ }
+
+ nsRefreshDriver* refreshDriver = GetRefreshDriver();
+ if (!refreshDriver) {
+ // We can't access RefreshDriver now. Just abort the Unregister().
+ return;
+ }
+
+ refreshDriver->RemoveRefreshObserver(this, Flush_Display);
+ mRegistered = false;
+}
+
+void
+ResizeObserverNotificationHelper::Disconnect()
+{
+ Unregister();
+ // Our owner is dying. Clear our pointer to it, in case we outlive it.
+ mOwner = nullptr;
+}
+
+ResizeObserverNotificationHelper::~ResizeObserverNotificationHelper()
+{
+ Unregister();
+}
+
+void
+ResizeObserverController::Traverse(nsCycleCollectionTraversalCallback& aCb)
+{
+ ImplCycleCollectionTraverse(aCb, mResizeObservers, "mResizeObservers");
+}
+
+void
+ResizeObserverController::Unlink()
+{
+ mResizeObservers.Clear();
+}
+
+void
+ResizeObserverController::AddResizeObserver(ResizeObserver* aObserver)
+{
+ MOZ_ASSERT(aObserver, "AddResizeObserver() should never be called with "
+ "a null parameter");
+ mResizeObservers.AppendElement(aObserver);
+}
+
+void
+ResizeObserverController::Notify()
+{
+ if (mResizeObservers.IsEmpty()) {
+ return;
+ }
+
+ uint32_t shallowestTargetDepth = 0;
+
+ GatherAllActiveObservations(shallowestTargetDepth);
+
+ while (HasAnyActiveObservations()) {
+ DebugOnly<uint32_t> oldShallowestTargetDepth = shallowestTargetDepth;
+ shallowestTargetDepth = BroadcastAllActiveObservations();
+ NS_ASSERTION(oldShallowestTargetDepth < shallowestTargetDepth,
+ "shallowestTargetDepth should be getting strictly deeper");
+
+ // Flush layout, so that any callback functions' style changes / resizes
+ // get a chance to take effect.
+ mDocument->FlushPendingNotifications(Flush_Layout);
+
+ // To avoid infinite resize loop, we only gather all active observations
+ // that have the depth of observed target element more than current
+ // shallowestTargetDepth.
+ GatherAllActiveObservations(shallowestTargetDepth);
+ }
+
+ mResizeObserverNotificationHelper->Unregister();
+
+ // Per spec, we deliver an error if the document has any skipped observations.
+ if (HasAnySkippedObservations()) {
+ RootedDictionary<ErrorEventInit> init(RootingCx());
+
+ init.mMessage.AssignLiteral("ResizeObserver loop completed with undelivered"
+ " notifications.");
+ init.mCancelable = true;
+ init.mBubbles = true;
+
+ nsEventStatus status = nsEventStatus_eIgnore;
+
+ nsCOMPtr<nsPIDOMWindowInner> window =
+ mDocument->GetWindow()->GetCurrentInnerWindow();
+
+ if (window) {
+ nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(window);
+ MOZ_ASSERT(sgo);
+
+ if (NS_WARN_IF(NS_FAILED(sgo->HandleScriptError(init, &status)))) {
+ status = nsEventStatus_eIgnore;
+ }
+ } else {
+ // We don't fire error events at any global for non-window JS on the main
+ // thread.
+ }
+
+ // We need to deliver pending notifications in next cycle.
+ ScheduleNotification();
+ }
+}
+
+void
+ResizeObserverController::GatherAllActiveObservations(uint32_t aDepth)
+{
+ for (auto observer : mResizeObservers) {
+ observer->GatherActiveObservations(aDepth);
+ }
+}
+
+uint32_t
+ResizeObserverController::BroadcastAllActiveObservations()
+{
+ uint32_t shallowestTargetDepth = UINT32_MAX;
+
+ for (auto observer : mResizeObservers) {
+
+ uint32_t targetDepth = observer->BroadcastActiveObservations();
+
+ if (targetDepth < shallowestTargetDepth) {
+ shallowestTargetDepth = targetDepth;
+ }
+ }
+
+ return shallowestTargetDepth;
+}
+
+bool
+ResizeObserverController::HasAnyActiveObservations() const
+{
+ for (auto observer : mResizeObservers) {
+ if (observer->HasActiveObservations()) {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool
+ResizeObserverController::HasAnySkippedObservations() const
+{
+ for (auto observer : mResizeObservers) {
+ if (observer->HasSkippedObservations()) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void
+ResizeObserverController::ScheduleNotification()
+{
+ mResizeObserverNotificationHelper->Register();
+}
+
+nsIPresShell*
+ResizeObserverController::GetShell() const
+{
+ return mDocument->GetShell();
+}
+
+ResizeObserverController::~ResizeObserverController()
+{
+ mResizeObserverNotificationHelper->Disconnect();
+}
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/base/ResizeObserverController.h b/dom/base/ResizeObserverController.h
new file mode 100644
index 000000000..a77511587
--- /dev/null
+++ b/dom/base/ResizeObserverController.h
@@ -0,0 +1,129 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_ResizeObserverController_h
+#define mozilla_dom_ResizeObserverController_h
+
+#include "mozilla/dom/ResizeObserver.h"
+#include "mozilla/TimeStamp.h"
+#include "nsRefreshDriver.h"
+
+namespace mozilla {
+namespace dom {
+
+class ResizeObserverController;
+
+/*
+ * ResizeObserverNotificationHelper will trigger ResizeObserver notifications
+ * by registering with the Refresh Driver.
+*/
+class ResizeObserverNotificationHelper final : public nsARefreshObserver
+{
+public:
+ NS_INLINE_DECL_REFCOUNTING(ResizeObserverNotificationHelper, override)
+
+ explicit ResizeObserverNotificationHelper(ResizeObserverController* aOwner)
+ : mOwner(aOwner)
+ , mRegistered(false)
+ {
+ MOZ_ASSERT(mOwner, "Need a non-null owner");
+ }
+
+ void WillRefresh(TimeStamp aTime) override;
+
+ nsRefreshDriver* GetRefreshDriver() const;
+
+ void Register();
+
+ void Unregister();
+
+ void Disconnect();
+
+protected:
+ virtual ~ResizeObserverNotificationHelper();
+
+ ResizeObserverController* mOwner;
+ bool mRegistered;
+};
+
+/*
+ * ResizeObserverController contains the list of ResizeObservers and controls
+ * the flow of notification.
+*/
+class ResizeObserverController final
+{
+public:
+ explicit ResizeObserverController(nsIDocument* aDocument)
+ : mDocument(aDocument)
+ , mIsNotificationActive(false)
+ {
+ MOZ_ASSERT(mDocument, "Need a non-null document");
+ mResizeObserverNotificationHelper =
+ new ResizeObserverNotificationHelper(this);
+ }
+
+ // Methods for supporting cycle-collection
+ void Traverse(nsCycleCollectionTraversalCallback& aCb);
+ void Unlink();
+
+ void AddResizeObserver(ResizeObserver* aObserver);
+
+ /*
+ * Schedule the notification via ResizeObserverNotificationHelper refresh
+ * observer.
+ */
+ void ScheduleNotification();
+
+ /*
+ * Notify all ResizeObservers by gathering and broadcasting all active
+ * observations.
+ */
+ void Notify();
+
+ nsIPresShell* GetShell() const;
+
+ ~ResizeObserverController();
+
+private:
+ /*
+ * Calls GatherActiveObservations(aDepth) for all ResizeObservers in this
+ * controller. All observations in each ResizeObserver with element's depth
+ * more than aDepth will be gathered.
+ */
+ void GatherAllActiveObservations(uint32_t aDepth);
+
+ /*
+ * Calls BroadcastActiveObservations() for all ResizeObservers in this
+ * controller. It also returns the shallowest depth of observed target
+ * elements from all ResizeObserver or UINT32_MAX if there is no any
+ * active obsevations at all.
+ */
+ uint32_t BroadcastAllActiveObservations();
+
+ /*
+ * Returns whether there is any ResizeObserver that has active observations.
+ */
+ bool HasAnyActiveObservations() const;
+
+ /*
+ * Returns whether there is any ResizeObserver that has skipped observations.
+ */
+ bool HasAnySkippedObservations() const;
+
+protected:
+ // Raw pointer is OK because mDocument strongly owns us & hence must outlive
+ // us.
+ nsIDocument* const mDocument;
+
+ RefPtr<ResizeObserverNotificationHelper> mResizeObserverNotificationHelper;
+ nsTArray<RefPtr<ResizeObserver>> mResizeObservers;
+ bool mIsNotificationActive;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_ResizeObserverController_h
diff --git a/dom/base/WindowNamedPropertiesHandler.h b/dom/base/WindowNamedPropertiesHandler.h
index 227d8c946..cafeadb85 100644
--- a/dom/base/WindowNamedPropertiesHandler.h
+++ b/dom/base/WindowNamedPropertiesHandler.h
@@ -15,7 +15,7 @@ namespace dom {
class WindowNamedPropertiesHandler : public BaseDOMProxyHandler
{
public:
- constexpr WindowNamedPropertiesHandler()
+ WindowNamedPropertiesHandler()
: BaseDOMProxyHandler(nullptr, /* hasPrototype = */ true)
{
}
diff --git a/dom/base/crashtests/1251361.html b/dom/base/crashtests/1251361.html
deleted file mode 100644
index 57c76121f..000000000
--- a/dom/base/crashtests/1251361.html
+++ /dev/null
@@ -1,33 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-<meta charset="UTF-8">
-<script>
-
-var frameRoot;
-
-function boom()
-{
- var frameWin = f.contentWindow;
- frameRoot = frameWin.document.documentElement;
- frameWin.location.replace("data:text/html;charset=UTF-8,<body onload='parent.g();'>2");
-}
-
-function g()
-{
- setTimeout(h, 0);
-}
-
-function h()
-{
- var newDoc = document.implementation.createDocument('', '', null);
- newDoc.adoptNode(frameRoot);
-}
-
-</script>
-<body onload="boom();">
-
-<iframe id="f" src="data:text/html;charset=UTF-8,<marquee>1"></iframe>
-
-</body>
-</html>
diff --git a/dom/base/crashtests/371466-1.xhtml b/dom/base/crashtests/371466-1.xhtml
deleted file mode 100644
index 8da0b22b1..000000000
--- a/dom/base/crashtests/371466-1.xhtml
+++ /dev/null
@@ -1,24 +0,0 @@
-<html xmlns="http://www.w3.org/1999/xhtml" class="reftest-wait">
-<head>
-<script>
-
-function boom()
-{
- var marquee = document.getElementById("marquee");
- var span = document.getElementById("span");
- marquee.appendChild(span);
- marquee.removeChild(span);
- document.documentElement.removeAttribute("class");
-}
-
-</script>
-</head>
-
-<body onload="setTimeout(boom, 30);">
-
-<marquee id="marquee" />
-
-<span id="span"><div>Foo</div><textarea/></span>
-
-</body>
-</html>
diff --git a/dom/base/crashtests/535926-1.html b/dom/base/crashtests/535926-1.html
deleted file mode 100644
index bddd8dc28..000000000
--- a/dom/base/crashtests/535926-1.html
+++ /dev/null
@@ -1,28 +0,0 @@
-<html class="reftest-wait">
-<head>
-
-<script type="text/javascript">
-
-var i = 0;
-function mmf()
-{
- if (++i == 2) {
- document.body.innerHTML = "<marquee>";
- document.documentElement.removeAttribute("class");
- }
-}
-
-function init()
-{
- document.documentElement.offsetHeight;
- for (var j = 0; j < 2; ++j) {
- var iframe = document.createElementNS("http://www.w3.org/1999/xhtml", "iframe");
- iframe.addEventListener("load", mmf, false);
- document.body.appendChild(iframe);
- }
-}
-
-</script>
-</head>
-<body onload="setTimeout(init, 0);"></body>
-</html>
diff --git a/dom/base/moz.build b/dom/base/moz.build
index 1de49424b..65e3c3d76 100755
--- a/dom/base/moz.build
+++ b/dom/base/moz.build
@@ -202,6 +202,8 @@ EXPORTS.mozilla.dom += [
'PartialSHistory.h',
'Pose.h',
'ProcessGlobal.h',
+ 'ResizeObserver.h',
+ 'ResizeObserverController.h',
'ResponsiveImageSelector.h',
'SameProcessMessageQueue.h',
'ScreenOrientation.h',
@@ -347,6 +349,8 @@ SOURCES += [
'Pose.cpp',
'PostMessageEvent.cpp',
'ProcessGlobal.cpp',
+ 'ResizeObserver.cpp',
+ 'ResizeObserverController.cpp',
'ResponsiveImageSelector.cpp',
'SameProcessMessageQueue.cpp',
'ScreenOrientation.cpp',
diff --git a/dom/base/nsAttrValue.h b/dom/base/nsAttrValue.h
index 23f61a614..33ee91afd 100644
--- a/dom/base/nsAttrValue.h
+++ b/dom/base/nsAttrValue.h
@@ -268,7 +268,7 @@ public:
// EnumTable can be initialized either with an int16_t value
// or a value of an enumeration type that can fit within an int16_t.
- constexpr EnumTable(const char* aTag, int16_t aValue)
+ EnumTable(const char* aTag, int16_t aValue)
: tag(aTag)
, value(aValue)
{
@@ -276,7 +276,7 @@ public:
template<typename T,
typename = typename std::enable_if<std::is_enum<T>::value>::type>
- constexpr EnumTable(const char* aTag, T aValue)
+ EnumTable(const char* aTag, T aValue)
: tag(aTag)
, value(static_cast<int16_t>(aValue))
{
diff --git a/dom/base/nsContentUtils.cpp b/dom/base/nsContentUtils.cpp
index 1a3f5b5ca..ffe50a015 100644
--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -9843,4 +9843,18 @@ nsContentUtils::IsLocalRefURL(const nsString& aString)
}
return false;
-} \ No newline at end of file
+}
+
+/* static */ uint32_t
+nsContentUtils::GetNodeDepth(nsINode* aNode)
+{
+ uint32_t depth = 1;
+
+ MOZ_ASSERT(aNode, "Node shouldn't be null");
+
+ while ((aNode = aNode->GetParentNode())) {
+ ++depth;
+ }
+
+ return depth;
+}
diff --git a/dom/base/nsContentUtils.h b/dom/base/nsContentUtils.h
index ffbd15e78..08587b5e4 100644
--- a/dom/base/nsContentUtils.h
+++ b/dom/base/nsContentUtils.h
@@ -2745,6 +2745,14 @@ public:
static bool
IsLocalRefURL(const nsString& aString);
+ /**
+ * Returns the length of the parent-traversal path (in terms of the number of
+ * nodes) to an unparented/root node from aNode. An unparented/root node is
+ * considered to have a depth of 1, its children have a depth of 2, etc.
+ * aNode is expected to be non-null.
+ */
+ static uint32_t GetNodeDepth(nsINode* aNode);
+
private:
static bool InitializeEventTable();
diff --git a/dom/base/nsDocument.cpp b/dom/base/nsDocument.cpp
index de793bfab..0b07ef4ec 100644
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -1727,6 +1727,10 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(nsDocument)
cb.NoteXPCOMChild(mql);
}
}
+
+ if (tmp->mResizeObserverController) {
+ tmp->mResizeObserverController->Traverse(cb);
+ }
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
NS_IMPL_CYCLE_COLLECTION_CLASS(nsDocument)
@@ -1827,11 +1831,15 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsDocument)
l != &tmp->mDOMMediaQueryLists; ) {
PRCList *next = PR_NEXT_LINK(l);
MediaQueryList *mql = static_cast<MediaQueryList*>(l);
- mql->RemoveAllListeners();
+ mql->Disconnect();
l = next;
}
tmp->mInUnlinkOrDeletion = false;
+
+ if (tmp->mResizeObserverController) {
+ tmp->mResizeObserverController->Unlink();
+ }
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
nsresult
@@ -12105,6 +12113,24 @@ nsDocument::QuerySelectorAll(const nsAString& aSelector, nsIDOMNodeList **aRetur
return nsINode::QuerySelectorAll(aSelector, aReturn);
}
+void
+nsDocument::AddResizeObserver(ResizeObserver* aResizeObserver)
+{
+ if (!mResizeObserverController) {
+ mResizeObserverController = MakeUnique<ResizeObserverController>(this);
+ }
+
+ mResizeObserverController->AddResizeObserver(aResizeObserver);
+}
+
+void
+nsDocument::ScheduleResizeObserversNotification() const
+{
+ if (mResizeObserverController) {
+ mResizeObserverController->ScheduleNotification();
+ }
+}
+
already_AddRefed<nsIDocument>
nsIDocument::Constructor(const GlobalObject& aGlobal,
ErrorResult& rv)
diff --git a/dom/base/nsDocument.h b/dom/base/nsDocument.h
index a319ad13e..220f4152d 100644
--- a/dom/base/nsDocument.h
+++ b/dom/base/nsDocument.h
@@ -59,6 +59,7 @@
#include "mozilla/MemoryReporting.h"
#include "mozilla/PendingAnimationTracker.h"
#include "mozilla/dom/DOMImplementation.h"
+#include "mozilla/dom/ResizeObserverController.h"
#include "mozilla/dom/ScriptLoader.h"
#include "mozilla/dom/StyleSheetList.h"
#include "nsDataHashtable.h"
@@ -1206,6 +1207,10 @@ public:
virtual void UnblockDOMContentLoaded() override;
+ void AddResizeObserver(mozilla::dom::ResizeObserver* aResizeObserver) override;
+
+ void ScheduleResizeObserversNotification() const override;
+
protected:
friend class nsNodeUtils;
friend class nsDocumentOnStack;
@@ -1342,6 +1347,9 @@ protected:
nsTArray<nsIObserver*> mCharSetObservers;
+ mozilla::UniquePtr<mozilla::dom::ResizeObserverController>
+ mResizeObserverController;
+
PLDHashTable *mSubDocuments;
// Array of owning references to all children
diff --git a/dom/base/nsGkAtomList.h b/dom/base/nsGkAtomList.h
index 96f5acf3a..22869bd66 100644
--- a/dom/base/nsGkAtomList.h
+++ b/dom/base/nsGkAtomList.h
@@ -580,7 +580,6 @@ GK_ATOM(marginTop, "margin-top")
GK_ATOM(marginheight, "marginheight")
GK_ATOM(marginwidth, "marginwidth")
GK_ATOM(mark, "mark")
-GK_ATOM(marquee, "marquee")
GK_ATOM(match, "match")
GK_ATOM(max, "max")
GK_ATOM(maxheight, "maxheight")
diff --git a/dom/base/nsGlobalWindow.cpp b/dom/base/nsGlobalWindow.cpp
index d696d826b..1c098897b 100644
--- a/dom/base/nsGlobalWindow.cpp
+++ b/dom/base/nsGlobalWindow.cpp
@@ -956,7 +956,7 @@ NS_IMPL_CYCLE_COLLECTING_RELEASE(DialogValueHolder)
class nsOuterWindowProxy : public js::Wrapper
{
public:
- constexpr nsOuterWindowProxy() : js::Wrapper(0) { }
+ nsOuterWindowProxy() : js::Wrapper(0) { }
virtual bool finalizeInBackground(const JS::Value& priv) const override {
return false;
@@ -1407,7 +1407,7 @@ nsOuterWindowProxy::singleton;
class nsChromeOuterWindowProxy : public nsOuterWindowProxy
{
public:
- constexpr nsChromeOuterWindowProxy() : nsOuterWindowProxy() { }
+ nsChromeOuterWindowProxy() : nsOuterWindowProxy() { }
virtual const char *className(JSContext *cx, JS::Handle<JSObject*> wrapper) const override;
diff --git a/dom/base/nsIDocument.h b/dom/base/nsIDocument.h
index 29afa5439..760048501 100644
--- a/dom/base/nsIDocument.h
+++ b/dom/base/nsIDocument.h
@@ -152,6 +152,7 @@ class ProcessingInstruction;
class Promise;
class Selection;
class ScriptLoader;
+class ResizeObserver;
class StyleSheetList;
class SVGDocument;
class SVGSVGElement;
@@ -2874,6 +2875,10 @@ public:
bool ModuleScriptsEnabled();
+ virtual void AddResizeObserver(mozilla::dom::ResizeObserver* aResizeObserver) = 0;
+
+ virtual void ScheduleResizeObserversNotification() const = 0;
+
protected:
bool GetUseCounter(mozilla::UseCounter aUseCounter)
{
diff --git a/dom/base/nsJSEnvironment.cpp b/dom/base/nsJSEnvironment.cpp
index 605b1917f..0411bee80 100644
--- a/dom/base/nsJSEnvironment.cpp
+++ b/dom/base/nsJSEnvironment.cpp
@@ -1161,7 +1161,7 @@ TimeUntilNow(TimeStamp start)
struct CycleCollectorStats
{
- constexpr CycleCollectorStats() :
+ CycleCollectorStats() :
mMaxGCDuration(0), mRanSyncForgetSkippable(false), mSuspected(0),
mMaxSkippableDuration(0), mMaxSliceTime(0), mMaxSliceTimeSinceClear(0),
mTotalSliceTime(0), mAnyLockedOut(false), mExtraForgetSkippableCalls(0),
diff --git a/dom/base/test/test_bug840098.html b/dom/base/test/test_bug840098.html
index 8eaceb589..e9275d55b 100644
--- a/dom/base/test/test_bug840098.html
+++ b/dom/base/test/test_bug840098.html
@@ -15,7 +15,7 @@ https://bugzilla.mozilla.org/show_bug.cgi?id=840098
<div id="content" style="display: none">
<div id="foo"></div>
</div>
-<marquee id="m">Hello</marquee>
+<div id="m">Hello</div>
<pre id="test">
<script type="application/javascript">
diff --git a/dom/base/test/test_caretPositionFromPoint.html b/dom/base/test/test_caretPositionFromPoint.html
index 50f12b1ef..054f73227 100644
--- a/dom/base/test/test_caretPositionFromPoint.html
+++ b/dom/base/test/test_caretPositionFromPoint.html
@@ -115,7 +115,7 @@
<div id="a" contenteditable><span id="test1">abc, abc, abc</span><br>
<span id="test2" style="color: blue;">abc, abc, abc</span><br>
<textarea id="test3">abc</textarea><input id="test4" value="abcdef"><br><br>
-<marquee>marquee</marquee>
+<div>div</div>
</div>
<input id="test5" value="The rabbit-hole went straight on like a tunnel for some way, and then dipped suddenly down, so suddenly that Alice had not a moment to think about stopping herself before she found herself falling down a very deep well. Either the well was very deep, or she fell very slowly, for she had plenty of time as she went down to look about her and to wonder what was going to happen next. First, she tried to look down and make out what she was coming to, but it was too dark to see anything; then she looked at the sides of the well, and noticed that they were filled with cupboards and book-shelves; here and there she saw maps and pictures hung upon pegs. She took down a jar from one of the shelves as she passed; it was labelled `ORANGE MARMALADE', but to her great disappointment it was empty: she did not like to drop the jar for fear of killing somebody, so managed to put it into one of the cupboards as she fell past it." type="text">
<input id="test6" type="number" style="width:150px; height:57px;" value="31415"><br>
diff --git a/dom/base/test/test_mutationobservers.html b/dom/base/test/test_mutationobservers.html
deleted file mode 100644
index a6de89595..000000000
--- a/dom/base/test/test_mutationobservers.html
+++ /dev/null
@@ -1,913 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<!--
-https://bugzilla.mozilla.org/show_bug.cgi?id=641821
--->
-<head>
- <meta charset="utf-8">
- <title>Test for Bug 641821</title>
- <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
- <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
-</head>
-<body onload="runTest()">
-<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=641821">Mozilla Bug 641821</a>
-<p id="display"></p>
-<div id="content" style="display: none">
-
-</div>
-<pre id="test">
-<script type="application/javascript">
-
-/** Test for Bug 641821 **/
-
-SimpleTest.requestFlakyTimeout("requestFlakyTimeout is silly. (But make sure marquee has time to initialize itself.)");
-
-var div = document.createElement("div");
-
-var M;
-if ("MozMutationObserver" in window) {
- M = window.MozMutationObserver;
-} else if ("WebKitMutationObserver" in window) {
- M = window.WebKitMutationObserver;
-} else {
- M = window.MutationObserver;
-}
-
-function log(str) {
- var d = document.createElement("div");
- d.textContent = str;
- if (str.indexOf("PASSED") >= 0) {
- d.setAttribute("style", "color: green;");
- } else {
- d.setAttribute("style", "color: red;");
- }
- document.getElementById("log").appendChild(d);
-}
-
-// Some helper functions so that this test runs also outside mochitest.
-if (!("ok" in window)) {
- window.ok = function(val, str) {
- log(str + (val ? " PASSED\n" : " FAILED\n"));
- }
-}
-
-if (!("is" in window)) {
- window.is = function(val, refVal, str) {
- log(str + (val == refVal? " PASSED " : " FAILED ") +
- (val != refVal ? "expected " + refVal + " got " + val + "\n" : "\n"));
- }
-}
-
-if (!("isnot" in window)) {
- window.isnot = function(val, refVal, str) {
- log(str + (val != refVal? " PASSED " : " FAILED ") +
- (val == refVal ? "Didn't expect " + refVal + "\n" : "\n"));
- }
-}
-
-if (!("SimpleTest" in window)) {
- window.SimpleTest =
- {
- finish: function() {
- document.getElementById("log").appendChild(document.createTextNode("DONE"));
- },
- waitForExplicitFinish: function() {}
- }
-}
-
-function then(thenFn) {
- setTimeout(function() {
- if (thenFn) {
- setTimeout(thenFn, 0);
- } else {
- SimpleTest.finish();
- }
- }, 0);
-}
-
-var m;
-var m2;
-var m3;
-var m4;
-
-// Checks basic parameter validation and normal 'this' handling.
-// Tests also basic attribute handling.
-function runTest() {
- m = new M(function(){});
- ok(m, "MutationObserver supported");
-
- var e = null;
- try {
- m.observe(document, {});
- } catch (ex) {
- e = ex;
- }
- ok(e, "Should have thrown an exception");
- is(e.name, "TypeError", "Should have thrown TypeError");
-
- e = null;
- try {
- m.observe(document, { childList: true, attributeOldValue: true });
- } catch (ex) {
- e = ex;
- }
- ok(!e, "Shouldn't have thrown an exception");
-
- e = null;
- try {
- m.observe(document, { childList: true, attributeFilter: ["foo"] });
- } catch (ex) {
- e = ex;
- }
- ok(!e, "Shouldn't have thrown an exception");
-
- e = null;
- try {
- m.observe(document, { childList: true, characterDataOldValue: true });
- } catch (ex) {
- e = ex;
- }
- ok(!e, "Shouldn't have thrown an exception");
-
- e = null;
- try {
- m.observe(document);
- } catch (ex) {
- e = ex;
- }
- ok(e, "Should have thrown an exception");
-
- m = new M(function(records, observer) {
- is(observer, m, "2nd parameter should be the mutation observer");
- is(observer, this, "2nd parameter should be 'this'");
- is(records.length, 1, "Should have one record.");
- is(records[0].type, "attributes", "Should have got attributes record");
- is(records[0].target, div, "Should have got div as target");
- is(records[0].attributeName, "foo", "Should have got record about foo attribute");
- observer.disconnect();
- then(testThisBind);
- m = null;
- });
- m.observe(div, { attributes: true, attributeFilter: ["foo"] });
- is(SpecialPowers.wrap(div).getBoundMutationObservers()[0].getObservingInfo()[0].attributes, true);
- is(SpecialPowers.wrap(div).getBoundMutationObservers()[0].getObservingInfo()[0].attributeFilter.length, 1)
- is(SpecialPowers.wrap(div).getBoundMutationObservers()[0].getObservingInfo()[0].attributeFilter[0], "foo")
- div.setAttribute("foo", "bar");
-}
-
-// 'this' handling when fn.bind() is used.
-function testThisBind() {
- var child = div.appendChild(document.createElement("div"));
- var gchild = child.appendChild(document.createElement("div"));
- m = new M((function(records, observer) {
- is(observer, m, "2nd parameter should be the mutation observer");
- isnot(observer, this, "2nd parameter should be 'this'");
- is(records.length, 3, "Should have one record.");
- is(records[0].type, "attributes", "Should have got attributes record");
- is(records[0].target, div, "Should have got div as target");
- is(records[0].attributeName, "foo", "Should have got record about foo attribute");
- is(records[0].oldValue, "bar", "oldValue should be bar");
- is(records[1].type, "attributes", "Should have got attributes record");
- is(records[1].target, div, "Should have got div as target");
- is(records[1].attributeName, "foo", "Should have got record about foo attribute");
- is(records[1].oldValue, "bar2", "oldValue should be bar2");
- is(records[2].type, "attributes", "Should have got attributes record");
- is(records[2].target, gchild, "Should have got div as target");
- is(records[2].attributeName, "foo", "Should have got record about foo attribute");
- is(records[2].oldValue, null, "oldValue should be bar2");
- observer.disconnect();
- then(testCharacterData);
- m = null;
- }).bind(window));
- m.observe(div, { attributes: true, attributeOldValue: true, subtree: true });
- is(SpecialPowers.wrap(div).getBoundMutationObservers()[0].getObservingInfo()[0].attributes, true)
- is(SpecialPowers.wrap(div).getBoundMutationObservers()[0].getObservingInfo()[0].attributeOldValue, true)
- is(SpecialPowers.wrap(div).getBoundMutationObservers()[0].getObservingInfo()[0].subtree, true)
- div.setAttribute("foo", "bar2");
- div.removeAttribute("foo");
- div.removeChild(child);
- child.removeChild(gchild);
- div.appendChild(gchild);
- div.removeChild(gchild);
- gchild.setAttribute("foo", "bar");
-}
-
-function testCharacterData() {
- m = new M(function(records, observer) {
- is(records[0].type, "characterData", "Should have got characterData");
- is(records[0].oldValue, null, "Shouldn't have got oldData");
- observer.disconnect();
- m = null;
- });
- m2 = new M(function(records, observer) {
- is(records[0].type, "characterData", "Should have got characterData");
- is(records[0].oldValue, "foo", "Should have got oldData");
- observer.disconnect();
- m2 = null;
- });
- m3 = new M(function(records, observer) {
- ok(false, "This should not be called!");
- observer.disconnect();
- m3 = null;
- });
- m4 = new M(function(records, observer) {
- is(records[0].oldValue, null, "Shouldn't have got oldData");
- observer.disconnect();
- m3.disconnect();
- m3 = null;
- then(testChildList);
- m4 = null;
- });
-
- div.appendChild(document.createTextNode("foo"));
- m.observe(div, { characterData: true, subtree: true });
- m2.observe(div, { characterData: true, characterDataOldValue: true, subtree: true});
- // If observing the same node twice, only the latter option should apply.
- m3.observe(div, { characterData: true, subtree: true });
- m3.observe(div, { characterData: true, subtree: false });
- m4.observe(div.firstChild, { characterData: true, subtree: false });
-
- is(SpecialPowers.wrap(div).getBoundMutationObservers().length, 3)
- is(SpecialPowers.wrap(div).getBoundMutationObservers()[2].getObservingInfo()[0].characterData, true)
- is(SpecialPowers.wrap(div).getBoundMutationObservers()[2].getObservingInfo()[0].subtree, false)
-
- div.firstChild.data = "bar";
-}
-
-function testChildList() {
- var fc = div.firstChild;
- m = new M(function(records, observer) {
- is(records[0].type, "childList", "Should have got childList");
- is(records[0].addedNodes.length, 0, "Shouldn't have got addedNodes");
- is(records[0].removedNodes.length, 1, "Should have got removedNodes");
- is(records[0].removedNodes[0], fc, "Should have removed a text node");
- observer.disconnect();
- then(testChildList2);
- m = null;
- });
- m.observe(div, { childList: true});
- div.removeChild(div.firstChild);
-}
-
-function testChildList2() {
- div.innerHTML = "<span>1</span><span>2</span>";
- m = new M(function(records, observer) {
- is(records[0].type, "childList", "Should have got childList");
- is(records[0].removedNodes.length, 2, "Should have got removedNodes");
- is(records[0].addedNodes.length, 1, "Should have got addedNodes");
- observer.disconnect();
- then(testChildList3);
- m = null;
- });
- m.observe(div, { childList: true });
- div.innerHTML = "<span><span>foo</span></span>";
-}
-
-function testChildList3() {
- m = new M(function(records, observer) {
- is(records[0].type, "childList", "Should have got childList");
- is(records[0].removedNodes.length, 1, "Should have got removedNodes");
- is(records[0].addedNodes.length, 1, "Should have got addedNodes");
- observer.disconnect();
- then(testChildList4);
- m = null;
- });
- m.observe(div, { childList: true });
- div.textContent = "hello";
-}
-
-function testChildList4() {
- div.textContent = null;
- var df = document.createDocumentFragment();
- var t1 = df.appendChild(document.createTextNode("Hello "));
- var t2 = df.appendChild(document.createTextNode("world!"));
- var s1 = div.appendChild(document.createElement("span"));
- s1.textContent = "foo";
- var s2 = div.appendChild(document.createElement("span"));
- function callback(records, observer) {
- is(records.length, 3, "Should have got one record for removing nodes from document fragment and one record for adding them to div");
- is(records[0].removedNodes.length, 2, "Should have got removedNodes");
- is(records[0].removedNodes[0], t1, "Should be the 1st textnode");
- is(records[0].removedNodes[1], t2, "Should be the 2nd textnode");
- is(records[1].addedNodes.length, 2, "Should have got addedNodes");
- is(records[1].addedNodes[0], t1, "Should be the 1st textnode");
- is(records[1].addedNodes[1], t2, "Should be the 2nd textnode");
- is(records[1].previousSibling, s1, "Should have previousSibling");
- is(records[1].nextSibling, s2, "Should have nextSibling");
- is(records[2].type, "characterData", "3rd record should be characterData");
- is(records[2].target, t1, "target should be the textnode");
- is(records[2].oldValue, "Hello ", "oldValue was 'Hello '");
- observer.disconnect();
- then(testChildList5);
- m = null;
- };
- m = new M(callback);
- m.observe(df, { childList: true, characterData: true, characterDataOldValue: true, subtree: true });
- is(SpecialPowers.wrap(df).getBoundMutationObservers()[0].getObservingInfo()[0].childList, true)
- is(SpecialPowers.wrap(df).getBoundMutationObservers()[0].getObservingInfo()[0].characterData, true)
- is(SpecialPowers.wrap(df).getBoundMutationObservers()[0].getObservingInfo()[0].characterDataOldValue, true)
- is(SpecialPowers.wrap(df).getBoundMutationObservers()[0].getObservingInfo()[0].subtree, true)
- ok(SpecialPowers.compare(SpecialPowers.wrap(df).getBoundMutationObservers()[0].mutationCallback, callback))
- m.observe(div, { childList: true });
- is(SpecialPowers.wrap(df).getBoundMutationObservers()[0].getObservingInfo().length, 2)
-
- // Make sure transient observers aren't leaked.
- var leakTest = new M(function(){});
- leakTest.observe(div, { characterData: true, subtree: true });
-
- div.insertBefore(df, s2);
- s1.firstChild.data = "bar"; // This should *not* create a record.
- t1.data = "Hello the whole "; // This should create a record.
-}
-
-function testChildList5() {
- div.textContent = null;
- var c1 = div.appendChild(document.createElement("div"));
- var c2 = document.createElement("div");
- var div2 = document.createElement("div");
- var c3 = div2.appendChild(document.createElement("div"));
- var c4 = document.createElement("div");
- var c5 = document.createElement("div");
- var df = document.createDocumentFragment();
- var emptyDF = document.createDocumentFragment();
- var dfc1 = df.appendChild(document.createElement("div"));
- var dfc2 = df.appendChild(document.createElement("div"));
- var dfc3 = df.appendChild(document.createElement("div"));
- m = new M(function(records, observer) {
- is(records.length, 6 , "");
- is(records[0].removedNodes.length, 1, "Should have got removedNodes");
- is(records[0].removedNodes[0], c1, "");
- is(records[0].addedNodes.length, 1, "Should have got addedNodes");
- is(records[0].addedNodes[0], c2, "");
- is(records[0].previousSibling, null, "");
- is(records[0].nextSibling, null, "");
- is(records[1].removedNodes.length, 1, "Should have got removedNodes");
- is(records[1].removedNodes[0], c3, "");
- is(records[1].addedNodes.length, 0, "Shouldn't have got addedNodes");
- is(records[1].previousSibling, null, "");
- is(records[1].nextSibling, null, "");
- is(records[2].removedNodes.length, 1, "Should have got removedNodes");
- is(records[2].removedNodes[0], c2, "");
- is(records[2].addedNodes.length, 1, "Should have got addedNodes");
- is(records[2].addedNodes[0], c3, "");
- is(records[2].previousSibling, null, "");
- is(records[2].nextSibling, null, "");
- // Check document fragment handling
- is(records[5].removedNodes.length, 1, "");
- is(records[5].removedNodes[0], c4, "");
- is(records[5].addedNodes.length, 3, "");
- is(records[5].addedNodes[0], dfc1, "");
- is(records[5].addedNodes[1], dfc2, "");
- is(records[5].addedNodes[2], dfc3, "");
- is(records[5].previousSibling, c3, "");
- is(records[5].nextSibling, c5, "");
- observer.disconnect();
- then(testAdoptNode);
- m = null;
- });
- m.observe(div, { childList: true, subtree: true });
- m.observe(div2, { childList: true, subtree: true });
- div.replaceChild(c2, c1);
- div.replaceChild(c3, c2);
- div.appendChild(c4);
- div.appendChild(c5);
- div.replaceChild(df, c4);
- div.appendChild(emptyDF); // empty document shouldn't cause mutation records
-}
-
-function testAdoptNode() {
- var d1 = document.implementation.createHTMLDocument(null);
- var d2 = document.implementation.createHTMLDocument(null);
- var addedNode;
- m = new M(function(records, observer) {
- is(records.length, 3, "Should have 2 records");
- is(records[0].target.ownerDocument, d1, "ownerDocument should be the initial document")
- is(records[1].target.ownerDocument, d2, "ownerDocument should be the new document");
- is(records[2].type, "attributes", "Should have got attribute mutation")
- is(records[2].attributeName, "foo", "Should have got foo attribute mutation")
- observer.disconnect();
- then(testOuterHTML);
- m = null;
- });
- m.observe(d1, { childList: true, subtree: true, attributes: true });
- d2.body.appendChild(d1.body);
- addedNode = d2.body.lastChild.appendChild(d2.createElement("div"));
- addedNode.setAttribute("foo", "bar");
-}
-
-function testOuterHTML() {
- var doc = document.implementation.createHTMLDocument(null);
- var d1 = doc.body.appendChild(document.createElement("div"));
- var d2 = doc.body.appendChild(document.createElement("div"));
- var d3 = doc.body.appendChild(document.createElement("div"));
- var d4 = doc.body.appendChild(document.createElement("div"));
- m = new M(function(records, observer) {
- is(records.length, 4, "Should have 1 record");
- is(records[0].removedNodes.length, 1, "Should have 1 removed nodes");
- is(records[0].addedNodes.length, 2, "Should have 2 added nodes");
- is(records[0].previousSibling, null, "");
- is(records[0].nextSibling, d2, "");
- is(records[1].removedNodes.length, 1, "Should have 1 removed nodes");
- is(records[1].addedNodes.length, 2, "Should have 2 added nodes");
- is(records[1].previousSibling, records[0].addedNodes[1], "");
- is(records[1].nextSibling, d3, "");
- is(records[2].removedNodes.length, 1, "Should have 1 removed nodes");
- is(records[2].addedNodes.length, 2, "Should have 2 added nodes");
- is(records[2].previousSibling, records[1].addedNodes[1], "");
- is(records[2].nextSibling, d4, "");
- is(records[3].removedNodes.length, 1, "Should have 1 removed nodes");
- is(records[3].addedNodes.length, 0);
- is(records[3].previousSibling, records[2].addedNodes[1], "");
- is(records[3].nextSibling, null, "");
- observer.disconnect();
- then(testInsertAdjacentHTML);
- m = null;
- });
- m.observe(doc, { childList: true, subtree: true });
- d1.outerHTML = "<div>1</div><div>1</div>";
- d2.outerHTML = "<div>2</div><div>2</div>";
- d3.outerHTML = "<div>3</div><div>3</div>";
- d4.outerHTML = "";
-}
-
-function testInsertAdjacentHTML() {
- var doc = document.implementation.createHTMLDocument(null);
- var d1 = doc.body.appendChild(document.createElement("div"));
- var d2 = doc.body.appendChild(document.createElement("div"));
- var d3 = doc.body.appendChild(document.createElement("div"));
- var d4 = doc.body.appendChild(document.createElement("div"));
- m = new M(function(records, observer) {
- is(records.length, 4, "");
- is(records[0].target, doc.body, "");
- is(records[0].previousSibling, null, "");
- is(records[0].nextSibling, d1, "");
- is(records[1].target, d2, "");
- is(records[1].previousSibling, null, "");
- is(records[1].nextSibling, null, "");
- is(records[2].target, d3, "");
- is(records[2].previousSibling, null, "");
- is(records[2].nextSibling, null, "");
- is(records[3].target, doc.body, "");
- is(records[3].previousSibling, d4, "");
- is(records[3].nextSibling, null, "");
- observer.disconnect();
- then(testSyncXHR);
- m = null;
- });
- m.observe(doc, { childList: true, subtree: true });
- d1.insertAdjacentHTML("beforebegin", "<div></div><div></div>");
- d2.insertAdjacentHTML("afterbegin", "<div></div><div></div>");
- d3.insertAdjacentHTML("beforeend", "<div></div><div></div>");
- d4.insertAdjacentHTML("afterend", "<div></div><div></div>");
-}
-
-
-var callbackHandled = false;
-
-function testSyncXHR() {
- div.textContent = null;
- m = new M(function(records, observer) {
- is(records.length, 1, "");
- is(records[0].addedNodes.length, 1, "");
- callbackHandled = true;
- observer.disconnect();
- m = null;
- });
- m.observe(div, { childList: true, subtree: true });
- div.innerHTML = "<div>hello</div>";
- var x = new XMLHttpRequest();
- x.open("GET", window.location, false);
- x.send();
- ok(!callbackHandled, "Shouldn't have called the mutation callback!");
- setTimeout(testSyncXHR2, 0);
-}
-
-function testSyncXHR2() {
- ok(callbackHandled, "Should have called the mutation callback!");
- then(testTakeRecords);
-}
-
-function testTakeRecords() {
- var s = "<span>1</span><span>2</span>";
- div.innerHTML = s;
- var takenRecords;
- m = new M(function(records, observer) {
- is(records.length, 3, "Should have got 3 records");
-
- is(records[0].type, "attributes", "Should have got attributes");
- is(records[0].attributeName, "foo", "");
- is(records[0].attributeNamespace, null, "");
- is(records[0].prevValue, null, "");
- is(records[1].type, "childList", "Should have got childList");
- is(records[1].removedNodes.length, 2, "Should have got removedNodes");
- is(records[1].addedNodes.length, 2, "Should have got addedNodes");
- is(records[2].type, "attributes", "Should have got attributes");
- is(records[2].attributeName, "foo", "");
-
- is(records.length, takenRecords.length, "Should have had similar mutations");
- is(records[0].type, takenRecords[0].type, "Should have had similar mutations");
- is(records[1].type, takenRecords[1].type, "Should have had similar mutations");
- is(records[2].type, takenRecords[2].type, "Should have had similar mutations");
-
- is(records[1].removedNodes.length, takenRecords[1].removedNodes.length, "Should have had similar mutations");
- is(records[1].addedNodes.length, takenRecords[1].addedNodes.length, "Should have had similar mutations");
-
- is(m.takeRecords().length, 0, "Shouldn't have any records");
- observer.disconnect();
- then(testMutationObserverAndEvents);
- m = null;
- });
- m.observe(div, { childList: true, attributes: true });
- div.setAttribute("foo", "bar");
- div.innerHTML = s;
- div.removeAttribute("foo");
- takenRecords = m.takeRecords();
- div.setAttribute("foo", "bar");
- div.innerHTML = s;
- div.removeAttribute("foo");
-}
-
-function testTakeRecords() {
- function mutationListener(e) {
- ++mutationEventCount;
- is(e.attrChange, MutationEvent.ADDITION, "unexpected change");
- }
-
- m = new M(function(records, observer) {
- is(records.length, 2, "Should have got 2 records");
- is(records[0].type, "attributes", "Should have got attributes");
- is(records[0].attributeName, "foo", "");
- is(records[0].oldValue, null, "");
- is(records[1].type, "attributes", "Should have got attributes");
- is(records[1].attributeName, "foo", "");
- is(records[1].oldValue, "bar", "");
- observer.disconnect();
- div.removeEventListener("DOMAttrModified", mutationListener);
- then(testExpandos);
- m = null;
- });
- m.observe(div, { attributes: true, attributeOldValue: true });
- // Note, [0] points to a mutation observer which is there for a leak test!
- ok(SpecialPowers.compare(SpecialPowers.wrap(div).getBoundMutationObservers()[1], m));
- var mutationEventCount = 0;
- div.addEventListener("DOMAttrModified", mutationListener);
- div.setAttribute("foo", "bar");
- div.setAttribute("foo", "bar");
- is(mutationEventCount, 1, "Should have got only one mutation event!");
-}
-
-function testExpandos() {
- var m2 = new M(function(records, observer) {
- is(observer.expandoProperty, true);
- observer.disconnect();
- then(testOutsideShadowDOM);
- });
- m2.expandoProperty = true;
- m2.observe(div, { attributes: true });
- m2 = null;
- if (SpecialPowers) {
- // Run GC several times to see if the expando property disappears.
-
- SpecialPowers.gc();
- SpecialPowers.gc();
- SpecialPowers.gc();
- SpecialPowers.gc();
- }
- div.setAttribute("foo", "bar2");
-}
-
-function testOutsideShadowDOM() {
- var m = new M(function(records, observer) {
- is(records.length, 1);
- is(records[0].type, "attributes", "Should have got attributes");
- observer.disconnect();
- then(testInsideShadowDOM);
- });
- m.observe(div, {
- attributes: true,
- childList: true,
- characterData: true,
- subtree: true
- })
- var sr = div.createShadowRoot();
- sr.innerHTML = "<div" + ">text</" + "div>";
- sr.firstChild.setAttribute("foo", "bar");
- sr.firstChild.firstChild.data = "text2";
- sr.firstChild.appendChild(document.createElement("div"));
- div.setAttribute("foo", "bar");
-}
-
-function testInsideShadowDOM() {
- var m = new M(function(records, observer) {
- is(records.length, 4);
- is(records[0].type, "childList");
- is(records[1].type, "attributes");
- is(records[2].type, "characterData");
- is(records[3].type, "childList");
- observer.disconnect();
- then(testMarquee);
- });
- var sr = div.createShadowRoot();
- m.observe(sr, {
- attributes: true,
- childList: true,
- characterData: true,
- subtree: true
- });
-
- sr.innerHTML = "<div" + ">text</" + "div>";
- sr.firstChild.setAttribute("foo", "bar");
- sr.firstChild.firstChild.data = "text2";
- sr.firstChild.appendChild(document.createElement("div"));
- div.setAttribute("foo", "bar2");
-
-}
-
-function testMarquee() {
- var m = new M(function(records, observer) {
- is(records.length, 1);
- is(records[0].type, "attributes");
- is(records[0].attributeName, "ok");
- is(records[0].oldValue, null);
- observer.disconnect();
- then(testStyleCreate);
- });
- var marquee = document.createElement("marquee");
- m.observe(marquee, {
- attributes: true,
- attributeOldValue: true,
- childList: true,
- characterData: true,
- subtree: true
- });
- document.body.appendChild(marquee);
- setTimeout(function() {marquee.setAttribute("ok", "ok")}, 500);
-}
-
-function testStyleCreate() {
- m = new M(function(records, observer) {
- is(records.length, 1, "number of records");
- is(records[0].type, "attributes", "record.type");
- is(records[0].attributeName, "style", "record.attributeName");
- is(records[0].oldValue, null, "record.oldValue");
- isnot(div.getAttribute("style"), null, "style attribute after creation");
- observer.disconnect();
- m = null;
- div.removeAttribute("style");
- then(testStyleModify);
- });
- m.observe(div, { attributes: true, attributeOldValue: true });
- is(div.getAttribute("style"), null, "style attribute before creation");
- div.style.color = "blue";
-}
-
-function testStyleModify() {
- div.style.color = "yellow";
- m = new M(function(records, observer) {
- is(records.length, 1, "number of records");
- is(records[0].type, "attributes", "record.type");
- is(records[0].attributeName, "style", "record.attributeName");
- isnot(div.getAttribute("style"), null, "style attribute after modification");
- observer.disconnect();
- m = null;
- div.removeAttribute("style");
- then(testStyleRead);
- });
- m.observe(div, { attributes: true });
- isnot(div.getAttribute("style"), null, "style attribute before modification");
- div.style.color = "blue";
-}
-
-function testStyleRead() {
- m = new M(function(records, observer) {
- is(records.length, 1, "number of records");
- is(records[0].type, "attributes", "record.type");
- is(records[0].attributeName, "data-test", "record.attributeName");
- is(div.getAttribute("style"), null, "style attribute after read");
- observer.disconnect();
- div.removeAttribute("data-test");
- m = null;
- then(testStyleRemoveProperty);
- });
- m.observe(div, { attributes: true });
- is(div.getAttribute("style"), null, "style attribute before read");
- var value = div.style.color; // shouldn't generate any mutation records
- div.setAttribute("data-test", "a");
-}
-
-function testStyleRemoveProperty() {
- div.style.color = "blue";
- m = new M(function(records, observer) {
- is(records.length, 1, "number of records");
- is(records[0].type, "attributes", "record.type");
- is(records[0].attributeName, "style", "record.attributeName");
- isnot(div.getAttribute("style"), null, "style attribute after successful removeProperty");
- observer.disconnect();
- m = null;
- div.removeAttribute("style");
- then(testStyleRemoveProperty2);
- });
- m.observe(div, { attributes: true });
- isnot(div.getAttribute("style"), null, "style attribute before successful removeProperty");
- div.style.removeProperty("color");
-}
-
-function testStyleRemoveProperty2() {
- m = new M(function(records, observer) {
- is(records.length, 1, "number of records");
- is(records[0].type, "attributes", "record.type");
- is(records[0].attributeName, "data-test", "record.attributeName");
- is(div.getAttribute("style"), null, "style attribute after unsuccessful removeProperty");
- observer.disconnect();
- m = null;
- div.removeAttribute("data-test");
- then(testAttributeRecordMerging1);
- });
- m.observe(div, { attributes: true });
- is(div.getAttribute("style"), null, "style attribute before unsuccessful removeProperty");
- div.style.removeProperty("color"); // shouldn't generate any mutation records
- div.setAttribute("data-test", "a");
-}
-
-function testAttributeRecordMerging1() {
- ok(true, "testAttributeRecordMerging1");
- var m = new M(function(records, observer) {
- is(records.length, 2);
- is(records[0].type, "attributes");
- is(records[0].target, div);
- is(records[0].attributeName, "foo");
- is(records[0].attributeNamespace, null);
- is(records[0].oldValue, null);
-
- is(records[1].type, "attributes");
- is(records[1].target, div.firstChild);
- is(records[1].attributeName, "foo");
- is(records[1].attributeNamespace, null);
- is(records[1].oldValue, null);
- observer.disconnect();
- div.innerHTML = "";
- div.removeAttribute("foo");
- then(testAttributeRecordMerging2);
- });
- m.observe(div, {
- attributes: true,
- subtree: true
- });
- SpecialPowers.wrap(m).mergeAttributeRecords = true;
-
- div.setAttribute("foo", "bar_1");
- div.setAttribute("foo", "bar_2");
- div.innerHTML = "<div></div>";
- div.firstChild.setAttribute("foo", "bar_1");
- div.firstChild.setAttribute("foo", "bar_2");
-}
-
-function testAttributeRecordMerging2() {
- ok(true, "testAttributeRecordMerging2");
- var m = new M(function(records, observer) {
- is(records.length, 2);
- is(records[0].type, "attributes");
- is(records[0].target, div);
- is(records[0].attributeName, "foo");
- is(records[0].attributeNamespace, null);
- is(records[0].oldValue, "initial");
-
- is(records[1].type, "attributes");
- is(records[1].target, div.firstChild);
- is(records[1].attributeName, "foo");
- is(records[1].attributeNamespace, null);
- is(records[1].oldValue, "initial");
- observer.disconnect();
- div.innerHTML = "";
- div.removeAttribute("foo");
- then(testAttributeRecordMerging3);
- });
-
- div.setAttribute("foo", "initial");
- div.innerHTML = "<div></div>";
- div.firstChild.setAttribute("foo", "initial");
- m.observe(div, {
- attributes: true,
- subtree: true,
- attributeOldValue: true
- });
- SpecialPowers.wrap(m).mergeAttributeRecords = true;
-
- div.setAttribute("foo", "bar_1");
- div.setAttribute("foo", "bar_2");
- div.firstChild.setAttribute("foo", "bar_1");
- div.firstChild.setAttribute("foo", "bar_2");
-}
-
-function testAttributeRecordMerging3() {
- ok(true, "testAttributeRecordMerging3");
- var m = new M(function(records, observer) {
- is(records.length, 4);
- is(records[0].type, "attributes");
- is(records[0].target, div);
- is(records[0].attributeName, "foo");
- is(records[0].attributeNamespace, null);
- is(records[0].oldValue, "initial");
-
- is(records[1].type, "attributes");
- is(records[1].target, div.firstChild);
- is(records[1].attributeName, "foo");
- is(records[1].attributeNamespace, null);
- is(records[1].oldValue, "initial");
-
- is(records[2].type, "attributes");
- is(records[2].target, div);
- is(records[2].attributeName, "foo");
- is(records[2].attributeNamespace, null);
- is(records[2].oldValue, "bar_1");
-
- is(records[3].type, "attributes");
- is(records[3].target, div.firstChild);
- is(records[3].attributeName, "foo");
- is(records[3].attributeNamespace, null);
- is(records[3].oldValue, "bar_1");
-
- observer.disconnect();
- div.innerHTML = "";
- div.removeAttribute("foo");
- then(testAttributeRecordMerging4);
- });
-
- div.setAttribute("foo", "initial");
- div.innerHTML = "<div></div>";
- div.firstChild.setAttribute("foo", "initial");
- m.observe(div, {
- attributes: true,
- subtree: true,
- attributeOldValue: true
- });
- SpecialPowers.wrap(m).mergeAttributeRecords = true;
-
- // No merging should happen.
- div.setAttribute("foo", "bar_1");
- div.firstChild.setAttribute("foo", "bar_1");
- div.setAttribute("foo", "bar_2");
- div.firstChild.setAttribute("foo", "bar_2");
-}
-
-function testAttributeRecordMerging4() {
- ok(true, "testAttributeRecordMerging4");
- var m = new M(function(records, observer) {
- });
-
- div.setAttribute("foo", "initial");
- div.innerHTML = "<div></div>";
- div.firstChild.setAttribute("foo", "initial");
- m.observe(div, {
- attributes: true,
- subtree: true,
- attributeOldValue: true
- });
- SpecialPowers.wrap(m).mergeAttributeRecords = true;
-
- div.setAttribute("foo", "bar_1");
- div.setAttribute("foo", "bar_2");
- div.firstChild.setAttribute("foo", "bar_1");
- div.firstChild.setAttribute("foo", "bar_2");
-
- var records = m.takeRecords();
-
- is(records.length, 2);
- is(records[0].type, "attributes");
- is(records[0].target, div);
- is(records[0].attributeName, "foo");
- is(records[0].attributeNamespace, null);
- is(records[0].oldValue, "initial");
-
- is(records[1].type, "attributes");
- is(records[1].target, div.firstChild);
- is(records[1].attributeName, "foo");
- is(records[1].attributeNamespace, null);
- is(records[1].oldValue, "initial");
- m.disconnect();
- div.innerHTML = "";
- div.removeAttribute("foo");
- then(testChromeOnly);
-}
-
-function testChromeOnly() {
- // Content can't access nativeAnonymousChildList
- try {
- var mo = new M(function(records, observer) { });
- mo.observe(div, { nativeAnonymousChildList: true });
- ok(false, "Should have thrown when trying to observe with chrome-only init");
- } catch (e) {
- ok(true, "Throws when trying to observe with chrome-only init");
- }
-
- then();
-}
-
-SimpleTest.waitForExplicitFinish();
-
-</script>
-</pre>
-<div id="log">
-</div>
-</body>
-</html>
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-25 12:13:38 +0000