| blob | a97ce90c8ed9b638c004f279440e0b2b534536f4 |
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 /* ***** BEGIN LICENSE BLOCK *****
4 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
5 *
6 * The contents of this file are subject to the Mozilla Public License Version
7 * 1.1 (the "License"); you may not use this file except in compliance with
8 * the License. You may obtain a copy of the License at
9 * http://www.mozilla.org/MPL/
10 *
11 * Software distributed under the License is distributed on an "AS IS" basis,
12 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
13 * for the specific language governing rights and limitations under the
14 * License.
15 *
16 * The Original Code is Mozilla Communicator client code.
17 *
18 * The Initial Developer of the Original Code is
19 * Netscape Communications Corporation.
20 * Portions created by the Initial Developer are Copyright (C) 1998
21 * the Initial Developer. All Rights Reserved.
22 *
23 * Contributor(s):
24 * Chris Waterson <waterson@netscape.com>
25 * Ben Goodger <ben@netscape.com>
26 * Pete Collins <petejc@collab.net>
27 * Dan Rosen <dr@netscape.com>
28 * Johnny Stenback <jst@netscape.com>
29 *
30 * Alternatively, the contents of this file may be used under the terms of
31 * either of the GNU General Public License Version 2 or later (the "GPL"),
32 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
33 * in which case the provisions of the GPL or the LGPL are applicable instead
34 * of those above. If you wish to allow use of your version of this file only
35 * under the terms of either the GPL or the LGPL, and not to allow others to
36 * use your version of this file under the terms of the MPL, indicate your
37 * decision by deleting the provisions above and replace them with the notice
38 * and other provisions required by the GPL or the LGPL. If you do not delete
39 * the provisions above, a recipient may use your version of this file under
40 * the terms of any one of the MPL, the GPL or the LGPL.
41 *
42 * ***** END LICENSE BLOCK ***** */
44 /*
46 An implementation for the XUL document. This implementation serves
47 as the basis for generating an NGLayout content model.
49 Notes
50 -----
52 1. We do some monkey business in the document observer methods to`
53 keep the element map in sync for HTML elements. Why don't we just
54 do it for _all_ elements? Well, in the case of XUL elements,
55 which may be lazily created during frame construction, the
56 document observer methods will never be called because we'll be
57 adding the XUL nodes into the content model "quietly".
59 */
61 // Note the ALPHABETICAL ORDERING
129 //----------------------------------------------------------------------
130 //
131 // CIDs
132 //
137 {
138 // why is this check a member function of nsXULDocument? -gagan
143 }
145 //----------------------------------------------------------------------
146 //
147 // Miscellaneous Constants
148 //
154 };
159 //----------------------------------------------------------------------
160 //
161 // Statics
162 //
173 //----------------------------------------------------------------------
178 };
181 nsWeakPtr mListener;
183 };
185 nsIContent*
187 {
189 }
191 void
193 {
196 }
197 }
199 PRBool
201 {
205 }
207 PRBool
209 {
212 }
214 //----------------------------------------------------------------------
215 //
216 // ctors & dtors
217 //
219 // NOTE! nsDocument::operator new() zeroes out all members, so
220 // don't bother initializing members to 0.
226 {
228 // NOTE! nsDocument::operator new() zeroes out all members, so don't
229 // bother initializing members to 0.
231 // Override the default in nsDocument
237 }
240 {
244 // In case we failed somewhere early on and the forward observer
245 // decls never got resolved.
248 // Destroy our broadcaster map.
251 }
258 }
269 // Remove the current document here from the FastLoad table in
270 // case the document did not make it past StartLayout in
271 // ResumeWalk. The FastLoad table must be clear of entries so
272 // that the FastLoad file footer can be properly written.
275 }
276 }
278 nsresult
280 {
291 nsresult rv;
295 }
299 }
302 //----------------------------------------------------------------------
303 //
304 // nsISupports interface
305 //
309 static PLDHashOperator
312 {
322 }
324 static PLDHashOperator
326 {
330 NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mOverlayLoadObservers/mPendingOverlayLoadNotifications value");
334 }
339 }
340 // XXX tmp->mForwardReferences?
341 // XXX tmp->mContextStack?
343 // An element will only have a template builder as long as it's in the
344 // document, so we'll traverse the table here instead of from the element.
349 nsIScriptGlobalObjectOwner)
351 nsIScriptGlobalObjectOwner)
353 nsIDOMXULCommandDispatcher)
359 }
368 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
372 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
378 // QueryInterface implementation for nsXULDocument
385 NS_OFFSET_AND_INTERFACE_TABLE_END
386 NS_OFFSET_AND_INTERFACE_TABLE_TO_MAP_SEGUE
391 //----------------------------------------------------------------------
392 //
393 // nsIDocument interface
394 //
396 void
398 {
400 }
402 void
405 {
407 }
409 // Override the nsDocument.cpp method to keep from returning the
410 // "cached XUL" type which is completely internal and may confuse
411 // people
412 NS_IMETHODIMP
414 {
417 }
419 void
421 {
424 // Don't do anything, xul always has the mimetype
425 // application/vnd.mozilla.xul+xml
426 }
428 // This is called when the master document begins loading, whether it's
429 // fastloaded or not.
430 nsresult
436 {
437 // NOTE: If this ever starts calling nsDocument::StartDocumentLoad
438 // we'll possibly need to reset our content type afterwards.
447 // Get the URI. Note that this should match nsDocShell::OnLoadingSite
448 nsresult rv =
457 // Look in the chrome cache: we've got this puppy loaded
458 // already.
461 nsnull;
463 // Same comment as nsChromeProtocolHandler::NewChannel and
464 // nsXULDocument::ResumeWalk
465 // - Ben Goodger
466 //
467 // We don't abort on failure here because there are too many valid
468 // cases that can return failure, and the null-ness of |proto| is enough
469 // to trigger the fail-safe parse-from-disk solution. Example failure cases
470 // (for reference) include:
471 //
472 // NS_ERROR_NOT_AVAILABLE: the URI cannot be found in the FastLoad cache,
473 // parse from disk
474 // other: the FastLoad cache file, XUL.mfl, could not be found, probably
475 // due to being accessed before a profile has been selected (e.g.
476 // loading chrome for the profile manager itself). This must be
477 // parsed from disk.
480 // If we're racing with another document to load proto, wait till the
481 // load has finished loading before trying to add cloned style sheets.
482 // nsXULDocument::EndLoad will call proto->NotifyLoadDone, which will
483 // find all racing documents and notify them via OnPrototypeLoadDone,
484 // which will add style sheet clones to each document.
485 PRBool loaded;
491 // Set up the right principal on ourselves.
494 // We need a listener, even if proto is not yet loaded, in which
495 // event the listener's OnStopRequest method does nothing, and all
496 // the interesting work happens below nsXULDocument::EndLoad, from
497 // the call there to mCurrentPrototype->NotifyLoadDone().
501 }
507 // It's just a vanilla document load. Create a parser to deal
508 // with the stream n' stuff.
515 // Predicate mIsWritingFastLoad on the XUL cache being enabled,
516 // so we don't have to re-check whether the cache is enabled all
517 // the time.
528 // Put the current prototype, created under PrepareToLoad, into the
529 // XUL prototype cache now. We can't do this under PrepareToLoad or
530 // overlay loading will break; search for PutPrototype in ResumeWalk
531 // and see the comment there.
534 }
535 }
539 }
541 // This gets invoked after a prototype for this document or one of
542 // its overlays is fully built in the content sink.
543 void
545 {
546 // This can happen if an overlay fails to load
550 nsresult rv;
552 // Whack the prototype document into the cache so that the next
553 // time somebody asks for it, they don't need to load it by hand.
558 // Remember if the XUL cache is on
561 // If the current prototype is an overlay document (non-master prototype)
562 // and we're filling the FastLoad disk cache, tell the cache we're done
563 // loading it, and write the prototype. The master prototype is put into
564 // the cache earlier in nsXULDocument::StartDocumentLoad.
568 }
579 PRBool moreSheets;
584 moreSheets) {
591 }
595 }
596 }
597 }
600 // If it's a chrome prototype document, then notify any
601 // documents that raced to load the prototype, and awaited
602 // its load completion via proto->AwaitLoadDone().
605 }
606 }
609 }
611 NS_IMETHODIMP
613 {
614 nsresult rv;
616 // Add the style overlays from chrome registry, if any.
626 }
628 }
630 // called when an error occurs parsing a document
631 PRBool
633 {
634 // don't report errors that are from overlays
643 }
646 }
649 }
651 static void
653 {
658 }
660 // N.B. that we need to manually run the dtor because we
661 // constructed the nsSmallVoidArray object in-place.
663 }
665 static PRBool
667 {
668 // Don't push changes to the |id|, |ref|, |persist|, |command| or
669 // |observes| attribute.
677 }
678 }
680 }
682 struct nsAttrNameInfo
683 {
689 PRInt32 mNamespaceID;
692 };
694 void
698 {
701 aAttr);
704 }
708 // We may be copying event handlers etc, so we must also copy
709 // the script-type to the listener.
720 // _Don't_ push the |id|, |ref|, or |persist| attribute's value!
726 }
732 nsAutoString value;
736 }
738 #if 0
739 // XXX we don't fire the |onbroadcast| handler during
740 // initial hookup: doing so would potentially run the
741 // |onbroadcast| handler before the |onload| handler,
742 // which could define JS properties that mask XBL
743 // properties, etc.
745 #endif
746 }
747 }
749 // Find out if the attribute is even present at all.
752 nsAutoString value;
755 mInitialLayoutComplete);
758 mInitialLayoutComplete);
759 }
761 #if 0
762 // XXX we don't fire the |onbroadcast| handler during initial
763 // hookup: doing so would potentially run the |onbroadcast|
764 // handler before the |onload| handler, which could define JS
765 // properties that mask XBL properties, etc.
767 #endif
768 }
769 }
771 NS_IMETHODIMP
775 {
778 nsresult rv =
780 aBroadcaster);
784 }
787 aListener);
791 }
794 PL_DHashAllocTable,
795 PL_DHashFreeTable,
796 PL_DHashVoidPtrKeyStub,
797 PL_DHashMatchEntryStub,
798 PL_DHashMoveEntryStub,
799 ClearBroadcasterMapEntry,
800 PL_DHashFinalizeStub,
801 nsnull
802 };
805 mBroadcasterMap =
807 PL_DHASH_MIN_SIZE);
811 }
816 PL_DHASH_LOOKUP));
819 entry =
822 PL_DHASH_ADD));
829 // N.B. placement new to construct the nsSmallVoidArray object
830 // in-place
832 }
834 // Only add the listener if it's not there already!
845 }
858 }
860 NS_IMETHODIMP
864 {
865 // If we haven't added any broadcast listeners, then there sure
866 // aren't any to remove.
873 PL_DHASH_LOOKUP));
889 PL_DHASH_REMOVE);
892 }
893 }
894 }
897 }
899 nsresult
903 {
904 // Now we execute the onchange handler in the context of the
905 // observer. We need to find the observer in order to
906 // execute the handler.
911 // Look for an <observes> element beneath the listener. This
912 // ought to have an |element| attribute that refers to
913 // aBroadcaster, and an |attribute| element that tells us what
914 // attriubtes we're listening for.
920 // Is this the element that was listening to us?
921 nsAutoString listeningToID;
924 nsAutoString broadcasterID;
930 // We are observing the broadcaster, but is this the right
931 // attribute?
932 nsAutoString listeningToAttribute;
934 listeningToAttribute);
939 }
941 // This is the right <observes> element. Execute the
942 // |onbroadcast| event handler
951 // Handle the DOM event
955 }
956 }
959 }
961 void
964 {
968 // XXXbz check aNameSpaceID, dammit!
969 // See if we need to update our ref map.
973 }
976 }
978 void
982 PRUint32 aStateMask)
983 {
986 // Do this here so that all the exit paths below don't leave this undone
990 // XXXbz check aNameSpaceID, dammit!
991 // See if we need to update our ref map.
995 }
997 nsresult rv;
999 // Synchronize broadcast listeners
1006 PL_DHASH_LOOKUP));
1009 // We've got listeners: push the value.
1010 nsAutoString value;
1013 PRInt32 i;
1024 listenerEl,
1025 aAttribute,
1026 value,
1027 attrSet);
1029 }
1030 }
1031 }
1032 }
1033 }
1035 // checks for modifications in broadcasters
1039 // See if there is anything we need to persist in the localstore.
1040 //
1041 // XXX Namespace handling broken :-(
1042 nsAutoString persist;
1045 nsAutoString attr;
1049 // XXXldb This should check that it's a token, not just a substring.
1053 }
1054 }
1055 }
1057 void
1060 PRInt32 aNewIndexInContainer)
1061 {
1064 // Update our element map
1071 }
1074 }
1076 void
1080 PRInt32 aIndexInContainer)
1081 {
1087 }
1089 void
1093 PRInt32 aIndexInContainer)
1094 {
1100 }
1102 //----------------------------------------------------------------------
1103 //
1104 // nsIXULDocument interface
1105 //
1107 NS_IMETHODIMP
1109 {
1116 }
1118 NS_IMETHODIMP
1121 {
1130 }
1134 }
1136 }
1138 nsresult
1140 {
1145 }
1146 }
1150 }
1153 }
1156 nsresult
1158 {
1162 // Resolve each outstanding 'forward' reference. We iterate
1163 // through the list of forward references until no more forward
1164 // references can be resolved. This annealing process is
1165 // guaranteed to converge because we've "closed the gate" to new
1166 // forward references.
1186 // fixup because we removed from list
1191 // do nothing. we'll try again later
1192 ;
1193 }
1194 }
1195 }
1196 }
1199 }
1203 }
1205 NS_IMETHODIMP
1207 {
1210 }
1212 //----------------------------------------------------------------------
1213 //
1214 // nsIDOMDocument interface
1215 //
1217 NS_IMETHODIMP
1221 {
1227 MatchAttribute,
1229 attrValue,
1230 PR_TRUE,
1231 attrAtom,
1232 kNameSpaceID_Unknown);
1237 }
1239 NS_IMETHODIMP
1244 {
1252 nsresult rv =
1254 nameSpaceId);
1256 }
1259 MatchAttribute,
1261 attrValue,
1262 PR_TRUE,
1263 attrAtom,
1264 nameSpaceId);
1269 }
1271 NS_IMETHODIMP
1274 {
1275 // If we're currently reading persisted attributes out of the
1276 // localstore, _don't_ re-enter and try to set them again!
1280 nsresult rv;
1295 PRInt32 nameSpaceID;
1301 }
1303 // Make sure that this QName is going to be valid.
1310 // There was an invalid character or it was malformed.
1312 }
1315 // We don't really handle namespace qualifiers in attribute names.
1317 }
1323 }
1329 }
1332 PRBool
1334 {
1335 nsresult rv;
1337 // NodePrincipal is guarantied to be non-null
1344 }
1347 nsresult
1350 {
1351 // For non-chrome documents, persistance is simply broken
1355 // First make sure we _have_ a local store to stuff the persisted
1356 // information into. (We might not have one if profile information
1357 // hasn't been loaded yet...)
1361 nsresult rv;
1367 // No ID, so nothing to persist.
1371 // Ick. Construct a property from the attribute. Punt on
1372 // namespaces for now.
1377 // Don't bother with unreasonable attributes. We clamp long values,
1378 // but truncating attribute names turns it into a different attribute
1379 // so there's no point in persisting anything at all
1383 }
1390 // Turn the value into a literal
1391 nsAutoString valuestr;
1394 // prevent over-long attributes that choke the parser (bug 319846)
1395 // (can't simply Truncate without testing, it's implemented
1396 // using SetLength and will grow a short string)
1400 }
1402 // See if there was an old value...
1408 // ...there was an oldvalue, and they've removed it. XXXThis
1409 // handling isn't quite right...
1411 }
1413 // Now either 'change' or 'assert' based on whether there was
1414 // an old value.
1422 else
1424 }
1427 }
1428 }
1432 // Add it to the persisted set for this document (if it's not
1433 // there already).
1434 {
1435 nsCAutoString docurl;
1443 PRBool hasAssertion;
1450 }
1451 }
1454 }
1457 nsresult
1460 {
1477 }
1479 NS_IMETHODIMP
1481 {
1484 PRInt32 height;
1486 }
1488 NS_IMETHODIMP
1490 {
1493 PRInt32 width;
1495 }
1497 //----------------------------------------------------------------------
1498 //
1499 // nsIDOMXULDocument interface
1500 //
1502 NS_IMETHODIMP
1504 {
1505 // Get popup node.
1511 }
1514 }
1516 NS_IMETHODIMP
1518 {
1519 // Get the focus controller.
1524 // Get the popup node.
1526 }
1528 NS_IMETHODIMP
1530 {
1531 nsresult rv;
1533 // get focus controller
1537 // set popup node
1541 }
1543 // Returns the rangeOffset element from the XUL Popup Manager. This is for
1544 // chrome callers only.
1545 NS_IMETHODIMP
1547 {
1555 PRInt32 offset;
1561 }
1564 }
1566 // Returns the rangeOffset element from the XUL Popup Manager. We check the
1567 // rangeParent to determine if the caller has rights to access to the data.
1568 NS_IMETHODIMP
1570 {
1577 PRInt32 offset;
1586 }
1588 NS_IMETHODIMP
1590 {
1593 }
1597 }
1599 NS_IMETHODIMP
1601 {
1604 }
1606 NS_IMETHODIMP
1608 {
1611 }
1614 NS_IMETHODIMP
1616 {
1620 }
1622 NS_IMETHODIMP
1625 {
1641 }
1647 }
1649 }
1651 nsresult
1653 {
1654 // Do a bunch of work that's necessary when an element gets added
1655 // to the XUL Document.
1656 nsresult rv;
1658 // 1. Add the element to the resource-to-element map. Also add it to
1659 // the id map, since it seems this can be called when creating
1660 // elements from prototypes.
1665 // 2. If the element is a 'command updater' (i.e., has a
1666 // "commandupdater='true'" attribute), then add the element to the
1667 // document's command dispatcher
1672 }
1674 // 3. Check for a broadcaster hookup attribute, in which case
1675 // we'll hook the node up as a listener on a broadcaster.
1680 // If it's not there yet, we may be able to defer hookup until
1681 // later.
1689 }
1692 }
1694 nsresult
1696 {
1697 // We need to pay special attention to the keyset tag to set up a listener
1699 // Create our XUL key listener and hook it up.
1704 }
1705 }
1707 // See if we need to attach a XUL template to this node
1708 PRBool needsHookup;
1718 }
1727 }
1728 }
1731 }
1733 NS_IMETHODIMP
1735 {
1736 // From here on we only care about elements.
1739 }
1741 // Do pre-order addition magic
1745 // Recurse to children
1752 }
1754 // Do post-order addition magic
1756 }
1758 NS_IMETHODIMP
1760 {
1761 // From here on we only care about elements.
1764 }
1766 // Do a bunch of cleanup to remove an element from the XUL
1767 // document.
1768 nsresult rv;
1775 }
1776 }
1778 // 1. Remove any children from the document.
1785 }
1787 // 2. Remove the element from the resource-to-element map.
1788 // Also remove it from the id map, since we added it in
1789 // AddElementToDocumentPre().
1793 // 3. If the element is a 'command updater', then remove the
1794 // element from the document's command dispatcher.
1804 }
1806 // 4. Remove the element from our broadcaster map, since it is no longer
1807 // in the document.
1814 }
1817 }
1819 NS_IMETHODIMP
1822 {
1828 }
1829 }
1833 }
1836 }
1839 }
1841 NS_IMETHODIMP
1844 {
1847 }
1848 else
1852 }
1854 static void
1856 {
1860 }
1861 }
1863 nsresult
1865 {
1866 // Look at the element's 'ref' attribute, and if set,
1867 // add an entry in the resource-to-element map to the element.
1868 nsAutoString value;
1879 }
1882 }
1884 void
1886 {
1887 // Remove the element from the resource-to-element map.
1888 nsAutoString value;
1899 }
1900 }
1901 }
1903 //----------------------------------------------------------------------
1904 //
1905 // nsIDOMNode interface
1906 //
1908 NS_IMETHODIMP
1910 {
1911 // We don't allow cloning of a document
1914 }
1917 //----------------------------------------------------------------------
1918 //
1919 // Implementation methods
1920 //
1922 nsresult
1924 {
1931 // Create our command dispatcher and hook it up.
1935 // this _could_ fail; e.g., if we've tried to grab the local store
1936 // before profiles have initialized. If so, no big deal; nothing
1937 // will persist.
1941 // Keep the RDF service cached in a member variable to make using
1942 // it a bit less painful
1954 // ensure that the XUL prototype cache is instantiated successfully,
1955 // so that we can use nsXULPrototypeCache::GetInstance() without
1956 // null-checks in the rest of the class.
1961 }
1962 }
1964 #ifdef PR_LOGGING
1967 #endif
1970 }
1973 nsresult
1975 {
1977 #ifdef PR_LOGGING
1979 nsCAutoString urlspec;
1984 }
1985 #endif
1987 }
1993 // Resize-reflow this time
2011 // Trigger a refresh before the call to InitialReflow(),
2012 // because the view manager's UpdateView() function is
2013 // dropping dirty rects if refresh is disabled rather than
2014 // accumulating them until refresh is enabled and then
2015 // triggering a repaint...
2016 // XXXbz Is that still the case?
2023 PRBool enabled;
2027 }
2028 }
2029 }
2033 // Make sure we're holding a strong ref to |shell| before we call
2034 // InitialReflow()
2038 }
2041 }
2043 /* static */
2044 PRBool
2046 PRInt32 aNamespaceID,
2049 {
2057 eCaseMatters);
2058 }
2060 // Qualified name match. This takes more work.
2065 PRBool nameMatch;
2072 }
2078 }
2079 }
2082 }
2084 nsresult
2090 {
2091 // Get the document's principal
2096 }
2099 nsresult
2103 {
2104 nsresult rv;
2106 // Create a new prototype document.
2114 }
2116 // Bootstrap the master document prototype.
2119 // Set our principal based on the master proto.
2121 }
2123 // Create a XUL content sink, a parser, and kick off a load for
2124 // the overlay.
2137 eViewSource);
2140 kCharsetFromDocTypeDefault);
2146 }
2149 nsresult
2151 {
2152 // For non-chrome documents, persistance is simply broken
2156 // Add all of the 'persisted' attributes into the content
2157 // model.
2166 }
2169 nsresult
2171 {
2174 nsCAutoString docurl;
2196 }
2203 nsAutoString id;
2209 // This will clear the array if there are no elements.
2216 }
2219 }
2222 nsresult
2225 {
2226 nsresult rv;
2233 PRBool hasmore;
2248 }
2258 // XXX could hang namespace off here, as well...
2269 }
2285 attr,
2286 wrapper,
2287 PR_TRUE);
2288 }
2289 }
2292 }
2294 //----------------------------------------------------------------------
2295 //
2296 // nsXULDocument::ContextStack
2297 //
2301 {
2302 }
2305 {
2311 }
2312 }
2314 nsresult
2317 {
2332 }
2334 nsresult
2336 {
2347 }
2349 nsresult
2353 {
2363 }
2366 nsresult
2368 {
2374 }
2377 PRBool
2379 {
2385 kNameSpaceID_XUL)) {
2387 }
2388 }
2389 }
2391 }
2394 //----------------------------------------------------------------------
2395 //
2396 // Content model walking routines
2397 //
2399 nsresult
2401 {
2402 // Prepare to walk the mCurrentPrototype
2403 nsresult rv;
2405 // Keep an owning reference to the prototype document so that its
2406 // elements aren't yanked from beneath us.
2409 // Get the prototype's root element and initialize the context
2410 // stack for the prototype walk.
2414 #ifdef PR_LOGGING
2418 nsCAutoString urlspec;
2424 }
2425 #endif
2428 }
2435 }
2445 }
2447 // Now check the chrome registry for any additional overlays.
2451 // Do one-time initialization if we're preparing to walk the
2452 // master document's prototype.
2456 // Add the root element
2463 // Add the root element to the XUL document's ID-to-element map.
2468 // Block onload until we've finished building the complete
2469 // document content model.
2471 }
2473 // There'd better not be anything on the context stack at this
2474 // point! This is the basis case for our "induction" in
2475 // ResumeWalk(), below, which'll assume that there's always a
2476 // content element on the context stack if either 1) we're in the
2477 // "master" document, or 2) we're in an overlay, and we've got
2478 // more than one prototype element (the single, root "overlay"
2479 // element) on the stack.
2488 }
2490 nsresult
2493 {
2497 nsresult rv;
2501 mNodeInfoManager,
2511 // No special processing, just add the PI to the document.
2513 }
2516 }
2518 nsresult
2521 PRUint32 aIndex,
2523 {
2528 nsresult rv;
2531 // We want to be notified when the style sheet finishes loading, so
2532 // disable style sheet loading for now.
2541 // load the stylesheet if necessary, passing ourselves as
2542 // nsICSSObserver
2543 PRBool willNotify;
2544 PRBool isAlternate;
2548 }
2550 // Ignore errors from UpdateStyleSheet; we don't want failure to
2551 // do that to break the XUL document load. But do propagate out
2552 // NS_ERROR_OUT_OF_MEMORY.
2555 }
2558 }
2560 nsresult
2563 PRUint32 aIndex,
2565 {
2566 nsresult rv;
2571 // xul-overlay PI is special only in prolog
2574 }
2576 nsAutoString href;
2579 href);
2581 // If there was no href, we can't do anything with this PI
2584 }
2586 // Add the overlay to our list of overlays that need to be processed.
2592 // We insert overlays into mUnloadedOverlays at the same index in
2593 // document order, so they end up in the reverse of the document
2594 // order in mUnloadedOverlays.
2595 // This is needed because the code in ResumeWalk loads the overlays
2596 // by processing the last item of mUnloadedOverlays and removing it
2597 // from the array.
2600 // The URL is bad, move along. Don't propagate for now.
2601 // XXX report this to the Error Console (bug 359846)
2603 }
2606 }
2608 nsresult
2610 {
2611 nsresult rv;
2615 /* overlays only apply to chrome, skip all content URIs */
2619 // In embedding situations, the chrome registry may not provide overlays,
2620 // or even exist at all; that's OK.
2627 PRBool moreOverlays;
2632 moreOverlays) {
2641 }
2643 // Same comment as in nsXULDocument::InsertXULOverlayPI
2646 }
2649 }
2651 NS_IMETHODIMP
2653 {
2654 nsresult rv;
2663 NS_ERROR_OUT_OF_MEMORY);
2668 // We don't support loading the same overlay twice into the same
2669 // document - that doesn't make sense anyway.
2671 }
2673 }
2677 mOverlayLoadObservers.Remove(uri); // remove the observer if LoadOverlayInternal generated an error
2679 }
2681 nsresult
2685 {
2686 nsresult rv;
2691 #ifdef PR_LOGGING
2693 nsCAutoString urlspec;
2698 }
2699 #endif
2704 // Chrome documents are allowed to load overlays from anywhere.
2705 // In all other cases, the overlay is only allowed to load if
2706 // the master document and prototype document have the same origin.
2709 // Make sure we're allowed to load this overlay.
2714 }
2715 }
2717 // Look in the prototype cache for the prototype document with
2718 // the specified overlay URI.
2723 // Same comment as nsChromeProtocolHandler::NewChannel and
2724 // nsXULDocument::StartDocumentLoad
2725 // - Ben Goodger
2726 //
2727 // We don't abort on failure here because there are too many valid
2728 // cases that can return failure, and the null-ness of |proto| is
2729 // enough to trigger the fail-safe parse-from-disk solution.
2730 // Example failure cases (for reference) include:
2731 //
2732 // NS_ERROR_NOT_AVAILABLE: the URI was not found in the FastLoad file,
2733 // parse from disk
2734 // other: the FastLoad file, XUL.mfl, could not be found, probably
2735 // due to being accessed before a profile has been selected
2736 // (e.g. loading chrome for the profile manager itself).
2737 // The .xul file must be parsed from disk.
2744 PRBool loaded;
2749 // Return to the main event loop and eagerly await the
2750 // prototype overlay load's completion. When the content
2751 // sink completes, it will trigger an EndLoad(), which'll
2752 // wind us back up here, in ResumeWalk().
2755 }
2759 // Found the overlay's prototype in the cache, fully loaded. If
2760 // this is a dynamic overlay, this will call ResumeWalk.
2761 // Otherwise, we'll return to ResumeWalk, which called us.
2763 }
2765 // Not there. Initiate a load.
2768 // We'll set the right principal on the proto doc when we get
2769 // OnStartRequest from the parser, so just pass in a null principal for
2770 // now.
2775 // Predicate mIsWritingFastLoad on the XUL cache being enabled,
2776 // so we don't have to re-check whether the cache is enabled all
2777 // the time.
2784 // Add an observer to the parser; this'll get called when
2785 // Necko fires its On[Start|Stop]Request() notifications,
2786 // and will let us recover from a missing overlay.
2799 // Abandon this prototype
2802 // The parser won't get an OnStartRequest and
2803 // OnStopRequest, so it needs a Terminate.
2806 // Just move on to the next overlay. NS_OpenURI could fail
2807 // just because a channel could not be opened, which can happen
2808 // if a file or chrome package does not exist.
2811 // XXX the error could indicate an internal error as well...
2814 }
2816 // If it's a 'chrome:' prototype document, then put it into
2817 // the prototype cache; other XUL documents will be reloaded
2818 // each time. We must do this after NS_OpenURI and AsyncOpen,
2819 // or chrome code will wrongly create a cached chrome channel
2820 // instead of a real one.
2823 }
2825 // Return to the main event loop and eagerly await the
2826 // overlay load's completion. When the content sink
2827 // completes, it will trigger an EndLoad(), which'll wind
2828 // us back in ResumeWalk().
2831 }
2833 }
2835 static PLDHashOperator
2837 {
2845 }
2847 nsresult
2849 {
2850 // Walk the prototype and build the delegate content model. The
2851 // walk is performed in a top-down, left-to-right fashion. That
2852 // is, a parent is built before any of its children; a node is
2853 // only built after all of its siblings to the left are fully
2854 // constructed.
2855 //
2856 // It is interruptable so that transcluded documents (e.g.,
2857 // <html:script src="..." />) can be properly re-loaded if the
2858 // cached copy of the document becomes stale.
2859 nsresult rv;
2863 // Begin (or resume) walking the current prototype.
2866 // Look at the top of the stack to determine what we're
2867 // currently working on.
2868 // This will always be a node already constructed and
2869 // inserted to the actual document.
2873 // inclusive) have already been constructed
2879 // We've processed all of the prototype's children. If
2880 // we're in the master prototype, do post-order
2881 // document-level hookup. (An overlay will get its
2882 // document hookup done when it's successfully
2883 // resolved.)
2888 kNameSpaceID_XHTML) ||
2890 kNameSpaceID_SVG)) {
2891 // XXX sucks that we have to do this -
2892 // see bug 370111
2897 PRBool willNotify;
2898 PRBool isAlternate;
2901 }
2902 }
2904 #ifdef MOZ_XTF
2907 }
2908 #endif
2909 }
2910 // Now pop the context stack back up to the parent
2911 // element and continue the prototype walk.
2914 }
2916 // Grab the next child, and advance the current context stack
2917 // to the next sibling to our right.
2921 // Whether we're in the "first ply" of an overlay:
2922 // the "hookup" nodes. In the case !processingOverlayHookupNodes,
2923 // we're in the master document -or- we're in an overlay, and far
2924 // enough down into the overlay's content that we can simply build
2925 // the delegates and attach them to the parent node.
2934 // An 'element', which may contain more content.
2945 // ...and append it to the content model.
2949 // do pre-order document-level hookup, but only if
2950 // we're in the master document. For an overlay,
2951 // this will happen when the overlay is
2952 // successfully resolved.
2955 }
2957 // We're in the "first ply" of an overlay: the
2958 // "hookup" nodes. Create an 'overlay' element so
2959 // that we can continue to build content, and
2960 // enter a forward reference so we can hook it up
2961 // later.
2964 }
2966 // If it has children, push the element onto the context
2967 // stack and begin to process them.
2971 }
2974 // If there are no children, and we're in the
2975 // master document, do post-order document hookup
2976 // immediately.
2978 }
2979 #ifdef MOZ_XTF
2983 }
2984 #endif
2985 }
2986 }
2990 // A script reference. Execute the script immediately;
2991 // this may have side effects in the content model.
2996 // A transcluded script reference; this may
2997 // "block" our prototype walk if the script isn't
2998 // cached, or the cached copy of the script is
2999 // stale and must be reloaded.
3000 PRBool blocked;
3002 // If the script cannot be loaded, just keep going!
3006 }
3008 // An inline script
3011 }
3012 }
3016 // A simple text node.
3019 // This does mean that text nodes that are direct children
3020 // of <overlay> get ignored.
3024 mNodeInfoManager);
3033 }
3034 }
3041 // <?xul-overlay?> and <?xml-stylesheet?> don't have effect
3042 // outside the prolog, like they used to. Issue a warning.
3053 overlayURI,
3059 }
3065 // an inline script could have removed the root element
3069 }
3070 }
3075 }
3076 }
3078 // Once we get here, the context stack will have been
3079 // depleted. That means that the entire prototype has been
3080 // walked and content has been constructed.
3082 // If we're not already, mark us as now processing overlays.
3085 // If there are no overlay URIs, then we're done.
3097 // The failure |rv| was the result of a problem in the content
3098 // rather than an unexpected problem in our implementation, so
3099 // just continue with the next overlay.
3106 // This overlay has an unloaded overlay, so it will never
3107 // notify. The best we can do is to notify for the unloaded
3108 // overlay instead, assuming nobody is already notifiable
3109 // for it. Note that this will confuse the observer.
3113 }
3114 }
3118 }
3120 // If we get here, there is nothing left for us to walk. The content
3121 // model is built and ready for layout.
3130 }
3132 }
3134 nsresult
3136 {
3140 // XXXldb This is where we should really be setting the chromehidden
3141 // attribute.
3146 }
3150 // Make sure we don't reenter here from StartLayout(). Note that
3151 // setting mDocumentLoaded to true here means that if StartLayout()
3152 // causes ResumeWalk() to be reentered, we'll take the other branch of
3153 // the |if (!mDocumentLoaded)| check above and since
3154 // mInitialLayoutComplete will be false will follow the else branch
3155 // there too. See the big comment there for how such reentry can
3156 // happen.
3161 // Before starting layout, check whether we're a toplevel chrome
3162 // window. If we are, set our chrome flags now, so that we don't have
3163 // to restyle the whole frame tree after StartLayout.
3174 // We're the chrome document! Apply our chrome flags now.
3176 }
3177 }
3178 }
3192 }
3196 // DispatchContentLoadedEvents undoes the onload-blocking we
3197 // did in PrepareToWalk().
3202 // Walk the set of pending load notifications and notify any observers.
3203 // See below for detail.
3205 mPendingOverlayLoadNotifications.Enumerate(FirePendingMergeNotification, (void*)&mOverlayLoadObservers);
3206 }
3212 // We have completed initial layout, so just send the notification.
3217 }
3219 // If we have not yet displayed the document for the first time
3220 // (i.e. we came in here as the result of a dynamic overlay load
3221 // which was spawned by a binding-attached event caused by
3222 // StartLayout() on the master prototype - we must remember that
3223 // this overlay has been merged and tell the listeners after
3224 // StartLayout() is completely finished rather than doing so
3225 // immediately - otherwise we may be executing code that needs to
3226 // access XBL Binding implementations on nodes for which frames
3227 // have not yet been constructed because their bindings have not
3228 // yet been attached. This can be a race condition because dynamic
3229 // overlay loading can take varying amounts of time depending on
3230 // whether or not the overlay prototype is in the XUL cache. The
3231 // most likely effect of this bug is odd UI initialization due to
3232 // methods and properties that do not work.
3233 // XXXbz really, we shouldn't be firing binding constructors
3234 // until after StartLayout returns!
3236 NS_ENSURE_TRUE(mPendingOverlayLoadNotifications.IsInitialized() || mPendingOverlayLoadNotifications.Init(),
3237 NS_ERROR_OUT_OF_MEMORY);
3244 }
3245 }
3246 }
3247 }
3250 }
3252 NS_IMETHODIMP
3254 PRBool aWasAlternate,
3255 nsresult aStatus)
3256 {
3258 // Don't care about when alternate sheets finish loading
3267 }
3268 }
3271 }
3273 void
3275 {
3282 delayedAttrChangeBroadcasts);
3290 PR_TRUE);
3291 }
3294 PR_TRUE);
3295 }
3300 attrName);
3301 }
3302 }
3312 }
3313 }
3314 }
3315 }
3317 void
3319 {
3322 nsCAutoString spec;
3331 mDocumentURI,
3337 }
3339 nsresult
3341 {
3342 // Load a transcluded script
3343 nsresult rv;
3350 // Ignore return value from execution, and don't block
3353 }
3355 // Try the XUL script cache, in case two XUL documents source the same
3356 // .js file (e.g., strres.js from navigator.xul and utilityOverlay.xul).
3357 // XXXbe the cache relies on aScriptProto's GC root!
3367 // The script language for a proto must remain constant - we
3368 // can't just change it for this unexpected language.
3372 }
3374 }
3379 // Ignore return value from execution, and don't block
3382 }
3383 }
3385 // Set the current script prototype so that OnStreamComplete can report
3386 // the right file if there are errors in the script.
3392 // Another XULDocument load has started, which is still in progress.
3393 // Remember to ResumeWalk this document when the load completes.
3397 }
3401 // Note: the loader will keep itself alive while it's loading.
3408 }
3411 }
3413 // Block until OnStreamComplete resumes us.
3416 }
3419 NS_IMETHODIMP
3422 nsresult aStatus,
3423 PRUint32 stringLen,
3425 {
3430 #ifdef DEBUG
3431 // print a load error on bad status
3437 nsCAutoString uriSpec;
3440 }
3441 }
3442 }
3443 #endif
3445 // This is the completion routine that will be called when a
3446 // transcluded script completes. Compile and execute the script
3447 // if the load was successful, then continue building content
3448 // from the prototype.
3449 nsresult rv;
3454 // Clear mCurrentScriptProto now, but save it first for use below in
3455 // the compile/execute code, and in the while loop that resumes walks
3456 // of other documents that raced to load this script
3460 // Clear the prototype's loading flag before executing the script or
3461 // resuming document walks, in case any of those control flows starts a
3462 // new script load.
3466 // If the including XUL document is a FastLoad document, and we're
3467 // compiling an out-of-line script (one with src=...), then we must
3468 // be writing a new FastLoad file. If we were reading this script
3469 // from the FastLoad file, XULContentSinkImpl::OpenScript (over in
3470 // nsXULContentSink.cpp) would have already deserialized a non-null
3471 // script->mScriptObject, causing control flow at the top of LoadScript
3472 // not to reach here.
3475 // XXX should also check nsIHttpChannel::requestSucceeded
3477 nsString stringStr;
3483 }
3489 }
3491 // If the XUL cache is enabled, save the script object there in
3492 // case different XUL documents source the same script.
3493 //
3494 // But don't save the script in the cache unless the master XUL
3495 // document URL is a chrome: URL. It is valid for a URL such as
3496 // about:config to translate into a master document URL, whose
3497 // prototype document nodes -- including prototype scripts that
3498 // hold GC roots protecting their mJSObject pointers -- are not
3499 // cached in the XUL prototype cache. See StartDocumentLoad,
3500 // the fillXULCache logic.
3501 //
3502 // A document such as about:config is free to load a script via
3503 // a URL such as chrome://global/content/config.js, and we must
3504 // not cache that script object without a prototype cache entry
3505 // containing a companion nsXULPrototypeScript node that owns a
3506 // GC root protecting the script object. Otherwise, the script
3507 // cache entry will dangle once the uncached prototype document
3508 // is released when its owning nsXULDocument is unloaded.
3509 //
3510 // (See http://bugzilla.mozilla.org/show_bug.cgi?id=98207 for
3511 // the true crime story.)
3519 }
3522 // If we are loading an overlay script, try to serialize
3523 // it to the FastLoad file here. Master scripts will be
3524 // serialized when the master prototype document gets
3525 // written, at the bottom of ResumeWalk. That way, master
3526 // out-of-line scripts are serialized in the same order that
3527 // they'll be read, in the FastLoad file, which reduces the
3528 // number of seeks that dump the underlying stream's buffer.
3529 //
3530 // Ignore the return value, as we don't need to propagate
3531 // a failure to write to the FastLoad file, because this
3532 // method aborts that whole process on error.
3545 }
3546 }
3547 }
3548 // ignore any evaluation errors
3549 }
3553 // Load a pointer to the prototype-script's list of nsXULDocuments who
3554 // raced to load the same script
3557 // Resume walking other documents that waited for this one's load, first
3558 // executing the script we just compiled, in each doc's script context
3565 // Unlink doc from scriptProto's list before executing and resuming
3569 // Execute only if we loaded and compiled successfully, then resume
3573 }
3576 }
3579 }
3582 nsresult
3584 {
3591 // Execute the precompiled script with the given version
3592 nsresult rv;
3596 global,
3600 }
3602 nsresult
3604 {
3610 nsresult rv;
3616 // failure getting a script context is fatal.
3621 else
3624 }
3627 nsresult
3630 {
3631 // Create a content model element from a prototype element.
3639 #ifdef PR_LOGGING
3641 nsAutoString tagstr;
3644 nsCAutoString tagstrC;
3649 }
3650 #endif
3655 // If it's a XUL element, it'll be lightweight until somebody
3656 // monkeys with it.
3659 }
3661 // If it's not a XUL element, it's gonna be heavyweight no matter
3662 // what. So we need to copy everything out of the prototype
3663 // into the element. Get a nodeinfo from our nodeinfo manager
3664 // for this node.
3674 #ifdef MOZ_XTF
3677 }
3678 #endif
3682 }
3687 }
3689 nsresult
3692 {
3693 nsresult rv;
3704 // transferring ownership to ya...
3710 }
3712 nsresult
3715 {
3716 nsresult rv;
3720 nsAutoString valueStr;
3726 valueStr,
3727 PR_FALSE);
3729 }
3732 }
3735 nsresult
3738 {
3739 // See if the element already has a `database' attribute. If it
3740 // does, then the template builder has already been created.
3741 //
3742 // XXX This approach will crash and burn (well, maybe not _that_
3743 // bad) if aElement is not a XUL element.
3744 //
3745 // XXXvarga Do we still want to support non XUL content?
3753 }
3754 }
3756 // Check aElement for a 'datasources' attribute, if it has
3757 // one a XUL template builder needs to be hooked up.
3761 }
3763 /* static */ nsresult
3765 {
3766 // Check if need to construct a tree builder or content builder.
3773 PRInt32 nameSpaceID;
3778 // By default, we build content for a tree and then we attach
3779 // the tree content view. However, if the `dont-build-content'
3780 // flag is set, then we we'll attach a tree builder which
3781 // directly implements the tree view.
3783 nsAutoString flags;
3787 }
3788 }
3791 // Create and initialize a tree builder.
3800 // Create a <treechildren> if one isn't there already.
3801 // XXXvarga what about attributes?
3810 PR_FALSE,
3815 }
3816 }
3818 // Create and initialize a content builder.
3827 }
3830 }
3833 nsresult
3835 {
3836 nsresult rv;
3848 // XXXldb We need to prevent bogus sheets from being held in the
3849 // prototype's list, but until then, don't propagate the failure
3850 // from LoadSheet (and thus exit the loop).
3855 }
3856 }
3857 }
3860 }
3863 //----------------------------------------------------------------------
3864 //
3865 // nsXULDocument::OverlayForwardReference
3866 //
3870 {
3871 // Resolve a forward reference from an overlay element; attempt to
3872 // hook it up into the main document.
3873 nsresult rv;
3881 nsAutoString id;
3884 // mOverlay is a direct child of <overlay> and has no id.
3885 // Insert it under the root element in the base document.
3889 }
3895 }
3897 // The hook-up element has an id, try to match it with an element
3898 // with the same id in the base document.
3903 // If we can't find the element in the document, defer the hookup
3904 // until later.
3910 // While merging, set the default script language of the element to be
3911 // the language from the overlay - attributes will then be correctly
3912 // hooked up with the appropriate language (while child nodes ignore
3913 // the default language - they have it in their proto.
3919 }
3922 // Add child and any descendants to the element map
3925 }
3927 #ifdef PR_LOGGING
3929 nsCAutoString idC;
3934 }
3935 #endif
3939 }
3943 nsresult
3946 PRBool aNotify)
3947 {
3948 // This function is given:
3949 // aTargetNode: the node in the document whose 'id' attribute
3950 // matches a toplevel node in our overlay.
3951 // aOverlayNode: the node in the overlay document that matches
3952 // a node in the actual document.
3953 // aNotify: whether or not content manipulation methods should
3954 // use the aNotify parameter. After the initial
3955 // reflow (i.e. in the dynamic overlay merge case),
3956 // we want all the content manipulation methods we
3957 // call to notify so that frames are constructed
3958 // etc. Otherwise do not, since that's during initial
3959 // document construction before StartLayout has been
3960 // called which will do everything for us.
3961 //
3962 // This function merges the tree from the overlay into the tree in
3963 // the document, overwriting attributes and appending child content
3964 // nodes appropriately. (See XUL overlay reference for details)
3966 nsresult rv;
3968 // Merge attributes from the overlay content node to that of the
3969 // actual document.
3970 PRUint32 i;
3973 // We don't want to swap IDs, they should be the same.
3977 // In certain cases merging command or observes is unsafe, so don't.
3980 kNameSpaceID_XUL))
3990 kNameSpaceID_XUL) &&
3992 kNameSpaceID_XUL))
3994 }
4000 nsAutoString value;
4003 // Element in the overlay has the 'removeelement' attribute set
4004 // so remove it from the actual document.
4012 }
4016 }
4019 // Walk our child nodes, looking for elements that have the 'id'
4020 // attribute set. If we find any, we must do a parent check in the
4021 // actual document to ensure that the structure matches that of
4022 // the actual document. If it does, we can call ourselves and attempt
4023 // to merge inside that subtree. If not, we just append the tree to
4024 // the parent like any other.
4028 // This must be a strong reference since it will be the only
4029 // reference to a content object during part of this loop.
4035 nsAutoString id;
4046 }
4048 // The item has an 'id' attribute set, and we need to check with
4049 // the actual document to see if an item with this id exists at
4050 // this locale. If so, we want to merge the subtree under that
4051 // node. Otherwise, we just do an append as if the element had
4052 // no id attribute.
4054 // Given two parents, aTargetNode and aOverlayNode, we want
4055 // to call merge on currContent if we find an associated
4056 // node in the document with the same id as currContent that
4057 // also has aTargetNode as its parent.
4064 nsAutoString parentID;
4068 // The element matches. "Go Deep!"
4076 }
4077 }
4084 }
4087 }
4092 {
4093 #ifdef PR_LOGGING
4095 nsAutoString id;
4098 nsCAutoString idC;
4103 }
4104 #endif
4105 }
4108 //----------------------------------------------------------------------
4109 //
4110 // nsXULDocument::BroadcasterHookup
4111 //
4115 {
4116 nsresult rv;
4118 PRBool listener;
4123 }
4127 {
4128 #ifdef PR_LOGGING
4130 // Tell the world we failed
4131 nsresult rv;
4135 nsAutoString broadcasterID;
4136 nsAutoString attribute;
4141 }
4145 }
4147 nsAutoString tagStr;
4160 }
4161 #endif
4162 }
4165 //----------------------------------------------------------------------
4166 //
4167 // nsXULDocument::TemplateBuilderHookup
4168 //
4172 {
4173 PRBool needsHookup;
4182 }
4185 }
4188 //----------------------------------------------------------------------
4190 nsresult
4196 {
4200 nsresult rv;
4206 // It's an <observes> element, which means that the actual
4207 // listener is the _parent_ node. This element should have an
4208 // 'element' attribute that specifies the ID of the
4209 // broadcaster element, and an 'attribute' element, which
4210 // specifies the name of the attribute to observe.
4213 // <observes> is the root element
4215 }
4217 // If we're still parented by an 'overlay' tag, then we haven't
4218 // made it into the real document yet. Defer hookup.
4220 kNameSpaceID_XUL)) {
4222 }
4230 }
4232 }
4234 // It's a generic element, which means that we'll use the
4235 // value of the 'observes' attribute to determine the ID of
4236 // the broadcaster element, and we'll watch _all_ of its
4237 // values.
4240 // Bail if there's no aBroadcasterID
4242 // Try the command attribute next.
4245 // We've got something in the command attribute. We
4246 // only treat this as a normal broadcaster if we are
4247 // not a menuitem or a key.
4252 }
4253 }
4256 }
4257 }
4263 }
4265 // Make sure we got a valid listener.
4268 // Try to find the broadcaster element in the document.
4272 // If we can't find the broadcaster, then we'll need to defer the
4273 // hookup. We may need to resolve some of the other overlays
4274 // first.
4277 }
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 }
4317 #ifdef PR_LOGGING
4318 // Tell the world we succeeded
4327 nsAutoString tagStr;
4340 }
4341 #endif
4346 }
4348 nsresult
4350 {
4351 // Insert aChild appropriately into aParent, accounting for a
4352 // 'pos' attribute set on aChild.
4353 nsresult rv;
4355 nsAutoString posStr;
4358 // insert after an element of a given id
4365 }
4383 }
4403 }
4404 }
4405 }
4411 // Positions are one-indexed.
4413 // Note: if the insertion index (which is |pos - 1|) would be less
4414 // than 0 or greater than the number of children aParent has, then
4415 // don't insert, since the position is bogus. Just skip on to
4416 // appending.
4422 // If the insertion fails, then we should still
4423 // attempt an append. Thus, rather than returning rv
4424 // immediately, we fall through to the final
4425 // "catch-all" case that just does an AppendChildTo.
4426 }
4427 }
4428 }
4433 }
4435 }
4437 nsresult
4439 {
4443 }
4445 //----------------------------------------------------------------------
4446 //
4447 // CachedChromeStreamListener
4448 //
4450 nsXULDocument::CachedChromeStreamListener::CachedChromeStreamListener(nsXULDocument* aDocument, PRBool aProtoLoaded)
4453 {
4455 }
4459 {
4461 }
4467 NS_IMETHODIMP
4470 {
4472 }
4475 NS_IMETHODIMP
4478 nsresult aStatus)
4479 {
4484 }
4487 NS_IMETHODIMP
4491 PRUint32 aSourceOffset,
4492 PRUint32 aCount)
4493 {
4496 }
4498 //----------------------------------------------------------------------
4499 //
4500 // ParserObserver
4501 //
4506 {
4507 }
4510 {
4511 }
4515 NS_IMETHODIMP
4518 {
4519 // Guard against buggy channels calling OnStartRequest multiple times.
4527 // Failure there is ok -- it'll just set a (safe) null principal
4529 }
4531 // Make sure to avoid cycles
4533 }
4536 }
4538 NS_IMETHODIMP
4541 nsresult aStatus)
4542 {
4546 // If an overlay load fails, we need to nudge the prototype
4547 // walk along.
4554 }
4555 }
4558 }
4560 // Drop the reference to the document to break cycle between the
4561 // document, the parser, the content sink, and the parser
4562 // observer.
4566 }
4568 void
4570 {
4577 }