| blob | c84769add8650ce362642f21c2c5ae4767a56c5c |
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 * vim: ft=cpp tw=78 sw=4 et ts=4 sts=4 cin
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 the Mozilla browser.
17 *
18 * The Initial Developer of the Original Code is
19 * Netscape Communications, Inc.
20 * Portions created by the Initial Developer are Copyright (C) 1999
21 * the Initial Developer. All Rights Reserved.
22 *
23 * Contributor(s):
24 * Travis Bogard <travis@netscape.com>
25 * Pierre Phaneuf <pp@ludusdesign.com>
26 * Peter Annema <disttsc@bart.nl>
27 * Dan Rosen <dr@netscape.com>
28 * Mats Palmgren <mats.palmgren@bredband.net>
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 #ifdef MOZ_LOGGING
45 // so we can get logging even in release builds (but only for some things)
46 #define FORCE_PR_LOG 1
47 #endif
113 // we want to explore making the document own the load group
114 // so we can associate the document URI with the load group.
115 // until this point, we have an evil hack:
119 // Local Includes
127 // Helper Classes
131 // Interfaces Needed
153 // Editor-related
164 // The following are for bug #13871: Prevent frameset spoofing
167 // For reporting errors with the console service.
168 // These can go away if error reporting is propagated up past nsDocShell.
172 // used to dispatch urls to default protocol handlers
190 #ifdef DEBUG_DOCSHELL_FOCUS
192 #endif
196 // for embedding
202 NS_DOM_SCRIPT_OBJECT_FACTORY_CID);
205 #if defined(DEBUG_bryner) || defined(DEBUG_chb)
206 //#define DEBUG_DOCSHELL_FOCUS
207 #define DEBUG_PAGE_CACHE
208 #endif
213 // Number of documents currently loading
216 // Global count of existing docshells.
219 // Global reference to the URI fixup service.
222 // True means we validate window targets to prevent frameset
223 // spoofing. Initialize this to a non-bolean value so we know to check
224 // the pref on the creation of the first docshell.
227 // Hint for native dispatch of events on how long to delay after
228 // all documents have loaded in milliseconds before favoring normal
229 // native event dispatch priorites over performance
230 #define NS_EVENT_STARVATION_DELAY_HINT 2000
232 // This is needed for displaying an error message
233 // when navigation is attempted on a document when printing
234 // The value arbitrary as long as it doesn't conflict with
235 // any of the other values in the errors in DisplayLoadError
236 #define NS_ERROR_DOCUMENT_IS_PRINTMODE NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_GENERAL,2001)
238 #ifdef PR_LOGGING
239 #ifdef DEBUG
241 #endif
243 #endif
248 static void
250 {
254 }
256 //*****************************************************************************
257 //*** nsDocShellFocusController
258 //*****************************************************************************
260 class nsDocShellFocusController
261 {
277 };
281 //*****************************************************************************
282 //*** nsDocShell: Object Management
283 //*****************************************************************************
318 #ifdef DEBUG
320 #endif
321 {
327 }
329 #ifdef PR_LOGGING
330 #ifdef DEBUG
333 #endif
338 #endif
339 }
342 {
346 }
351 }
353 #ifdef PR_LOGGING
356 #endif
357 }
359 nsresult
361 {
376 // We want to hold a strong ref to the loadgroup, so it better hold a weak
377 // ref to us... use an InterfaceRequestorProxy to do this.
387 // Add as |this| a progress listener to itself. A little weird, but
388 // simpler than reproducing all the listener-notification logic in
389 // overrides of the various methods via which nsDocLoader can be
390 // notified. Note that this holds an nsWeakPtr to ourselves, so it's ok.
394 }
396 void
398 {
407 }
408 }
411 }
413 //*****************************************************************************
414 // nsDocShell::nsISupports
415 //*****************************************************************************
443 ///*****************************************************************************
444 // nsDocShell::nsIInterfaceRequestor
445 //*****************************************************************************
447 {
454 }
458 }
464 }
469 }
473 // Return application cache associated with this docshell, if any
486 #if defined(PR_LOGGING) && defined(DEBUG)
490 #endif
492 }
495 nsresult rv;
502 // Get the an auth prompter for our window so that the parenting
503 // of the dialogs works as it should when using tabs.
511 }
517 }
520 nsresult
521 rv =
527 }
529 }
537 }
542 {
546 }
549 }
555 }
561 }
567 }
570 }
574 }
576 PRUint32
579 {
636 }
639 }
642 nsDocShellInfoLoadType
644 {
701 }
704 }
706 //*****************************************************************************
707 // nsDocShell::nsIDocShell
708 //*****************************************************************************
709 NS_IMETHODIMP
712 PRUint32 aLoadFlags,
713 PRBool aFirstParty)
714 {
719 // Note: we allow loads to get through here even if mFiredUnloadEvent is
720 // true; that case will get handled in LoadInternal or LoadHistoryEntry.
723 }
724 nsresult rv;
732 nsXPIDLString target;
737 // Extract the info from the DocShellLoadInfo struct...
743 // Get the appropriate loadType from nsIDocShellLoadInfo type
753 }
755 #if defined(PR_LOGGING) && defined(DEBUG)
757 nsCAutoString uristr;
762 }
763 #endif
767 // First verify if this is a subframe.
771 PRUint32 parentLoadType;
774 /* OK. It is a subframe. Checkout the
775 * parent's loadtype. If the parent was loaded thro' a history
776 * mechanism, then get the SH entry for the child from the parent.
777 * This is done to restore frameset navigation while going back/forward.
778 * If the parent was loaded through any other loadType, set the
779 * child's loadType too accordingly, so that session history does not
780 * get confused.
781 */
783 // Get the parent's load type
788 // Get the ShEntry for the child from the parent
790 // Make some decisions on the child frame's loadType based on the
791 // parent's loadType.
793 // This is a newly created frame. Check for exception cases first.
794 // By default the subframe will inherit the parent's loadType.
798 // The parent was loaded normally. In this case, this *brand new* child really shouldn't
799 // have a SHEntry. If it does, it could be because the parent is replacing an
800 // existing frame with a new frame, in the onLoadHandler. We don't want this
801 // url to get into session history. Clear off shEntry, and set laod type to
802 // LOAD_BYPASS_HISTORY.
808 }
809 }
811 // Clear shEntry. For refresh loads, we have to load
812 // what comes thro' the pipe, not what's in history.
814 }
821 // If the parent url, bypassed history or was loaded from
822 // history, pass on the parent's loadType to the new child
823 // frame too, so that the child frame will also
824 // avoid getting into history.
826 }
827 }
829 // This is a pre-existing subframe. If the load was not originally initiated
830 // by session history, (if (!shEntry) condition succeeded) and mCurrentURI is not null,
831 // it is possible that a parent's onLoadHandler or even self's onLoadHandler is loading
832 // a new page in this child. Check parent's and self's busy flag and if it is set,
833 // we don't want this onLoadHandler load to get in to session history.
840 shEntry) {
843 }
844 }
848 // This is the root docshell. If we got here while
849 // executing an onLoad Handler,this load will not go
850 // into session history.
855 }
856 }
860 #ifdef DEBUG
863 #endif
866 }
867 // Perform the load...
869 // We need an owner (a referring principal). 4 possibilities:
870 // (1) If the system principal was passed in and we're a typeContent
871 // docshell, inherit the principal from the current document
872 // instead.
873 // (2) In all other cases when the principal passed in is not null,
874 // use that principal.
875 // (3) If the caller has allowed inheriting from the current document,
876 // or if we're being called from system code (eg chrome JS or pure
877 // C++) then inheritOwner should be true and InternalLoad will get
878 // an owner from the current document. If none of these things are
879 // true, then
880 // (4) we pass a null owner into the channel, and an owner will be
881 // created later from the channel's internal data.
882 //
883 // NOTE: This all only works because the only thing the owner is used
884 // for in InternalLoad is data:, javascript:, and about:blank
885 // URIs. For other URIs this would all be dead wrong!
892 PRBool isSystem;
899 }
900 }
902 // See if there's system or chrome JS code running
905 // Set it back to false
907 }
908 }
928 referrer,
929 owner,
930 flags,
933 postStream,
934 headersStream,
935 loadType,
937 aFirstParty,
940 }
943 }
945 NS_IMETHODIMP
950 {
955 // if the caller doesn't pass in a URI we need to create a dummy URI. necko
956 // currently requires a URI in various places during the load. Some consumers
957 // do as well.
960 // HACK ALERT
965 // Make sure that the URI spec "looks" like a protocol and path...
966 // For now, just use a bogus protocol called "internal"
970 }
976 // Get the appropriate LoadType from nsIDocShellLoadInfo type
978 }
984 // build up a channel for this stream.
989 NS_ERROR_FAILURE);
996 NS_ERROR_FAILURE);
998 }
1000 NS_IMETHODIMP
1002 {
1010 }
1013 /*
1014 * Reset state to a new content model within the current document and the document
1015 * viewer. Called by the document before initiating an out of band document.write().
1016 */
1017 NS_IMETHODIMP
1019 {
1022 }
1025 NS_IMETHODIMP
1027 {
1029 // Keep an explicit reference since calling PageHide could release
1030 // mContentViewer
1041 }
1047 }
1048 }
1049 // Now make sure our editor, if any, is detached before we go
1050 // any farther.
1052 }
1055 }
1057 //
1058 // Bug 13871: Prevent frameset spoofing
1059 //
1060 // This routine answers: 'Is origin's document from same domain as
1061 // target's document?'
1062 //
1063 // file: uris are considered the same domain for the purpose of
1064 // frame navigation regardless of script accessibility (bug 420425)
1065 //
1066 /* static */
1067 PRBool
1070 {
1076 nsresult rv =
1081 // We're called from JS, check if UniversalBrowserWrite is
1082 // enabled.
1090 }
1091 }
1093 // Get origin document principal
1099 // Get target principal
1105 PRBool equal;
1110 }
1112 // Not strictly equal, special case if both are file: uris
1132 }
1134 NS_IMETHODIMP
1136 {
1153 }
1154 }
1157 }
1159 NS_IMETHODIMP
1161 {
1172 }
1174 NS_IMETHODIMP
1176 {
1187 }
1190 }
1192 NS_IMETHODIMP
1194 {
1205 }
1208 }
1210 NS_IMETHODIMP
1212 {
1218 }
1220 NS_IMETHODIMP
1222 {
1225 // Weak reference. Don't addref.
1231 }
1234 }
1236 NS_IMETHODIMP
1238 {
1243 }
1245 /* [noscript] void setCurrentURI (in nsIURI uri); */
1246 NS_IMETHODIMP
1248 {
1251 }
1253 PRBool
1255 PRBool aFireOnLocationChange)
1256 {
1257 #ifdef PR_LOGGING
1259 nsCAutoString spec;
1263 }
1264 #endif
1266 // We don't want to send a location change when we're displaying an error
1267 // page, and we don't want to change our idea of "current URI" either
1270 }
1281 {
1282 // This is the root docshell
1284 }
1287 }
1290 /*
1291 * We don't want to send OnLocationChange notifications when
1292 * a subframe is being loaded for the first time, while
1293 * visiting a frameset page
1294 */
1296 }
1300 }
1302 }
1304 NS_IMETHODIMP
1306 {
1318 }
1321 }
1323 NS_IMETHODIMP
1325 {
1326 // set the default charset
1333 NS_ERROR_FAILURE);
1334 }
1335 }
1337 // set the charset override
1344 }
1347 }
1349 NS_IMETHODIMP
1351 aDocumentCharsetInfo)
1352 {
1355 // if the mDocumentCharsetInfo does not exist already, we create it now
1360 }
1365 }
1367 NS_IMETHODIMP
1369 aDocumentCharsetInfo)
1370 {
1373 }
1375 NS_IMETHODIMP
1377 {
1384 }
1389 }
1392 }
1394 NS_IMETHODIMP
1396 {
1402 }
1404 PRBool unsafe;
1407 }
1409 NS_IMETHODIMP
1411 {
1413 //XXX should enable or disable a plugin host
1415 }
1417 NS_IMETHODIMP
1419 {
1425 }
1427 PRBool unsafe;
1430 }
1432 NS_IMETHODIMP
1434 {
1437 }
1440 {
1446 }
1448 PRBool unsafe;
1451 }
1454 {
1457 }
1460 {
1465 }
1468 {
1471 }
1474 {
1479 }
1482 {
1485 }
1487 NS_IMETHODIMP
1488 nsDocShell::GetDocShellEnumerator(PRInt32 aItemType, PRInt32 aDirection, nsISimpleEnumerator **outEnum)
1489 {
1496 else
1513 }
1515 NS_IMETHODIMP
1517 {
1520 }
1522 NS_IMETHODIMP
1524 {
1527 }
1530 NS_IMETHODIMP
1532 {
1535 }
1537 NS_IMETHODIMP
1539 {
1542 }
1544 NS_IMETHODIMP
1546 {
1550 }
1552 NS_IMETHODIMP
1554 {
1556 }
1558 NS_IMETHODIMP
1560 {
1565 }
1567 NS_IMETHODIMP
1569 {
1572 }
1574 NS_IMETHODIMP
1576 {
1581 }
1583 NS_IMETHODIMP
1585 {
1588 }
1590 NS_IMETHODIMP
1592 {
1597 }
1599 NS_IMETHODIMP
1601 {
1608 else
1614 }
1616 NS_IMETHODIMP
1618 {
1621 }
1623 NS_IMETHODIMP
1625 {
1628 }
1630 NS_IMETHODIMP
1632 {
1635 }
1637 NS_IMETHODIMP
1639 {
1640 // If mUseErrorPages is set explicitly, stop observing the pref.
1646 }
1647 }
1650 }
1652 NS_IMETHODIMP
1654 {
1657 }
1659 NS_IMETHODIMP
1661 {
1664 }
1666 NS_IMETHODIMP
1668 {
1669 // These indices are used for fastback cache eviction, to determine
1670 // which session history entries are candidates for content viewer
1671 // eviction. We need to adjust by the number of entries that we
1672 // just purged from history, so that we look at the right session history
1673 // entries during eviction.
1682 }
1683 }
1686 }
1688 NS_IMETHODIMP
1690 PRBool aCreate,
1692 {
1705 }
1717 "GetSessionStorageForPrincipal got a storage "
1722 }
1723 }
1726 }
1728 NS_IMETHODIMP
1731 {
1733 }
1735 nsresult
1737 PRBool aCreate,
1739 {
1762 nsCAutoString currentDomain;
1784 }
1787 }
1789 nsresult
1792 {
1806 // Do not replace an existing session storage.
1812 }
1815 }
1816 }
1819 }
1821 NS_IMETHODIMP
1823 {
1837 }
1840 }
1842 //*****************************************************************************
1843 // nsDocShell::nsIDocShellTreeItem
1844 //*****************************************************************************
1846 NS_IMETHODIMP
1848 {
1852 }
1854 NS_IMETHODIMP
1856 {
1859 }
1861 NS_IMETHODIMP
1863 {
1868 }
1870 NS_IMETHODIMP
1872 {
1877 }
1879 NS_IMETHODIMP
1881 {
1884 // Only allow setting the type on root docshells. Those would be the ones
1885 // that have the docloader service as mParent or have no mParent at all.
1894 // disable auth prompting for anything but content
1898 }
1900 NS_IMETHODIMP
1902 {
1907 }
1908 // Note that in the case when the parent is not an nsIDocShellTreeItem we
1909 // don't want to throw; we just want to return null.
1911 }
1913 nsresult
1915 {
1918 // Curse ambiguous nsISupports inheritance!
1921 // If parent is another docshell, we inherit all their flags for
1922 // allowing plugins, scripting etc.
1925 {
1926 PRBool value;
1928 {
1930 }
1932 {
1934 }
1936 {
1938 }
1940 {
1942 }
1944 {
1946 }
1947 }
1953 }
1955 NS_IMETHODIMP
1957 {
1966 PRInt32 parentType;
1971 }
1973 }
1975 NS_IMETHODIMP
1977 {
1986 NS_ERROR_FAILURE);
1987 }
1990 }
1992 NS_IMETHODIMP
1994 {
2000 NS_ERROR_FAILURE);
2005 NS_ERROR_FAILURE);
2006 }
2009 }
2011 /* static */
2012 PRBool
2015 PRBool aConsiderOpener)
2016 {
2020 // Good to go
2022 }
2024 // XXXbz should we care if aAccessingItem or the document therein is
2025 // chrome? Should those get extra privileges?
2027 // For historical context, see:
2028 //
2029 // Bug 13871: Prevent frameset spoofing
2030 // Bug 103638: Targets with same name in different windows open in wrong
2031 // window with javascript
2032 // Bug 408052: Adopt "ancestor" frame navigation policy
2034 // Now do a security check
2035 //
2036 // Allow navigation if
2037 // 1) aAccessingItem can script aTargetItem or one of its ancestors in
2038 // the frame hierarchy or
2039 // 2) aTargetItem is a top-level frame and aAccessingItem is its descendant
2040 // 3) aTargetItem is a top-level frame and aAccessingItem can target
2041 // its opener per rule (1) or (2).
2044 // A frame is allowed to navigate itself.
2046 }
2052 // A frame can navigate its root.
2054 }
2056 // Check if aAccessingItem can navigate one of aTargetItem's ancestors.
2061 }
2072 // target is a subframe, not in accessor's frame hierarchy, and all its
2073 // ancestors have origins different from that of the accessor. Don't
2074 // allow access.
2076 }
2079 // All done here
2081 }
2088 }
2097 }
2100 }
2102 static PRBool
2104 {
2109 PRBool isClosed;
2113 }
2114 }
2117 }
2119 NS_IMETHODIMP
2124 {
2128 // If we don't find one, we return NS_OK and a null result
2135 {
2138 // This is the entry point into the target-finding algorithm. Check
2139 // for special names. This should only be done once, hence the check
2140 // for a null aRequestor.
2145 }
2147 {
2148 // Just return null. Caller must handle creating a new window with
2149 // a blank name himself.
2151 }
2153 {
2157 }
2159 {
2162 }
2163 // _main is an IE target which should be case-insensitive but isn't
2164 // see bug 217886 for details
2167 {
2168 // Must pass our same type root as requestor to the
2169 // treeowner to make sure things work right.
2176 }
2177 #ifdef DEBUG
2180 "You might like to try that. "
2182 // Note: _content should always exist. If we don't have one
2183 // hanging off the treeowner, just create a named window....
2184 // so don't return here, in case we did that and can now find
2185 // it.
2186 // XXXbz should we be using |root| instead of creating
2187 // a new window?
2188 }
2189 #endif
2190 }
2194 }
2197 // We return foundItem here even if it's not an active
2198 // item since all the names we've dealt with so far are
2199 // special cases that we won't bother looking for further.
2203 }
2204 }
2206 // Keep looking
2208 // First we check our name.
2213 }
2215 // This QI may fail, but the places where we want to compare, comparing
2216 // against nsnull serves the same purpose.
2219 // Second we check our children making sure not to ask a child if
2220 // it is the aRequestor.
2221 #ifdef DEBUG
2222 nsresult rv =
2223 #endif
2231 // Third if we have a parent and it isn't the requestor then we
2232 // should ask it to do the search. If it is the requestor we
2233 // should just stop here and let the parent do the rest. If we
2234 // don't have a parent, then we should ask the
2235 // docShellTreeOwner to do the search.
2242 PRInt32 parentType;
2249 aOriginalRequestor,
2250 _retval);
2251 }
2252 }
2254 // If the parent is null or not of the same type fall through and ask tree
2255 // owner.
2257 // This may fail, but comparing against null serves the same purpose
2264 }
2267 }
2269 NS_IMETHODIMP
2271 {
2277 }
2279 #ifdef DEBUG_DOCSHELL_FOCUS
2280 static void
2282 {
2285 PRInt32 childWebshellCount;
2288 PRInt32 type;
2302 }
2316 }
2317 }
2318 }
2320 static void
2322 {
2332 }
2334 }
2338 }
2341 }
2342 #endif
2344 NS_IMETHODIMP
2346 {
2347 #ifdef DEBUG_DOCSHELL_FOCUS
2351 }
2352 #endif
2354 // Don't automatically set the progress based on the tree owner for frames
2367 }
2372 }
2373 }
2374 }
2383 child->GetItemType(&childType); // We don't care if this fails, if it does we won't set the owner
2386 }
2389 }
2391 NS_IMETHODIMP
2393 {
2396 }
2398 NS_IMETHODIMP
2400 {
2403 }
2405 //*****************************************************************************
2406 // nsDocShell::nsIDocShellTreeNode
2407 //*****************************************************************************
2409 NS_IMETHODIMP
2411 {
2415 }
2419 NS_IMETHODIMP
2421 {
2427 // Make sure we're not creating a loop in the docshell tree
2432 }
2436 // Make sure to remove the child from its current parent.
2440 }
2442 // Make sure to clear the treeowner in case this child is a different type
2443 // from us.
2451 // Set the child's index in the parent's children list
2452 // XXX What if the parent had different types of children?
2453 // XXX in that case docshell hierarchy and SH hierarchy won't match.
2454 {
2457 // If there are frameloaders in the finalization list, reduce
2458 // the offset so that the SH hierarchy is more likely to match the
2459 // docshell hierarchy
2470 }
2471 }
2472 }
2475 }
2476 }
2478 /* Set the child's global history if the parent has one */
2484 }
2491 // Everything below here is only done when the child is the same type.
2500 // charset, style-disabling, and zoom will be inherited in SetupNewViewer()
2502 // Now take this document's charset and set the parentCharset field of the
2503 // child's DocumentCharsetInfo to it. We'll later use that field, in the
2504 // loading process, for the charset choosing algorithm.
2505 // If we fail, at any point, we just return NS_OK.
2506 // This code has some performance impact. But this will be reduced when
2507 // the current charset will finally be stored as an Atom, avoiding the
2508 // alias resolution extra look-up.
2510 // we are NOT going to propagate the charset is this Chrome's docshell
2514 // get the child's docCSInfo object
2520 // get the parent's current charset
2533 // Check if the url is wyciwyg
2535 }
2538 // If this docshell is loaded from a wyciwyg: URI, don't
2539 // advertise our charset since it does not in any way reflect
2540 // the actual source charset, which is what we're trying to
2541 // expose here.
2543 // set the child's parentCharset
2551 // set the child's parentCharset
2555 }
2557 // printf("### 1 >>> Adding child. Parent CS = %s. ItemType = %d.\n", NS_LossyConvertUTF16toASCII(parentCS).get(), mItemType);
2560 }
2562 NS_IMETHODIMP
2564 {
2576 }
2578 NS_IMETHODIMP
2580 {
2583 #ifdef DEBUG
2586 }
2589 }
2590 #endif
2596 }
2598 NS_IMETHODIMP
2604 {
2613 nsXPIDLString childName;
2618 PRInt32 childType;
2630 }
2636 {
2637 // See if child contains the shell with the given name
2638 #ifdef DEBUG
2639 nsresult rv =
2640 #endif
2642 aSameType,
2645 aOriginalRequestor,
2646 _retval);
2651 }
2652 }
2654 }
2656 //*****************************************************************************
2657 // nsDocShell::nsIDocShellHistory
2658 //*****************************************************************************
2659 NS_IMETHODIMP
2661 {
2668 // A nsISHEntry for a child is *only* available when the parent is in
2669 // the progress of loading a document too...
2672 /* Before looking for the subframe's url, check
2673 * the expiration status of the parent. If the parent
2674 * has expired from cache, then subframes will not be
2675 * loaded from history in certain situations.
2676 */
2680 /* Get the parent's Load Type so that it can be set on the child too.
2681 * By default give a loadHistory value
2682 */
2685 // If the user did a shift-reload on this frameset page,
2686 // we don't want to load the subframes from history.
2693 /* If the user pressed reload and the parent frame has expired
2694 * from cache, we do not want to load the child frame from history.
2695 */
2697 // The parent has expired. Return null.
2700 }
2704 // Get the child subframe from session history.
2708 }
2709 }
2711 }
2713 NS_IMETHODIMP
2715 PRInt32 aChildOffset)
2716 {
2717 nsresult rv;
2720 /* You get here if you are currently building a
2721 * hierarchy ie.,you just visited a frameset page
2722 */
2726 }
2727 }
2729 /* This is an initial load in some subframe. Just append it if we can */
2733 }
2734 }
2736 /* You are currently in the rootDocShell.
2737 * You will get here when a subframe has a new url
2738 * to load and you have walked up the tree all the
2739 * way to the top to clone the current SHEntry hierarchy
2740 * and replace the subframe where a new url was loaded with
2741 * a new entry.
2742 */
2766 }
2767 }
2768 }
2770 /* Just pass this along */
2775 }
2776 }
2778 }
2780 nsresult
2782 {
2783 /* You will get here when you are in a subframe and
2784 * a new url has been loaded on you.
2785 * The mOSHE in this subframe will be the previous url's
2786 * mOSHE. This mOSHE will be used as the identification
2787 * for this subframe in the CloneAndReplace function.
2788 */
2790 // In this case, we will end up calling AddEntry, which increases the
2791 // current index by 1
2796 }
2798 nsresult rv;
2803 }
2808 #ifdef DEBUG_PAGE_CACHE
2810 mLoadedTransIndex);
2811 #endif
2812 }
2815 }
2817 NS_IMETHODIMP
2819 {
2820 nsresult rv;
2825 }
2829 }
2833 }
2835 NS_IMETHODIMP
2837 {
2840 }
2842 //-------------------------------------
2843 //-- Helper Method for Print discovery
2844 //-------------------------------------
2845 PRBool
2847 {
2850 }
2853 }
2855 PRBool
2857 {
2859 }
2861 //*****************************************************************************
2862 // nsDocShell::nsIWebNavigation
2863 //*****************************************************************************
2865 NS_IMETHODIMP
2867 {
2871 }
2872 nsresult rv;
2880 }
2882 NS_IMETHODIMP
2884 {
2888 }
2889 nsresult rv;
2897 }
2899 NS_IMETHODIMP
2901 {
2904 }
2905 nsresult rv;
2913 }
2915 NS_IMETHODIMP
2917 {
2920 }
2921 nsresult rv;
2929 }
2932 {
2935 }
2936 nsresult rv;
2944 }
2947 NS_IMETHODIMP
2949 PRUint32 aLoadFlags,
2953 {
2958 }
2962 // Create a URI from our string; if that succeeds, we want to
2963 // change aLoadFlags to not include the ALLOW_THIRD_PARTY_FIXUP
2964 // flag.
2967 // Cleanup the empty spaces that might be on each end.
2969 // Eliminate embedded newlines, which single-line text fields now allow:
2976 }
2979 // Call the fixup object. This will clobber the rv from NS_NewURI
2980 // above, but that's fine with us. Note that we need to do this even
2981 // if NS_NewURI returned a URI, because fixup handles nested URIs, etc
2982 // (things like view-source:mozilla.org for example).
2986 }
2989 }
2990 // else no fixup service so just use the URI we created and see
2991 // what happens
2995 }
3000 PopupControlState popupState;
3006 }
3010 // Don't pass certain flags that aren't needed and end up confusing
3011 // ConvertLoadTypeToDocShellLoadInfo. We do need to ensure that they are
3012 // passed to LoadURI though, since it uses them.
3029 }
3031 NS_IMETHODIMP
3035 {
3036 // Get prompt and string bundle servcies
3045 nsAutoString error;
3051 nsAutoString messageStr;
3052 nsCAutoString cssClass;
3053 nsCAutoString errorPage;
3057 // Turn the error code into a human readable error message.
3060 // extract the scheme
3061 nsCAutoString scheme;
3066 }
3070 }
3073 // Get the host
3074 nsCAutoString host;
3080 }
3085 }
3090 }
3093 // Get the host
3094 nsCAutoString host;
3099 }
3104 PRUint32 errorClass;
3108 }
3116 // Usually we should have aFailedChannel and get a detailed message
3118 }
3120 // No channel, let's obtain the generic error message
3123 }
3124 }
3133 }
3135 // See if an alternate cert error page is registered
3136 nsXPIDLCString alternateErrorPage;
3143 }
3144 }
3146 nsCAutoString host;
3151 // Malware and phishing detectors may want to use an alternate error
3152 // page, but if the pref's not set, we'll fall back on the standard page
3153 nsXPIDLCString alternateErrorPage;
3161 else
3164 }
3166 // Errors requiring simple formatting
3169 // URI is malformed
3173 // Doc failed to load because the server generated too many redirects
3177 // Doc failed to load because PSM is not installed
3181 // Doc failed to load because the server kept reseting the connection
3182 // before we could read any data from it
3186 // Doc failed to load because we are offline and the cache does not
3187 // contain a copy of the document.
3191 // Doc navigation attempted while Printing or Print Preview
3195 // Port blocked for security reasons
3200 // Proxy hostname could not be resolved.
3204 // Proxy connection was refused.
3208 // Bad Content Encoding.
3212 // Channel refused to load from an unrecognized content type.
3215 }
3216 }
3218 // Test if the error should be displayed
3221 }
3223 // Test if the error needs to be formatted
3225 // already obtained message
3226 }
3229 // Build up the host:port string.
3230 nsCAutoString hostport;
3235 }
3237 }
3239 nsCAutoString spec;
3242 // displaying "file://" is aesthetically unpleasing and could even be
3243 // confusing to the user
3248 else
3251 nsCAutoString charset;
3252 // unescape and convert from origin charset
3258 }
3261 }
3270 }
3271 nsXPIDLString str;
3277 }
3279 // Display the error as a page or an alert prompt
3281 // Note: For now, display an alert instead of an error page if we have no
3282 // URI object. Missing URI objects are handled badly by session history.
3284 // Display an error page
3287 }
3288 else
3289 {
3290 // The prompter reqires that our private window has a document (or it
3291 // asserts). Satisfy that assertion now since GetDocument will force
3292 // creation of one if it hasn't already been created.
3297 }
3299 // Display a message box
3301 }
3304 }
3307 NS_IMETHODIMP
3314 {
3315 #if defined(PR_LOGGING) && defined(DEBUG)
3317 nsCAutoString spec;
3320 nsCAutoString chanName;
3323 else
3329 }
3330 #endif
3331 // Create an shistory entry for the old load, if we have a channel
3338 }
3339 // Be sure to have a correct mLSHE, it may have been cleared by
3340 // EndPageLoad. See bug 302115.
3342 PRInt32 idx;
3351 }
3353 nsCAutoString url;
3354 nsCAutoString charset;
3356 {
3357 // Set our current URI
3363 }
3365 {
3367 }
3368 else
3369 {
3371 }
3373 // Create a URL to pass all the error information through to the page.
3391 }
3411 }
3414 NS_IMETHODIMP
3416 {
3419 }
3420 nsresult rv;
3429 // Send notifications to the HistoryListener if any, about the impending reload
3439 }
3440 }
3445 /* If you change this part of code, make sure bug 45297 does not re-occur */
3448 }
3451 }
3457 nsAutoString contentTypeHint;
3461 }
3464 mReferrerURI,
3465 principal,
3473 PR_TRUE,
3476 }
3480 }
3482 NS_IMETHODIMP
3484 {
3485 // Revoke any pending event related to content viewer restoration
3489 // Stop the document loading
3492 }
3495 // Suspend any timers that were set for this loader. We'll clear
3496 // them out for good in CreateContentViewer.
3501 }
3506 }
3508 // XXXbz We could also pass |this| to nsIURILoader::Stop. That will
3509 // just call Stop() on us as an nsIDocumentLoader... We need fewer
3510 // redundant apis!
3512 }
3514 PRInt32 n;
3520 }
3523 }
3525 /*
3526 NS_IMETHODIMP nsDocShell::SetDocument(nsIDOMDocument* aDocument,
3527 const PRUnichar* aContentType)
3528 {
3529 //XXX First Checkin
3530 NS_ERROR("Not Yet Implemented");
3531 return NS_ERROR_FAILURE;
3532 }
3533 */
3535 NS_IMETHODIMP
3537 {
3542 }
3544 NS_IMETHODIMP
3546 {
3551 }
3555 }
3557 NS_IMETHODIMP
3559 {
3566 }
3568 NS_IMETHODIMP
3570 {
3573 // make sure that we are the root docshell and
3574 // set a handle to root docshell in SH.
3577 /* Get the root docshell. If *this* is the root docshell
3578 * then save a handle to *this* in SH. SH needs it to do
3579 * traversions thro' its entries
3580 */
3590 }
3593 }
3596 NS_IMETHODIMP
3598 {
3603 }
3605 //*****************************************************************************
3606 // nsDocShell::nsIWebPageDescriptor
3607 //*****************************************************************************
3608 NS_IMETHODIMP
3610 {
3613 // Currently, the opaque 'page descriptor' is an nsISHEntry...
3616 }
3618 // Now clone shEntryIn, since we might end up modifying it later on, and we
3619 // want a page descriptor to be reusable.
3624 //
3625 // load the page as view-source
3626 //
3631 // Create a new view-source URI and replace the original.
3643 }
3645 }
3649 }
3651 NS_IMETHODIMP
3653 {
3665 }
3667 // null out inappropriate cloned attributes...
3672 }
3675 }
3678 //*****************************************************************************
3679 // nsDocShell::nsIBaseWindow
3680 //*****************************************************************************
3682 NS_IMETHODIMP
3686 {
3693 }
3695 NS_IMETHODIMP
3697 {
3705 PRBool tmpbool;
3712 // Check pref to see if we should prevent frameset spoofing
3718 }
3719 }
3721 // Should we use XUL error pages instead of alerts if possible?
3729 }
3736 }
3739 }
3741 NS_IMETHODIMP
3743 {
3754 }
3755 }
3759 // Remove our pref observers
3765 }
3766 }
3768 // Make sure to blow away our mLoadingURI just in case. No loads
3769 // from inside this pagehide.
3772 // Fire unload event before we blow anything away.
3775 // Clear pointers to any detached nsEditorData that's lying
3776 // around in shistory entries. Breaks cycle. See bug 430921.
3782 // Note: mContentListener can be null if Init() failed and we're being
3783 // called from the destructor.
3787 // Note that we do NOT set mContentListener to null here; that
3788 // way if someone tries to do a load in us after this point
3789 // the nsDSURIContentListener will block it. All of which
3790 // means that we should do this before calling Stop(), of
3791 // course.
3792 }
3794 // Stop any URLs that are currently being loaded...
3801 // Save the state of the current document, before destroying the window.
3802 // This is needed to capture the state of a frameset when the new document
3803 // causes the frameset to be destroyed...
3806 // Remove this docshell from its parent's child list
3814 suppressor =
3821 }
3833 }
3838 // required to break ref cycle
3841 // Cancel any timers that were set for this docshell; this is needed
3842 // to break the cycle between us and the timers.
3846 }
3848 }
3850 NS_IMETHODIMP
3852 {
3860 }
3862 NS_IMETHODIMP
3864 {
3865 PRInt32 dummyHolder;
3867 }
3869 NS_IMETHODIMP
3871 {
3875 }
3877 NS_IMETHODIMP
3879 {
3880 PRInt32 dummyHolder;
3882 }
3884 NS_IMETHODIMP
3887 {
3893 // Hold strong ref, since SetBounds can make us null out mContentViewer
3896 //XXX Border figured in here or is that handled elsewhere?
3898 }
3901 }
3903 NS_IMETHODIMP
3906 {
3907 // We should really consider just getting this information from
3908 // our window instead of duplicating the storage and code...
3913 }
3917 }
3919 void
3922 {
3931 }
3933 NS_IMETHODIMP
3935 {
3943 // what about aForce ?
3946 }
3948 NS_IMETHODIMP
3950 {
3957 }
3959 NS_IMETHODIMP
3961 {
3965 }
3967 NS_IMETHODIMP
3969 {
3974 else
3978 }
3980 NS_IMETHODIMP
3982 {
3984 }
3986 NS_IMETHODIMP
3988 {
4001 // get the view manager
4005 // get the root view
4010 // if our root view is hidden, we are not visible
4014 // otherwise, we must walk up the document and view trees checking
4015 // for a hidden view, unless we're an off screen browser, which
4016 // would make this test meaningless.
4029 // Null-check for crash in bug 267804
4033 }
4047 }
4053 }
4055 // Check with the tree owner as well to give embedders a chance to
4056 // expose visibility as well.
4058 }
4060 NS_IMETHODIMP
4062 {
4065 }
4067 NS_IMETHODIMP
4069 {
4072 }
4074 NS_IMETHODIMP
4076 {
4081 }
4084 }
4087 }
4089 NS_IMETHODIMP
4091 {
4095 }
4097 NS_IMETHODIMP
4099 {
4101 }
4103 NS_IMETHODIMP
4105 {
4109 }
4111 NS_IMETHODIMP
4113 {
4115 }
4117 NS_IMETHODIMP
4119 {
4120 // We don't create our own widget, so simply return the parent one.
4122 }
4124 NS_IMETHODIMP
4126 {
4127 #ifdef DEBUG_DOCSHELL_FOCUS
4129 #endif
4131 // Tell itself (and the DocShellFocusController) who has focus
4132 // this way focus gets removed from the currently focused DocShell
4137 }
4139 NS_IMETHODIMP
4141 {
4146 }
4148 NS_IMETHODIMP
4150 {
4151 // Store local title
4157 // When title is set on the top object it should then be passed to the
4158 // tree owner.
4164 }
4168 }
4171 // Update SessionHistory with the document's title. If the
4172 // page was loaded from history or the page bypassed history,
4173 // there is no need to update the title. There is no need to
4174 // go to mSessionHistory to update the title. Setting it in mOSHE
4175 // would suffice.
4179 }
4183 }
4185 //*****************************************************************************
4186 // nsDocShell::nsIScrollable
4187 //*****************************************************************************
4189 NS_IMETHODIMP
4191 {
4196 NS_ERROR_FAILURE);
4199 }
4215 }
4217 }
4219 NS_IMETHODIMP
4221 {
4224 NS_ERROR_FAILURE);
4227 }
4229 PRInt32 other;
4230 PRInt32 x;
4231 PRInt32 y;
4250 }
4253 NS_ERROR_FAILURE);
4255 }
4257 NS_IMETHODIMP
4259 {
4262 NS_ERROR_FAILURE);
4265 }
4268 NS_ERROR_FAILURE);
4270 }
4272 // XXX This is wrong
4273 NS_IMETHODIMP
4276 {
4281 NS_ERROR_FAILURE);
4284 }
4286 PRInt32 cx;
4287 PRInt32 cy;
4303 }
4306 }
4308 NS_IMETHODIMP
4311 {
4312 //XXX First Check
4313 /*
4314 Retrieves or Sets the valid ranges for the thumb. When maxPos is set to
4315 something less than the current thumb position, curPos is set = to maxPos.
4317 @return NS_OK - Setting or Getting completed successfully.
4318 NS_ERROR_INVALID_ARG - returned when curPos is not within the
4319 minPos and maxPos.
4320 */
4322 }
4324 NS_IMETHODIMP
4327 PRInt32 maxVerticalPos)
4328 {
4329 //XXX First Check
4330 /*
4331 Retrieves or Sets the valid ranges for the thumb. When maxPos is set to
4332 something less than the current thumb position, curPos is set = to maxPos.
4334 @return NS_OK - Setting or Getting completed successfully.
4335 NS_ERROR_INVALID_ARG - returned when curPos is not within the
4336 minPos and maxPos.
4337 */
4339 }
4341 // This returns setting for all documents in this webshell
4342 NS_IMETHODIMP
4345 {
4358 }
4360 }
4362 // Set scrolling preference for all documents in this shell
4363 //
4364 // There are three possible values stored in the shell:
4365 // 1) nsIScrollable::Scrollbar_Never = no scrollbar
4366 // 2) nsIScrollable::Scrollbar_Auto = scrollbar appears if the document
4367 // being displayed would normally have scrollbar
4368 // 3) nsIScrollable::Scrollbar_Always = scrollbar always appears
4369 //
4370 // One important client is nsHTMLFrameInnerFrame::CreateWebShell()
4371 NS_IMETHODIMP
4373 PRInt32 scrollbarPref)
4374 {
4386 }
4388 }
4390 NS_IMETHODIMP
4393 {
4396 NS_ERROR_FAILURE);
4400 // We should now call nsLayoutUtils::GetScrollableFrameFor,
4401 // but we can't because of stupid linkage!
4417 }
4419 //*****************************************************************************
4420 // nsDocShell::nsITextScroll
4421 //*****************************************************************************
4423 NS_IMETHODIMP
4425 {
4429 NS_ERROR_FAILURE);
4432 }
4437 }
4439 NS_IMETHODIMP
4441 {
4445 NS_ERROR_FAILURE);
4448 }
4453 }
4455 //*****************************************************************************
4456 // nsDocShell::nsIScriptGlobalObjectOwner
4457 //*****************************************************************************
4459 nsIScriptGlobalObject*
4461 {
4465 }
4467 //*****************************************************************************
4468 // nsDocShell::nsIRefreshURI
4469 //*****************************************************************************
4471 NS_IMETHODIMP
4473 PRBool aMetaRefresh)
4474 {
4477 /* Check if Meta refresh/redirects are permitted. Some
4478 * embedded applications may not want to do this.
4479 * Must do this before sending out NOTIFY_REFRESH events
4480 * because listeners may have side effects (e.g. displaying a
4481 * button to manually trigger the refresh later).
4482 */
4488 // If any web progress listeners are listening for NOTIFY_REFRESH events,
4489 // give them a chance to block this refresh.
4490 PRBool sameURI;
4512 NS_ERROR_FAILURE);
4513 }
4516 // We are busy loading another page. Don't create the
4517 // timer right now. Instead queue up the request and trigger the
4518 // timer in EndPageLoad().
4520 }
4522 // There is no page loading going on right now. Create the
4523 // timer and fire it right away.
4529 }
4531 }
4533 nsresult
4535 PRInt32 aDelay,
4536 PRBool aMetaRefresh,
4538 {
4541 // Remove aTimer from mRefreshURIList if needed
4551 }
4552 }
4553 }
4556 }
4558 NS_IMETHODIMP
4560 PRInt32 aDelay,
4561 PRBool aMetaRefresh)
4562 {
4569 /* We do need to pass in a referrer, but we don't want it to
4570 * be sent to the server.
4571 */
4574 /* for most refreshes the current URI is an appropriate
4575 * internal referrer
4576 */
4579 /* Check if this META refresh causes a redirection
4580 * to another site.
4581 */
4586 /* It is a META refresh based redirection. Now check if it happened
4587 within the threshold time we have in mind(15000 ms as defined by
4588 REFRESH_REDIRECT_TIMER). If so, pass a REPLACE flag to LoadURI().
4589 */
4593 /* for redirects we mimic HTTP, which passes the
4594 * original referrer
4595 */
4600 }
4601 }
4602 else
4604 /*
4605 * LoadURI(...) will cancel all refresh timers... This causes the
4606 * Timer and its refreshData instance to be released...
4607 */
4610 }
4611 else
4617 }
4619 nsresult
4622 {
4623 // Refresh headers are parsed with the following format in mind
4624 // <META HTTP-EQUIV=REFRESH CONTENT="5; URL=http://uri">
4625 // By the time we are here, the following is true:
4626 // header = "REFRESH"
4627 // content = "5; URL=http://uri" // note the URL attribute is
4628 // optional, if it is absent, the currently loaded url is used.
4629 // Also note that the seconds and URL separator can be either
4630 // a ';' or a ','. The ',' separator should be illegal but CNN
4631 // is using it.
4632 //
4633 // We need to handle the following strings, where
4634 // - X is a set of digits
4635 // - URI is either a relative or absolute URI
4636 //
4637 // Note that URI should start with "url=" but we allow omission
4638 //
4639 // "" || ";" || ","
4640 // empty string. use the currently loaded URI
4641 // and refresh immediately.
4642 // "X" || "X;" || "X,"
4643 // Refresh the currently loaded URI in X seconds.
4644 // "X; URI" || "X, URI"
4645 // Refresh using URI as the destination in X seconds.
4646 // "URI" || "; URI" || ", URI"
4647 // Refresh immediately using URI as the destination.
4648 //
4649 // Currently, anything immediately following the URI, if
4650 // separated by any char in the set "'\"\t\r\n " will be
4651 // ignored. So "10; url=go.html ; foo=bar" will work,
4652 // and so will "10; url='go.html'; foo=bar". However,
4653 // "10; url=go.html; foo=bar" will result in the uri
4654 // "go.html;" since ';' and ',' are valid uri characters.
4655 //
4656 // Note that we need to remove any tokens wrapping the URI.
4657 // These tokens currently include spaces, double and single
4658 // quotes.
4660 // when done, seconds is 0 or the given number of seconds
4661 // uriAttrib is empty or the URI specified
4662 nsCAutoString uriAttrib;
4671 // skip leading whitespace
4677 // skip leading + and -
4681 // parse number
4686 }
4689 // if we started with a '-', number is negative
4693 // skip to next ';' or ','
4696 {
4698 {
4699 // Non-whitespace characters here mean that the string is
4700 // malformed but tolerate sites that specify a decimal point,
4701 // even though meta refresh only works on whole seconds.
4704 {
4705 // The characters between the seconds and the next
4706 // section are just garbage!
4707 // e.g. content="2a0z+,URL=http://www.mozilla.org/"
4708 // Just ignore this redirect.
4710 }
4712 {
4713 // We've had at least one whitespace so tolerate the mistake
4714 // and drop through.
4715 // e.g. content="10 foo"
4718 }
4719 }
4721 }
4723 // skip any remaining whitespace
4727 // skip ';' or ','
4730 }
4732 // skip whitespace
4735 }
4737 // possible start of URI
4740 // skip "url = " to real start of URI
4748 // skip whitespace
4755 // skip whitespace
4759 // found real start of URI
4761 }
4762 }
4763 }
4764 }
4766 // skip a leading '"' or '\''.
4770 {
4773 }
4775 // set iter to start of URI
4778 // tokenStart here points to the beginning of URI
4780 // grab the rest of the URI
4782 {
4786 }
4788 // move iter one back if the last character is a '"' or '\''
4793 }
4795 // URI is whatever's contained from tokenStart to iter.
4796 // note: if tokenStart == doneIterating, so is iter.
4804 }
4807 // NS_NewURI takes care of any whitespace surrounding the URL
4810 }
4812 // No URI or seconds were specified
4814 {
4815 // Do nothing because the alternative is to spin around in a refresh
4816 // loop forever!
4818 }
4828 LOAD_IS_AUTOMATIC_DOCUMENT_REPLACEMENT);
4830 // Since we can't travel back in time yet, just pretend
4831 // negative numbers do nothing at all.
4836 }
4837 }
4838 }
4840 }
4843 {
4844 nsresult rv;
4847 nsCAutoString refreshHeader;
4849 refreshHeader);
4856 }
4857 }
4858 }
4860 }
4862 static void
4864 {
4878 }
4879 }
4881 NS_IMETHODIMP
4883 {
4890 }
4892 NS_IMETHODIMP
4894 {
4898 }
4900 PRUint32 count;
4905 }
4907 NS_IMETHODIMP
4909 {
4919 // Replace this timer object with a nsRefreshTimer object.
4929 }
4930 }
4932 // Suspend refresh URIs for our child shells as well.
4939 }
4942 }
4944 NS_IMETHODIMP
4946 {
4949 // Resume refresh URIs for our child shells as well.
4956 }
4959 }
4961 nsresult
4963 {
4975 // This is the nsRefreshTimer object, waiting to be
4976 // setup in a timer object and fired.
4977 // Create the timer and trigger it.
4978 PRUint32 delay = static_cast<nsRefreshTimer*>(static_cast<nsITimerCallback*>(refreshInfo))->GetDelay();
4981 // Replace the nsRefreshTimer element in the queue with
4982 // its corresponding timer object, so that in case another
4983 // load comes through before the timer can go off, the timer will
4984 // get cancelled in CancelRefreshURITimer()
4987 }
4988 }
4992 }
4994 //*****************************************************************************
4995 // nsDocShell::nsIContentViewerContainer
4996 //*****************************************************************************
4998 NS_IMETHODIMP
5001 {
5002 // Save the LayoutHistoryState of the previous document, before
5003 // setting up new document
5008 // If we are loading a wyciwyg url from history, change the base URI for
5009 // the document to the original http url that created the document.write().
5010 // This makes sure that all relative urls in a document.written page loaded
5011 // via history work properly.
5017 // Check if the url is wyciwyg
5021 }
5022 // XXX What if SetupNewViewer fails?
5024 // Restore the editing state, if it's stored in session history.
5027 }
5029 }
5033 // Determine if this type of load should update history
5044 }
5050 }
5052 /* void setIsPrinting (in boolean aIsPrinting); */
5053 NS_IMETHODIMP
5055 {
5058 }
5060 //*****************************************************************************
5061 // nsDocShell::nsIWebProgressListener
5062 //*****************************************************************************
5064 NS_IMETHODIMP
5067 PRInt32 aCurSelfProgress,
5068 PRInt32 aMaxSelfProgress,
5069 PRInt32 aCurTotalProgress,
5070 PRInt32 aMaxTotalProgress)
5071 {
5073 }
5075 NS_IMETHODIMP
5078 {
5079 nsresult rv;
5081 // Update the busy cursor
5087 // Was the wyciwyg document loaded on this docshell?
5093 // Store the wyciwyg url in session history, only if it is
5094 // being loaded fresh for the first time. We don't want
5095 // multiple entries for successive loads
5099 // This is a document.write(). Get the made-up url
5100 // from the channel and store it in session history.
5104 // Save history state of the previous page
5108 }
5110 }
5111 // Page has begun to load
5117 }
5118 }
5120 // Page is loading
5122 }
5124 // Page has finished loading
5130 }
5131 }
5135 // Is the document stop notification for this document?
5139 }
5140 }
5141 // note that redirect state changes will go through here as well, but it
5142 // is better to handle those in OnRedirectStateChange where more
5143 // information is available.
5145 }
5147 NS_IMETHODIMP
5150 {
5153 }
5155 void
5158 PRUint32 aRedirectFlags,
5159 PRUint32 aStateFlags)
5160 {
5166 // If this load is being checked by the URI classifier, we need to
5167 // query the classifier again for the new URI.
5170 }
5175 // notify global history of this redirect
5178 }
5181 // when there is no GlobalHistory3, or it doesn't implement
5182 // AddToplevelRedirect, we fall back to GlobalHistory2. Just notify
5183 // that the redirecting page was a rePdirect so it will be link colored
5184 // but not visible.
5190 }
5192 // check if the new load should go through the application cache.
5199 }
5200 }
5202 NS_IMETHODIMP
5206 {
5209 }
5211 NS_IMETHODIMP
5214 {
5217 }
5220 nsresult
5223 {
5224 //
5225 // one of many safeguards that prevent death and destruction if
5226 // someone is so very very rude as to bring this window down
5227 // during this load handler.
5228 //
5231 // We're done with the URI classifier for this channel
5234 //
5235 // Notify the ContentViewer that the Document has finished loading...
5236 //
5237 // This will cause any OnLoad(...) handlers to fire, if it is a HTML
5238 // document...
5239 //
5247 // If all documents have completed their loading
5248 // favor native event dispatch priorities
5249 // over performance
5251 // Hint to use normal native event dispatch priorities
5253 }
5254 }
5255 /* Check if the httpChannel has any cache-control related response headers,
5256 * like no-store, no-cache. If so, update SHEntry so that
5257 * when a user goes back/forward to this page, we appropriately do
5258 * form value restoration or load from server.
5259 */
5265 // figure out if SH should be saving layout state.
5270 }
5272 // Clear mLSHE after calling the onLoadHandlers. This way, if the
5273 // onLoadHandler tries to load something different in
5274 // itself or one of its children, we can deal with it appropriately.
5278 // Clear the mLSHE reference to indicate document loading is done one
5279 // way or another.
5281 }
5282 // if there's a refresh header in the channel, this method
5283 // will set it up for us.
5287 }
5290 //*****************************************************************************
5291 // nsDocShell: Content Viewer Management
5292 //*****************************************************************************
5294 NS_IMETHODIMP
5296 {
5307 }
5311 }
5320 "Should have doc if CreateAboutBlankContentViewer "
5324 }
5327 }
5329 nsresult
5331 {
5336 /* mCreatingDocument should never be true at this point. However, it's
5337 a theoretical possibility. We want to know about it and make it stop,
5338 and this sounds like a job for an assertion. */
5345 // mContentViewer->PermitUnload may release |this| docshell.
5349 // We've got a content viewer already. Make sure the user
5350 // permits us to discard the current document and replace it
5351 // with about:blank. And also ensure we fire the unload events
5352 // in the current document.
5354 PRBool okToUnload;
5358 // The user chose not to unload the page, interrupt the load.
5360 }
5364 // Make sure to blow away our mLoadingURI just in case. No loads
5365 // from inside this pagehide.
5368 // Notify the current document that it is about to be unloaded!!
5369 //
5370 // It is important to fire the unload() notification *before* any state
5371 // is changed within the DocShell - otherwise, javascript will get the
5372 // wrong information :-(
5373 //
5375 }
5377 // Now make sure we don't think we're in the middle of firing unload after
5378 // this point. This will make us fire unload when the about:blank document
5379 // unloads... but that's ok, more or less. Would be nice if it fired load
5380 // too, of course.
5383 // one helper factory, please
5388 nsXPIDLCString contractId;
5389 rv = catMan->GetCategoryEntry("Gecko-Content-Viewers", "text/html", getter_Copies(contractId));
5395 // generate (about:blank) document to load
5401 // create a content viewer for us and the new document
5405 // hook 'em up
5414 }
5415 }
5416 }
5419 // The transient about:blank viewer doesn't have a session history entry.
5423 }
5425 PRBool
5429 {
5433 // Only save presentation for "normal" loads and link loads. Anything else
5434 // probably wants to refetch the page, so caching the old presentation
5435 // would be incorrect.
5444 // If the session history entry has the saveLayoutState flag set to false,
5445 // then we should not cache the presentation.
5446 PRBool canSaveState;
5451 // If the document is not done loading, don't cache it.
5459 // Avoid doing the work of saving the presentation state in the case where
5460 // the content viewer cache is disabled.
5464 // Don't cache the content viewer if we're in a subframe and the subframe
5465 // pref is disabled.
5474 }
5475 }
5477 // If the document does not want its presentation cached, then don't.
5483 }
5485 void
5487 {
5500 }
5501 }
5503 void
5505 {
5516 // Make aSHEntry hold the owning ref to the editor data.
5519 else
5521 }
5523 #ifdef DEBUG
5524 {
5525 PRBool isEditable;
5529 }
5532 }
5534 void
5536 {
5538 }
5540 nsresult
5542 {
5544 // No entry to save into, or we're replacing the existing entry.
5546 }
5556 #ifdef DEBUG_PAGE_CACHE
5559 nsCAutoString spec;
5564 #endif
5569 // Suspend refresh URIs and save off the timer queue
5573 // Capture the current content viewer bounds.
5587 }
5588 }
5589 }
5590 }
5592 // Capture the docshell hierarchy.
5601 }
5604 }
5606 NS_IMETHODIMP
5608 {
5612 }
5614 NS_IMETHODIMP
5616 {
5617 nsresult rv;
5623 }
5625 // Dispatch events for restoring the presentation. We try to simulate
5626 // the progress notifications loading the document would cause, so we add
5627 // the document's channel to the loadgroup to initiate stateChange
5628 // notifications.
5640 }
5641 }
5644 // This point corresponds to us having gotten OnStartRequest or
5645 // STATE_START, so do the same thing that CreateContentViewer does at
5646 // this point to ensure that unload/pagehide events for this document
5647 // will fire when it's unloaded again.
5650 // For non-top frames, there is no notion of making sure that the
5651 // previous document is in the domwindow when STATE_START notifications
5652 // happen. We can just call BeginRestore for all of the child shells
5653 // now.
5656 }
5659 }
5661 nsresult
5663 {
5670 }
5671 }
5673 }
5675 NS_IMETHODIMP
5677 {
5678 // First we call finishRestore() on our children. In the simulated load,
5679 // all of the child frames finish loading before the main document.
5686 }
5687 }
5691 }
5699 // Finally, we remove the request from the loadgroup. This will
5700 // cause onStateChange(STATE_STOP) to fire, which will fire the
5701 // pageshow event to the chrome.
5708 }
5709 }
5710 }
5713 }
5715 NS_IMETHODIMP
5717 {
5720 }
5722 nsresult
5724 {
5731 #ifdef DEBUG_PAGE_CACHE
5735 nsCAutoString spec;
5738 #endif
5743 #ifdef DEBUG_PAGE_CACHE
5745 #endif
5747 }
5749 // We need to make sure the content viewer's container is this docshell.
5750 // In subframe navigation, it's possible for the docshell that the
5751 // content viewer was originally loaded into to be replaced with a
5752 // different one. We don't currently support restoring the presentation
5753 // in that case.
5758 #ifdef DEBUG_PAGE_CACHE
5760 #endif
5763 }
5767 #ifdef DEBUG_PAGE_CACHE
5769 #endif
5773 // Add the request to our load group. We do this before swapping out
5774 // the content viewers so that consumers of STATE_START can access
5775 // the old document. We only deal with the toplevel load at this time --
5776 // to be consistent with normal document loading, subframes cannot start
5777 // loading until after data arrives, which is after STATE_START completes.
5781 // Post an event that will remove the request after we've returned
5782 // to the event loop. This mimics the way it is called by nsIChannel
5783 // implementations.
5785 // Revoke any pending restore (just in case)
5794 // The rest of the restore processing will happen on our event
5795 // callback.
5797 }
5800 }
5802 nsresult
5804 {
5807 // This section of code follows the same ordering as CreateContentViewer.
5817 // We determined that it was safe to cache the document presentation
5818 // at the time we initiated the new load. We need to check whether
5819 // it's still safe to do so, since there may have been DOM mutations
5820 // or new requests initiated.
5828 }
5837 }
5839 // Protect against mLSHE going away via a load triggered from
5840 // pagehide or unload.
5843 // Make sure to blow away our mLoadingURI just in case. No loads
5844 // from inside this pagehide.
5847 // Notify the old content viewer that it's being hidden.
5850 // If mLSHE was changed as a result of the pagehide event, then
5851 // something else was loaded. Don't finish restoring.
5855 // Set mFiredUnloadEvent = PR_FALSE so that the unload handler for the
5856 // *new* document will fire.
5867 #ifdef DEBUG_PAGE_CACHE
5869 mLoadedTransIndex);
5870 #endif
5871 }
5873 // Rather than call Embed(), we will retrieve the viewer from the session
5874 // history entry and swap it in.
5875 // XXX can we refactor this so that we can just call Embed()?
5877 nsresult rv;
5882 }
5884 }
5885 }
5889 // In cases where we use a transient about:blank viewer between loads,
5890 // we never show the transient viewer, so _its_ previous viewer is never
5891 // unhooked from the view hierarchy. Destroy any such previous viewer now,
5892 // before we grab the root view sibling, so that we don't grab a view
5893 // that's about to go away.
5901 }
5902 }
5904 // Save off the root view's parent and sibling so that we can insert the
5905 // new content viewer's root view at the same position. Also save the
5906 // bounds of the root view's widget.
5926 }
5927 }
5928 }
5929 }
5931 // Transfer ownership to mContentViewer. By ensuring that either the
5932 // docshell or the session history, but not both, have references to the
5933 // content viewer, we prevent the viewer from being torn down after
5934 // Destroy() is called.
5939 }
5944 // Grab all of the related presentation from the SHEntry now.
5945 // Clearing the viewer from the SHEntry will clear all of this state.
5950 PRBool sticky;
5960 child) {
5962 }
5964 // get the previous content viewer size
5968 // Restore the refresh URI list. The refresh timers will be restarted
5969 // when EndPageLoad() is called.
5973 // Reattach to the window object.
5976 // Now remove it from the cached presentation.
5980 #ifdef DEBUG
5981 {
5988 }
5989 #endif
5991 // Restore the sticky state of the viewer. The viewer has set this state
5992 // on the history entry in Destroy() just before marking itself non-sticky,
5993 // to avoid teardown of the presentation.
5996 // Now that we have switched documents, forget all of our children.
6000 // mLSHE is now our currently-loaded document.
6003 // XXX special wyciwyg handling in Embed()?
6005 // We aren't going to restore any items from the LayoutHistoryState,
6006 // but we don't want them to stay around in case the page is reloaded.
6009 // This is the end of our Embed() replacement
6014 // Tell the event loop to favor plevents over user events, see comments
6015 // in CreateContentViewer.
6023 }
6027 // Use the uri from the mLSHE we had when we entered this function
6028 // (which need not match the document's URI if anchors are involved),
6029 // since that's the history entry we're loading. Note that if we use
6030 // origLSHE we don't have to worry about whether the entry in question
6031 // is still mLSHE or whether it's now mOSHE.
6035 }
6037 // This is the end of our CreateContentViewer() replacement.
6038 // Now we simulate a load. First, we restore the state of the javascript
6039 // window object.
6047 // Now, dispatch a title change event which would happen as the
6048 // <head> is parsed.
6051 // Now we simulate appending child docshells for subframes.
6056 // Make sure to not clobber the state of the child. Since AddChild
6057 // always clobbers it, save it off first.
6058 PRBool allowPlugins;
6061 PRBool allowJavascript;
6064 PRBool allowRedirects;
6067 PRBool allowSubframes;
6070 PRBool allowImages;
6083 }
6093 // Insert the new root view at the correct location in the view tree.
6098 // InsertChild(parent, child, sib, PR_TRUE) inserts the child after
6099 // sib in content order, which is before sib in view order. BUT
6100 // when sib is null it inserts at the end of the the document
6101 // order, i.e., first in view order. But when oldRootSibling is
6102 // null, the old root as at the end of the view list --- last in
6103 // content order --- and we want to call InsertChild(parent, child,
6104 // nsnull, PR_FALSE) in that case.
6106 rootViewSibling,
6111 }
6112 }
6114 // Now that all of the child docshells have been put into place, we can
6115 // restart the timers for the window and all of the child frames.
6118 // Restore the refresh URI list. The refresh timers will be restarted
6119 // when EndPageLoad() is called.
6122 // Meta-refresh timers have been restarted for this shell, but not
6123 // for our children. Walk the child shells and restart their timers.
6129 }
6131 // Make sure this presentation is the same size as the previous
6132 // presentation. If this is not the same size we showed it at last time,
6133 // then we need to resize the widget.
6135 // XXXbryner This interacts poorly with Firefox's infobar. If the old
6136 // presentation had the infobar visible, then we will resize the new
6137 // presentation to that smaller size. However, firing the locationchanged
6138 // event will hide the infobar, which will immediately resize the window
6139 // back to the larger size. A future optimization might be to restore
6140 // the presentation at the "wrong" size, then fire the locationchanged
6141 // event and check whether the docshell's new size is the same as the
6142 // cached viewer size (skipping the resize if they are equal).
6147 #ifdef DEBUG_PAGE_CACHE
6150 #endif
6154 }
6155 }
6157 // Simulate the completion of the load.
6160 // Restart plugins, and paint the content.
6165 }
6167 NS_IMETHODIMP
6171 {
6174 // Can we check the content type of the current content viewer
6175 // and reuse it without destroying it and re-creating it?
6179 // Instantiate the content viewer object
6187 // Notify the current document that it is about to be unloaded!!
6188 //
6189 // It is important to fire the unload() notification *before* any state
6190 // is changed within the DocShell - otherwise, javascript will get the
6191 // wrong information :-(
6192 //
6195 // We determined that it was safe to cache the document presentation
6196 // at the time we initiated the new load. We need to check whether
6197 // it's still safe to do so, since there may have been DOM mutations
6198 // or new requests initiated.
6203 }
6210 }
6214 // Set mFiredUnloadEvent = PR_FALSE so that the unload handler for the
6215 // *new* document will fire.
6218 // we've created a new document so go ahead and call
6219 // OnLoadingSite(), but don't fire OnLocationChange()
6220 // notifications before we've called Embed(). See bug 284993.
6225 // let's try resetting the load group if we need to...
6229 NS_ERROR_FAILURE);
6234 //Cancel any URIs that are currently loading...
6235 /// XXX: Need to do this eventually Stop();
6236 //
6237 // Retarget the document to this loadgroup...
6238 //
6239 /* First attach the channel to the right loadgroup
6240 * and then remove from the old loadgroup. This
6241 * puts the notifications in the right order and
6242 * we don't null-out mLSHE in OnStateChange() for
6243 * all redirected urls
6244 */
6247 // Mark the channel as being a document URI...
6256 NS_BINDING_RETARGETED);
6258 // Update the notification callbacks, so that progress and
6259 // status information are sent to the right docshell...
6261 }
6264 NS_ERROR_FAILURE);
6270 // if this document is part of a multipart document,
6271 // the ID can be used to distinguish it from the other parts.
6279 PRUint32 partID;
6282 }
6283 }
6284 }
6286 // Give hint to native plevent dispatch mechanism. If a document
6287 // is loading the native plevent dispatch mechanism should favor
6288 // performance over normal native event dispatch priorities.
6290 // Hint to favor performance for the plevent notification mechanism.
6291 // We want the pages to load as fast as possible even if its means
6292 // native messages might be starved.
6294 }
6298 }
6301 }
6303 nsresult
6308 {
6311 nsresult rv;
6316 nsXPIDLCString contractId;
6317 rv = catMan->GetCategoryEntry("Gecko-Content-Viewers", aContentType, getter_Copies(contractId));
6319 // Create an instance of the document-loader-factory
6326 }
6328 // Now create an instance of the content viewer
6329 // nsLayoutDLF makes the determination if it should be a "view-source" instead of "view"
6331 aOpenedChannel,
6334 nsnull,
6335 aContentHandler,
6336 aViewer),
6337 NS_ERROR_FAILURE);
6341 }
6343 NS_IMETHODIMP
6345 {
6346 //
6347 // Copy content viewer state from previous or parent content viewer.
6348 //
6349 // The following logic is mirrored in nsHTMLDocument::StartDocumentLoad!
6350 //
6351 // Do NOT to maintain a reference to the old content viewer outside
6352 // of this "copying" block, or it will not be destroyed until the end of
6353 // this routine and all <SCRIPT>s and event handlers fail! (bug 20315)
6354 //
6355 // In this block of code, if we get an error result, we return it
6356 // but if we get a null pointer, that's perfectly legal for parent
6357 // and parentContentViewer.
6358 //
6365 // This will get the size from the current content viewer or from the
6366 // Init settings
6371 NS_ERROR_FAILURE);
6374 nsCAutoString defaultCharset;
6375 nsCAutoString forceCharset;
6376 nsCAutoString hintCharset;
6377 PRInt32 hintCharsetSource;
6378 nsCAutoString prevDocCharset;
6381 PRBool styleDisabled;
6382 // |newMUDV| also serves as a flag to set the data from the above vars
6388 // Get any interesting state from old content viewer
6389 // XXX: it would be far better to just reuse the document viewer ,
6390 // since we know we're just displaying the same document as before
6393 // Tell the old content viewer to hibernate in session history when
6394 // it is destroyed.
6399 }
6401 }
6402 }
6404 // No old content viewer, so get state from parent's content viewer
6408 }
6411 nsresult rv;
6417 NS_ERROR_FAILURE);
6420 NS_ERROR_FAILURE);
6423 NS_ERROR_FAILURE);
6426 NS_ERROR_FAILURE);
6429 NS_ERROR_FAILURE);
6432 NS_ERROR_FAILURE);
6435 NS_ERROR_FAILURE);
6438 NS_ERROR_FAILURE);
6439 }
6440 }
6441 }
6443 // It is necessary to obtain the focus controller to utilize its ability
6444 // to suppress focus. This is necessary to fix Win32-only bugs related to
6445 // a loss of focus when mContentViewer is set to null. The internal window
6446 // is destroyed, and the OS focuses the parent window. This call ends up
6447 // notifying the focus controller that the outer window should focus
6448 // and this hoses us on any link traversal.
6449 //
6450 // Please do not touch any of the focus controller code here without
6451 // testing bugs #28580 and 50509. These are immensely important bugs,
6452 // so PLEASE take care not to regress them if you decide to alter this
6453 // code later -- hyatt
6459 // Suppress the command dispatcher.
6462 // Remove focus from the element that has it
6466 // We want to null out the last focused element if the document containing
6467 // it is going away. If the last focused element is in a descendent
6468 // window of our domwindow, its document will be destroyed when we
6469 // destroy our children. So, check for this case and null out the
6470 // last focused element. See bug 70484.
6480 }
6482 // don't use nsCOMPtr here to avoid extra addref
6483 // when assigning to curwin
6489 }
6491 }
6495 }
6496 }
6501 // Ensure that the content viewer is destroyed *after* the GC - bug 71515
6504 // Stop any activity that may be happening in the old document before
6505 // releasing it...
6508 // Try to extract the default background color from the old
6509 // view manager, so we can use it for the next document.
6522 // If the background color is not known, don't propagate it.
6524 }
6525 }
6526 }
6532 }
6545 }
6547 // If we have old state to copy, set the old state onto the new content
6548 // viewer
6551 NS_ERROR_FAILURE);
6553 NS_ERROR_FAILURE);
6555 NS_ERROR_FAILURE);
6558 NS_ERROR_FAILURE);
6560 NS_ERROR_FAILURE);
6562 NS_ERROR_FAILURE);
6564 NS_ERROR_FAILURE);
6566 NS_ERROR_FAILURE);
6567 }
6569 // End copying block (Don't mess with the old content/document viewer
6570 // beyond here!!)
6572 // See the book I wrote above regarding why the focus controller is
6573 // being used here. -- hyatt
6575 /* Note it's important that focus suppression be turned off no earlier
6576 because in cases where the docshell is lazily creating an about:blank
6577 document, mContentViewer->Init finally puts a reference to that
6578 document into the DOM window, which prevents an infinite recursion
6579 attempting to lazily create the document as focus is unsuppressed
6580 (bug 110856). */
6586 // Stuff the bgcolor from the last view manager into the new
6587 // view manager. This improves page load continuity.
6600 }
6601 }
6602 }
6603 }
6605 // XXX: It looks like the LayoutState gets restored again in Embed()
6606 // right after the call to SetupNewViewer(...)
6608 // We don't show the mContentViewer yet, since we want to draw the old page
6609 // until we have enough of the new page to show. Just return with the new
6610 // viewer still set to hidden.
6612 // Now that we have switched documents, forget all of our children
6616 }
6619 nsresult
6621 {
6622 // This method checks whether the caller may load content into
6623 // this docshell. Even though we've done our best to hide windows
6624 // from code that doesn't have the right to access them, it's
6625 // still possible for an evil site to open a window and access
6626 // frames in the new window through window.frames[] (which is
6627 // allAccess for historic reasons), so we still need to do this
6628 // check on load.
6632 // Origin validation was turned off, or we're not a frame.
6633 // Permit all loads.
6636 }
6638 // We're a frame. Check that the caller has write permission to
6639 // the parent before allowing it to load anything into this
6640 // docshell.
6651 }
6657 // Check if the caller is from the same origin as this docshell,
6658 // or any of it's ancestors.
6667 }
6669 // Compare origins
6670 PRBool equal;
6674 // Same origin, permit load
6677 }
6680 }
6688 }
6690 //*****************************************************************************
6691 // nsDocShell: Site Loading
6692 //*****************************************************************************
6694 {
6711 {
6712 // Make sure to keep null things null as needed
6715 }
6716 }
6723 }
6730 PRUint32 mFlags;
6732 // Use IDL strings so .get() returns null by default
6733 nsXPIDLString mWindowTarget;
6734 nsXPIDLCString mTypeHint;
6738 PRUint32 mLoadType;
6740 PRBool mFirstParty;
6741 };
6743 NS_IMETHODIMP
6747 PRUint32 aFlags,
6752 PRUint32 aLoadType,
6754 PRBool aFirstParty,
6757 {
6760 #ifdef PR_LOGGING
6762 nsCAutoString spec;
6766 }
6767 #endif
6769 // Initialize aDocShell/aRequest
6772 }
6775 }
6779 }
6785 // wyciwyg urls can only be loaded through history. Any normal load of
6786 // wyciwyg through docshell is illegal. Disallow such loads.
6792 }
6797 }
6799 //
6800 // First, notify any nsIContentPolicy listeners about the document load.
6801 // Only abort the load if a content policy listener explicitly vetos it!
6802 //
6804 // Use nsPIDOMWindow since we _want_ to cross the chrome boundary if needed
6810 PRUint32 contentType;
6816 }
6821 }
6823 // XXXbz would be nice to know the loading principal here... but we don't
6832 }
6835 aURI,
6836 loadingPrincipal,
6837 context,
6845 }
6848 }
6851 //
6852 // Get an owner from the current document if necessary. Note that we only
6853 // do this for URIs that inherit a security context and local file URIs;
6854 // in particular we do NOT do this for about:blank. This way, random
6855 // about:blank loads that have no owner (which basically means they were
6856 // done by someone from chrome manually messing with our nsIWebNavigation
6857 // or by C++ setting document.location) don't get a funky principal. If
6858 // callers want something interesting to happen with the about:blank
6859 // principal in this case, they should pass an owner in.
6860 //
6861 {
6862 PRBool inherits;
6863 // One more twist: Don't inherit the owner for external loads.
6869 // Don't allow loads that would inherit our security context
6870 // if this document came from an unsafe channel.
6875 PRBool isUnsafe;
6878 isUnsafe) {
6880 }
6888 }
6889 }
6891 //
6892 // Resolve the window target before going any further...
6893 // If the load has been targeted to another DocShell, then transfer the
6894 // load to it...
6895 //
6897 // We've already done our owner-inheriting. Mask out that bit, so we
6898 // don't try inheriting an owner from the target window if we came up
6899 // with a null owner above.
6902 // Locate the target DocShell.
6903 // This may involve creating a new toplevel window - if necessary.
6904 //
6924 // In some cases the Open call doesn't actually result in a new
6925 // window being opened. We can detect these cases by examining the
6926 // document in |newWin|, if any.
6934 }
6935 }
6939 }
6941 //
6942 // Transfer the load to the target DocShell... Pass nsnull as the
6943 // window target name from to prevent recursive retargeting!
6944 //
6947 aReferrer,
6948 owner,
6949 aFlags,
6951 aTypeHint,
6952 aPostData,
6953 aHeadersData,
6954 aLoadType,
6955 aSHEntry,
6956 aFirstParty,
6957 aDocShell,
6958 aRequest);
6960 // XXXbz except we never reach this code!
6962 //
6963 // At this point, a new window has been created, but the
6964 // URI did not have any data associated with it...
6965 //
6966 // So, the best we can do, is to tear down the new window
6967 // that was just created!
6968 //
6973 }
6974 }
6975 //
6976 // NS_ERROR_NO_CONTENT should not be returned to the
6977 // caller... This is an internal error code indicating that
6978 // the URI had no data associated with it - probably a
6979 // helper-app style protocol (ie. mailto://)
6980 //
6982 }
6984 // XXX: Once new windows are created hidden, the new
6985 // window will need to be made visible... For now,
6986 // do nothing.
6987 }
6988 }
6990 // Else we ran out of memory, or were a popup and got blocked,
6991 // or something.
6994 }
6996 //
6997 // Load is being targetted at this docshell so return an error if the
6998 // docshell is in the process of being destroyed.
6999 //
7002 }
7007 }
7009 // If this docshell is owned by a frameloader, make sure to cancel
7010 // possible frameloader initialization before loading a new page.
7018 }
7019 }
7026 // If this is a replace load, make whatever load triggered
7027 // the unload event also a replace load, so we don't
7028 // create extra history entries.
7031 }
7033 // Do this asynchronously
7039 }
7041 // Just ignore this load attempt
7043 }
7045 // Before going any further vet loads initiated by external programs.
7047 // Disallow external chrome: loads targetted at content windows
7052 }
7054 // clear the decks to prevent context bleed-through (bug 298255)
7059 // reset loadType so we don't have to add lots of tests for
7060 // LOAD_NORMAL_EXTERNAL after this point
7062 }
7064 mAllowKeywordFixup =
7068 //
7069 // First:
7070 // Check to see if the new URI is an anchor in the existing document.
7071 // Skip this check if we're doing some sort of abnormal load, if the
7072 // new load is a non-history load and has postdata, or if we're doing
7073 // a history load and the page identifiers of mOSHE and aSHEntry
7074 // don't match.
7075 //
7080 PRUint32 ourPageIdent;
7082 PRUint32 otherPageIdent;
7085 #ifdef DEBUG
7091 }
7092 #endif
7093 }
7107 /* we need to assign mLSHE to aSHEntry right here, so that on History loads,
7108 * SetCurrentURI() called from OnNewURI() will send proper
7109 * onLocationChange() notifications to the browser to update
7110 * back/forward buttons.
7111 */
7114 /* This is a anchor traversal with in the same page.
7115 * call OnNewURI() so that, this traversal will be
7116 * recorded in session and global history.
7117 */
7121 }
7128 /* save current position of scroller(s) (bug 59774) */
7130 // Get the postdata and page ident from the current page, if
7131 // the new load is being done via normal means. Note that
7132 // "normal means" can be checked for just by checking for
7133 // LOAD_CMD_NORMAL, given the loadType and allowScroll check
7134 // above -- it filters out some LOAD_CMD_NORMAL cases that we
7135 // wouldn't want here.
7140 }
7141 }
7143 /* Assign mOSHE to mLSHE. This will either be a new entry created
7144 * by OnNewURI() for normal loads or aSHEntry for history loads.
7145 */
7148 // Save the postData obtained from the previous page
7149 // in to the session history entry created for the
7150 // anchor page, so that any history load of the anchor
7151 // page will restore the appropriate postData.
7155 // Make sure we won't just repost without hitting the
7156 // cache first
7160 // Propagate our page ident to the new mOSHE so that
7161 // we'll know it just differed by a scroll on the page.
7164 }
7166 /* restore previous position of scroller(s), if we're moving
7167 * back in history (bug 59774)
7168 */
7170 {
7174 }
7176 /* Clear out mLSHE so that further anchor visits get
7177 * recorded in SH and SH won't misbehave.
7178 */
7180 /* Set the title for the SH entry for this target url. so that
7181 * SH menus in go/back/forward buttons won't be empty for this.
7182 */
7193 }
7196 }
7197 }
7199 // mContentViewer->PermitUnload can destroy |this| docShell, which
7200 // causes the next call of CanSavePresentation to crash.
7201 // Hold onto |this| until we return, to prevent a crash from happening.
7202 // (bug#331040)
7205 // Check if the page doesn't want to be unloaded. The javascript:
7206 // protocol handler deals with this for javascript: URLs.
7208 PRBool okToUnload;
7212 // The user chose not to unload the page, interrupt the
7213 // load.
7215 }
7216 }
7218 // Check for saving the presentation here, before calling Stop().
7219 // This is necessary so that we can catch any pending requests.
7220 // Since the new request has not been created yet, we pass null for the
7221 // new request parameter.
7222 // Also pass nsnull for the document, since it doesn't affect the return
7223 // value for our purposes here.
7226 // Don't stop current network activity for javascript: URL's since
7227 // they might not result in any data, and thus nothing should be
7228 // stopped in those cases. In the case where they do result in
7229 // data, the javascript: URL channel takes care of stopping
7230 // current network activity.
7232 // Stop any current network activity.
7233 // Also stop content if this is a zombie doc. otherwise
7234 // the onload will be delayed by other loads initiated in the
7235 // background by the first document that
7236 // didn't fully load before the next load was initiated.
7237 // If not a zombie, don't stop content until data
7238 // starts arriving from the new URI...
7243 }
7250 }
7254 }
7258 // mLSHE should be assigned to aSHEntry, only after Stop() has
7259 // been called. But when loading an error page, do not clear the
7260 // mLSHE for the real page.
7266 // If we have a saved content viewer in history, restore and show it now.
7268 // It's possible that the previous viewer of mContentViewer is the
7269 // viewer that will end up in aSHEntry when it gets closed. If that's
7270 // the case, we need to go ahead and force it into its shentry so we
7271 // can restore it.
7276 #ifdef DEBUG
7280 #endif
7284 // Make sure this viewer ends up in the right place
7287 }
7288 }
7289 }
7291 PRBool restoring;
7296 // We failed to restore the presentation, so clean up.
7297 // Both the old and new history entries could potentially be in
7298 // an inconsistent state.
7304 }
7305 }
7320 }
7323 }
7325 nsIPrincipal*
7327 {
7336 }
7344 }
7345 }
7350 }
7352 // Make sure we end up with _something_ as the principal no matter
7353 // what.
7355 // docViewer and bail.
7362 }
7364 //-- Get the document's principal
7367 }
7370 }
7372 PRBool
7374 {
7379 }
7381 PRBool allowed;
7383 nsnull,
7386 }
7388 nsresult
7391 PRBool aSendReferrer,
7396 PRBool aFirstParty,
7399 PRBool aIsNewWindowTarget,
7400 PRBool aBypassClassifier)
7401 {
7402 nsresult rv;
7410 // tag first party URL loads
7412 }
7415 // Error pages are LOAD_BACKGROUND
7417 }
7419 // open a channel for the url
7423 aURI,
7424 nsnull,
7425 nsnull,
7427 loadFlags);
7430 // This is a uri with a protocol scheme we don't know how
7431 // to handle. Embedders might still be interested in
7432 // handling the load, though, so we fire a notification
7433 // before throwing the load away.
7437 // Hey, they're handling the load for us! How convenient!
7439 }
7440 }
7443 }
7448 // Any document load should not inherit application cache.
7451 // Loads with the correct permissions should check for a matching
7452 // application cache.
7454 }
7456 // Make sure to give the caller a channel if we managed to create one
7457 // This is important for correct error page/session history interaction
7465 }
7468 }
7470 //hack
7478 }
7479 }
7483 {
7484 // save true referrer for those who need it (e.g. xpinstall whitelisting)
7485 // Currently only http and ftp channels support this.
7487 aReferrerURI);
7488 }
7490 //
7491 // If this is a HTTP channel, then set up the HTTP specific information
7492 // (ie. POST data, referrer, ...)
7493 //
7496 /* Get the cache Key from SH */
7500 }
7504 // figure out if we need to set the post data stream on the channel...
7505 // right now, this is only done for http channels.....
7507 // XXX it's a bit of a hack to rewind the postdata stream here but
7508 // it has to be done in case the post data is being reused multiple
7509 // times.
7515 }
7520 // we really need to have a content type associated with this stream!!
7522 /* If there is a valid postdata *and* it is a History Load,
7523 * set up the cache key on the channel, to retrieve the
7524 * data *only* from the cache. If it is a normal reload, the
7525 * cache is free to go to the server for updated postdata.
7526 */
7530 PRUint32 loadFlags;
7533 }
7536 }
7537 }
7539 /* If there is no postdata, set the cache key on the channel, and
7540 * do not set the LOAD_ONLY_FROM_CACHE flag, so that the channel
7541 * will be free to get it from net if it is not found in cache.
7542 * New cache may use it creatively on CGI pages with GET
7543 * method and even on those that say "no-cache"
7544 */
7549 }
7550 }
7553 }
7554 // Set the referrer explicitly
7556 // Referrer is currenly only set for link clicks here.
7558 }
7559 }
7560 //
7561 // Set the owner of the channel, but only for channels that can't
7562 // provide their own security context.
7563 //
7564 // XXX: Is seems wrong that the owner is ignored - even if one is
7565 // supplied) unless the URI is javascript or data or about:blank.
7566 // XXX: If this is ever changed, check all callers for what owners they're
7567 // passing in. In particular, see the code and comments in LoadURI
7568 // where we fall back on inheriting the owner if called
7569 // from chrome. That would be very wrong if this code changed
7570 // anything but channels that can't provide their own security context!
7571 //
7572 // (Currently chrome URIs set the owner when they are created!
7573 // So setting a NULL owner would be bad!)
7574 //
7575 // If this code ever changes, change nsObjectLoadingContent::LoadObject
7576 // accordingly.
7577 PRBool inherit;
7578 // We expect URIInheritsSecurityContext to return success for an
7579 // about:blank URI, so don't call IsAboutBlank() if this call fails.
7583 }
7585 //
7586 // file: uri special-casing
7587 //
7588 // If this is a file: load opened from another file: then it may need
7589 // to inherit the owner from the referrer so they can script each other.
7590 // If we don't set the owner explicitly then each file: gets an owner
7591 // based on its own codebase later.
7592 //
7596 // One more check here. CheckMayLoad will always return true for the
7597 // system principal, but we do NOT want to inherit in that case.
7598 PRBool isSystem;
7606 }
7607 }
7611 // Allow execution against our context if the principals match
7612 scriptChannel->
7614 }
7621 PR_TRUE);
7622 }
7623 }
7627 //
7628 // If the channel load failed, we failed and nsIWebProgress just ain't
7629 // gonna happen.
7630 //
7635 }
7636 }
7639 }
7641 static NS_METHOD
7645 PRUint32 toOffset,
7646 PRUint32 count,
7648 {
7649 // aFromSegment now contains aCount bytes of data.
7654 // Indicate that we have consumed all of aFromSegment
7657 }
7659 NS_IMETHODIMP
7662 {
7666 PRUint32 numRead;
7667 nsCAutoString headersString;
7670 PR_UINT32_MAX,
7674 // used during the manipulation of the String from the InputStream
7675 nsCAutoString headerName;
7676 nsCAutoString headerValue;
7677 PRInt32 crlf;
7678 PRInt32 colon;
7680 //
7681 // Iterate over the headersString: for each "\r\n" delimited chunk,
7682 // add the value as a header to the nsIHttpChannel
7683 //
7705 //
7706 // FINALLY: we can set the header!
7707 //
7711 }
7715 }
7719 PRBool aBypassClassifier)
7720 {
7721 nsresult rv;
7722 // Mark the channel as being a document URI and allow content sniffing...
7728 // Load attributes depend on load type...
7754 // Set cache checking flags
7755 PRInt32 prefSetting;
7770 }
7771 }
7773 }
7787 }
7788 }
7791 }
7793 nsresult
7795 {
7805 }
7807 NS_IMETHODIMP
7810 {
7816 }
7822 }
7827 // If we failed to get the shell, or if there is no shell,
7828 // nothing left to do here.
7831 }
7833 // NOTE: we assume URIs are absolute for comparison purposes
7835 nsCAutoString currentSpec;
7837 NS_ERROR_FAILURE);
7839 nsCAutoString newSpec;
7842 // Search for hash marks in the current URI and the new URI and
7843 // take a copy of everything to the left of the hash for
7844 // comparison.
7848 // Split the new URI into a left and right part
7849 // (assume we're parsing it out right
7857 }
7860 // found it
7867 }
7869 // no hash at all
7871 }
7875 // Split the current URI in a left and right part
7882 }
7887 }
7890 }
7892 // If we have no new anchor, we do not want to scroll, unless there is a
7893 // current anchor and we are doing a history load. So return if we have no
7894 // new anchor, and there is no current anchor or the load is not a history
7895 // load.
7901 }
7903 // Compare the URIs.
7904 //
7905 // NOTE: this is a case sensitive comparison because some parts of the
7906 // URI are case sensitive, and some are not. i.e. the domain name
7907 // is case insensitive but the the paths are not.
7908 //
7909 // This means that comparing "http://www.ABC.com/" to "http://www.abc.com/"
7910 // will fail this test.
7914 }
7916 // Now we know we are dealing with an anchor
7919 // Both the new and current URIs refer to the same page. We can now
7920 // browse to the hash stored in the new URI.
7921 //
7922 // But first let's capture positions of scroller(s) that can
7923 // (and usually will) be modified by GoToAnchor() call.
7929 // anchor is there, but if it's a load from history,
7930 // we don't have any anchor jumping to do
7937 }
7939 // nsUnescape modifies the string that is passed into it.
7942 // We assume that the bytes are in UTF-8, as it says in the
7943 // spec:
7944 // http://www.w3.org/TR/html4/appendix/notes.html#h-B.2.1
7946 // We try the UTF-8 string first, and then try the document's
7947 // charset (see below). If the string is not UTF-8,
7948 // conversion will fail and give us an empty Unicode string.
7949 // In that case, we should just fall through to using the
7950 // page's charset.
7955 }
7958 // Above will fail if the anchor name is not UTF-8. Need to
7959 // convert from document charset to unicode.
7962 // Get a document charset
7976 // Unescape and convert to unicode
7977 nsXPIDLString uStr;
7984 // Ignore return value of GoToAnchor, since it will return an error
7985 // if there is no such anchor in the document, which is actually a
7986 // success condition for us (we want to update the session history
7987 // with the new URI no matter whether we actually scrolled
7988 // somewhere).
7990 }
7991 }
7994 // Tell the shell it's at an anchor, without scrolling.
7997 // An empty anchor was found, but if it's a load from history,
7998 // we don't have to jump to the top of the page. Scrollbar
7999 // position will be restored by the caller, based on positions
8000 // stored in session history.
8003 //An empty anchor. Scroll to the top of the page.
8005 }
8008 }
8010 void
8012 {
8019 }
8020 }
8021 }
8023 PRBool
8026 PRBool aAddToGlobalHistory)
8027 {
8031 #if defined(PR_LOGGING) && defined(DEBUG)
8033 nsCAutoString spec;
8036 nsCAutoString chanName;
8039 else
8045 }
8046 #endif
8052 // Get the post data from the channel
8057 // Check if the HTTPChannel is hiding under a multiPartChannel
8060 }
8066 }
8067 }
8068 }
8069 /* Create SH Entry (mLSHE) only if there is a SessionHistory object (mSessionHistory) in
8070 * the current frame or in the root docshell
8071 */
8074 // Get the handle to SH from the root docshell
8081 // Determine if this type of load should update history.
8088 // Check if the url to be loaded is the same as the one already loaded.
8092 #ifdef DEBUG
8096 #endif
8098 /* If the url to be loaded is the same as the one already there,
8099 * and the original loadType is LOAD_NORMAL, LOAD_LINK, or
8100 * LOAD_STOP_CONTENT, set loadType to LOAD_NORMAL_REPLACE so that
8101 * AddToSessionHistory() won't mess with the current SHEntry and
8102 * if this page has any frame children, it also will be handled
8103 * properly. see bug 83684
8104 *
8105 * XXX Hopefully changing the loadType at this time will not hurt
8106 * anywhere. The other way to take care of sequentially repeating
8107 * frameset pages is to add new methods to nsIDocShellTreeItem.
8108 * Hopefully I don't have to do that.
8109 */
8115 {
8117 }
8119 // If this is a refresh to the currently loaded url, we don't
8120 // have to update session or global history.
8123 }
8126 /* If the user pressed shift-reload, cache will create a new cache key
8127 * for the page. Save the new cacheKey in Session History.
8128 * see bug 90098
8129 */
8139 // Get the Cache Key and store it in SH.
8142 // If we already have a loading history entry, store the new cache key
8143 // in it. Otherwise, since we're doing a reload and won't be updating
8144 // our history entry, store the cache key in our current history entry.
8149 }
8152 // Update session history if necessary...
8154 /* This is a fresh page getting loaded for the first time
8155 *.Create a Entry for it and add it to SH, if this is the
8156 * rootDocShell
8157 */
8160 }
8162 // Update Global history
8164 // Get the referrer uri from the channel
8166 }
8167 }
8169 // If this was a history load, update the index in
8170 // SH.
8177 #ifdef DEBUG_PAGE_CACHE
8180 #endif
8181 }
8182 }
8184 aFireOnLocationChange);
8185 // Make sure to store the referrer from the channel, if any
8188 }
8190 PRBool
8192 PRBool aAddToGlobalHistory)
8193 {
8195 // If this a redirect, use the final url (uri)
8196 // else use the original url
8197 //
8198 // Note that this should match what documents do (see nsDocument::Reset).
8203 aAddToGlobalHistory);
8205 }
8207 void
8209 {
8211 }
8213 //*****************************************************************************
8214 // nsDocShell: Session History
8215 //*****************************************************************************
8216 PRBool
8218 {
8219 // I believe none of the about: urls should go in the history. But then
8220 // that could just be me... If the intent is only deny about:blank then we
8221 // should just do a spec compare, rather than two gets of the scheme and
8222 // then the path. -Gagan
8223 nsresult rv;
8224 nsCAutoString buf;
8237 }
8238 }
8240 }
8242 nsresult
8245 {
8249 #if defined(PR_LOGGING) && defined(DEBUG)
8251 nsCAutoString spec;
8254 nsCAutoString chanName;
8257 else
8263 }
8264 #endif
8268 PRBool shouldPersist;
8272 // Get a handle to the root docshell
8275 /*
8276 * If this is a LOAD_FLAGS_REPLACE_HISTORY in a subframe, we use
8277 * the existing SH entry in the page and replace the url and
8278 * other vitalities.
8279 */
8282 // This is a subframe
8288 // Remove all children of this entry
8295 }
8297 // Create a new entry if necessary.
8303 }
8304 }
8306 // Get the post data & referrer
8317 /* If there is a caching channel, get the Cache Key and store it
8318 * in SH.
8319 */
8323 }
8326 // Check if the httpChannel is hiding under a multipartChannel
8329 }
8334 }
8338 }
8340 }
8342 //Title is set in nsDocShell::SetTitle()
8351 /* If cache got a 'no-store', ask SH not to store
8352 * HistoryLayoutState. By default, SH will set this
8353 * flag to PR_TRUE and save HistoryLayoutState.
8354 */
8357 }
8359 // Check if the page has expired from cache
8362 PRUint32 expTime;
8368 }
8369 }
8375 // This is the root docshell
8377 // Replace current entry in session history.
8381 // Replace the current entry with the new entry
8384 }
8386 // Add to session history
8393 #ifdef DEBUG_PAGE_CACHE
8396 #endif
8397 }
8398 }
8400 // This is a subframe.
8402 LOAD_FLAGS_REPLACE_HISTORY))
8404 }
8406 // Return the new SH entry...
8412 }
8413 }
8416 }
8419 NS_IMETHODIMP
8421 {
8424 }
8429 nsCAutoString contentType;
8436 NS_ERROR_FAILURE);
8438 NS_ERROR_FAILURE);
8441 NS_ERROR_FAILURE);
8443 // Calling CreateAboutBlankContentViewer can set mOSHE to null, and if
8444 // that's the only thing holding a ref to aEntry that will cause aEntry to
8445 // die while we're loading it. So hold a strong ref to aEntry here, just
8446 // in case.
8448 PRBool isJS;
8451 // We're loading a URL that will execute script from inside asyncOpen.
8452 // Replace the current document with about:blank now to prevent
8453 // anything from the current document from leaking into any JavaScript
8454 // code in the URL.
8459 // The creation of the intermittent about:blank content
8460 // viewer failed for some reason (potentially because the
8461 // user prevented it). Interrupt the history load.
8463 }
8466 // Ensure that we have an owner. Otherwise javascript: URIs will
8467 // pick it up from the about:blank page we just loaded, and we
8468 // don't really want even that in this case.
8471 }
8472 }
8474 /* If there is a valid postdata *and* the user pressed
8475 * reload or shift-reload, take user's permission before we
8476 * repost the data to the server.
8477 */
8479 PRBool repost;
8483 // If the user pressed cancel in the dialog, return. We're done here.
8486 }
8489 referrerURI,
8490 owner,
8498 PR_TRUE,
8502 }
8505 {
8508 // Don't capture historystate and save it in history
8509 // if the page asked not to do so.
8511 }
8514 }
8517 {
8526 PR_TRUE);
8527 }
8528 }
8531 }
8533 /* static */ nsresult
8536 WalkHistoryEntriesFunc aCallback,
8538 {
8545 PRInt32 childCount;
8551 // childEntry can be null for valid reasons, for example if the
8552 // docshell at index i never loaded anything useful.
8554 }
8558 // Walk the children of aRootShell and see if one of them
8559 // has srcChild as a SHEntry.
8569 }
8570 }
8571 }
8574 }
8577 }
8579 // callback data for WalkHistoryEntries
8580 struct NS_STACK_CLASS CloneAndReplaceData
8581 {
8588 PRUint32 cloneID;
8592 };
8594 /* static */ nsresult
8597 {
8605 PRUint32 srcID;
8609 // Just replace the entry, and don't walk the children.
8613 // Clone the SHEntry...
8618 // This entry is for a subframe navigation
8621 // Walk the children
8630 }
8639 }
8641 /* static */ nsresult
8644 PRUint32 aCloneID,
8647 {
8656 }
8659 void
8661 {
8667 }
8670 struct SwapEntriesData
8671 {
8675 // whose children will correspond to aEntry
8676 };
8679 nsresult
8682 {
8696 // aEntry is a clone of some child of destTreeParent, but since the
8697 // trees aren't necessarily in sync, we'll have to locate it.
8698 // Note that we could set aShell's entry to null if we don't find a
8699 // corresponding entry under destTreeParent.
8704 // First look at the given index, since this is the common case.
8710 PRInt32 childCount;
8721 }
8722 }
8723 }
8726 }
8730 // Now handle the children of aEntry.
8734 }
8739 {
8745 }
8748 }
8751 void
8753 {
8754 // We need to sync up the docshell and session history trees for
8755 // subframe navigation. If the load was in a subframe, we forward up to
8756 // the root docshell, which will then recursively sync up all docshells
8757 // to their corresponding entries in the new session history tree.
8758 // If we don't do this, then we can cache a content viewer on the wrong
8759 // cloned entry, and subsequently restore it at the wrong time.
8763 // newRootEntry is now the new root entry.
8764 // Find the old root entry as well.
8766 // Need a strong ref. on |oldRootEntry| so it isn't destroyed when
8767 // SetChildHistoryEntry() does SwapHistoryEntries() (bug 304639).
8780 #ifdef NS_DEBUG
8781 nsresult rv =
8782 #endif
8786 }
8787 }
8788 }
8791 }
8794 nsresult
8796 {
8797 nsresult rv;
8800 //Get the root docshell
8802 // QI to nsIWebNavigation
8805 // Get the handle to SH from the root docshell
8807 }
8809 }
8811 nsresult
8813 {
8825 }
8827 }
8829 PRBool
8831 {
8832 // By default layout State will be saved.
8836 // figure out if SH should be saving layout state
8844 }
8846 //*****************************************************************************
8847 // nsDocShell: nsIEditorDocShell
8848 //*****************************************************************************
8851 {
8857 }
8860 }
8863 {
8868 }
8872 {
8876 }
8880 {
8884 {
8888 }
8889 else
8890 {
8892 }
8895 }
8898 {
8903 }
8905 nsresult
8908 {
8912 // If this is a POST request, we do not want to include this in global
8913 // history, so return early.
8916 nsCAutoString type;
8920 }
8922 PRBool visited;
8940 }
8941 }
8944 }
8946 //*****************************************************************************
8947 // nsDocShell: Helper Routines
8948 //*****************************************************************************
8950 NS_IMETHODIMP
8952 {
8955 }
8957 NS_IMETHODIMP
8959 {
8962 }
8964 nsresult
8966 {
8967 nsresult rv;
8987 nsXPIDLString brandName;
8995 }
8997 // Brand available - if the app has an override file with formatting, the app name will
8998 // be included. Without an override, the prompt will look like the generic version.
9003 }
9010 PRInt32 buttonPressed;
9020 }
9022 NS_IMETHODIMP
9025 {
9027 NS_ERROR_FAILURE);
9035 aStringBundle),
9036 NS_ERROR_FAILURE);
9039 }
9041 NS_IMETHODIMP
9044 {
9049 NS_ERROR_FAILURE);
9057 NS_ERROR_FAILURE);
9063 }
9064 }
9067 }
9069 NS_IMETHODIMP
9071 {
9079 NS_ERROR_FAILURE);
9083 }
9085 }
9087 #ifdef DEBUG
9088 class nsDebugAutoBoolTrueSetter
9089 {
9093 {
9095 }
9098 {
9100 }
9103 };
9104 #endif
9106 NS_IMETHODIMP
9108 {
9114 }
9116 #ifdef DEBUG
9118 "Infinite loop! Calling EnsureScriptEnvironment() from "
9121 // Yeah, this isn't re-entrant safe, but that's ok since if we
9122 // re-enter this method, we'll infinitely loop...
9124 #endif
9133 PRUint32 chromeFlags;
9136 PRBool isModalContentWindow =
9140 // If our window is modal and we're not opened as chrome, make
9141 // this window a modal content window.
9143 isModalContentWindow,
9150 // Ensure the script object is set to run javascript - other languages
9151 // setup on demand.
9152 // XXXmarkh - should this be setup to run the default language for this doc?
9153 nsresult rv;
9158 }
9161 NS_IMETHODIMP
9163 {
9166 // We shouldn't recreate the editor data if it already exists, or
9167 // we're shutting down, or we already have a detached editor data
9168 // stored in the session history. We should only have one editordata
9169 // per docshell.
9171 }
9174 }
9176 nsresult
9178 {
9182 }
9185 }
9189 {
9190 nsresult rv;
9192 {
9195 }
9197 // we promise that the nsIWebBrowserFind that we return has been set
9198 // up to point to the focused, or content window, so we have to
9199 // set that up each time.
9204 // default to our window
9208 // if we can, search the focused window
9214 {
9219 }
9230 }
9232 PRBool
9234 {
9242 }
9245 }
9247 NS_IMETHODIMP
9249 {
9252 }
9254 NS_IMETHODIMP
9256 {
9257 #ifdef DEBUG_DOCSHELL_FOCUS
9260 #endif
9267 }
9270 // We may be in a situation where the focus outline was shown
9271 // on this document because the user tabbed into it, but the focus
9272 // is now switching to another document via a click. In this case,
9273 // we need to make sure the focus outline is removed from this document.
9275 }
9278 }
9280 // Find an nsICanvasFrame under aFrame. Only search the principal
9281 // child lists. aFrame must be non-null.
9283 {
9287 }
9294 }
9296 }
9299 }
9301 //-------------------------------------------------------
9302 // Tells the HTMLFrame/CanvasFrame that is now has focus
9303 NS_IMETHODIMP
9305 {
9325 }
9326 }
9327 }
9329 // Look for the frame the hard way
9335 }
9336 }
9337 }
9340 }
9342 NS_IMETHODIMP
9344 {
9346 }
9348 /* boolean IsBeingDestroyed (); */
9349 NS_IMETHODIMP
9351 {
9355 }
9358 NS_IMETHODIMP
9360 {
9364 }
9366 NS_IMETHODIMP
9368 {
9372 }
9374 NS_IMETHODIMP
9376 {
9380 }
9382 //*****************************************************************************
9383 //*** nsRefreshTimer: Object Management
9384 //*****************************************************************************
9388 {
9389 }
9392 {
9393 }
9395 //*****************************************************************************
9396 // nsRefreshTimer::nsISupports
9397 //*****************************************************************************
9405 NS_INTERFACE_MAP_END_THREADSAFE
9407 ///*****************************************************************************
9408 // nsRefreshTimer::nsITimerCallback
9409 //******************************************************************************
9410 NS_IMETHODIMP
9412 {
9416 // Get the delay count to determine load type
9420 }
9422 }
9424 //*****************************************************************************
9425 //*** nsDocShellFocusController: Object Management
9426 //*****************************************************************************
9427 void
9429 {
9430 #ifdef DEBUG_DOCSHELL_FOCUS
9433 #endif
9438 }
9440 }
9442 }
9444 //--------------------------------------------------
9445 // This is need for when the document with focus goes away
9446 void
9448 {
9451 }
9452 }
9454 //*****************************************************************************
9455 // nsDocShell::InterfaceRequestorProxy
9456 //*****************************************************************************
9458 {
9461 }
9462 }
9465 {
9467 }
9471 NS_IMETHODIMP
9473 {
9478 }
9481 }
9483 nsresult
9485 {
9497 // Get the current document and set the base uri
9504 }
9505 }
9507 }
9509 //*****************************************************************************
9510 // nsDocShell::nsIAuthPromptProvider
9511 //*****************************************************************************
9513 NS_IMETHODIMP
9516 {
9517 // a priority prompt request will override a false mAllowAuth setting
9523 // we're either allowing auth, or it's a proxy request
9524 nsresult rv;
9534 // Get the an auth prompter for our window so that the parenting
9535 // of the dialogs works as it should when using tabs.
9539 }
9541 //*****************************************************************************
9542 // nsDocShell::nsIObserver
9543 //*****************************************************************************
9545 NS_IMETHODIMP
9548 {
9558 PRBool tmpbool;
9565 }
9567 }
9569 //*****************************************************************************
9570 // nsDocShell::nsILoadContext
9571 //*****************************************************************************
9572 NS_IMETHODIMP
9574 {
9576 }
9578 NS_IMETHODIMP
9580 {
9581 nsresult rv;
9585 }
9587 NS_IMETHODIMP
9589 {
9592 PRUint32 type;
9597 }
9602 }
9606 }
9608 NS_IMETHODIMP
9610 {
9613 }
9615 /* static */
9616 nsresult
9618 {
9619 // Note: about:blank URIs do NOT inherit the security context from the
9620 // current document, which is what this function tests for...
9623 aResult);
9624 }
9626 /* static */
9627 PRBool
9629 {
9630 PRBool isFile;
9636 isFile;
9637 }
9639 /* static */
9640 PRBool
9642 {
9645 // GetSpec can be expensive for some URIs, so check the scheme first.
9649 }
9651 nsCAutoString str;
9654 }
9656 PRBool
9658 {
9663 }
9667 }
9671 return
9672 secMan &&
9674 }
9676 //*****************************************************************************
9677 // nsClassifierCallback
9678 //*****************************************************************************
9681 nsIChannelClassifier,
9682 nsIURIClassifierCallback,
9683 nsIRunnable,
9684 nsIChannelEventSink,
9685 nsIInterfaceRequestor)
9687 NS_IMETHODIMP
9689 {
9692 }
9695 "nsClassifierCallback::Run() called while a "
9701 // Don't bother to run the classifier on a load that has already failed.
9702 // (this might happen after a redirect)
9703 PRUint32 status;
9708 // Don't bother to run the classifier on a cached load that was
9709 // previously classified.
9712 }
9718 // Don't bother checking certain types of URIs.
9719 PRBool hasFlags;
9748 // no URI classifier, ignore this failure.
9750 }
9753 PRBool expectCallback;
9758 // Suspend the channel, it will be resumed when we get the classifier
9759 // callback.
9762 // Some channels (including nsJSChannel) fail on Suspend. This
9763 // shouldn't be fatal, but will prevent malware from being
9764 // blocked on these channels.
9766 }
9769 #ifdef DEBUG
9773 #endif
9774 }
9777 }
9779 // Note in the cache entry that this URL was classified, so that future
9780 // cached loads don't need to be checked.
9781 void
9783 {
9788 }
9794 }
9800 }
9804 }
9806 PRBool
9808 {
9813 }
9815 // Only check the tag if we are loading from the cache without
9816 // validation.
9817 PRBool fromCache;
9820 }
9826 }
9832 }
9834 nsXPIDLCString tag;
9837 }
9839 NS_IMETHODIMP
9841 {
9846 #ifdef DEBUG
9850 #endif
9852 }
9853 #ifdef DEBUG
9857 #endif
9860 }
9863 }
9865 NS_IMETHODIMP
9867 {
9878 }
9881 }
9883 NS_IMETHODIMP
9886 {
9889 // we call the Run() from the main loop to give the channel a
9890 // chance to AsyncOpen() before we suspend it.
9894 }
9896 NS_IMETHODIMP
9898 {
9900 #ifdef DEBUG
9904 #endif
9907 }
9911 }
9914 }
9916 NS_IMETHODIMP
9919 PRUint32 aFlags)
9920 {
9929 }
9930 }
9933 }
9935 NS_IMETHODIMP
9937 {
9946 }
9947 }