dom/xul/XULBroadcastManager.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=4 sw=2 et tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "XULBroadcastManager.h"
   8 #include "nsCOMPtr.h"
   9 #include "nsContentUtils.h"
  10 #include "mozilla/EventDispatcher.h"
  11 #include "mozilla/Logging.h"
  12 #include "mozilla/dom/DocumentInlines.h"
  13 #include "nsXULElement.h"
  14
  15 struct BroadcastListener {
  16   nsWeakPtr mListener;
  17   RefPtr<nsAtom> mAttribute;
  18 };
  19
  20 struct BroadcasterMapEntry : public PLDHashEntryHdr {
  21   mozilla::dom::Element* mBroadcaster;  // [WEAK]
  22   nsTArray<BroadcastListener*>
  23       mListeners;  // [OWNING] of BroadcastListener objects
  24 };
  25
  26 struct nsAttrNameInfo {
  27   nsAttrNameInfo(int32_t aNamespaceID, nsAtom* aName, nsAtom* aPrefix)
  28       : mNamespaceID(aNamespaceID), mName(aName), mPrefix(aPrefix) {}
  29   nsAttrNameInfo(const nsAttrNameInfo& aOther) = delete;
  30   nsAttrNameInfo(nsAttrNameInfo&& aOther) = default;
  31
  32   int32_t mNamespaceID;
  33   RefPtr<nsAtom> mName;
  34   RefPtr<nsAtom> mPrefix;
  35 };
  36
  37 static void ClearBroadcasterMapEntry(PLDHashTable* aTable,
  38                                      PLDHashEntryHdr* aEntry) {
  39   BroadcasterMapEntry* entry = static_cast<BroadcasterMapEntry*>(aEntry);
  40   for (size_t i = entry->mListeners.Length() - 1; i != (size_t)-1; --i) {
  41     delete entry->mListeners[i];
  42   }
  43   entry->mListeners.Clear();
  44
  45   // N.B. that we need to manually run the dtor because we
  46   // constructed the nsTArray object in-place.
  47   entry->mListeners.~nsTArray<BroadcastListener*>();
  48 }
  49
  50 static bool CanBroadcast(int32_t aNameSpaceID, nsAtom* aAttribute) {
  51   // Don't push changes to the |id|, |persist|, |command| or
  52   // |observes| attribute.
  53   if (aNameSpaceID == kNameSpaceID_None) {
  54     if ((aAttribute == nsGkAtoms::id) || (aAttribute == nsGkAtoms::persist) ||
  55         (aAttribute == nsGkAtoms::command) ||
  56         (aAttribute == nsGkAtoms::observes)) {
  57       return false;
  58     }
  59   }
  60   return true;
  61 }
  62
  63 namespace mozilla::dom {
  64 static LazyLogModule sXULBroadCastManager("XULBroadcastManager");
  65
  66 class XULBroadcastManager::nsDelayedBroadcastUpdate {
  67  public:
  68   nsDelayedBroadcastUpdate(Element* aBroadcaster, Element* aListener,
  69                            const nsAString& aAttr)
  70       : mBroadcaster(aBroadcaster),
  71         mListener(aListener),
  72         mAttr(aAttr),
  73         mSetAttr(false),
  74         mNeedsAttrChange(false) {}
  75
  76   nsDelayedBroadcastUpdate(Element* aBroadcaster, Element* aListener,
  77                            nsAtom* aAttrName, const nsAString& aAttr,
  78                            bool aSetAttr, bool aNeedsAttrChange)
  79       : mBroadcaster(aBroadcaster),
  80         mListener(aListener),
  81         mAttr(aAttr),
  82         mAttrName(aAttrName),
  83         mSetAttr(aSetAttr),
  84         mNeedsAttrChange(aNeedsAttrChange) {}
  85
  86   nsDelayedBroadcastUpdate(const nsDelayedBroadcastUpdate& aOther) = delete;
  87   nsDelayedBroadcastUpdate(nsDelayedBroadcastUpdate&& aOther) = default;
  88
  89   RefPtr<Element> mBroadcaster;
  90   RefPtr<Element> mListener;
  91   // Note if mAttrName isn't used, this is the name of the attr, otherwise
  92   // this is the value of the attribute.
  93   nsString mAttr;
  94   RefPtr<nsAtom> mAttrName;
  95   bool mSetAttr;
  96   bool mNeedsAttrChange;
  97
  98   class Comparator {
  99    public:
 100     static bool Equals(const nsDelayedBroadcastUpdate& a,
 101                        const nsDelayedBroadcastUpdate& b) {
 102       return a.mBroadcaster == b.mBroadcaster && a.mListener == b.mListener &&
 103              a.mAttrName == b.mAttrName;
 104     }
 105   };
 106 };
 107
 108 /* static */
 109 bool XULBroadcastManager::MayNeedListener(const Element& aElement) {
 110   if (aElement.NodeInfo()->Equals(nsGkAtoms::observes, kNameSpaceID_XUL)) {
 111     return true;
 112   }
 113   if (aElement.HasAttr(nsGkAtoms::observes)) {
 114     return true;
 115   }
 116   if (aElement.HasAttr(nsGkAtoms::command) &&
 117       !(aElement.NodeInfo()->Equals(nsGkAtoms::menuitem, kNameSpaceID_XUL) ||
 118         aElement.NodeInfo()->Equals(nsGkAtoms::key, kNameSpaceID_XUL))) {
 119     return true;
 120   }
 121   return false;
 122 }
 123
 124 XULBroadcastManager::XULBroadcastManager(Document* aDocument)
 125     : mDocument(aDocument),
 126       mBroadcasterMap(nullptr),
 127       mHandlingDelayedAttrChange(false),
 128       mHandlingDelayedBroadcasters(false) {}
 129
 130 XULBroadcastManager::~XULBroadcastManager() { delete mBroadcasterMap; }
 131
 132 void XULBroadcastManager::DropDocumentReference(void) { mDocument = nullptr; }
 133
 134 void XULBroadcastManager::SynchronizeBroadcastListener(Element* aBroadcaster,
 135                                                        Element* aListener,
 136                                                        const nsAString& aAttr) {
 137   if (!nsContentUtils::IsSafeToRunScript()) {
 138     mDelayedBroadcasters.EmplaceBack(aBroadcaster, aListener, aAttr);
 139     MaybeBroadcast();
 140     return;
 141   }
 142   bool notify = mHandlingDelayedBroadcasters;
 143
 144   if (aAttr.EqualsLiteral("*")) {
 145     uint32_t count = aBroadcaster->GetAttrCount();
 146     nsTArray<nsAttrNameInfo> attributes(count);
 147     for (uint32_t i = 0; i < count; ++i) {
 148       const nsAttrName* attrName = aBroadcaster->GetAttrNameAt(i);
 149       int32_t nameSpaceID = attrName->NamespaceID();
 150       nsAtom* name = attrName->LocalName();
 151
 152       // _Don't_ push the |id|, |ref|, or |persist| attribute's value!
 153       if (!CanBroadcast(nameSpaceID, name)) continue;
 154
 155       attributes.AppendElement(
 156           nsAttrNameInfo(nameSpaceID, name, attrName->GetPrefix()));
 157     }
 158
 159     count = attributes.Length();
 160     while (count-- > 0) {
 161       int32_t nameSpaceID = attributes[count].mNamespaceID;
 162       nsAtom* name = attributes[count].mName;
 163       nsAutoString value;
 164       if (aBroadcaster->GetAttr(nameSpaceID, name, value)) {
 165         aListener->SetAttr(nameSpaceID, name, attributes[count].mPrefix, value,
 166                            notify);
 167       }
 168
 169 #if 0
 170             // XXX we don't fire the |onbroadcast| handler during
 171             // initial hookup: doing so would potentially run the
 172             // |onbroadcast| handler before the |onload| handler,
 173             // which could define JS properties that mask XBL
 174             // properties, etc.
 175             ExecuteOnBroadcastHandlerFor(aBroadcaster, aListener, name);
 176 #endif
 177     }
 178   } else {
 179     // Find out if the attribute is even present at all.
 180     RefPtr<nsAtom> name = NS_Atomize(aAttr);
 181
 182     nsAutoString value;
 183     if (aBroadcaster->GetAttr(kNameSpaceID_None, name, value)) {
 184       aListener->SetAttr(kNameSpaceID_None, name, value, notify);
 185     } else {
 186       aListener->UnsetAttr(kNameSpaceID_None, name, notify);
 187     }
 188
 189 #if 0
 190         // XXX we don't fire the |onbroadcast| handler during initial
 191         // hookup: doing so would potentially run the |onbroadcast|
 192         // handler before the |onload| handler, which could define JS
 193         // properties that mask XBL properties, etc.
 194         ExecuteOnBroadcastHandlerFor(aBroadcaster, aListener, name);
 195 #endif
 196   }
 197 }
 198
 199 void XULBroadcastManager::AddListenerFor(Element& aBroadcaster,
 200                                          Element& aListener,
 201                                          const nsAString& aAttr,
 202                                          ErrorResult& aRv) {
 203   if (!mDocument) {
 204     aRv.Throw(NS_ERROR_FAILURE);
 205     return;
 206   }
 207
 208   nsresult rv = nsContentUtils::CheckSameOrigin(mDocument, &aBroadcaster);
 209
 210   if (NS_FAILED(rv)) {
 211     aRv.Throw(rv);
 212     return;
 213   }
 214
 215   rv = nsContentUtils::CheckSameOrigin(mDocument, &aListener);
 216
 217   if (NS_FAILED(rv)) {
 218     aRv.Throw(rv);
 219     return;
 220   }
 221
 222   static const PLDHashTableOps gOps = {
 223       PLDHashTable::HashVoidPtrKeyStub, PLDHashTable::MatchEntryStub,
 224       PLDHashTable::MoveEntryStub, ClearBroadcasterMapEntry, nullptr};
 225
 226   if (!mBroadcasterMap) {
 227     mBroadcasterMap = new PLDHashTable(&gOps, sizeof(BroadcasterMapEntry));
 228   }
 229
 230   auto entry =
 231       static_cast<BroadcasterMapEntry*>(mBroadcasterMap->Search(&aBroadcaster));
 232   if (!entry) {
 233     entry = static_cast<BroadcasterMapEntry*>(
 234         mBroadcasterMap->Add(&aBroadcaster, fallible));
 235
 236     if (!entry) {
 237       aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
 238       return;
 239     }
 240
 241     entry->mBroadcaster = &aBroadcaster;
 242
 243     // N.B. placement new to construct the nsTArray object in-place
 244     new (&entry->mListeners) nsTArray<BroadcastListener*>();
 245   }
 246
 247   // Only add the listener if it's not there already!
 248   RefPtr<nsAtom> attr = NS_Atomize(aAttr);
 249
 250   for (size_t i = entry->mListeners.Length() - 1; i != (size_t)-1; --i) {
 251     BroadcastListener* bl = entry->mListeners[i];
 252     nsCOMPtr<Element> blListener = do_QueryReferent(bl->mListener);
 253
 254     if (blListener == &aListener && bl->mAttribute == attr) return;
 255   }
 256
 257   BroadcastListener* bl = new BroadcastListener;
 258   bl->mListener = do_GetWeakReference(&aListener);
 259   bl->mAttribute = attr;
 260
 261   entry->mListeners.AppendElement(bl);
 262
 263   SynchronizeBroadcastListener(&aBroadcaster, &aListener, aAttr);
 264 }
 265
 266 void XULBroadcastManager::RemoveListenerFor(Element& aBroadcaster,
 267                                             Element& aListener,
 268                                             const nsAString& aAttr) {
 269   // If we haven't added any broadcast listeners, then there sure
 270   // aren't any to remove.
 271   if (!mBroadcasterMap) return;
 272
 273   auto entry =
 274       static_cast<BroadcasterMapEntry*>(mBroadcasterMap->Search(&aBroadcaster));
 275   if (entry) {
 276     RefPtr<nsAtom> attr = NS_Atomize(aAttr);
 277     for (size_t i = entry->mListeners.Length() - 1; i != (size_t)-1; --i) {
 278       BroadcastListener* bl = entry->mListeners[i];
 279       nsCOMPtr<Element> blListener = do_QueryReferent(bl->mListener);
 280
 281       if (blListener == &aListener && bl->mAttribute == attr) {
 282         entry->mListeners.RemoveElementAt(i);
 283         delete bl;
 284
 285         if (entry->mListeners.IsEmpty()) mBroadcasterMap->RemoveEntry(entry);
 286
 287         break;
 288       }
 289     }
 290   }
 291 }
 292
 293 nsresult XULBroadcastManager::ExecuteOnBroadcastHandlerFor(
 294     Element* aBroadcaster, Element* aListener, nsAtom* aAttr) {
 295   if (!mDocument) {
 296     return NS_OK;
 297   }
 298   // Now we execute the onchange handler in the context of the
 299   // observer. We need to find the observer in order to
 300   // execute the handler.
 301
 302   for (nsCOMPtr<nsIContent> child = aListener->GetFirstChild(); child;
 303        child = child->GetNextSibling()) {
 304     // Look for an <observes> element beneath the listener. This
 305     // ought to have an |element| attribute that refers to
 306     // aBroadcaster, and an |attribute| element that tells us what
 307     // attriubtes we're listening for.
 308     if (!child->IsXULElement(nsGkAtoms::observes)) continue;
 309
 310     // Is this the element that was listening to us?
 311     nsAutoString listeningToID;
 312     child->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::element,
 313                                 listeningToID);
 314
 315     nsAutoString broadcasterID;
 316     aBroadcaster->GetAttr(kNameSpaceID_None, nsGkAtoms::id, broadcasterID);
 317
 318     if (listeningToID != broadcasterID) continue;
 319
 320     // We are observing the broadcaster, but is this the right
 321     // attribute?
 322     nsAutoString listeningToAttribute;
 323     child->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::attribute,
 324                                 listeningToAttribute);
 325
 326     if (!aAttr->Equals(listeningToAttribute) &&
 327         !listeningToAttribute.EqualsLiteral("*")) {
 328       continue;
 329     }
 330
 331     // This is the right <observes> element. Execute the
 332     // |onbroadcast| event handler
 333     WidgetEvent event(true, eXULBroadcast);
 334
 335     if (RefPtr<nsPresContext> presContext = mDocument->GetPresContext()) {
 336       // Handle the DOM event
 337       nsEventStatus status = nsEventStatus_eIgnore;
 338       EventDispatcher::Dispatch(child, presContext, &event, nullptr, &status);
 339     }
 340   }
 341
 342   return NS_OK;
 343 }
 344
 345 void XULBroadcastManager::AttributeChanged(Element* aElement,
 346                                            int32_t aNameSpaceID,
 347                                            nsAtom* aAttribute) {
 348   if (!mDocument) {
 349     return;
 350   }
 351   NS_ASSERTION(aElement->OwnerDoc() == mDocument, "unexpected doc");
 352
 353   // Synchronize broadcast listeners
 354   if (mBroadcasterMap && CanBroadcast(aNameSpaceID, aAttribute)) {
 355     auto entry =
 356         static_cast<BroadcasterMapEntry*>(mBroadcasterMap->Search(aElement));
 357
 358     if (entry) {
 359       // We've got listeners: push the value.
 360       nsAutoString value;
 361       bool attrSet = aElement->GetAttr(kNameSpaceID_None, aAttribute, value);
 362
 363       for (size_t i = entry->mListeners.Length() - 1; i != (size_t)-1; --i) {
 364         BroadcastListener* bl = entry->mListeners[i];
 365         if ((bl->mAttribute == aAttribute) ||
 366             (bl->mAttribute == nsGkAtoms::_asterisk)) {
 367           nsCOMPtr<Element> listenerEl = do_QueryReferent(bl->mListener);
 368           if (listenerEl) {
 369             nsAutoString currentValue;
 370             bool hasAttr = listenerEl->GetAttr(kNameSpaceID_None, aAttribute,
 371                                                currentValue);
 372             // We need to update listener only if we're
 373             // (1) removing an existing attribute,
 374             // (2) adding a new attribute or
 375             // (3) changing the value of an attribute.
 376             bool needsAttrChange =
 377                 attrSet != hasAttr || !value.Equals(currentValue);
 378             nsDelayedBroadcastUpdate delayedUpdate(aElement, listenerEl,
 379                                                    aAttribute, value, attrSet,
 380                                                    needsAttrChange);
 381
 382             size_t index = mDelayedAttrChangeBroadcasts.IndexOf(
 383                 delayedUpdate, 0, nsDelayedBroadcastUpdate::Comparator());
 384             if (index != mDelayedAttrChangeBroadcasts.NoIndex) {
 385               if (mHandlingDelayedAttrChange) {
 386                 NS_WARNING("Broadcasting loop!");
 387                 continue;
 388               }
 389               mDelayedAttrChangeBroadcasts.RemoveElementAt(index);
 390             }
 391
 392             mDelayedAttrChangeBroadcasts.AppendElement(
 393                 std::move(delayedUpdate));
 394           }
 395         }
 396       }
 397     }
 398   }
 399 }
 400
 401 void XULBroadcastManager::MaybeBroadcast() {
 402   // Only broadcast when not in an update and when safe to run scripts.
 403   if (mDocument && mDocument->UpdateNestingLevel() == 0 &&
 404       (mDelayedAttrChangeBroadcasts.Length() ||
 405        mDelayedBroadcasters.Length())) {
 406     if (!nsContentUtils::IsSafeToRunScript()) {
 407       if (mDocument) {
 408         nsContentUtils::AddScriptRunner(
 409             NewRunnableMethod("dom::XULBroadcastManager::MaybeBroadcast", this,
 410                               &XULBroadcastManager::MaybeBroadcast));
 411       }
 412       return;
 413     }
 414     if (!mHandlingDelayedAttrChange) {
 415       mHandlingDelayedAttrChange = true;
 416       for (uint32_t i = 0; i < mDelayedAttrChangeBroadcasts.Length(); ++i) {
 417         RefPtr<nsAtom> attrName = mDelayedAttrChangeBroadcasts[i].mAttrName;
 418         RefPtr<Element> listener = mDelayedAttrChangeBroadcasts[i].mListener;
 419         if (mDelayedAttrChangeBroadcasts[i].mNeedsAttrChange) {
 420           const nsString& value = mDelayedAttrChangeBroadcasts[i].mAttr;
 421           if (mDelayedAttrChangeBroadcasts[i].mSetAttr) {
 422             listener->SetAttr(kNameSpaceID_None, attrName, value, true);
 423           } else {
 424             listener->UnsetAttr(kNameSpaceID_None, attrName, true);
 425           }
 426         }
 427         RefPtr<Element> broadcaster =
 428             mDelayedAttrChangeBroadcasts[i].mBroadcaster;
 429         ExecuteOnBroadcastHandlerFor(broadcaster, listener, attrName);
 430       }
 431       mDelayedAttrChangeBroadcasts.Clear();
 432       mHandlingDelayedAttrChange = false;
 433     }
 434
 435     uint32_t length = mDelayedBroadcasters.Length();
 436     if (length) {
 437       bool oldValue = mHandlingDelayedBroadcasters;
 438       mHandlingDelayedBroadcasters = true;
 439       nsTArray<nsDelayedBroadcastUpdate> delayedBroadcasters =
 440           std::move(mDelayedBroadcasters);
 441       for (uint32_t i = 0; i < length; ++i) {
 442         SynchronizeBroadcastListener(delayedBroadcasters[i].mBroadcaster,
 443                                      delayedBroadcasters[i].mListener,
 444                                      delayedBroadcasters[i].mAttr);
 445       }
 446       mHandlingDelayedBroadcasters = oldValue;
 447     }
 448   }
 449 }
 450
 451 nsresult XULBroadcastManager::FindBroadcaster(Element* aElement,
 452                                               Element** aListener,
 453                                               nsString& aBroadcasterID,
 454                                               nsString& aAttribute,
 455                                               Element** aBroadcaster) {
 456   NodeInfo* ni = aElement->NodeInfo();
 457   *aListener = nullptr;
 458   *aBroadcaster = nullptr;
 459
 460   if (ni->Equals(nsGkAtoms::observes, kNameSpaceID_XUL)) {
 461     // It's an <observes> element, which means that the actual
 462     // listener is the _parent_ node. This element should have an
 463     // 'element' attribute that specifies the ID of the
 464     // broadcaster element, and an 'attribute' element, which
 465     // specifies the name of the attribute to observe.
 466     nsIContent* parent = aElement->GetParent();
 467     if (!parent) {
 468       // <observes> is the root element
 469       return NS_FINDBROADCASTER_NOT_FOUND;
 470     }
 471
 472     *aListener = Element::FromNode(parent);
 473     NS_IF_ADDREF(*aListener);
 474
 475     aElement->GetAttr(kNameSpaceID_None, nsGkAtoms::element, aBroadcasterID);
 476     if (aBroadcasterID.IsEmpty()) {
 477       return NS_FINDBROADCASTER_NOT_FOUND;
 478     }
 479     aElement->GetAttr(kNameSpaceID_None, nsGkAtoms::attribute, aAttribute);
 480   } else {
 481     // It's a generic element, which means that we'll use the
 482     // value of the 'observes' attribute to determine the ID of
 483     // the broadcaster element, and we'll watch _all_ of its
 484     // values.
 485     aElement->GetAttr(kNameSpaceID_None, nsGkAtoms::observes, aBroadcasterID);
 486
 487     // Bail if there's no aBroadcasterID
 488     if (aBroadcasterID.IsEmpty()) {
 489       // Try the command attribute next.
 490       aElement->GetAttr(kNameSpaceID_None, nsGkAtoms::command, aBroadcasterID);
 491       if (!aBroadcasterID.IsEmpty()) {
 492         // We've got something in the command attribute.  We
 493         // only treat this as a normal broadcaster if we are
 494         // not a menuitem or a key.
 495
 496         if (ni->Equals(nsGkAtoms::menuitem, kNameSpaceID_XUL) ||
 497             ni->Equals(nsGkAtoms::key, kNameSpaceID_XUL)) {
 498           return NS_FINDBROADCASTER_NOT_FOUND;
 499         }
 500       } else {
 501         return NS_FINDBROADCASTER_NOT_FOUND;
 502       }
 503     }
 504
 505     *aListener = aElement;
 506     NS_ADDREF(*aListener);
 507
 508     aAttribute.Assign('*');
 509   }
 510
 511   // Make sure we got a valid listener.
 512   NS_ENSURE_TRUE(*aListener, NS_ERROR_UNEXPECTED);
 513
 514   // Try to find the broadcaster element in the document.
 515   Document* doc = aElement->GetComposedDoc();
 516   if (doc) {
 517     *aBroadcaster = doc->GetElementById(aBroadcasterID);
 518   }
 519
 520   // The broadcaster element is missing.
 521   if (!*aBroadcaster) {
 522     return NS_FINDBROADCASTER_NOT_FOUND;
 523   }
 524
 525   NS_ADDREF(*aBroadcaster);
 526
 527   return NS_FINDBROADCASTER_FOUND;
 528 }
 529
 530 nsresult XULBroadcastManager::UpdateListenerHookup(Element* aElement,
 531                                                    HookupAction aAction) {
 532   // Resolve a broadcaster hookup. Look at the element that we're
 533   // trying to resolve: it could be an '<observes>' element, or just
 534   // a vanilla element with an 'observes' attribute on it.
 535   nsresult rv;
 536
 537   nsCOMPtr<Element> listener;
 538   nsAutoString broadcasterID;
 539   nsAutoString attribute;
 540   nsCOMPtr<Element> broadcaster;
 541
 542   rv = FindBroadcaster(aElement, getter_AddRefs(listener), broadcasterID,
 543                        attribute, getter_AddRefs(broadcaster));
 544   switch (rv) {
 545     case NS_FINDBROADCASTER_NOT_FOUND:
 546       return NS_OK;
 547     case NS_FINDBROADCASTER_FOUND:
 548       break;
 549     default:
 550       return rv;
 551   }
 552
 553   NS_ENSURE_ARG(broadcaster && listener);
 554   if (aAction == eHookupAdd) {
 555     ErrorResult domRv;
 556     AddListenerFor(*broadcaster, *listener, attribute, domRv);
 557     if (domRv.Failed()) {
 558       return domRv.StealNSResult();
 559     }
 560   } else {
 561     RemoveListenerFor(*broadcaster, *listener, attribute);
 562   }
 563
 564   // Tell the world we succeeded
 565   if (MOZ_LOG_TEST(sXULBroadCastManager, LogLevel::Debug)) {
 566     nsCOMPtr<nsIContent> content = listener;
 567     NS_ASSERTION(content != nullptr, "not an nsIContent");
 568     if (!content) {
 569       return rv;
 570     }
 571
 572     nsAutoCString attributeC, broadcasteridC;
 573     LossyCopyUTF16toASCII(attribute, attributeC);
 574     LossyCopyUTF16toASCII(broadcasterID, broadcasteridC);
 575     MOZ_LOG(sXULBroadCastManager, LogLevel::Debug,
 576             ("xul: broadcaster hookup <%s attribute='%s'> to %s",
 577              nsAtomCString(content->NodeInfo()->NameAtom()).get(),
 578              attributeC.get(), broadcasteridC.get()));
 579   }
 580
 581   return NS_OK;
 582 }
 583
 584 nsresult XULBroadcastManager::AddListener(Element* aElement) {
 585   return UpdateListenerHookup(aElement, eHookupAdd);
 586 }
 587
 588 nsresult XULBroadcastManager::RemoveListener(Element* aElement) {
 589   return UpdateListenerHookup(aElement, eHookupRemove);
 590 }
 591
 592 }  // namespace mozilla::dom