| blob | d2212b3c91e79348b30dc1461afb3645c7f84761 |
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /* vim: set ts=4 sw=4 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/. */
7 /*
9 An implementation for the XUL document. This implementation serves
10 as the basis for generating an NGLayout content model.
12 Notes
13 -----
15 1. We do some monkey business in the document observer methods to
16 keep the element map in sync for HTML elements. Why don't we just
17 do it for _all_ elements? Well, in the case of XUL elements,
18 which may be lazily created during frame construction, the
19 document observer methods will never be called because we'll be
20 adding the XUL nodes into the content model "quietly".
22 */
99 //----------------------------------------------------------------------
100 //
101 // CIDs
102 //
107 {
114 }
116 //----------------------------------------------------------------------
117 //
118 // Miscellaneous Constants
119 //
125 };
127 //----------------------------------------------------------------------
128 //
129 // Statics
130 //
136 //----------------------------------------------------------------------
141 };
144 nsWeakPtr mListener;
146 };
148 Element*
150 {
152 }
154 void
156 {
159 }
160 }
162 bool
164 {
168 }
170 bool
172 {
175 }
177 //----------------------------------------------------------------------
178 //
179 // ctors & dtors
180 //
190 {
191 // NOTE! nsDocument::operator new() zeroes out all members, so don't
192 // bother initializing members to 0.
194 // Override the default in nsDocument
203 }
206 {
210 // In case we failed somewhere early on and the forward observer
211 // decls never got resolved.
213 // Likewise for any references we have to IDs where we might
214 // look for persisted data:
217 // Destroy our broadcaster map.
220 }
229 }
230 }
235 nsresult
237 {
248 nsresult rv;
252 }
256 }
262 //----------------------------------------------------------------------
263 //
264 // nsISupports interface
265 //
267 static PLDHashOperator
270 {
280 }
282 static PLDHashOperator
284 {
288 NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mOverlayLoadObservers/mPendingOverlayLoadNotifications value");
292 }
299 // XXX tmp->mForwardReferences?
300 // XXX tmp->mContextStack?
302 // An element will only have a template builder as long as it's in the
303 // document, so we'll traverse the table here instead of from the element.
315 }
318 }
319 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
327 //XXX We should probably unlink all the objects we traverse.
328 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
334 // QueryInterface implementation for XULDocument
342 //----------------------------------------------------------------------
343 //
344 // nsIDocument interface
345 //
347 void
349 {
351 }
353 void
356 {
358 }
360 void
362 {
365 // Don't do anything, xul always has the mimetype
366 // application/vnd.mozilla.xul+xml
367 }
369 // This is called when the master document begins loading, whether it's
370 // being cached or not.
371 nsresult
377 {
378 #ifdef PR_LOGGING
384 nsAutoCString urlspec;
389 }
390 }
391 }
392 #endif
393 // NOTE: If this ever starts calling nsDocument::StartDocumentLoad
394 // we'll possibly need to reset our content type afterwards.
403 // Get the URI. Note that this should match nsDocShell::OnLoadingSite
404 nsresult rv =
412 // Look in the chrome cache: we've got this puppy loaded
413 // already.
418 // Same comment as nsChromeProtocolHandler::NewChannel and
419 // XULDocument::ResumeWalk
420 // - Ben Goodger
421 //
422 // We don't abort on failure here because there are too many valid
423 // cases that can return failure, and the null-ness of |proto| is enough
424 // to trigger the fail-safe parse-from-disk solution. Example failure cases
425 // (for reference) include:
426 //
427 // NS_ERROR_NOT_AVAILABLE: the URI cannot be found in the startup cache,
428 // parse from disk
429 // other: the startup cache file could not be found, probably
430 // due to being accessed before a profile has been selected (e.g.
431 // loading chrome for the profile manager itself). This must be
432 // parsed from disk.
435 // If we're racing with another document to load proto, wait till the
436 // load has finished loading before trying to add cloned style sheets.
437 // XULDocument::EndLoad will call proto->NotifyLoadDone, which will
438 // find all racing documents and notify them via OnPrototypeLoadDone,
439 // which will add style sheet clones to each document.
446 // Set up the right principal on ourselves.
449 // We need a listener, even if proto is not yet loaded, in which
450 // event the listener's OnStopRequest method does nothing, and all
451 // the interesting work happens below XULDocument::EndLoad, from
452 // the call there to mCurrentPrototype->NotifyLoadDone().
456 }
462 // It's just a vanilla document load. Create a parser to deal
463 // with the stream n' stuff.
470 // Predicate mIsWritingFastLoad on the XUL cache being enabled,
471 // so we don't have to re-check whether the cache is enabled all
472 // the time.
483 // Put the current prototype, created under PrepareToLoad, into the
484 // XUL prototype cache now. We can't do this under PrepareToLoad or
485 // overlay loading will break; search for PutPrototype in ResumeWalk
486 // and see the comment there.
489 }
490 }
494 }
496 // This gets invoked after a prototype for this document or one of
497 // its overlays is fully built in the content sink.
498 void
500 {
501 // This can happen if an overlay fails to load
505 nsresult rv;
507 // Whack the prototype document into the cache so that the next
508 // time somebody asks for it, they don't need to load it by hand.
513 // Remember if the XUL cache is on
516 // If the current prototype is an overlay document (non-master prototype)
517 // and we're filling the FastLoad disk cache, tell the cache we're done
518 // loading it, and write the prototype. The master prototype is put into
519 // the cache earlier in XULDocument::StartDocumentLoad.
523 }
539 moreSheets) {
546 }
550 }
551 }
552 }
555 // If it's a chrome prototype document, then notify any
556 // documents that raced to load the prototype, and awaited
557 // its load completion via proto->AwaitLoadDone().
560 }
561 }
564 #ifdef PR_LOGGING
566 nsAutoCString urlspec;
571 }
572 }
573 #endif
574 }
576 NS_IMETHODIMP
578 {
579 nsresult rv;
581 // Add the style overlays from chrome registry, if any.
591 }
593 }
595 // called when an error occurs parsing a document
596 bool
598 {
599 // don't report errors that are from overlays
608 }
611 }
614 }
616 static void
618 {
623 }
625 // N.B. that we need to manually run the dtor because we
626 // constructed the nsSmallVoidArray object in-place.
628 }
630 static bool
632 {
633 // Don't push changes to the |id|, |ref|, |persist|, |command| or
634 // |observes| attribute.
642 }
643 }
645 }
647 struct nsAttrNameInfo
648 {
657 };
659 void
663 {
666 aAttr);
670 }
681 // _Don't_ push the |id|, |ref|, or |persist| attribute's value!
687 }
693 nsAutoString value;
697 }
699 #if 0
700 // XXX we don't fire the |onbroadcast| handler during
701 // initial hookup: doing so would potentially run the
702 // |onbroadcast| handler before the |onload| handler,
703 // which could define JS properties that mask XBL
704 // properties, etc.
706 #endif
707 }
708 }
710 // Find out if the attribute is even present at all.
713 nsAutoString value;
718 }
720 #if 0
721 // XXX we don't fire the |onbroadcast| handler during initial
722 // hookup: doing so would potentially run the |onbroadcast|
723 // handler before the |onload| handler, which could define JS
724 // properties that mask XBL properties, etc.
726 #endif
727 }
728 }
730 NS_IMETHODIMP
734 {
735 ErrorResult rv;
741 }
743 void
746 {
747 nsresult rv =
753 }
760 }
763 PL_DHashAllocTable,
764 PL_DHashFreeTable,
765 PL_DHashVoidPtrKeyStub,
766 PL_DHashMatchEntryStub,
767 PL_DHashMoveEntryStub,
768 ClearBroadcasterMapEntry,
769 PL_DHashFinalizeStub,
770 nullptr
771 };
774 mBroadcasterMap =
780 }
781 }
788 entry =
795 }
799 // N.B. placement new to construct the nsSmallVoidArray object
800 // in-place
802 }
804 // Only add the listener if it's not there already!
815 }
825 }
827 NS_IMETHODIMP
831 {
837 }
839 void
843 {
844 // If we haven't added any broadcast listeners, then there sure
845 // aren't any to remove.
869 }
870 }
871 }
872 }
874 nsresult
878 {
879 // Now we execute the onchange handler in the context of the
880 // observer. We need to find the observer in order to
881 // execute the handler.
884 child;
887 // Look for an <observes> element beneath the listener. This
888 // ought to have an |element| attribute that refers to
889 // aBroadcaster, and an |attribute| element that tells us what
890 // attriubtes we're listening for.
894 // Is this the element that was listening to us?
895 nsAutoString listeningToID;
898 nsAutoString broadcasterID;
904 // We are observing the broadcaster, but is this the right
905 // attribute?
906 nsAutoString listeningToAttribute;
908 listeningToAttribute);
913 }
915 // This is the right <observes> element. Execute the
916 // |onbroadcast| event handler
923 // Handle the DOM event
927 }
928 }
931 }
933 void
937 {
941 // XXXbz check aNameSpaceID, dammit!
942 // See if we need to update our ref map.
944 // Might not need this, but be safe for now.
947 }
948 }
950 void
954 {
957 // Might not need this, but be safe for now.
960 // XXXbz check aNameSpaceID, dammit!
961 // See if we need to update our ref map.
964 }
966 nsresult rv;
968 // Synchronize broadcast listeners
976 // We've got listeners: push the value.
977 nsAutoString value;
990 nsAutoString currentValue;
992 aAttribute,
993 currentValue);
994 // We need to update listener only if we're
995 // (1) removing an existing attribute,
996 // (2) adding a new attribute or
997 // (3) changing the value of an attribute.
1001 listenerEl,
1002 aAttribute,
1003 value,
1004 attrSet,
1005 needsAttrChange);
1014 }
1016 }
1019 }
1020 }
1021 }
1022 }
1023 }
1025 // checks for modifications in broadcasters
1029 // See if there is anything we need to persist in the localstore.
1030 //
1031 // XXX Namespace handling broken :-(
1032 nsAutoString persist;
1035 // XXXldb This should check that it's a token, not just a substring.
1039 }
1040 }
1041 }
1043 void
1048 {
1051 // Might not need this, but be safe for now.
1054 // Update our element map
1059 }
1060 }
1062 void
1067 {
1070 // Might not need this, but be safe for now.
1074 }
1076 void
1082 {
1085 // Might not need this, but be safe for now.
1089 }
1091 //----------------------------------------------------------------------
1092 //
1093 // nsIXULDocument interface
1094 //
1096 void
1099 {
1105 }
1109 }
1110 }
1112 nsresult
1114 {
1119 }
1120 }
1124 }
1127 }
1129 nsresult
1131 {
1138 // Resolve each outstanding 'forward' reference. We iterate
1139 // through the list of forward references until no more forward
1140 // references can be resolved. This annealing process is
1141 // guaranteed to converge because we've "closed the gate" to new
1142 // forward references.
1162 // fixup because we removed from list
1167 // do nothing. we'll try again later
1168 ;
1169 }
1172 // Resolve() loaded a dynamic overlay,
1173 // (see XULDocument::LoadOverlayInternal()).
1174 // Return for now, we will be called again.
1176 }
1177 }
1178 }
1179 }
1182 }
1186 }
1188 //----------------------------------------------------------------------
1189 //
1190 // nsIDOMDocument interface
1191 //
1193 NS_IMETHODIMP
1197 {
1200 }
1205 {
1209 MatchAttribute,
1211 attrValue,
1213 attrAtom,
1214 kNameSpaceID_Unknown);
1217 }
1219 NS_IMETHODIMP
1224 {
1225 ErrorResult rv;
1229 }
1236 {
1242 nsresult rv =
1244 nameSpaceId);
1248 }
1249 }
1252 MatchAttribute,
1254 attrValue,
1256 attrAtom,
1257 nameSpaceId);
1259 }
1261 NS_IMETHODIMP
1264 {
1265 // If we're currently reading persisted attributes out of the
1266 // localstore, _don't_ re-enter and try to set them again!
1278 nsresult rv;
1282 }
1284 // Make sure that this QName is going to be valid.
1289 // There was an invalid character or it was malformed.
1291 }
1294 // We don't really handle namespace qualifiers in attribute names.
1296 }
1302 }
1305 }
1307 nsresult
1310 {
1311 // For non-chrome documents, persistance is simply broken
1319 }
1320 }
1322 nsAutoString id;
1327 nsAutoString valuestr;
1330 nsAutoCString utf8uri;
1334 }
1341 }
1347 }
1348 }
1351 nsresult
1354 {
1371 }
1373 NS_IMETHODIMP
1375 {
1380 }
1382 int32_t
1384 {
1388 }
1390 NS_IMETHODIMP
1392 {
1397 }
1399 int32_t
1401 {
1405 }
1407 JSObject*
1409 {
1412 // Window root occasionally keeps alive a node of a document whose
1413 // window is already dead. If in this brief period someone calls
1414 // GetPopupNode and we return that node, nsNodeSH::PreCreate will throw,
1415 // because it will not know which scope this node belongs to. Returning
1416 // an orphan node like that to JS would be a bug anyway, so to avoid
1417 // this, let's do the same check as nsNodeSH::PreCreate does to
1418 // determine the scope and if it fails let's just return null in
1419 // XULDocument::GetPopupNode.
1428 }
1430 //----------------------------------------------------------------------
1431 //
1432 // nsIDOMXULDocument interface
1433 //
1435 NS_IMETHODIMP
1437 {
1449 }
1450 }
1455 }
1458 }
1462 {
1468 }
1470 NS_IMETHODIMP
1472 {
1474 // only allow real node objects
1477 }
1484 }
1486 void
1488 {
1492 }
1494 // Returns the rangeOffset element from the XUL Popup Manager. This is for
1495 // chrome callers only.
1496 NS_IMETHODIMP
1498 {
1512 }
1515 }
1519 {
1524 }
1527 // Returns the rangeOffset element from the XUL Popup Manager. We check the
1528 // rangeParent to determine if the caller has rights to access to the data.
1529 NS_IMETHODIMP
1531 {
1532 ErrorResult rv;
1535 }
1537 int32_t
1539 {
1544 }
1553 }
1555 }
1557 NS_IMETHODIMP
1559 {
1567 }
1570 }
1574 {
1580 }
1582 NS_IMETHODIMP
1584 {
1585 // do nothing
1587 }
1590 NS_IMETHODIMP
1592 {
1596 }
1598 Element*
1600 {
1609 }
1616 }
1618 }
1620 nsresult
1622 {
1623 // Do a bunch of work that's necessary when an element gets added
1624 // to the XUL Document.
1625 nsresult rv;
1627 // 1. Add the element to the resource-to-element map. Also add it to
1628 // the id map, since it seems this can be called when creating
1629 // elements from prototypes.
1632 // FIXME: Shouldn't BindToTree take care of this?
1633 nsAutoScriptBlocker scriptBlocker;
1635 }
1639 // 2. If the element is a 'command updater' (i.e., has a
1640 // "commandupdater='true'" attribute), then add the element to the
1641 // document's command dispatcher
1646 }
1648 // 3. Check for a broadcaster hookup attribute, in which case
1649 // we'll hook the node up as a listener on a broadcaster.
1654 // If it's not there yet, we may be able to defer hookup until
1655 // later.
1663 }
1666 }
1668 nsresult
1670 {
1671 // We need to pay special attention to the keyset tag to set up a listener
1673 // Create our XUL key listener and hook it up.
1675 }
1677 // See if we need to attach a XUL template to this node
1688 }
1697 }
1698 }
1701 }
1703 NS_IMETHODIMP
1705 {
1707 // From here on we only care about elements.
1710 }
1714 // Do pre-order addition magic
1718 // Recurse to children
1720 child;
1726 }
1728 // Do post-order addition magic
1730 }
1732 NS_IMETHODIMP
1734 {
1735 // From here on we only care about elements.
1738 }
1742 // Do a bunch of cleanup to remove an element from the XUL
1743 // document.
1744 nsresult rv;
1748 }
1750 // 1. Remove any children from the document.
1752 child;
1758 }
1760 // 2. Remove the element from the resource-to-element map.
1761 // Also remove it from the id map, since we added it in
1762 // AddElementToDocumentPre().
1766 // FIXME: Shouldn't UnbindFromTree take care of this?
1767 nsAutoScriptBlocker scriptBlocker;
1769 }
1771 // 3. If the element is a 'command updater', then remove the
1772 // element from the document's command dispatcher.
1782 }
1784 // 4. Remove the element from our broadcaster map, since it is no longer
1785 // in the document.
1792 }
1795 }
1797 NS_IMETHODIMP
1800 {
1804 }
1806 }
1810 }
1813 }
1816 }
1818 NS_IMETHODIMP
1821 {
1824 }
1825 else
1829 }
1831 static void
1833 {
1835 }
1837 nsresult
1839 {
1840 // Look at the element's 'ref' attribute, and if set,
1841 // add an entry in the resource-to-element map to the element.
1842 nsAutoString value;
1850 }
1853 }
1855 void
1857 {
1858 // Remove the element from the resource-to-element map.
1859 nsAutoString value;
1867 }
1868 }
1869 }
1871 //----------------------------------------------------------------------
1872 //
1873 // nsIDOMNode interface
1874 //
1876 nsresult
1878 {
1879 // We don't allow cloning of a XUL document
1882 }
1885 //----------------------------------------------------------------------
1886 //
1887 // Implementation methods
1888 //
1890 nsresult
1892 {
1896 // Create our command dispatcher and hook it up.
1901 // ensure that the XUL prototype cache is instantiated successfully,
1902 // so that we can use nsXULPrototypeCache::GetInstance() without
1903 // null-checks in the rest of the class.
1908 }
1909 }
1914 #ifdef PR_LOGGING
1917 #endif
1920 }
1923 nsresult
1925 {
1929 // Resize-reflow this time
1944 }
1947 }
1949 /* static */
1950 bool
1955 {
1963 eCaseMatters);
1964 }
1966 // Qualified name match. This takes more work.
1978 }
1984 }
1985 }
1988 }
1990 nsresult
1996 {
1997 // Get the document's principal
2002 }
2005 nsresult
2009 {
2010 nsresult rv;
2012 // Create a new prototype document.
2020 }
2022 // Bootstrap the master document prototype.
2025 // Set our principal based on the master proto.
2027 }
2029 // Create a XUL content sink, a parser, and kick off a load for
2030 // the overlay.
2043 eViewSource);
2046 kCharsetFromDocTypeDefault);
2052 }
2055 nsresult
2057 {
2058 // For non-chrome documents, persistance is simply broken
2062 // Add all of the 'persisted' attributes into the content
2063 // model.
2068 }
2069 }
2075 // After we've applied persistence once, we should only reapply
2076 // it to nodes created by overlays
2081 }
2084 nsresult
2086 {
2089 nsAutoCString utf8uri;
2093 }
2096 // Get a list of element IDs for which persisted values are available
2101 }
2108 }
2110 nsAutoString id;
2115 }
2117 // This will clear the array if there are no elements.
2121 }
2126 }
2127 }
2130 }
2133 nsresult
2136 {
2137 nsAutoCString utf8uri;
2141 }
2144 // Get a list of attributes for which persisted values are available
2149 }
2156 }
2158 nsAutoString attrstr;
2161 nsAutoString value;
2165 }
2170 }
2178 }
2181 }
2182 }
2185 }
2187 void
2189 {
2193 }
2194 }
2196 //----------------------------------------------------------------------
2197 //
2198 // XULDocument::ContextStack
2199 //
2203 {
2204 }
2207 {
2213 }
2214 }
2216 nsresult
2219 {
2234 }
2236 nsresult
2238 {
2249 }
2251 nsresult
2255 {
2265 }
2268 nsresult
2270 {
2276 }
2279 //----------------------------------------------------------------------
2280 //
2281 // Content model walking routines
2282 //
2284 nsresult
2286 {
2287 // Prepare to walk the mCurrentPrototype
2288 nsresult rv;
2290 // Keep an owning reference to the prototype document so that its
2291 // elements aren't yanked from beneath us.
2294 // Get the prototype's root element and initialize the context
2295 // stack for the prototype walk.
2299 #ifdef PR_LOGGING
2303 nsAutoCString urlspec;
2309 }
2310 #endif
2313 }
2321 }
2331 }
2333 // Now check the chrome registry for any additional overlays.
2337 // Do one-time initialization if we're preparing to walk the
2338 // master document's prototype.
2342 // Add the root element
2352 // Block onload until we've finished building the complete
2353 // document content model.
2355 }
2357 // There'd better not be anything on the context stack at this
2358 // point! This is the basis case for our "induction" in
2359 // ResumeWalk(), below, which'll assume that there's always a
2360 // content element on the context stack if either 1) we're in the
2361 // "master" document, or 2) we're in an overlay, and we've got
2362 // more than one prototype element (the single, root "overlay"
2363 // element) on the stack.
2372 }
2374 nsresult
2377 {
2385 nsresult rv;
2391 // No special processing, just add the PI to the document.
2393 }
2396 }
2398 nsresult
2403 {
2408 nsresult rv;
2411 // We want to be notified when the style sheet finishes loading, so
2412 // disable style sheet loading for now.
2421 // load the stylesheet if necessary, passing ourselves as
2422 // nsICSSObserver
2428 }
2430 // Ignore errors from UpdateStyleSheet; we don't want failure to
2431 // do that to break the XUL document load. But do propagate out
2432 // NS_ERROR_OUT_OF_MEMORY.
2435 }
2438 }
2440 nsresult
2445 {
2446 nsresult rv;
2451 // xul-overlay PI is special only in prolog
2454 }
2456 nsAutoString href;
2459 href);
2461 // If there was no href, we can't do anything with this PI
2464 }
2466 // Add the overlay to our list of overlays that need to be processed.
2472 // We insert overlays into mUnloadedOverlays at the same index in
2473 // document order, so they end up in the reverse of the document
2474 // order in mUnloadedOverlays.
2475 // This is needed because the code in ResumeWalk loads the overlays
2476 // by processing the last item of mUnloadedOverlays and removing it
2477 // from the array.
2481 // The URL is bad, move along. Don't propagate for now.
2482 // XXX report this to the Error Console (bug 359846)
2484 }
2487 }
2489 nsresult
2491 {
2492 nsresult rv;
2496 /* overlays only apply to chrome or about URIs */
2501 // In embedding situations, the chrome registry may not provide overlays,
2502 // or even exist at all; that's OK.
2514 moreOverlays) {
2523 }
2525 // Same comment as in XULDocument::InsertXULOverlayPI
2527 }
2530 }
2532 NS_IMETHODIMP
2534 {
2535 nsresult rv;
2545 }
2549 // We don't support loading the same overlay twice into the same
2550 // document - that doesn't make sense anyway.
2552 }
2554 }
2558 mOverlayLoadObservers->Remove(uri); // remove the observer if LoadOverlayInternal generated an error
2560 }
2562 nsresult
2566 {
2567 nsresult rv;
2572 #ifdef PR_LOGGING
2574 nsAutoCString urlspec;
2576 nsAutoCString parentDoc;
2586 }
2587 #endif
2592 // Chrome documents are allowed to load overlays from anywhere.
2593 // In all other cases, the overlay is only allowed to load if
2594 // the master document and prototype document have the same origin.
2598 // Make sure we're allowed to load this overlay.
2603 }
2604 }
2606 // Look in the prototype cache for the prototype document with
2607 // the specified overlay URI. Only use the cache if the containing
2608 // document is chrome otherwise it may not have a system principal and
2609 // the cached document will, see bug 565610.
2614 // Same comment as nsChromeProtocolHandler::NewChannel and
2615 // XULDocument::StartDocumentLoad
2616 // - Ben Goodger
2617 //
2618 // We don't abort on failure here because there are too many valid
2619 // cases that can return failure, and the null-ness of |proto| is
2620 // enough to trigger the fail-safe parse-from-disk solution.
2621 // Example failure cases (for reference) include:
2622 //
2623 // NS_ERROR_NOT_AVAILABLE: the URI was not found in the FastLoad file,
2624 // parse from disk
2625 // other: the FastLoad file, XUL.mfl, could not be found, probably
2626 // due to being accessed before a profile has been selected
2627 // (e.g. loading chrome for the profile manager itself).
2628 // The .xul file must be parsed from disk.
2637 // Return to the main event loop and eagerly await the
2638 // prototype overlay load's completion. When the content
2639 // sink completes, it will trigger an EndLoad(), which'll
2640 // wind us back up here, in ResumeWalk().
2643 }
2647 // Found the overlay's prototype in the cache, fully loaded. If
2648 // this is a dynamic overlay, this will call ResumeWalk.
2649 // Otherwise, we'll return to ResumeWalk, which called us.
2651 }
2653 // Not there. Initiate a load.
2659 }
2661 // We'll set the right principal on the proto doc when we get
2662 // OnStartRequest from the parser, so just pass in a null principal for
2663 // now.
2668 // Predicate mIsWritingFastLoad on the XUL cache being enabled,
2669 // so we don't have to re-check whether the cache is enabled all
2670 // the time.
2677 // Add an observer to the parser; this'll get called when
2678 // Necko fires its On[Start|Stop]Request() notifications,
2679 // and will let us recover from a missing overlay.
2691 // Set the owner of the channel to be our principal so
2692 // that the overlay's JSObjects etc end up being created
2693 // with the right principal and in the correct
2694 // compartment.
2696 aURI,
2700 group);
2704 }
2707 // Abandon this prototype
2710 // The parser won't get an OnStartRequest and
2711 // OnStopRequest, so it needs a Terminate.
2714 // Just move on to the next overlay.
2717 // XXX the error could indicate an internal error as well...
2720 }
2722 // If it's a 'chrome:' prototype document, then put it into
2723 // the prototype cache; other XUL documents will be reloaded
2724 // each time. We must do this after AsyncOpen,
2725 // or chrome code will wrongly create a cached chrome channel
2726 // instead of a real one. Prototypes are only cached when the
2727 // document to be overlayed is chrome to avoid caching overlay
2728 // scripts with incorrect principals, see bug 565610.
2731 }
2733 // Return to the main event loop and eagerly await the
2734 // overlay load's completion. When the content sink
2735 // completes, it will trigger an EndLoad(), which'll wind
2736 // us back in ResumeWalk().
2739 }
2741 }
2743 static PLDHashOperator
2745 {
2752 }
2755 }
2757 nsresult
2759 {
2760 // Walk the prototype and build the delegate content model. The
2761 // walk is performed in a top-down, left-to-right fashion. That
2762 // is, a parent is built before any of its children; a node is
2763 // only built after all of its siblings to the left are fully
2764 // constructed.
2765 //
2766 // It is interruptable so that transcluded documents (e.g.,
2767 // <html:script src="..." />) can be properly re-loaded if the
2768 // cached copy of the document becomes stale.
2769 nsresult rv;
2774 // Begin (or resume) walking the current prototype.
2777 // Look at the top of the stack to determine what we're
2778 // currently working on.
2779 // This will always be a node already constructed and
2780 // inserted to the actual document.
2784 // inclusive) have already been constructed
2790 // We've processed all of the prototype's children. If
2791 // we're in the master prototype, do post-order
2792 // document-level hookup. (An overlay will get its
2793 // document hookup done when it's successfully
2794 // resolved.)
2799 kNameSpaceID_XHTML) ||
2801 kNameSpaceID_SVG)) {
2802 // XXX sucks that we have to do this -
2803 // see bug 370111
2812 }
2813 }
2814 }
2815 // Now pop the context stack back up to the parent
2816 // element and continue the prototype walk.
2819 }
2821 // Grab the next child, and advance the current context stack
2822 // to the next sibling to our right.
2826 // Whether we're in the "first ply" of an overlay:
2827 // the "hookup" nodes. In the case !processingOverlayHookupNodes,
2828 // we're in the master document -or- we're in an overlay, and far
2829 // enough down into the overlay's content that we can simply build
2830 // the delegates and attach them to the parent node.
2839 // An 'element', which may contain more content.
2851 // ...and append it to the content model.
2855 // If we're only restoring persisted things on
2856 // some elements, store the ID here to do that.
2861 }
2862 }
2864 // do pre-order document-level hookup, but only if
2865 // we're in the master document. For an overlay,
2866 // this will happen when the overlay is
2867 // successfully resolved.
2870 }
2872 // We're in the "first ply" of an overlay: the
2873 // "hookup" nodes. Create an 'overlay' element so
2874 // that we can continue to build content, and
2875 // enter a forward reference so we can hook it up
2876 // later.
2879 }
2881 // If it has children, push the element onto the context
2882 // stack and begin to process them.
2886 }
2889 // If there are no children, and we're in the
2890 // master document, do post-order document hookup
2891 // immediately.
2893 }
2894 }
2895 }
2899 // A script reference. Execute the script immediately;
2900 // this may have side effects in the content model.
2905 // A transcluded script reference; this may
2906 // "block" our prototype walk if the script isn't
2907 // cached, or the cached copy of the script is
2908 // stale and must be reloaded.
2911 // If the script cannot be loaded, just keep going!
2915 }
2917 // An inline script
2920 }
2921 }
2925 // A simple text node.
2928 // This does mean that text nodes that are direct children
2929 // of <overlay> get ignored.
2940 }
2941 }
2948 // <?xul-overlay?> and <?xml-stylesheet?> don't have effect
2949 // outside the prolog, like they used to. Issue a warning.
2962 overlayURI);
2963 }
2969 // an inline script could have removed the root element
2973 }
2974 }
2979 }
2980 }
2982 // Once we get here, the context stack will have been
2983 // depleted. That means that the entire prototype has been
2984 // walked and content has been constructed.
2986 // If we're not already, mark us as now processing overlays.
2989 // If there are no overlay URIs, then we're done.
3001 // The failure |rv| was the result of a problem in the content
3002 // rather than an unexpected problem in our implementation, so
3003 // just continue with the next overlay.
3010 // This overlay has an unloaded overlay, so it will never
3011 // notify. The best we can do is to notify for the unloaded
3012 // overlay instead, assuming nobody is already notifiable
3013 // for it. Note that this will confuse the observer.
3017 }
3018 }
3022 }
3024 // If we get here, there is nothing left for us to walk. The content
3025 // model is built and ready for layout.
3034 }
3036 }
3038 nsresult
3040 {
3044 // XXXldb This is where we should really be setting the chromehidden
3045 // attribute.
3050 }
3054 // Make sure we don't reenter here from StartLayout(). Note that
3055 // setting mDocumentLoaded to true here means that if StartLayout()
3056 // causes ResumeWalk() to be reentered, we'll take the other branch of
3057 // the |if (!mDocumentLoaded)| check above and since
3058 // mInitialLayoutComplete will be false will follow the else branch
3059 // there too. See the big comment there for how such reentry can
3060 // happen.
3065 // Before starting layout, check whether we're a toplevel chrome
3066 // window. If we are, set our chrome flags now, so that we don't have
3067 // to restyle the whole frame tree after StartLayout.
3077 // We're the chrome document! Apply our chrome flags now.
3079 }
3080 }
3081 }
3095 }
3099 // DispatchContentLoadedEvents undoes the onload-blocking we
3100 // did in PrepareToWalk().
3105 // Walk the set of pending load notifications and notify any observers.
3106 // See below for detail.
3110 }
3116 // We have completed initial layout, so just send the notification.
3121 }
3123 // If we have not yet displayed the document for the first time
3124 // (i.e. we came in here as the result of a dynamic overlay load
3125 // which was spawned by a binding-attached event caused by
3126 // StartLayout() on the master prototype - we must remember that
3127 // this overlay has been merged and tell the listeners after
3128 // StartLayout() is completely finished rather than doing so
3129 // immediately - otherwise we may be executing code that needs to
3130 // access XBL Binding implementations on nodes for which frames
3131 // have not yet been constructed because their bindings have not
3132 // yet been attached. This can be a race condition because dynamic
3133 // overlay loading can take varying amounts of time depending on
3134 // whether or not the overlay prototype is in the XUL cache. The
3135 // most likely effect of this bug is odd UI initialization due to
3136 // methods and properties that do not work.
3137 // XXXbz really, we shouldn't be firing binding constructors
3138 // until after StartLayout returns!
3141 mPendingOverlayLoadNotifications =
3143 }
3150 }
3151 }
3152 }
3153 }
3156 }
3158 NS_IMETHODIMP
3161 nsresult aStatus)
3162 {
3164 // Don't care about when alternate sheets finish loading
3173 }
3174 }
3177 }
3179 void
3181 {
3182 // Only broadcast when not in an update and when safe to run scripts.
3190 }
3192 }
3207 }
3208 }
3211 attrName);
3212 }
3215 }
3227 }
3229 }
3230 }
3231 }
3233 void
3235 {
3239 }
3241 void
3243 {
3246 nsAutoCString spec;
3256 }
3258 nsresult
3260 {
3261 // Load a transcluded script
3262 nsresult rv;
3269 // Ignore return value from execution, and don't block
3272 }
3274 // Try the XUL script cache, in case two XUL documents source the same
3275 // .js file (e.g., strres.js from navigator.xul and utilityOverlay.xul).
3276 // XXXbe the cache relies on aScriptProto's GC root!
3284 // The script language for a proto must remain constant - we
3285 // can't just change it for this unexpected language.
3287 }
3292 // Ignore return value from execution, and don't block
3295 }
3296 }
3298 // Allow security manager and content policies to veto the load. Note that
3299 // at this point we already lost context information of the script.
3308 }
3310 // Release script objects from FastLoad since we decided against using them
3313 // Set the current script prototype so that OnStreamComplete can report
3314 // the right file if there are errors in the script.
3320 // Another XULDocument load has started, which is still in progress.
3321 // Remember to ResumeWalk this document when the load completes.
3325 }
3329 // Note: the loader will keep itself alive while it's loading.
3338 group);
3343 }
3346 }
3348 // Block until OnStreamComplete resumes us.
3351 }
3353 NS_IMETHODIMP
3356 nsresult aStatus,
3359 {
3364 #ifdef DEBUG
3365 // print a load error on bad status
3371 nsAutoCString uriSpec;
3374 }
3375 }
3376 }
3377 #endif
3379 // This is the completion routine that will be called when a
3380 // transcluded script completes. Compile and execute the script
3381 // if the load was successful, then continue building content
3382 // from the prototype.
3388 // XXX Wallpaper for bug 270042
3390 }
3393 // If the including XUL document is a FastLoad document, and we're
3394 // compiling an out-of-line script (one with src=...), then we must
3395 // be writing a new FastLoad file. If we were reading this script
3396 // from the FastLoad file, XULContentSinkImpl::OpenScript (over in
3397 // nsXULContentSink.cpp) would have already deserialized a non-null
3398 // script->mScriptObject, causing control flow at the top of LoadScript
3399 // not to reach here.
3402 // XXX should also check nsIHttpChannel::requestSucceeded
3410 mOffThreadCompileStringBuf,
3411 mOffThreadCompileStringLength);
3413 // Attempt to give ownership of the buffer to the JS engine. If
3414 // we hit offthread compilation, however, we will have to take it
3415 // back below in order to keep the memory alive until compilation
3416 // completes.
3418 mOffThreadCompileStringLength,
3425 // We will be notified via OnOffThreadCompileComplete when the
3426 // compile finishes. Keep the contents of the compiled script
3427 // alive until the compilation finishes.
3429 // If the JS engine did not take the source buffer, then take
3430 // it back here to ensure it remains alive.
3434 }
3437 }
3438 }
3439 }
3442 }
3444 NS_IMETHODIMP
3446 {
3447 // When compiling off thread the script will not have been attached to the
3448 // script proto yet.
3452 // Allow load events to be fired once off thread compilation finishes.
3456 }
3458 // After compilation finishes the script's characters are no longer needed.
3463 }
3465 // Clear mCurrentScriptProto now, but save it first for use below in
3466 // the execute code, and in the while loop that resumes walks of other
3467 // documents that raced to load this script.
3471 // Clear the prototype's loading flag before executing the script or
3472 // resuming document walks, in case any of those control flows starts a
3473 // new script load.
3480 // If the XUL cache is enabled, save the script object there in
3481 // case different XUL documents source the same script.
3482 //
3483 // But don't save the script in the cache unless the master XUL
3484 // document URL is a chrome: URL. It is valid for a URL such as
3485 // about:config to translate into a master document URL, whose
3486 // prototype document nodes -- including prototype scripts that
3487 // hold GC roots protecting their mJSObject pointers -- are not
3488 // cached in the XUL prototype cache. See StartDocumentLoad,
3489 // the fillXULCache logic.
3490 //
3491 // A document such as about:config is free to load a script via
3492 // a URL such as chrome://global/content/config.js, and we must
3493 // not cache that script object without a prototype cache entry
3494 // containing a companion nsXULPrototypeScript node that owns a
3495 // GC root protecting the script object. Otherwise, the script
3496 // cache entry will dangle once the uncached prototype document
3497 // is released when its owning XULDocument is unloaded.
3498 //
3499 // (See http://bugzilla.mozilla.org/show_bug.cgi?id=98207 for
3500 // the true crime story.)
3507 }
3510 // If we are loading an overlay script, try to serialize
3511 // it to the FastLoad file here. Master scripts will be
3512 // serialized when the master prototype document gets
3513 // written, at the bottom of ResumeWalk. That way, master
3514 // out-of-line scripts are serialized in the same order that
3515 // they'll be read, in the FastLoad file, which reduces the
3516 // number of seeks that dump the underlying stream's buffer.
3517 //
3518 // Ignore the return value, as we don't need to propagate
3519 // a failure to write to the FastLoad file, because this
3520 // method aborts that whole process on error.
3522 }
3523 // ignore any evaluation errors
3524 }
3528 // Load a pointer to the prototype-script's list of XULDocuments who
3529 // raced to load the same script
3532 // Resume walking other documents that waited for this one's load, first
3533 // executing the script we just compiled, in each doc's script context
3540 // Unlink doc from scriptProto's list before executing and resuming
3544 // Execute only if we loaded and compiled successfully, then resume
3547 }
3550 }
3553 }
3555 nsresult
3557 {
3562 nsresult rv;
3569 // Execute the precompiled script with the given version
3570 nsAutoMicroTask mt;
3572 // We're about to run script via JS::CloneAndExecuteScript, so we need an
3573 // AutoEntryScript. This is Gecko specific and not in any spec.
3580 JSAddonId* addonId = mCurrentPrototype ? MapURIToAddonID(mCurrentPrototype->GetURI()) : nullptr;
3588 // The script is in the compilation scope. Clone it into the target scope
3589 // and execute it. On failure, ~AutoScriptEntry will handle exceptions, so
3590 // there is no need to manually check the return value.
3594 }
3597 nsresult
3601 {
3602 // Create a content model element from a prototype element.
3610 #ifdef PR_LOGGING
3615 }
3616 #endif
3621 // If it's a XUL element, it'll be lightweight until somebody
3622 // monkeys with it.
3625 }
3627 // If it's not a XUL element, it's gonna be heavyweight no matter
3628 // what. So we need to copy everything out of the prototype
3629 // into the element. Get a nodeinfo from our nodeinfo manager
3630 // for this node.
3639 NOT_FROM_PARSER);
3645 }
3650 }
3652 nsresult
3655 {
3656 nsresult rv;
3667 // transferring ownership to ya...
3673 }
3675 nsresult
3678 {
3679 nsresult rv;
3683 nsAutoString valueStr;
3689 valueStr,
3692 }
3695 }
3698 nsresult
3701 {
3702 // See if the element already has a `database' attribute. If it
3703 // does, then the template builder has already been created.
3704 //
3705 // XXX This approach will crash and burn (well, maybe not _that_
3706 // bad) if aElement is not a XUL element.
3707 //
3708 // XXXvarga Do we still want to support non XUL content?
3716 }
3717 }
3719 // Check aElement for a 'datasources' attribute, if it has
3720 // one a XUL template builder needs to be hooked up.
3724 }
3726 /* static */ nsresult
3728 {
3729 // Check if need to construct a tree builder or content builder.
3732 // return successful if the element is not is a document, as an inline
3733 // script could have removed it
3742 // By default, we build content for a tree and then we attach
3743 // the tree content view. However, if the `dont-build-content'
3744 // flag is set, then we we'll attach a tree builder which
3745 // directly implements the tree view.
3747 nsAutoString flags;
3751 }
3752 }
3755 // Create and initialize a tree builder.
3764 // Create a <treechildren> if one isn't there already.
3765 // XXXvarga what about attributes?
3772 nsresult rv =
3779 }
3780 }
3782 // Create and initialize a content builder.
3791 }
3794 }
3797 nsresult
3799 {
3800 nsresult rv;
3813 // XXXldb We need to prevent bogus sheets from being held in the
3814 // prototype's list, but until then, don't propagate the failure
3815 // from LoadSheet (and thus exit the loop).
3820 }
3821 }
3822 }
3825 }
3828 //----------------------------------------------------------------------
3829 //
3830 // XULDocument::OverlayForwardReference
3831 //
3835 {
3836 // Resolve a forward reference from an overlay element; attempt to
3837 // hook it up into the main document.
3838 nsresult rv;
3844 nsAutoString id;
3847 // mOverlay is a direct child of <overlay> and has no id.
3848 // Insert it under the root element in the base document.
3852 }
3858 }
3860 // The hook-up element has an id, try to match it with an element
3861 // with the same id in the base document.
3864 // If we can't find the element in the document, defer the hookup
3865 // until later.
3871 }
3873 // Check if 'target' is still in our document --- it might not be!
3875 // Add child and any descendants to the element map
3876 // XXX this is bogus, the content in 'target' might already be
3877 // in the document
3880 }
3882 #ifdef PR_LOGGING
3884 nsAutoCString idC;
3889 }
3890 #endif
3894 }
3898 nsresult
3902 {
3903 // This function is given:
3904 // aTargetNode: the node in the document whose 'id' attribute
3905 // matches a toplevel node in our overlay.
3906 // aOverlayNode: the node in the overlay document that matches
3907 // a node in the actual document.
3908 // aNotify: whether or not content manipulation methods should
3909 // use the aNotify parameter. After the initial
3910 // reflow (i.e. in the dynamic overlay merge case),
3911 // we want all the content manipulation methods we
3912 // call to notify so that frames are constructed
3913 // etc. Otherwise do not, since that's during initial
3914 // document construction before StartLayout has been
3915 // called which will do everything for us.
3916 //
3917 // This function merges the tree from the overlay into the tree in
3918 // the document, overwriting attributes and appending child content
3919 // nodes appropriately. (See XUL overlay reference for details)
3921 nsresult rv;
3923 // Merge attributes from the overlay content node to that of the
3924 // actual document.
3928 // We don't want to swap IDs, they should be the same.
3932 // In certain cases merging command or observes is unsafe, so don't.
3935 kNameSpaceID_XUL))
3945 kNameSpaceID_XUL) &&
3947 kNameSpaceID_XUL))
3949 }
3955 nsAutoString value;
3958 // Element in the overlay has the 'removeelement' attribute set
3959 // so remove it from the actual document.
3969 }
3974 nameSpaceID,
3976 value);
3978 }
3981 // Walk our child nodes, looking for elements that have the 'id'
3982 // attribute set. If we find any, we must do a parent check in the
3983 // actual document to ensure that the structure matches that of
3984 // the actual document. If it does, we can call ourselves and attempt
3985 // to merge inside that subtree. If not, we just append the tree to
3986 // the parent like any other.
3990 // This must be a strong reference since it will be the only
3991 // reference to a content object during part of this loop.
4005 //XXXsmaug should we use ShadowRoot::GetElementById()
4006 // if doc is null?
4010 }
4011 }
4013 // The item has an 'id' attribute set, and we need to check with
4014 // the actual document to see if an item with this id exists at
4015 // this locale. If so, we want to merge the subtree under that
4016 // node. Otherwise, we just do an append as if the element had
4017 // no id attribute.
4019 // Given two parents, aTargetNode and aOverlayNode, we want
4020 // to call merge on currContent if we find an associated
4021 // node in the document with the same id as currContent that
4022 // also has aTargetNode as its parent.
4030 eCaseMatters)) {
4031 // The element matches. "Go Deep!"
4037 }
4038 }
4044 }
4047 }
4052 {
4053 #ifdef PR_LOGGING
4055 nsAutoString id;
4058 nsAutoCString idC;
4062 nsAutoCString urlspec;
4066 nsAutoCString parentDoc;
4073 }
4074 #endif
4075 }
4078 //----------------------------------------------------------------------
4079 //
4080 // XULDocument::BroadcasterHookup
4081 //
4085 {
4086 nsresult rv;
4093 }
4097 {
4098 #ifdef PR_LOGGING
4100 // Tell the world we failed
4103 nsAutoString broadcasterID;
4104 nsAutoString attribute;
4109 }
4113 }
4123 }
4124 #endif
4125 }
4128 //----------------------------------------------------------------------
4129 //
4130 // XULDocument::TemplateBuilderHookup
4131 //
4135 {
4145 }
4148 }
4151 //----------------------------------------------------------------------
4153 nsresult
4159 {
4173 // We've got listeners: push the value.
4188 }
4189 }
4191 }
4193 nsresult
4199 {
4205 // It's an <observes> element, which means that the actual
4206 // listener is the _parent_ node. This element should have an
4207 // 'element' attribute that specifies the ID of the
4208 // broadcaster element, and an 'attribute' element, which
4209 // specifies the name of the attribute to observe.
4212 // <observes> is the root element
4214 }
4216 // If we're still parented by an 'overlay' tag, then we haven't
4217 // made it into the real document yet. Defer hookup.
4219 kNameSpaceID_XUL)) {
4221 }
4229 }
4231 }
4233 // It's a generic element, which means that we'll use the
4234 // value of the 'observes' attribute to determine the ID of
4235 // the broadcaster element, and we'll watch _all_ of its
4236 // values.
4239 // Bail if there's no aBroadcasterID
4241 // Try the command attribute next.
4244 // We've got something in the command attribute. We
4245 // only treat this as a normal broadcaster if we are
4246 // not a menuitem or a key.
4251 }
4252 }
4255 }
4256 }
4262 }
4264 // Make sure we got a valid listener.
4267 // Try to find the broadcaster element in the document.
4270 // If we can't find the broadcaster, then we'll need to defer the
4271 // hookup. We may need to resolve some of the other overlays
4272 // first.
4275 }
4280 }
4282 nsresult
4286 {
4287 // Resolve a broadcaster hookup. Look at the element that we're
4288 // trying to resolve: it could be an '<observes>' element, or just
4289 // a vanilla element with an 'observes' attribute on it.
4290 nsresult rv;
4295 nsAutoString broadcasterID;
4296 nsAutoString attribute;
4312 }
4315 ErrorResult domRv;
4319 }
4321 #ifdef PR_LOGGING
4322 // Tell the world we succeeded
4339 }
4340 #endif
4345 }
4347 nsresult
4350 {
4351 // Insert aChild appropriately into aParent, accounting for a
4352 // 'pos' attribute set on aChild.
4354 nsAutoString posStr;
4357 // insert after an element of a given id
4364 }
4381 }
4394 }
4395 }
4396 }
4402 nsresult rv;
4403 // Positions are one-indexed.
4405 // Note: if the insertion index (which is |pos - 1|) would be less
4406 // than 0 or greater than the number of children aParent has, then
4407 // don't insert, since the position is bogus. Just skip on to
4408 // appending.
4414 // If the insertion fails, then we should still
4415 // attempt an append. Thus, rather than returning rv
4416 // immediately, we fall through to the final
4417 // "catch-all" case that just does an AppendChildTo.
4418 }
4419 }
4420 }
4424 }
4426 }
4428 nsresult
4430 {
4435 }
4437 //----------------------------------------------------------------------
4438 //
4439 // CachedChromeStreamListener
4440 //
4442 XULDocument::CachedChromeStreamListener::CachedChromeStreamListener(XULDocument* aDocument, bool aProtoLoaded)
4445 {
4447 }
4451 {
4453 }
4459 NS_IMETHODIMP
4462 {
4464 }
4467 NS_IMETHODIMP
4470 nsresult aStatus)
4471 {
4476 }
4479 NS_IMETHODIMP
4485 {
4488 }
4490 //----------------------------------------------------------------------
4491 //
4492 // ParserObserver
4493 //
4498 {
4499 }
4502 {
4503 }
4507 NS_IMETHODIMP
4510 {
4511 // Guard against buggy channels calling OnStartRequest multiple times.
4519 // Failure there is ok -- it'll just set a (safe) null principal
4521 }
4523 // Make sure to avoid cycles
4525 }
4528 }
4530 NS_IMETHODIMP
4533 nsresult aStatus)
4534 {
4538 // If an overlay load fails, we need to nudge the prototype
4539 // walk along.
4546 }
4547 }
4550 }
4552 // Drop the reference to the document to break cycle between the
4553 // document, the parser, the content sink, and the parser
4554 // observer.
4558 }
4562 {
4565 }
4569 }
4571 bool
4573 {
4574 // setting the localedir attribute on the root element forces a
4575 // specific direction for the document.
4585 }
4586 }
4588 // otherwise, get the locale from the chrome registry and
4589 // look up the intl.uidirection.<locale> preference
4595 nsAutoCString package;
4598 isChrome) {
4600 }
4602 // use the 'global' package for about and resource uris.
4603 // otherwise, just default to left-to-right.
4606 isAbout) {
4608 }
4610 isResource) {
4612 }
4615 }
4616 }
4621 }
4623 void
4625 {
4627 }
4629 void
4631 {
4632 // Reset the direction and restyle the document if necessary.
4636 }
4637 }
4639 int
4641 {
4646 nsAutoString hasLWTheme;
4652 nsAutoString lwTheme;
4659 }
4660 }
4661 }
4663 }
4665 NS_IMETHODIMP
4667 {
4668 ErrorResult rv;
4672 }
4674 JSObject*
4676 {
4678 }