| blob | de9238a594042e3d257dab93819410779c21342a |
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
111 // we want to explore making the document own the load group
112 // so we can associate the document URI with the load group.
113 // until this point, we have an evil hack:
117 // Local Includes
125 // Helper Classes
129 // Interfaces Needed
147 // Editor-related
158 // The following are for bug #13871: Prevent frameset spoofing
161 // For reporting errors with the console service.
162 // These can go away if error reporting is propagated up past nsDocShell.
166 // used to dispatch urls to default protocol handlers
184 #ifdef DEBUG_DOCSHELL_FOCUS
186 #endif
190 // for embedding
197 NS_DOM_SCRIPT_OBJECT_FACTORY_CID);
200 #if defined(DEBUG_bryner) || defined(DEBUG_chb)
201 //#define DEBUG_DOCSHELL_FOCUS
202 #define DEBUG_PAGE_CACHE
203 #endif
208 // Number of documents currently loading
211 // Global count of existing docshells.
214 // Global reference to the URI fixup service.
217 // True means we validate window targets to prevent frameset
218 // spoofing. Initialize this to a non-bolean value so we know to check
219 // the pref on the creation of the first docshell.
222 // Hint for native dispatch of events on how long to delay after
223 // all documents have loaded in milliseconds before favoring normal
224 // native event dispatch priorites over performance
225 #define NS_EVENT_STARVATION_DELAY_HINT 2000
227 // This is needed for displaying an error message
228 // when navigation is attempted on a document when printing
229 // The value arbitrary as long as it doesn't conflict with
230 // any of the other values in the errors in DisplayLoadError
231 #define NS_ERROR_DOCUMENT_IS_PRINTMODE NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_GENERAL,2001)
233 #ifdef PR_LOGGING
234 #ifdef DEBUG
236 #endif
238 #endif
243 static void
245 {
249 }
251 //*****************************************************************************
252 //*** nsDocShellFocusController
253 //*****************************************************************************
255 class nsDocShellFocusController
256 {
272 };
276 //*****************************************************************************
277 //*** nsDocShell: Object Management
278 //*****************************************************************************
312 #ifdef DEBUG
314 #endif
315 {
321 }
323 #ifdef PR_LOGGING
324 #ifdef DEBUG
327 #endif
332 #endif
333 }
336 {
340 }
345 }
347 #ifdef PR_LOGGING
350 #endif
351 }
353 nsresult
355 {
370 // We want to hold a strong ref to the loadgroup, so it better hold a weak
371 // ref to us... use an InterfaceRequestorProxy to do this.
381 // Add as |this| a progress listener to itself. A little weird, but
382 // simpler than reproducing all the listener-notification logic in
383 // overrides of the various methods via which nsDocLoader can be
384 // notified. Note that this holds an nsWeakPtr to ourselves, so it's ok.
388 }
390 void
392 {
401 }
402 }
405 }
407 //*****************************************************************************
408 // nsDocShell::nsISupports
409 //*****************************************************************************
435 ///*****************************************************************************
436 // nsDocShell::nsIInterfaceRequestor
437 //*****************************************************************************
439 {
446 }
450 }
456 }
461 }
464 nsresult rv;
471 // Get the an auth prompter for our window so that the parenting
472 // of the dialogs works as it should when using tabs.
480 }
486 }
489 nsresult
490 rv =
496 }
498 }
506 }
511 {
515 }
518 }
524 }
530 }
536 }
539 }
543 }
545 PRUint32
548 {
605 }
608 }
611 nsDocShellInfoLoadType
613 {
670 }
673 }
675 //*****************************************************************************
676 // nsDocShell::nsIDocShell
677 //*****************************************************************************
678 NS_IMETHODIMP
681 PRUint32 aLoadFlags,
682 PRBool aFirstParty)
683 {
684 // Note: we allow loads to get through here even if mFiredUnloadEvent is
685 // true; that case will get handled in LoadInternal or LoadHistoryEntry.
688 }
689 nsresult rv;
697 nsXPIDLString target;
702 // Extract the info from the DocShellLoadInfo struct...
708 // Get the appropriate loadType from nsIDocShellLoadInfo type
718 }
720 #if defined(PR_LOGGING) && defined(DEBUG)
722 nsCAutoString uristr;
727 }
728 #endif
732 // First verify if this is a subframe.
736 PRUint32 parentLoadType;
739 /* OK. It is a subframe. Checkout the
740 * parent's loadtype. If the parent was loaded thro' a history
741 * mechanism, then get the SH entry for the child from the parent.
742 * This is done to restore frameset navigation while going back/forward.
743 * If the parent was loaded through any other loadType, set the
744 * child's loadType too accordingly, so that session history does not
745 * get confused.
746 */
748 // Get the parent's load type
753 // Get the ShEntry for the child from the parent
755 // Make some decisions on the child frame's loadType based on the
756 // parent's loadType.
758 // This is a newly created frame. Check for exception cases first.
759 // By default the subframe will inherit the parent's loadType.
763 // The parent was loaded normally. In this case, this *brand new* child really shouldn't
764 // have a SHEntry. If it does, it could be because the parent is replacing an
765 // existing frame with a new frame, in the onLoadHandler. We don't want this
766 // url to get into session history. Clear off shEntry, and set laod type to
767 // LOAD_BYPASS_HISTORY.
773 }
774 }
776 // Clear shEntry. For refresh loads, we have to load
777 // what comes thro' the pipe, not what's in history.
779 }
786 // If the parent url, bypassed history or was loaded from
787 // history, pass on the parent's loadType to the new child
788 // frame too, so that the child frame will also
789 // avoid getting into history.
791 }
792 }
794 // This is a pre-existing subframe. If the load was not originally initiated
795 // by session history, (if (!shEntry) condition succeeded) and mCurrentURI is not null,
796 // it is possible that a parent's onLoadHandler or even self's onLoadHandler is loading
797 // a new page in this child. Check parent's and self's busy flag and if it is set,
798 // we don't want this onLoadHandler load to get in to session history.
805 shEntry) {
808 }
809 }
813 // This is the root docshell. If we got here while
814 // executing an onLoad Handler,this load will not go
815 // into session history.
820 }
821 }
825 #ifdef DEBUG
828 #endif
831 }
832 // Perform the load...
834 // We need an owner (a referring principal). 4 possibilities:
835 // (1) If the system principal was passed in and we're a typeContent
836 // docshell, inherit the principal from the current document
837 // instead.
838 // (2) In all other cases when the principal passed in is not null,
839 // use that principal.
840 // (3) If the caller has allowed inheriting from the current document,
841 // or if we're being called from system code (eg chrome JS or pure
842 // C++) then inheritOwner should be true and InternalLoad will get
843 // an owner from the current document. If none of these things are
844 // true, then
845 // (4) we pass a null owner into the channel, and an owner will be
846 // created later from the channel's internal data.
847 //
848 // NOTE: This all only works because the only thing the owner is used
849 // for in InternalLoad is data:, javascript:, and about:blank
850 // URIs. For other URIs this would all be dead wrong!
857 PRBool isSystem;
864 }
865 }
867 // See if there's system or chrome JS code running
870 // Set it back to false
872 }
873 }
893 referrer,
894 owner,
895 flags,
898 postStream,
899 headersStream,
900 loadType,
902 aFirstParty,
905 }
908 }
910 NS_IMETHODIMP
915 {
920 // if the caller doesn't pass in a URI we need to create a dummy URI. necko
921 // currently requires a URI in various places during the load. Some consumers
922 // do as well.
925 // HACK ALERT
930 // Make sure that the URI spec "looks" like a protocol and path...
931 // For now, just use a bogus protocol called "internal"
935 }
941 // Get the appropriate LoadType from nsIDocShellLoadInfo type
943 }
949 // build up a channel for this stream.
954 NS_ERROR_FAILURE);
961 NS_ERROR_FAILURE);
963 }
965 NS_IMETHODIMP
967 {
975 }
978 /*
979 * Reset state to a new content model within the current document and the document
980 * viewer. Called by the document before initiating an out of band document.write().
981 */
982 NS_IMETHODIMP
984 {
987 }
990 NS_IMETHODIMP
992 {
994 // Keep an explicit reference since calling PageHide could release
995 // mContentViewer
1006 }
1012 }
1013 }
1014 // Now make sure our editor, if any, is detached before we go
1015 // any farther.
1017 }
1020 }
1022 //
1023 // Bug 13871: Prevent frameset spoofing
1024 //
1025 // This routine answers: 'Is origin's document from same domain as
1026 // target's document?'
1027 //
1028 // file: uris are considered the same domain for the purpose of
1029 // frame navigation regardless of script accessibility (bug 420425)
1030 //
1031 /* static */
1032 PRBool
1035 {
1041 nsresult rv =
1046 // We're called from JS, check if UniversalBrowserWrite is
1047 // enabled.
1055 }
1056 }
1058 // Get origin document principal
1064 // Get target principal
1070 PRBool equal;
1075 }
1077 // Not strictly equal, special case if both are file: uris
1097 }
1099 NS_IMETHODIMP
1101 {
1118 }
1119 }
1122 }
1124 NS_IMETHODIMP
1126 {
1137 }
1139 NS_IMETHODIMP
1141 {
1152 }
1155 }
1157 NS_IMETHODIMP
1159 {
1170 }
1173 }
1175 NS_IMETHODIMP
1177 {
1183 }
1185 NS_IMETHODIMP
1187 {
1190 // Weak reference. Don't addref.
1196 }
1199 }
1201 NS_IMETHODIMP
1203 {
1208 }
1210 /* [noscript] void setCurrentURI (in nsIURI uri); */
1211 NS_IMETHODIMP
1213 {
1216 }
1218 PRBool
1220 PRBool aFireOnLocationChange)
1221 {
1222 #ifdef PR_LOGGING
1224 nsCAutoString spec;
1228 }
1229 #endif
1231 // We don't want to send a location change when we're displaying an error
1232 // page, and we don't want to change our idea of "current URI" either
1235 }
1246 {
1247 // This is the root docshell
1249 }
1252 }
1255 /*
1256 * We don't want to send OnLocationChange notifications when
1257 * a subframe is being loaded for the first time, while
1258 * visiting a frameset page
1259 */
1261 }
1265 }
1267 }
1269 NS_IMETHODIMP
1271 {
1283 }
1286 }
1288 NS_IMETHODIMP
1290 {
1291 // set the default charset
1298 NS_ERROR_FAILURE);
1299 }
1300 }
1302 // set the charset override
1309 }
1312 }
1314 NS_IMETHODIMP
1316 aDocumentCharsetInfo)
1317 {
1320 // if the mDocumentCharsetInfo does not exist already, we create it now
1325 }
1330 }
1332 NS_IMETHODIMP
1334 aDocumentCharsetInfo)
1335 {
1338 }
1340 NS_IMETHODIMP
1342 {
1349 }
1354 }
1357 }
1359 NS_IMETHODIMP
1361 {
1367 }
1369 PRBool unsafe;
1372 }
1374 NS_IMETHODIMP
1376 {
1378 //XXX should enable or disable a plugin host
1380 }
1382 NS_IMETHODIMP
1384 {
1390 }
1392 PRBool unsafe;
1395 }
1397 NS_IMETHODIMP
1399 {
1402 }
1405 {
1411 }
1413 PRBool unsafe;
1416 }
1419 {
1422 }
1425 {
1430 }
1433 {
1436 }
1439 {
1444 }
1447 {
1450 }
1452 NS_IMETHODIMP
1453 nsDocShell::GetDocShellEnumerator(PRInt32 aItemType, PRInt32 aDirection, nsISimpleEnumerator **outEnum)
1454 {
1461 else
1478 }
1480 NS_IMETHODIMP
1482 {
1485 }
1487 NS_IMETHODIMP
1489 {
1492 }
1495 NS_IMETHODIMP
1497 {
1500 }
1502 NS_IMETHODIMP
1504 {
1507 }
1509 NS_IMETHODIMP
1511 {
1515 }
1517 NS_IMETHODIMP
1519 {
1521 }
1523 NS_IMETHODIMP
1525 {
1530 }
1532 NS_IMETHODIMP
1534 {
1537 }
1539 NS_IMETHODIMP
1541 {
1546 }
1548 NS_IMETHODIMP
1550 {
1553 }
1555 NS_IMETHODIMP
1557 {
1562 }
1564 NS_IMETHODIMP
1566 {
1573 else
1579 }
1581 NS_IMETHODIMP
1583 {
1586 }
1588 NS_IMETHODIMP
1590 {
1593 }
1595 NS_IMETHODIMP
1597 {
1600 }
1602 NS_IMETHODIMP
1604 {
1605 // If mUseErrorPages is set explicitly, stop observing the pref.
1611 }
1612 }
1615 }
1617 NS_IMETHODIMP
1619 {
1622 }
1624 NS_IMETHODIMP
1626 {
1629 }
1631 NS_IMETHODIMP
1633 {
1634 // These indices are used for fastback cache eviction, to determine
1635 // which session history entries are candidates for content viewer
1636 // eviction. We need to adjust by the number of entries that we
1637 // just purged from history, so that we look at the right session history
1638 // entries during eviction.
1647 }
1648 }
1651 }
1653 NS_IMETHODIMP
1656 {
1673 nsCAutoString currentDomain;
1696 }
1699 }
1701 nsresult
1704 {
1720 }
1723 }
1724 }
1727 }
1729 NS_IMETHODIMP
1731 {
1745 }
1748 }
1750 //*****************************************************************************
1751 // nsDocShell::nsIDocShellTreeItem
1752 //*****************************************************************************
1754 NS_IMETHODIMP
1756 {
1760 }
1762 NS_IMETHODIMP
1764 {
1767 }
1769 NS_IMETHODIMP
1771 {
1776 }
1778 NS_IMETHODIMP
1780 {
1785 }
1787 NS_IMETHODIMP
1789 {
1792 // Only allow setting the type on root docshells. Those would be the ones
1793 // that have the docloader service as mParent or have no mParent at all.
1802 // disable auth prompting for anything but content
1806 }
1808 NS_IMETHODIMP
1810 {
1815 }
1816 // Note that in the case when the parent is not an nsIDocShellTreeItem we
1817 // don't want to throw; we just want to return null.
1819 }
1821 nsresult
1823 {
1826 // Curse ambiguous nsISupports inheritance!
1829 // If parent is another docshell, we inherit all their flags for
1830 // allowing plugins, scripting etc.
1833 {
1834 PRBool value;
1836 {
1838 }
1840 {
1842 }
1844 {
1846 }
1848 {
1850 }
1852 {
1854 }
1855 }
1861 }
1863 NS_IMETHODIMP
1865 {
1874 PRInt32 parentType;
1879 }
1881 }
1883 NS_IMETHODIMP
1885 {
1894 NS_ERROR_FAILURE);
1895 }
1898 }
1900 NS_IMETHODIMP
1902 {
1908 NS_ERROR_FAILURE);
1913 NS_ERROR_FAILURE);
1914 }
1917 }
1919 /* static */
1920 PRBool
1923 PRBool aConsiderOpener)
1924 {
1928 // Good to go
1930 }
1932 // XXXbz should we care if aAccessingItem or the document therein is
1933 // chrome? Should those get extra privileges?
1935 // For historical context, see:
1936 //
1937 // Bug 13871: Prevent frameset spoofing
1938 // Bug 103638: Targets with same name in different windows open in wrong
1939 // window with javascript
1940 // Bug 408052: Adopt "ancestor" frame navigation policy
1942 // Now do a security check
1943 //
1944 // Allow navigation if
1945 // 1) aAccessingItem can script aTargetItem or one of its ancestors in
1946 // the frame hierarchy or
1947 // 2) aTargetItem is a top-level frame and aAccessingItem is its descendant
1948 // 3) aTargetItem is a top-level frame and aAccessingItem can target
1949 // its opener per rule (1) or (2).
1952 // A frame is allowed to navigate itself.
1954 }
1960 // A frame can navigate its root.
1962 }
1964 // Check if aAccessingItem can navigate one of aTargetItem's ancestors.
1969 }
1980 // target is a subframe, not in accessor's frame hierarchy, and all its
1981 // ancestors have origins different from that of the accessor. Don't
1982 // allow access.
1984 }
1987 // All done here
1989 }
1996 }
2005 }
2008 }
2010 static PRBool
2012 {
2017 PRBool isClosed;
2021 }
2022 }
2025 }
2027 NS_IMETHODIMP
2032 {
2036 // If we don't find one, we return NS_OK and a null result
2043 {
2046 // This is the entry point into the target-finding algorithm. Check
2047 // for special names. This should only be done once, hence the check
2048 // for a null aRequestor.
2053 }
2055 {
2056 // Just return null. Caller must handle creating a new window with
2057 // a blank name himself.
2059 }
2061 {
2065 }
2067 {
2070 }
2071 // _main is an IE target which should be case-insensitive but isn't
2072 // see bug 217886 for details
2075 {
2076 // Must pass our same type root as requestor to the
2077 // treeowner to make sure things work right.
2084 }
2085 #ifdef DEBUG
2088 "You might like to try that. "
2090 // Note: _content should always exist. If we don't have one
2091 // hanging off the treeowner, just create a named window....
2092 // so don't return here, in case we did that and can now find
2093 // it.
2094 // XXXbz should we be using |root| instead of creating
2095 // a new window?
2096 }
2097 #endif
2098 }
2102 }
2105 // We return foundItem here even if it's not an active
2106 // item since all the names we've dealt with so far are
2107 // special cases that we won't bother looking for further.
2111 }
2112 }
2114 // Keep looking
2116 // First we check our name.
2121 }
2123 // This QI may fail, but the places where we want to compare, comparing
2124 // against nsnull serves the same purpose.
2127 // Second we check our children making sure not to ask a child if
2128 // it is the aRequestor.
2129 #ifdef DEBUG
2130 nsresult rv =
2131 #endif
2139 // Third if we have a parent and it isn't the requestor then we
2140 // should ask it to do the search. If it is the requestor we
2141 // should just stop here and let the parent do the rest. If we
2142 // don't have a parent, then we should ask the
2143 // docShellTreeOwner to do the search.
2150 PRInt32 parentType;
2157 aOriginalRequestor,
2158 _retval);
2159 }
2160 }
2162 // If the parent is null or not of the same type fall through and ask tree
2163 // owner.
2165 // This may fail, but comparing against null serves the same purpose
2172 }
2175 }
2177 NS_IMETHODIMP
2179 {
2185 }
2187 #ifdef DEBUG_DOCSHELL_FOCUS
2188 static void
2190 {
2193 PRInt32 childWebshellCount;
2196 PRInt32 type;
2210 }
2224 }
2225 }
2226 }
2228 static void
2230 {
2240 }
2242 }
2246 }
2249 }
2250 #endif
2252 NS_IMETHODIMP
2254 {
2255 #ifdef DEBUG_DOCSHELL_FOCUS
2259 }
2260 #endif
2262 // Don't automatically set the progress based on the tree owner for frames
2275 }
2280 }
2281 }
2282 }
2291 child->GetItemType(&childType); // We don't care if this fails, if it does we won't set the owner
2294 }
2297 }
2299 NS_IMETHODIMP
2301 {
2304 }
2306 NS_IMETHODIMP
2308 {
2311 }
2313 //*****************************************************************************
2314 // nsDocShell::nsIDocShellTreeNode
2315 //*****************************************************************************
2317 NS_IMETHODIMP
2319 {
2323 }
2327 NS_IMETHODIMP
2329 {
2335 // Make sure we're not creating a loop in the docshell tree
2340 }
2344 // Make sure to remove the child from its current parent.
2348 }
2350 // Make sure to clear the treeowner in case this child is a different type
2351 // from us.
2359 // Set the child's index in the parent's children list
2360 // XXX What if the parent had different types of children?
2361 // XXX in that case docshell hierarchy and SH hierarchy won't match.
2362 {
2365 // If there are frameloaders in the finalization list, reduce
2366 // the offset so that the SH hierarchy is more likely to match the
2367 // docshell hierarchy
2378 }
2379 }
2380 }
2383 }
2384 }
2386 /* Set the child's global history if the parent has one */
2392 }
2399 // Everything below here is only done when the child is the same type.
2408 // charset, style-disabling, and zoom will be inherited in SetupNewViewer()
2410 // Now take this document's charset and set the parentCharset field of the
2411 // child's DocumentCharsetInfo to it. We'll later use that field, in the
2412 // loading process, for the charset choosing algorithm.
2413 // If we fail, at any point, we just return NS_OK.
2414 // This code has some performance impact. But this will be reduced when
2415 // the current charset will finally be stored as an Atom, avoiding the
2416 // alias resolution extra look-up.
2418 // we are NOT going to propagate the charset is this Chrome's docshell
2422 // get the child's docCSInfo object
2428 // get the parent's current charset
2441 // Check if the url is wyciwyg
2443 }
2446 // If this docshell is loaded from a wyciwyg: URI, don't
2447 // advertise our charset since it does not in any way reflect
2448 // the actual source charset, which is what we're trying to
2449 // expose here.
2451 // set the child's parentCharset
2459 // set the child's parentCharset
2463 }
2465 // printf("### 1 >>> Adding child. Parent CS = %s. ItemType = %d.\n", NS_LossyConvertUTF16toASCII(parentCS).get(), mItemType);
2468 }
2470 NS_IMETHODIMP
2472 {
2484 }
2486 NS_IMETHODIMP
2488 {
2491 #ifdef DEBUG
2494 }
2497 }
2498 #endif
2504 }
2506 NS_IMETHODIMP
2512 {
2521 nsXPIDLString childName;
2526 PRInt32 childType;
2538 }
2544 {
2545 // See if child contains the shell with the given name
2546 #ifdef DEBUG
2547 nsresult rv =
2548 #endif
2550 aSameType,
2553 aOriginalRequestor,
2554 _retval);
2559 }
2560 }
2562 }
2564 //*****************************************************************************
2565 // nsDocShell::nsIDocShellHistory
2566 //*****************************************************************************
2567 NS_IMETHODIMP
2569 {
2576 // A nsISHEntry for a child is *only* available when the parent is in
2577 // the progress of loading a document too...
2580 /* Before looking for the subframe's url, check
2581 * the expiration status of the parent. If the parent
2582 * has expired from cache, then subframes will not be
2583 * loaded from history in certain situations.
2584 */
2588 /* Get the parent's Load Type so that it can be set on the child too.
2589 * By default give a loadHistory value
2590 */
2593 // If the user did a shift-reload on this frameset page,
2594 // we don't want to load the subframes from history.
2601 /* If the user pressed reload and the parent frame has expired
2602 * from cache, we do not want to load the child frame from history.
2603 */
2605 // The parent has expired. Return null.
2608 }
2612 // Get the child subframe from session history.
2616 }
2617 }
2619 }
2621 NS_IMETHODIMP
2623 PRInt32 aChildOffset)
2624 {
2625 nsresult rv;
2628 /* You get here if you are currently building a
2629 * hierarchy ie.,you just visited a frameset page
2630 */
2634 }
2635 }
2637 /* This is an initial load in some subframe. Just append it if we can */
2641 }
2642 }
2644 /* You are currently in the rootDocShell.
2645 * You will get here when a subframe has a new url
2646 * to load and you have walked up the tree all the
2647 * way to the top to clone the current SHEntry hierarchy
2648 * and replace the subframe where a new url was loaded with
2649 * a new entry.
2650 */
2674 }
2675 }
2676 }
2678 /* Just pass this along */
2683 }
2684 }
2686 }
2688 nsresult
2690 {
2691 /* You will get here when you are in a subframe and
2692 * a new url has been loaded on you.
2693 * The mOSHE in this subframe will be the previous url's
2694 * mOSHE. This mOSHE will be used as the identification
2695 * for this subframe in the CloneAndReplace function.
2696 */
2698 // In this case, we will end up calling AddEntry, which increases the
2699 // current index by 1
2704 }
2706 nsresult rv;
2711 }
2716 #ifdef DEBUG_PAGE_CACHE
2718 mLoadedTransIndex);
2719 #endif
2720 }
2723 }
2725 NS_IMETHODIMP
2727 {
2728 nsresult rv;
2733 }
2737 }
2741 }
2743 NS_IMETHODIMP
2745 {
2748 }
2750 //-------------------------------------
2751 //-- Helper Method for Print discovery
2752 //-------------------------------------
2753 PRBool
2755 {
2758 }
2761 }
2763 PRBool
2765 {
2767 }
2769 //*****************************************************************************
2770 // nsDocShell::nsIWebNavigation
2771 //*****************************************************************************
2773 NS_IMETHODIMP
2775 {
2779 }
2780 nsresult rv;
2788 }
2790 NS_IMETHODIMP
2792 {
2796 }
2797 nsresult rv;
2805 }
2807 NS_IMETHODIMP
2809 {
2812 }
2813 nsresult rv;
2821 }
2823 NS_IMETHODIMP
2825 {
2828 }
2829 nsresult rv;
2837 }
2840 {
2843 }
2844 nsresult rv;
2852 }
2855 NS_IMETHODIMP
2857 PRUint32 aLoadFlags,
2861 {
2864 }
2868 // Create a URI from our string; if that succeeds, we want to
2869 // change aLoadFlags to not include the ALLOW_THIRD_PARTY_FIXUP
2870 // flag.
2873 // Cleanup the empty spaces that might be on each end.
2875 // Eliminate embedded newlines, which single-line text fields now allow:
2882 }
2885 // Call the fixup object. This will clobber the rv from NS_NewURI
2886 // above, but that's fine with us. Note that we need to do this even
2887 // if NS_NewURI returned a URI, because fixup handles nested URIs, etc
2888 // (things like view-source:mozilla.org for example).
2892 }
2895 }
2896 // else no fixup service so just use the URI we created and see
2897 // what happens
2901 }
2906 PopupControlState popupState;
2912 }
2916 // Don't pass certain flags that aren't needed and end up confusing
2917 // ConvertLoadTypeToDocShellLoadInfo. We do need to ensure that they are
2918 // passed to LoadURI though, since it uses them.
2935 }
2937 NS_IMETHODIMP
2941 {
2942 // Get prompt and string bundle servcies
2951 nsAutoString error;
2957 nsAutoString messageStr;
2958 nsCAutoString cssClass;
2959 nsCAutoString errorPage;
2963 // Turn the error code into a human readable error message.
2966 // extract the scheme
2967 nsCAutoString scheme;
2972 }
2976 }
2979 // Get the host
2980 nsCAutoString host;
2986 }
2991 }
2996 }
2999 // Get the host
3000 nsCAutoString host;
3005 }
3010 PRUint32 errorClass;
3014 }
3022 // Usually we should have aFailedChannel and get a detailed message
3024 }
3026 // No channel, let's obtain the generic error message
3029 }
3030 }
3039 }
3042 }
3043 }
3045 nsCAutoString host;
3050 // Malware and phishing detectors may want to use an alternate error
3051 // page, but if the pref's not set, we'll fall back on the standard page
3052 nsXPIDLCString alternateErrorPage;
3060 else
3063 }
3065 // Errors requiring simple formatting
3068 // URI is malformed
3072 // Doc failed to load because the server generated too many redirects
3076 // Doc failed to load because PSM is not installed
3080 // Doc failed to load because the server kept reseting the connection
3081 // before we could read any data from it
3085 // Doc failed to load because we are offline and the cache does not
3086 // contain a copy of the document.
3090 // Doc navigation attempted while Printing or Print Preview
3094 // Port blocked for security reasons
3099 // Proxy hostname could not be resolved.
3103 // Proxy connection was refused.
3107 // Bad Content Encoding.
3111 // Channel refused to load from an unrecognized content type.
3114 }
3115 }
3117 // Test if the error should be displayed
3120 }
3122 // Test if the error needs to be formatted
3124 // already obtained message
3125 }
3128 // Build up the host:port string.
3129 nsCAutoString hostport;
3134 }
3136 }
3138 nsCAutoString spec;
3141 // displaying "file://" is aesthetically unpleasing and could even be
3142 // confusing to the user
3147 else
3150 nsCAutoString charset;
3151 // unescape and convert from origin charset
3157 }
3160 }
3169 }
3170 nsXPIDLString str;
3176 }
3178 // Display the error as a page or an alert prompt
3180 // Note: For now, display an alert instead of an error page if we have no
3181 // URI object. Missing URI objects are handled badly by session history.
3183 // Display an error page
3186 }
3187 else
3188 {
3189 // The prompter reqires that our private window has a document (or it
3190 // asserts). Satisfy that assertion now since GetDocument will force
3191 // creation of one if it hasn't already been created.
3196 }
3198 // Display a message box
3200 }
3203 }
3206 NS_IMETHODIMP
3213 {
3214 #if defined(PR_LOGGING) && defined(DEBUG)
3216 nsCAutoString spec;
3219 nsCAutoString chanName;
3222 else
3228 }
3229 #endif
3230 // Create an shistory entry for the old load, if we have a channel
3237 }
3238 // Be sure to have a correct mLSHE, it may have been cleared by
3239 // EndPageLoad. See bug 302115.
3241 PRInt32 idx;
3250 }
3252 nsCAutoString url;
3253 nsCAutoString charset;
3255 {
3256 // Set our current URI
3262 }
3264 {
3266 }
3267 else
3268 {
3270 }
3272 // Create a URL to pass all the error information through to the page.
3290 }
3309 }
3312 NS_IMETHODIMP
3314 {
3317 }
3318 nsresult rv;
3325 // Send notifications to the HistoryListener if any, about the impending reload
3335 }
3336 }
3341 /* If you change this part of code, make sure bug 45297 does not re-occur */
3344 }
3347 }
3353 nsAutoString contentTypeHint;
3357 }
3360 mReferrerURI,
3361 principal,
3369 PR_TRUE,
3372 }
3376 }
3378 NS_IMETHODIMP
3380 {
3381 // Revoke any pending event related to content viewer restoration
3385 // Stop the document loading
3388 }
3391 // Suspend any timers that were set for this loader. We'll clear
3392 // them out for good in CreateContentViewer.
3397 }
3402 }
3404 // XXXbz We could also pass |this| to nsIURILoader::Stop. That will
3405 // just call Stop() on us as an nsIDocumentLoader... We need fewer
3406 // redundant apis!
3408 }
3410 PRInt32 n;
3416 }
3419 }
3421 /*
3422 NS_IMETHODIMP nsDocShell::SetDocument(nsIDOMDocument* aDocument,
3423 const PRUnichar* aContentType)
3424 {
3425 //XXX First Checkin
3426 NS_ERROR("Not Yet Implemented");
3427 return NS_ERROR_FAILURE;
3428 }
3429 */
3431 NS_IMETHODIMP
3433 {
3438 }
3440 NS_IMETHODIMP
3442 {
3447 }
3451 }
3453 NS_IMETHODIMP
3455 {
3462 }
3464 NS_IMETHODIMP
3466 {
3469 // make sure that we are the root docshell and
3470 // set a handle to root docshell in SH.
3473 /* Get the root docshell. If *this* is the root docshell
3474 * then save a handle to *this* in SH. SH needs it to do
3475 * traversions thro' its entries
3476 */
3486 }
3489 }
3492 NS_IMETHODIMP
3494 {
3499 }
3501 //*****************************************************************************
3502 // nsDocShell::nsIWebPageDescriptor
3503 //*****************************************************************************
3504 NS_IMETHODIMP
3506 {
3509 // Currently, the opaque 'page descriptor' is an nsISHEntry...
3512 }
3514 // Now clone shEntryIn, since we might end up modifying it later on, and we
3515 // want a page descriptor to be reusable.
3520 //
3521 // load the page as view-source
3522 //
3527 // Create a new view-source URI and replace the original.
3539 }
3541 }
3545 }
3547 NS_IMETHODIMP
3549 {
3561 }
3563 // null out inappropriate cloned attributes...
3568 }
3571 }
3574 //*****************************************************************************
3575 // nsDocShell::nsIBaseWindow
3576 //*****************************************************************************
3578 NS_IMETHODIMP
3582 {
3589 }
3591 NS_IMETHODIMP
3593 {
3601 PRBool tmpbool;
3608 // Check pref to see if we should prevent frameset spoofing
3614 }
3615 }
3617 // Should we use XUL error pages instead of alerts if possible?
3625 }
3632 }
3635 }
3637 NS_IMETHODIMP
3639 {
3650 }
3651 }
3655 // Remove our pref observers
3661 }
3662 }
3664 // Make sure to blow away our mLoadingURI just in case. No loads
3665 // from inside this pagehide.
3668 // Fire unload event before we blow anything away.
3671 // Clear pointers to any detached nsEditorData that's lying
3672 // around in shistory entries. Breaks cycle. See bug 430921.
3678 // Note: mContentListener can be null if Init() failed and we're being
3679 // called from the destructor.
3683 // Note that we do NOT set mContentListener to null here; that
3684 // way if someone tries to do a load in us after this point
3685 // the nsDSURIContentListener will block it. All of which
3686 // means that we should do this before calling Stop(), of
3687 // course.
3688 }
3690 // Stop any URLs that are currently being loaded...
3697 // Save the state of the current document, before destroying the window.
3698 // This is needed to capture the state of a frameset when the new document
3699 // causes the frameset to be destroyed...
3702 // Remove this docshell from its parent's child list
3710 suppressor =
3717 }
3729 }
3734 // required to break ref cycle
3737 // Cancel any timers that were set for this docshell; this is needed
3738 // to break the cycle between us and the timers.
3742 }
3744 }
3746 NS_IMETHODIMP
3748 {
3756 }
3758 NS_IMETHODIMP
3760 {
3761 PRInt32 dummyHolder;
3763 }
3765 NS_IMETHODIMP
3767 {
3771 }
3773 NS_IMETHODIMP
3775 {
3776 PRInt32 dummyHolder;
3778 }
3780 NS_IMETHODIMP
3783 {
3789 // Hold strong ref, since SetBounds can make us null out mContentViewer
3792 //XXX Border figured in here or is that handled elsewhere?
3794 }
3797 }
3799 NS_IMETHODIMP
3802 {
3803 // We should really consider just getting this information from
3804 // our window instead of duplicating the storage and code...
3809 }
3813 }
3815 void
3818 {
3827 }
3829 NS_IMETHODIMP
3831 {
3839 // what about aForce ?
3842 }
3844 NS_IMETHODIMP
3846 {
3853 }
3855 NS_IMETHODIMP
3857 {
3861 }
3863 NS_IMETHODIMP
3865 {
3870 else
3874 }
3876 NS_IMETHODIMP
3878 {
3880 }
3882 NS_IMETHODIMP
3884 {
3889 }
3891 // get the pres shell
3894 NS_ERROR_FAILURE);
3897 // get the view manager
3901 // get the root view
3906 // if our root view is hidden, we are not visible
3910 }
3912 // otherwise, we must walk up the document and view trees checking
3913 // for a hidden view.
3926 // Null-check for crash in bug 267804
3931 }
3941 }
3945 }
3952 }
3954 // Check with the tree owner as well to give embedders a chance to
3955 // expose visibility as well.
3957 }
3959 NS_IMETHODIMP
3961 {
3966 }
3969 }
3972 }
3974 NS_IMETHODIMP
3976 {
3980 }
3982 NS_IMETHODIMP
3984 {
3986 }
3988 NS_IMETHODIMP
3990 {
3994 }
3996 NS_IMETHODIMP
3998 {
4000 }
4002 NS_IMETHODIMP
4004 {
4005 // We don't create our own widget, so simply return the parent one.
4007 }
4009 NS_IMETHODIMP
4011 {
4012 #ifdef DEBUG_DOCSHELL_FOCUS
4014 #endif
4016 // Tell itself (and the DocShellFocusController) who has focus
4017 // this way focus gets removed from the currently focused DocShell
4022 }
4024 NS_IMETHODIMP
4026 {
4031 }
4033 NS_IMETHODIMP
4035 {
4036 // Store local title
4042 // When title is set on the top object it should then be passed to the
4043 // tree owner.
4049 }
4053 }
4056 // Update SessionHistory with the document's title. If the
4057 // page was loaded from history or the page bypassed history,
4058 // there is no need to update the title. There is no need to
4059 // go to mSessionHistory to update the title. Setting it in mOSHE
4060 // would suffice.
4064 }
4068 }
4070 //*****************************************************************************
4071 // nsDocShell::nsIScrollable
4072 //*****************************************************************************
4074 NS_IMETHODIMP
4076 {
4081 NS_ERROR_FAILURE);
4084 }
4100 }
4102 }
4104 NS_IMETHODIMP
4106 {
4109 NS_ERROR_FAILURE);
4112 }
4114 PRInt32 other;
4115 PRInt32 x;
4116 PRInt32 y;
4135 }
4138 NS_ERROR_FAILURE);
4140 }
4142 NS_IMETHODIMP
4144 {
4147 NS_ERROR_FAILURE);
4150 }
4153 NS_VMREFRESH_IMMEDIATE),
4154 NS_ERROR_FAILURE);
4156 }
4158 // XXX This is wrong
4159 NS_IMETHODIMP
4162 {
4167 NS_ERROR_FAILURE);
4170 }
4172 PRInt32 cx;
4173 PRInt32 cy;
4189 }
4192 }
4194 NS_IMETHODIMP
4197 {
4198 //XXX First Check
4199 /*
4200 Retrieves or Sets the valid ranges for the thumb. When maxPos is set to
4201 something less than the current thumb position, curPos is set = to maxPos.
4203 @return NS_OK - Setting or Getting completed successfully.
4204 NS_ERROR_INVALID_ARG - returned when curPos is not within the
4205 minPos and maxPos.
4206 */
4208 }
4210 NS_IMETHODIMP
4213 PRInt32 maxVerticalPos)
4214 {
4215 //XXX First Check
4216 /*
4217 Retrieves or Sets the valid ranges for the thumb. When maxPos is set to
4218 something less than the current thumb position, curPos is set = to maxPos.
4220 @return NS_OK - Setting or Getting completed successfully.
4221 NS_ERROR_INVALID_ARG - returned when curPos is not within the
4222 minPos and maxPos.
4223 */
4225 }
4227 // This returns setting for all documents in this webshell
4228 NS_IMETHODIMP
4231 {
4244 }
4246 }
4248 // Set scrolling preference for all documents in this shell
4249 //
4250 // There are three possible values stored in the shell:
4251 // 1) nsIScrollable::Scrollbar_Never = no scrollbar
4252 // 2) nsIScrollable::Scrollbar_Auto = scrollbar appears if the document
4253 // being displayed would normally have scrollbar
4254 // 3) nsIScrollable::Scrollbar_Always = scrollbar always appears
4255 //
4256 // One important client is nsHTMLFrameInnerFrame::CreateWebShell()
4257 NS_IMETHODIMP
4259 PRInt32 scrollbarPref)
4260 {
4272 }
4274 }
4276 NS_IMETHODIMP
4279 {
4282 NS_ERROR_FAILURE);
4286 // We should now call nsLayoutUtils::GetScrollableFrameFor,
4287 // but we can't because of stupid linkage!
4304 }
4306 //*****************************************************************************
4307 // nsDocShell::nsITextScroll
4308 //*****************************************************************************
4310 NS_IMETHODIMP
4312 {
4316 NS_ERROR_FAILURE);
4319 }
4324 }
4326 NS_IMETHODIMP
4328 {
4332 NS_ERROR_FAILURE);
4335 }
4340 }
4342 //*****************************************************************************
4343 // nsDocShell::nsIScriptGlobalObjectOwner
4344 //*****************************************************************************
4346 nsIScriptGlobalObject*
4348 {
4352 }
4354 //*****************************************************************************
4355 // nsDocShell::nsIRefreshURI
4356 //*****************************************************************************
4358 NS_IMETHODIMP
4360 PRBool aMetaRefresh)
4361 {
4364 /* Check if Meta refresh/redirects are permitted. Some
4365 * embedded applications may not want to do this.
4366 * Must do this before sending out NOTIFY_REFRESH events
4367 * because listeners may have side effects (e.g. displaying a
4368 * button to manually trigger the refresh later).
4369 */
4375 // If any web progress listeners are listening for NOTIFY_REFRESH events,
4376 // give them a chance to block this refresh.
4377 PRBool sameURI;
4399 NS_ERROR_FAILURE);
4400 }
4403 // We are busy loading another page. Don't create the
4404 // timer right now. Instead queue up the request and trigger the
4405 // timer in EndPageLoad().
4407 }
4409 // There is no page loading going on right now. Create the
4410 // timer and fire it right away.
4416 }
4418 }
4420 NS_IMETHODIMP
4422 PRInt32 aDelay,
4423 PRBool aMetaRefresh)
4424 {
4431 /* We do need to pass in a referrer, but we don't want it to
4432 * be sent to the server.
4433 */
4436 /* for most refreshes the current URI is an appropriate
4437 * internal referrer
4438 */
4441 /* Check if this META refresh causes a redirection
4442 * to another site.
4443 */
4448 /* It is a META refresh based redirection. Now check if it happened
4449 within the threshold time we have in mind(15000 ms as defined by
4450 REFRESH_REDIRECT_TIMER). If so, pass a REPLACE flag to LoadURI().
4451 */
4455 /* for redirects we mimic HTTP, which passes the
4456 * original referrer
4457 */
4462 }
4463 }
4464 else
4466 /*
4467 * LoadURI(...) will cancel all refresh timers... This causes the
4468 * Timer and its refreshData instance to be released...
4469 */
4472 }
4473 else
4479 }
4481 nsresult
4484 {
4485 // Refresh headers are parsed with the following format in mind
4486 // <META HTTP-EQUIV=REFRESH CONTENT="5; URL=http://uri">
4487 // By the time we are here, the following is true:
4488 // header = "REFRESH"
4489 // content = "5; URL=http://uri" // note the URL attribute is
4490 // optional, if it is absent, the currently loaded url is used.
4491 // Also note that the seconds and URL separator can be either
4492 // a ';' or a ','. The ',' separator should be illegal but CNN
4493 // is using it.
4494 //
4495 // We need to handle the following strings, where
4496 // - X is a set of digits
4497 // - URI is either a relative or absolute URI
4498 //
4499 // Note that URI should start with "url=" but we allow omission
4500 //
4501 // "" || ";" || ","
4502 // empty string. use the currently loaded URI
4503 // and refresh immediately.
4504 // "X" || "X;" || "X,"
4505 // Refresh the currently loaded URI in X seconds.
4506 // "X; URI" || "X, URI"
4507 // Refresh using URI as the destination in X seconds.
4508 // "URI" || "; URI" || ", URI"
4509 // Refresh immediately using URI as the destination.
4510 //
4511 // Currently, anything immediately following the URI, if
4512 // separated by any char in the set "'\"\t\r\n " will be
4513 // ignored. So "10; url=go.html ; foo=bar" will work,
4514 // and so will "10; url='go.html'; foo=bar". However,
4515 // "10; url=go.html; foo=bar" will result in the uri
4516 // "go.html;" since ';' and ',' are valid uri characters.
4517 //
4518 // Note that we need to remove any tokens wrapping the URI.
4519 // These tokens currently include spaces, double and single
4520 // quotes.
4522 // when done, seconds is 0 or the given number of seconds
4523 // uriAttrib is empty or the URI specified
4524 nsCAutoString uriAttrib;
4533 // skip leading whitespace
4539 // skip leading + and -
4543 // parse number
4548 }
4551 // if we started with a '-', number is negative
4555 // skip to next ';' or ','
4558 {
4560 {
4561 // Non-whitespace characters here mean that the string is
4562 // malformed but tolerate sites that specify a decimal point,
4563 // even though meta refresh only works on whole seconds.
4566 {
4567 // The characters between the seconds and the next
4568 // section are just garbage!
4569 // e.g. content="2a0z+,URL=http://www.mozilla.org/"
4570 // Just ignore this redirect.
4572 }
4574 {
4575 // We've had at least one whitespace so tolerate the mistake
4576 // and drop through.
4577 // e.g. content="10 foo"
4580 }
4581 }
4583 }
4585 // skip any remaining whitespace
4589 // skip ';' or ','
4592 }
4594 // skip whitespace
4597 }
4599 // possible start of URI
4602 // skip "url = " to real start of URI
4610 // skip whitespace
4617 // skip whitespace
4621 // found real start of URI
4623 }
4624 }
4625 }
4626 }
4628 // skip a leading '"' or '\''.
4632 {
4635 }
4637 // set iter to start of URI
4640 // tokenStart here points to the beginning of URI
4642 // grab the rest of the URI
4644 {
4648 }
4650 // move iter one back if the last character is a '"' or '\''
4655 }
4657 // URI is whatever's contained from tokenStart to iter.
4658 // note: if tokenStart == doneIterating, so is iter.
4666 }
4669 // NS_NewURI takes care of any whitespace surrounding the URL
4672 }
4674 // No URI or seconds were specified
4676 {
4677 // Do nothing because the alternative is to spin around in a refresh
4678 // loop forever!
4680 }
4690 LOAD_IS_AUTOMATIC_DOCUMENT_REPLACEMENT);
4692 // Since we can't travel back in time yet, just pretend
4693 // negative numbers do nothing at all.
4698 }
4699 }
4700 }
4702 }
4705 {
4706 nsresult rv;
4709 nsCAutoString refreshHeader;
4711 refreshHeader);
4718 }
4719 }
4720 }
4722 }
4724 static void
4726 {
4740 }
4741 }
4743 NS_IMETHODIMP
4745 {
4752 }
4754 NS_IMETHODIMP
4756 {
4760 }
4762 PRUint32 count;
4767 }
4769 NS_IMETHODIMP
4771 {
4781 // Replace this timer object with a nsRefreshTimer object.
4791 }
4792 }
4794 // Suspend refresh URIs for our child shells as well.
4801 }
4804 }
4806 NS_IMETHODIMP
4808 {
4811 // Resume refresh URIs for our child shells as well.
4818 }
4821 }
4823 nsresult
4825 {
4837 // This is the nsRefreshTimer object, waiting to be
4838 // setup in a timer object and fired.
4839 // Create the timer and trigger it.
4840 PRUint32 delay = static_cast<nsRefreshTimer*>(static_cast<nsITimerCallback*>(refreshInfo))->GetDelay();
4843 // Replace the nsRefreshTimer element in the queue with
4844 // its corresponding timer object, so that in case another
4845 // load comes through before the timer can go off, the timer will
4846 // get cancelled in CancelRefreshURITimer()
4849 }
4850 }
4854 }
4856 //*****************************************************************************
4857 // nsDocShell::nsIContentViewerContainer
4858 //*****************************************************************************
4860 NS_IMETHODIMP
4863 {
4864 // Save the LayoutHistoryState of the previous document, before
4865 // setting up new document
4870 // If we are loading a wyciwyg url from history, change the base URI for
4871 // the document to the original http url that created the document.write().
4872 // This makes sure that all relative urls in a document.written page loaded
4873 // via history work properly.
4879 // Check if the url is wyciwyg
4883 }
4884 // XXX What if SetupNewViewer fails?
4886 // Restore the editing state, if it's stored in session history.
4889 }
4891 }
4895 // Determine if this type of load should update history
4906 }
4912 }
4914 /* void setIsPrinting (in boolean aIsPrinting); */
4915 NS_IMETHODIMP
4917 {
4920 }
4922 //*****************************************************************************
4923 // nsDocShell::nsIWebProgressListener
4924 //*****************************************************************************
4926 NS_IMETHODIMP
4929 PRInt32 aCurSelfProgress,
4930 PRInt32 aMaxSelfProgress,
4931 PRInt32 aCurTotalProgress,
4932 PRInt32 aMaxTotalProgress)
4933 {
4935 }
4937 NS_IMETHODIMP
4940 {
4941 nsresult rv;
4943 // Update the busy cursor
4949 // Was the wyciwyg document loaded on this docshell?
4955 // Store the wyciwyg url in session history, only if it is
4956 // being loaded fresh for the first time. We don't want
4957 // multiple entries for successive loads
4961 // This is a document.write(). Get the made-up url
4962 // from the channel and store it in session history.
4965 // Save history state of the previous page
4969 }
4971 }
4972 // Page has begun to load
4978 }
4979 }
4981 // Page is loading
4983 }
4985 // Page has finished loading
4991 }
4992 }
4996 // Is the document stop notification for this document?
5000 }
5001 }
5002 // note that redirect state changes will go through here as well, but it
5003 // is better to handle those in OnRedirectStateChange where more
5004 // information is available.
5006 }
5008 NS_IMETHODIMP
5011 {
5014 }
5016 void
5019 PRUint32 aRedirectFlags,
5020 PRUint32 aStateFlags)
5021 {
5027 // If this load is being checked by the URI classifier, we need to
5028 // query the classifier again for the new URI.
5031 }
5036 // notify global history of this redirect
5039 }
5042 // when there is no GlobalHistory3, or it doesn't implement
5043 // AddToplevelRedirect, we fall back to GlobalHistory2. Just notify
5044 // that the redirecting page was a redirect so it will be link colored
5045 // but not visible.
5051 }
5052 }
5054 NS_IMETHODIMP
5058 {
5061 }
5063 NS_IMETHODIMP
5066 {
5069 }
5072 nsresult
5075 {
5076 //
5077 // one of many safeguards that prevent death and destruction if
5078 // someone is so very very rude as to bring this window down
5079 // during this load handler.
5080 //
5083 // We're done with the URI classifier for this channel
5086 //
5087 // Notify the ContentViewer that the Document has finished loading...
5088 //
5089 // This will cause any OnLoad(...) handlers to fire, if it is a HTML
5090 // document...
5091 //
5099 // If all documents have completed their loading
5100 // favor native event dispatch priorities
5101 // over performance
5103 // Hint to use normal native event dispatch priorities
5105 }
5106 }
5107 /* Check if the httpChannel has any cache-control related response headers,
5108 * like no-store, no-cache. If so, update SHEntry so that
5109 * when a user goes back/forward to this page, we appropriately do
5110 * form value restoration or load from server.
5111 */
5117 // figure out if SH should be saving layout state.
5122 }
5124 // Clear mLSHE after calling the onLoadHandlers. This way, if the
5125 // onLoadHandler tries to load something different in
5126 // itself or one of its children, we can deal with it appropriately.
5130 // Clear the mLSHE reference to indicate document loading is done one
5131 // way or another.
5133 }
5134 // if there's a refresh header in the channel, this method
5135 // will set it up for us.
5139 }
5142 //*****************************************************************************
5143 // nsDocShell: Content Viewer Management
5144 //*****************************************************************************
5146 NS_IMETHODIMP
5148 {
5159 }
5163 }
5172 "Should have doc if CreateAboutBlankContentViewer "
5176 }
5179 }
5181 nsresult
5183 {
5188 /* mCreatingDocument should never be true at this point. However, it's
5189 a theoretical possibility. We want to know about it and make it stop,
5190 and this sounds like a job for an assertion. */
5197 // mContentViewer->PermitUnload may release |this| docshell.
5201 // We've got a content viewer already. Make sure the user
5202 // permits us to discard the current document and replace it
5203 // with about:blank. And also ensure we fire the unload events
5204 // in the current document.
5206 PRBool okToUnload;
5210 // The user chose not to unload the page, interrupt the load.
5212 }
5216 // Make sure to blow away our mLoadingURI just in case. No loads
5217 // from inside this pagehide.
5220 // Notify the current document that it is about to be unloaded!!
5221 //
5222 // It is important to fire the unload() notification *before* any state
5223 // is changed within the DocShell - otherwise, javascript will get the
5224 // wrong information :-(
5225 //
5227 }
5229 // Now make sure we don't think we're in the middle of firing unload after
5230 // this point. This will make us fire unload when the about:blank document
5231 // unloads... but that's ok, more or less. Would be nice if it fired load
5232 // too, of course.
5235 // one helper factory, please
5240 nsXPIDLCString contractId;
5241 rv = catMan->GetCategoryEntry("Gecko-Content-Viewers", "text/html", getter_Copies(contractId));
5247 // generate (about:blank) document to load
5253 // create a content viewer for us and the new document
5257 // hook 'em up
5266 }
5267 }
5268 }
5271 // The transient about:blank viewer doesn't have a session history entry.
5275 }
5277 PRBool
5281 {
5285 // Only save presentation for "normal" loads and link loads. Anything else
5286 // probably wants to refetch the page, so caching the old presentation
5287 // would be incorrect.
5296 // If the session history entry has the saveLayoutState flag set to false,
5297 // then we should not cache the presentation.
5298 PRBool canSaveState;
5303 // If the document is not done loading, don't cache it.
5311 // Avoid doing the work of saving the presentation state in the case where
5312 // the content viewer cache is disabled.
5316 // Don't cache the content viewer if we're in a subframe and the subframe
5317 // pref is disabled.
5326 }
5327 }
5329 // If the document does not want its presentation cached, then don't.
5335 }
5337 void
5339 {
5352 }
5353 }
5355 void
5357 {
5368 // Make aSHEntry hold the owning ref to the editor data.
5371 else
5373 }
5375 #ifdef DEBUG
5376 {
5377 PRBool isEditable;
5381 }
5384 }
5386 void
5388 {
5391 }
5393 nsresult
5395 {
5397 // No entry to save into, or we're replacing the existing entry.
5399 }
5409 #ifdef DEBUG_PAGE_CACHE
5412 nsCAutoString spec;
5417 #endif
5422 // Suspend refresh URIs and save off the timer queue
5426 // Capture the current content viewer bounds.
5440 }
5441 }
5442 }
5443 }
5445 // Capture the docshell hierarchy.
5454 }
5457 }
5459 NS_IMETHODIMP
5461 {
5465 }
5467 NS_IMETHODIMP
5469 {
5470 nsresult rv;
5476 }
5478 // Dispatch events for restoring the presentation. We try to simulate
5479 // the progress notifications loading the document would cause, so we add
5480 // the document's channel to the loadgroup to initiate stateChange
5481 // notifications.
5493 }
5494 }
5497 // This point corresponds to us having gotten OnStartRequest or
5498 // STATE_START, so do the same thing that CreateContentViewer does at
5499 // this point to ensure that unload/pagehide events for this document
5500 // will fire when it's unloaded again.
5503 // For non-top frames, there is no notion of making sure that the
5504 // previous document is in the domwindow when STATE_START notifications
5505 // happen. We can just call BeginRestore for all of the child shells
5506 // now.
5509 }
5512 }
5514 nsresult
5516 {
5523 }
5524 }
5526 }
5528 NS_IMETHODIMP
5530 {
5531 // First we call finishRestore() on our children. In the simulated load,
5532 // all of the child frames finish loading before the main document.
5539 }
5540 }
5544 }
5552 // Finally, we remove the request from the loadgroup. This will
5553 // cause onStateChange(STATE_STOP) to fire, which will fire the
5554 // pageshow event to the chrome.
5561 }
5562 }
5563 }
5566 }
5568 NS_IMETHODIMP
5570 {
5573 }
5575 nsresult
5577 {
5584 #ifdef DEBUG_PAGE_CACHE
5588 nsCAutoString spec;
5591 #endif
5596 #ifdef DEBUG_PAGE_CACHE
5598 #endif
5600 }
5602 // We need to make sure the content viewer's container is this docshell.
5603 // In subframe navigation, it's possible for the docshell that the
5604 // content viewer was originally loaded into to be replaced with a
5605 // different one. We don't currently support restoring the presentation
5606 // in that case.
5611 #ifdef DEBUG_PAGE_CACHE
5613 #endif
5616 }
5620 #ifdef DEBUG_PAGE_CACHE
5622 #endif
5626 // Add the request to our load group. We do this before swapping out
5627 // the content viewers so that consumers of STATE_START can access
5628 // the old document. We only deal with the toplevel load at this time --
5629 // to be consistent with normal document loading, subframes cannot start
5630 // loading until after data arrives, which is after STATE_START completes.
5634 // Post an event that will remove the request after we've returned
5635 // to the event loop. This mimics the way it is called by nsIChannel
5636 // implementations.
5638 // Revoke any pending restore (just in case)
5647 // The rest of the restore processing will happen on our event
5648 // callback.
5650 }
5653 }
5655 nsresult
5657 {
5660 // This section of code follows the same ordering as CreateContentViewer.
5670 // We determined that it was safe to cache the document presentation
5671 // at the time we initiated the new load. We need to check whether
5672 // it's still safe to do so, since there may have been DOM mutations
5673 // or new requests initiated.
5681 }
5690 }
5692 // Protect against mLSHE going away via a load triggered from
5693 // pagehide or unload.
5696 // Make sure to blow away our mLoadingURI just in case. No loads
5697 // from inside this pagehide.
5700 // Notify the old content viewer that it's being hidden.
5703 // If mLSHE was changed as a result of the pagehide event, then
5704 // something else was loaded. Don't finish restoring.
5708 // Set mFiredUnloadEvent = PR_FALSE so that the unload handler for the
5709 // *new* document will fire.
5720 #ifdef DEBUG_PAGE_CACHE
5722 mLoadedTransIndex);
5723 #endif
5724 }
5726 // Rather than call Embed(), we will retrieve the viewer from the session
5727 // history entry and swap it in.
5728 // XXX can we refactor this so that we can just call Embed()?
5730 nsresult rv;
5735 }
5737 }
5738 }
5742 // In cases where we use a transient about:blank viewer between loads,
5743 // we never show the transient viewer, so _its_ previous viewer is never
5744 // unhooked from the view hierarchy. Destroy any such previous viewer now,
5745 // before we grab the root view sibling, so that we don't grab a view
5746 // that's about to go away.
5754 }
5755 }
5757 // Save off the root view's parent and sibling so that we can insert the
5758 // new content viewer's root view at the same position. Also save the
5759 // bounds of the root view's widget.
5779 }
5780 }
5781 }
5782 }
5784 // Transfer ownership to mContentViewer. By ensuring that either the
5785 // docshell or the session history, but not both, have references to the
5786 // content viewer, we prevent the viewer from being torn down after
5787 // Destroy() is called.
5792 }
5797 // Grab all of the related presentation from the SHEntry now.
5798 // Clearing the viewer from the SHEntry will clear all of this state.
5803 PRBool sticky;
5813 child) {
5815 }
5817 // get the previous content viewer size
5821 // Restore the refresh URI list. The refresh timers will be restarted
5822 // when EndPageLoad() is called.
5826 // Reattach to the window object.
5829 // Now remove it from the cached presentation.
5833 #ifdef DEBUG
5834 {
5841 }
5842 #endif
5844 // Restore the sticky state of the viewer. The viewer has set this state
5845 // on the history entry in Destroy() just before marking itself non-sticky,
5846 // to avoid teardown of the presentation.
5849 // Now that we have switched documents, forget all of our children.
5853 // mLSHE is now our currently-loaded document.
5856 // XXX special wyciwyg handling in Embed()?
5858 // We aren't going to restore any items from the LayoutHistoryState,
5859 // but we don't want them to stay around in case the page is reloaded.
5862 // This is the end of our Embed() replacement
5867 // Tell the event loop to favor plevents over user events, see comments
5868 // in CreateContentViewer.
5876 }
5880 // Use the uri from the mLSHE we had when we entered this function
5881 // (which need not match the document's URI if anchors are involved),
5882 // since that's the history entry we're loading. Note that if we use
5883 // origLSHE we don't have to worry about whether the entry in question
5884 // is still mLSHE or whether it's now mOSHE.
5888 }
5890 // This is the end of our CreateContentViewer() replacement.
5891 // Now we simulate a load. First, we restore the state of the javascript
5892 // window object.
5900 // Now, dispatch a title change event which would happen as the
5901 // <head> is parsed.
5904 // Now we simulate appending child docshells for subframes.
5909 // Make sure to not clobber the state of the child. Since AddChild
5910 // always clobbers it, save it off first.
5911 PRBool allowPlugins;
5914 PRBool allowJavascript;
5917 PRBool allowRedirects;
5920 PRBool allowSubframes;
5923 PRBool allowImages;
5936 }
5946 // Insert the new root view at the correct location in the view tree.
5951 // InsertChild(parent, child, sib, PR_TRUE) inserts the child after
5952 // sib in content order, which is before sib in view order. BUT
5953 // when sib is null it inserts at the end of the the document
5954 // order, i.e., first in view order. But when oldRootSibling is
5955 // null, the old root as at the end of the view list --- last in
5956 // content order --- and we want to call InsertChild(parent, child,
5957 // nsnull, PR_FALSE) in that case.
5959 rootViewSibling,
5964 }
5965 }
5967 // Now that all of the child docshells have been put into place, we can
5968 // restart the timers for the window and all of the child frames.
5971 // Restore the refresh URI list. The refresh timers will be restarted
5972 // when EndPageLoad() is called.
5975 // Meta-refresh timers have been restarted for this shell, but not
5976 // for our children. Walk the child shells and restart their timers.
5982 }
5984 // Make sure this presentation is the same size as the previous
5985 // presentation. If this is not the same size we showed it at last time,
5986 // then we need to resize the widget.
5988 // XXXbryner This interacts poorly with Firefox's infobar. If the old
5989 // presentation had the infobar visible, then we will resize the new
5990 // presentation to that smaller size. However, firing the locationchanged
5991 // event will hide the infobar, which will immediately resize the window
5992 // back to the larger size. A future optimization might be to restore
5993 // the presentation at the "wrong" size, then fire the locationchanged
5994 // event and check whether the docshell's new size is the same as the
5995 // cached viewer size (skipping the resize if they are equal).
6000 #ifdef DEBUG_PAGE_CACHE
6003 #endif
6007 }
6008 }
6010 // Simulate the completion of the load.
6013 // Restart plugins, and paint the content.
6018 }
6020 NS_IMETHODIMP
6024 {
6027 // Can we check the content type of the current content viewer
6028 // and reuse it without destroying it and re-creating it?
6032 // Instantiate the content viewer object
6040 // Notify the current document that it is about to be unloaded!!
6041 //
6042 // It is important to fire the unload() notification *before* any state
6043 // is changed within the DocShell - otherwise, javascript will get the
6044 // wrong information :-(
6045 //
6048 // We determined that it was safe to cache the document presentation
6049 // at the time we initiated the new load. We need to check whether
6050 // it's still safe to do so, since there may have been DOM mutations
6051 // or new requests initiated.
6056 }
6063 }
6067 // Set mFiredUnloadEvent = PR_FALSE so that the unload handler for the
6068 // *new* document will fire.
6071 // we've created a new document so go ahead and call
6072 // OnLoadingSite(), but don't fire OnLocationChange()
6073 // notifications before we've called Embed(). See bug 284993.
6078 // let's try resetting the load group if we need to...
6082 NS_ERROR_FAILURE);
6087 //Cancel any URIs that are currently loading...
6088 /// XXX: Need to do this eventually Stop();
6089 //
6090 // Retarget the document to this loadgroup...
6091 //
6092 /* First attach the channel to the right loadgroup
6093 * and then remove from the old loadgroup. This
6094 * puts the notifications in the right order and
6095 * we don't null-out mLSHE in OnStateChange() for
6096 * all redirected urls
6097 */
6100 // Mark the channel as being a document URI...
6109 NS_BINDING_RETARGETED);
6111 // Update the notification callbacks, so that progress and
6112 // status information are sent to the right docshell...
6114 }
6117 NS_ERROR_FAILURE);
6123 // if this document is part of a multipart document,
6124 // the ID can be used to distinguish it from the other parts.
6132 PRUint32 partID;
6135 }
6136 }
6137 }
6139 // Give hint to native plevent dispatch mechanism. If a document
6140 // is loading the native plevent dispatch mechanism should favor
6141 // performance over normal native event dispatch priorities.
6143 // Hint to favor performance for the plevent notification mechanism.
6144 // We want the pages to load as fast as possible even if its means
6145 // native messages might be starved.
6147 }
6151 }
6154 }
6156 nsresult
6161 {
6164 nsresult rv;
6169 nsXPIDLCString contractId;
6170 rv = catMan->GetCategoryEntry("Gecko-Content-Viewers", aContentType, getter_Copies(contractId));
6172 // Create an instance of the document-loader-factory
6179 }
6181 // Now create an instance of the content viewer
6182 // nsLayoutDLF makes the determination if it should be a "view-source" instead of "view"
6184 aOpenedChannel,
6187 nsnull,
6188 aContentHandler,
6189 aViewer),
6190 NS_ERROR_FAILURE);
6194 }
6196 NS_IMETHODIMP
6198 {
6199 //
6200 // Copy content viewer state from previous or parent content viewer.
6201 //
6202 // The following logic is mirrored in nsHTMLDocument::StartDocumentLoad!
6203 //
6204 // Do NOT to maintain a reference to the old content viewer outside
6205 // of this "copying" block, or it will not be destroyed until the end of
6206 // this routine and all <SCRIPT>s and event handlers fail! (bug 20315)
6207 //
6208 // In this block of code, if we get an error result, we return it
6209 // but if we get a null pointer, that's perfectly legal for parent
6210 // and parentContentViewer.
6211 //
6218 // This will get the size from the current content viewer or from the
6219 // Init settings
6224 NS_ERROR_FAILURE);
6227 nsCAutoString defaultCharset;
6228 nsCAutoString forceCharset;
6229 nsCAutoString hintCharset;
6230 PRInt32 hintCharsetSource;
6231 nsCAutoString prevDocCharset;
6234 PRBool styleDisabled;
6235 // |newMUDV| also serves as a flag to set the data from the above vars
6241 // Get any interesting state from old content viewer
6242 // XXX: it would be far better to just reuse the document viewer ,
6243 // since we know we're just displaying the same document as before
6246 // Tell the old content viewer to hibernate in session history when
6247 // it is destroyed.
6252 }
6254 }
6255 }
6257 // No old content viewer, so get state from parent's content viewer
6261 }
6264 nsresult rv;
6270 NS_ERROR_FAILURE);
6273 NS_ERROR_FAILURE);
6276 NS_ERROR_FAILURE);
6279 NS_ERROR_FAILURE);
6282 NS_ERROR_FAILURE);
6285 NS_ERROR_FAILURE);
6288 NS_ERROR_FAILURE);
6291 NS_ERROR_FAILURE);
6292 }
6293 }
6294 }
6296 // It is necessary to obtain the focus controller to utilize its ability
6297 // to suppress focus. This is necessary to fix Win32-only bugs related to
6298 // a loss of focus when mContentViewer is set to null. The internal window
6299 // is destroyed, and the OS focuses the parent window. This call ends up
6300 // notifying the focus controller that the outer window should focus
6301 // and this hoses us on any link traversal.
6302 //
6303 // Please do not touch any of the focus controller code here without
6304 // testing bugs #28580 and 50509. These are immensely important bugs,
6305 // so PLEASE take care not to regress them if you decide to alter this
6306 // code later -- hyatt
6312 // Suppress the command dispatcher.
6315 // Remove focus from the element that has it
6319 // We want to null out the last focused element if the document containing
6320 // it is going away. If the last focused element is in a descendent
6321 // window of our domwindow, its document will be destroyed when we
6322 // destroy our children. So, check for this case and null out the
6323 // last focused element. See bug 70484.
6333 }
6335 // don't use nsCOMPtr here to avoid extra addref
6336 // when assigning to curwin
6342 }
6344 }
6348 }
6349 }
6354 // Ensure that the content viewer is destroyed *after* the GC - bug 71515
6357 // Stop any activity that may be happening in the old document before
6358 // releasing it...
6361 // Try to extract the default background color from the old
6362 // view manager, so we can use it for the next document.
6375 // If the background color is not known, don't propagate it.
6377 }
6378 }
6379 }
6385 }
6397 }
6405 }
6407 // If we have old state to copy, set the old state onto the new content
6408 // viewer
6411 NS_ERROR_FAILURE);
6413 NS_ERROR_FAILURE);
6415 NS_ERROR_FAILURE);
6418 NS_ERROR_FAILURE);
6420 NS_ERROR_FAILURE);
6422 NS_ERROR_FAILURE);
6424 NS_ERROR_FAILURE);
6426 NS_ERROR_FAILURE);
6427 }
6429 // End copying block (Don't mess with the old content/document viewer
6430 // beyond here!!)
6432 // See the book I wrote above regarding why the focus controller is
6433 // being used here. -- hyatt
6435 /* Note it's important that focus suppression be turned off no earlier
6436 because in cases where the docshell is lazily creating an about:blank
6437 document, mContentViewer->Init finally puts a reference to that
6438 document into the DOM window, which prevents an infinite recursion
6439 attempting to lazily create the document as focus is unsuppressed
6440 (bug 110856). */
6446 // Stuff the bgcolor from the last view manager into the new
6447 // view manager. This improves page load continuity.
6460 }
6461 }
6462 }
6463 }
6465 // XXX: It looks like the LayoutState gets restored again in Embed()
6466 // right after the call to SetupNewViewer(...)
6468 // We don't show the mContentViewer yet, since we want to draw the old page
6469 // until we have enough of the new page to show. Just return with the new
6470 // viewer still set to hidden.
6472 // Now that we have switched documents, forget all of our children
6476 }
6479 nsresult
6481 {
6482 // This method checks whether the caller may load content into
6483 // this docshell. Even though we've done our best to hide windows
6484 // from code that doesn't have the right to access them, it's
6485 // still possible for an evil site to open a window and access
6486 // frames in the new window through window.frames[] (which is
6487 // allAccess for historic reasons), so we still need to do this
6488 // check on load.
6492 // Origin validation was turned off, or we're not a frame.
6493 // Permit all loads.
6496 }
6498 // We're a frame. Check that the caller has write permission to
6499 // the parent before allowing it to load anything into this
6500 // docshell.
6511 }
6517 // Check if the caller is from the same origin as this docshell,
6518 // or any of it's ancestors.
6527 }
6529 // Compare origins
6530 PRBool equal;
6534 // Same origin, permit load
6537 }
6540 }
6548 }
6550 //*****************************************************************************
6551 // nsDocShell: Site Loading
6552 //*****************************************************************************
6554 {
6571 {
6572 // Make sure to keep null things null as needed
6575 }
6576 }
6583 }
6590 PRUint32 mFlags;
6592 // Use IDL strings so .get() returns null by default
6593 nsXPIDLString mWindowTarget;
6594 nsXPIDLCString mTypeHint;
6598 PRUint32 mLoadType;
6600 PRBool mFirstParty;
6601 };
6603 NS_IMETHODIMP
6607 PRUint32 aFlags,
6612 PRUint32 aLoadType,
6614 PRBool aFirstParty,
6617 {
6620 #ifdef PR_LOGGING
6622 nsCAutoString spec;
6626 }
6627 #endif
6629 // Initialize aDocShell/aRequest
6632 }
6635 }
6639 }
6645 // wyciwyg urls can only be loaded through history. Any normal load of
6646 // wyciwyg through docshell is illegal. Disallow such loads.
6652 }
6657 }
6659 //
6660 // First, notify any nsIContentPolicy listeners about the document load.
6661 // Only abort the load if a content policy listener explicitly vetos it!
6662 //
6664 // Use nsPIDOMWindow since we _want_ to cross the chrome boundary if needed
6670 PRUint32 contentType;
6676 }
6681 }
6683 // XXXbz would be nice to know the loading principal here... but we don't
6692 }
6695 aURI,
6696 loadingPrincipal,
6697 context,
6705 }
6708 }
6711 //
6712 // Get an owner from the current document if necessary. Note that we only
6713 // do this for URIs that inherit a security context and local file URIs;
6714 // in particular we do NOT do this for about:blank. This way, random
6715 // about:blank loads that have no owner (which basically means they were
6716 // done by someone from chrome manually messing with our nsIWebNavigation
6717 // or by C++ setting document.location) don't get a funky principal. If
6718 // callers want something interesting to happen with the about:blank
6719 // principal in this case, they should pass an owner in.
6720 //
6721 {
6722 PRBool inherits;
6723 // One more twist: Don't inherit the owner for external loads.
6729 // Don't allow loads that would inherit our security context
6730 // if this document came from an unsafe channel.
6735 PRBool isUnsafe;
6738 isUnsafe) {
6740 }
6748 }
6749 }
6751 //
6752 // Resolve the window target before going any further...
6753 // If the load has been targeted to another DocShell, then transfer the
6754 // load to it...
6755 //
6757 // We've already done our owner-inheriting. Mask out that bit, so we
6758 // don't try inheriting an owner from the target window if we came up
6759 // with a null owner above.
6762 // Locate the target DocShell.
6763 // This may involve creating a new toplevel window - if necessary.
6764 //
6784 // In some cases the Open call doesn't actually result in a new
6785 // window being opened. We can detect these cases by examining the
6786 // document in |newWin|, if any.
6794 }
6795 }
6809 }
6810 }
6812 // We opened a new window for the target, clone the
6813 // session storage if the current URI's domain matches
6814 // that of the loading URI.
6829 newstorage);
6830 }
6831 }
6832 }
6833 }
6835 //
6836 // Transfer the load to the target DocShell... Pass nsnull as the
6837 // window target name from to prevent recursive retargeting!
6838 //
6841 aReferrer,
6842 owner,
6843 aFlags,
6845 aTypeHint,
6846 aPostData,
6847 aHeadersData,
6848 aLoadType,
6849 aSHEntry,
6850 aFirstParty,
6851 aDocShell,
6852 aRequest);
6854 // XXXbz except we never reach this code!
6856 //
6857 // At this point, a new window has been created, but the
6858 // URI did not have any data associated with it...
6859 //
6860 // So, the best we can do, is to tear down the new window
6861 // that was just created!
6862 //
6867 }
6868 }
6869 //
6870 // NS_ERROR_NO_CONTENT should not be returned to the
6871 // caller... This is an internal error code indicating that
6872 // the URI had no data associated with it - probably a
6873 // helper-app style protocol (ie. mailto://)
6874 //
6876 }
6878 // XXX: Once new windows are created hidden, the new
6879 // window will need to be made visible... For now,
6880 // do nothing.
6881 }
6882 }
6884 // Else we ran out of memory, or were a popup and got blocked,
6885 // or something.
6888 }
6890 //
6891 // Load is being targetted at this docshell so return an error if the
6892 // docshell is in the process of being destroyed.
6893 //
6896 }
6901 }
6903 // If this docshell is owned by a frameloader, make sure to cancel
6904 // possible frameloader initialization before loading a new page.
6912 }
6913 }
6920 // If this is a replace load, make whatever load triggered
6921 // the unload event also a replace load, so we don't
6922 // create extra history entries.
6925 }
6927 // Do this asynchronously
6933 }
6935 // Just ignore this load attempt
6937 }
6939 // Before going any further vet loads initiated by external programs.
6941 // Disallow external chrome: loads targetted at content windows
6946 }
6948 // clear the decks to prevent context bleed-through (bug 298255)
6953 // reset loadType so we don't have to add lots of tests for
6954 // LOAD_NORMAL_EXTERNAL after this point
6956 }
6958 mAllowKeywordFixup =
6962 //
6963 // First:
6964 // Check to see if the new URI is an anchor in the existing document.
6965 // Skip this check if we're doing some sort of abnormal load, if the
6966 // new load is a non-history load and has postdata, or if we're doing
6967 // a history load and the page identifiers of mOSHE and aSHEntry
6968 // don't match.
6969 //
6974 PRUint32 ourPageIdent;
6976 PRUint32 otherPageIdent;
6979 #ifdef DEBUG
6985 }
6986 #endif
6987 }
7001 /* we need to assign mLSHE to aSHEntry right here, so that on History loads,
7002 * SetCurrentURI() called from OnNewURI() will send proper
7003 * onLocationChange() notifications to the browser to update
7004 * back/forward buttons.
7005 */
7008 /* This is a anchor traversal with in the same page.
7009 * call OnNewURI() so that, this traversal will be
7010 * recorded in session and global history.
7011 */
7018 /* save current position of scroller(s) (bug 59774) */
7020 // Get the postdata and page ident from the current page, if
7021 // the new load is being done via normal means. Note that
7022 // "normal means" can be checked for just by checking for
7023 // LOAD_CMD_NORMAL, given the loadType and allowScroll check
7024 // above -- it filters out some LOAD_CMD_NORMAL cases that we
7025 // wouldn't want here.
7030 }
7031 }
7033 /* Assign mOSHE to mLSHE. This will either be a new entry created
7034 * by OnNewURI() for normal loads or aSHEntry for history loads.
7035 */
7038 // Save the postData obtained from the previous page
7039 // in to the session history entry created for the
7040 // anchor page, so that any history load of the anchor
7041 // page will restore the appropriate postData.
7045 // Make sure we won't just repost without hitting the
7046 // cache first
7050 // Propagate our page ident to the new mOSHE so that
7051 // we'll know it just differed by a scroll on the page.
7054 }
7056 /* restore previous position of scroller(s), if we're moving
7057 * back in history (bug 59774)
7058 */
7060 {
7064 }
7066 /* Clear out mLSHE so that further anchor visits get
7067 * recorded in SH and SH won't misbehave.
7068 */
7070 /* Set the title for the SH entry for this target url. so that
7071 * SH menus in go/back/forward buttons won't be empty for this.
7072 */
7083 }
7086 }
7087 }
7089 // mContentViewer->PermitUnload can destroy |this| docShell, which
7090 // causes the next call of CanSavePresentation to crash.
7091 // Hold onto |this| until we return, to prevent a crash from happening.
7092 // (bug#331040)
7095 // Check if the page doesn't want to be unloaded. The javascript:
7096 // protocol handler deals with this for javascript: URLs.
7098 PRBool okToUnload;
7102 // The user chose not to unload the page, interrupt the
7103 // load.
7105 }
7106 }
7108 // Check for saving the presentation here, before calling Stop().
7109 // This is necessary so that we can catch any pending requests.
7110 // Since the new request has not been created yet, we pass null for the
7111 // new request parameter.
7112 // Also pass nsnull for the document, since it doesn't affect the return
7113 // value for our purposes here.
7116 // Don't stop current network activity for javascript: URL's since
7117 // they might not result in any data, and thus nothing should be
7118 // stopped in those cases. In the case where they do result in
7119 // data, the javascript: URL channel takes care of stopping
7120 // current network activity.
7122 // Stop any current network activity.
7123 // Also stop content if this is a zombie doc. otherwise
7124 // the onload will be delayed by other loads initiated in the
7125 // background by the first document that
7126 // didn't fully load before the next load was initiated.
7127 // If not a zombie, don't stop content until data
7128 // starts arriving from the new URI...
7133 }
7140 }
7144 }
7148 // mLSHE should be assigned to aSHEntry, only after Stop() has
7149 // been called. But when loading an error page, do not clear the
7150 // mLSHE for the real page.
7156 // If we have a saved content viewer in history, restore and show it now.
7158 // It's possible that the previous viewer of mContentViewer is the
7159 // viewer that will end up in aSHEntry when it gets closed. If that's
7160 // the case, we need to go ahead and force it into its shentry so we
7161 // can restore it.
7166 #ifdef DEBUG
7170 #endif
7174 // Make sure this viewer ends up in the right place
7177 }
7178 }
7179 }
7181 PRBool restoring;
7186 // We failed to restore the presentation, so clean up.
7187 // Both the old and new history entries could potentially be in
7188 // an inconsistent state.
7194 }
7195 }
7210 }
7213 }
7215 nsIPrincipal*
7217 {
7226 }
7234 }
7235 }
7240 }
7242 // Make sure we end up with _something_ as the principal no matter
7243 // what.
7245 // docViewer and bail.
7252 }
7254 //-- Get the document's principal
7257 }
7260 }
7262 nsresult
7265 PRBool aSendReferrer,
7270 PRBool aFirstParty,
7273 PRBool aIsNewWindowTarget,
7274 PRBool aBypassClassifier)
7275 {
7276 nsresult rv;
7284 // tag first party URL loads
7286 }
7289 // Error pages are LOAD_BACKGROUND
7291 }
7293 // open a channel for the url
7297 aURI,
7298 nsnull,
7299 nsnull,
7301 loadFlags);
7304 // This is a uri with a protocol scheme we don't know how
7305 // to handle. Embedders might still be interested in
7306 // handling the load, though, so we fire a notification
7307 // before throwing the load away.
7311 // Hey, they're handling the load for us! How convenient!
7313 }
7314 }
7317 }
7319 // Make sure to give the caller a channel if we managed to create one
7320 // This is important for correct error page/session history interaction
7328 }
7331 }
7333 //hack
7341 }
7342 }
7346 {
7347 // save true referrer for those who need it (e.g. xpinstall whitelisting)
7348 // Currently only http and ftp channels support this.
7350 aReferrerURI);
7351 }
7353 //
7354 // If this is a HTTP channel, then set up the HTTP specific information
7355 // (ie. POST data, referrer, ...)
7356 //
7359 /* Get the cache Key from SH */
7363 }
7367 // figure out if we need to set the post data stream on the channel...
7368 // right now, this is only done for http channels.....
7370 // XXX it's a bit of a hack to rewind the postdata stream here but
7371 // it has to be done in case the post data is being reused multiple
7372 // times.
7378 }
7383 // we really need to have a content type associated with this stream!!
7385 /* If there is a valid postdata *and* it is a History Load,
7386 * set up the cache key on the channel, to retrieve the
7387 * data *only* from the cache. If it is a normal reload, the
7388 * cache is free to go to the server for updated postdata.
7389 */
7393 PRUint32 loadFlags;
7396 }
7399 }
7400 }
7402 /* If there is no postdata, set the cache key on the channel, and
7403 * do not set the LOAD_ONLY_FROM_CACHE flag, so that the channel
7404 * will be free to get it from net if it is not found in cache.
7405 * New cache may use it creatively on CGI pages with GET
7406 * method and even on those that say "no-cache"
7407 */
7412 }
7413 }
7416 }
7417 // Set the referrer explicitly
7419 // Referrer is currenly only set for link clicks here.
7421 }
7422 }
7423 //
7424 // Set the owner of the channel, but only for channels that can't
7425 // provide their own security context.
7426 //
7427 // XXX: Is seems wrong that the owner is ignored - even if one is
7428 // supplied) unless the URI is javascript or data or about:blank.
7429 // XXX: If this is ever changed, check all callers for what owners they're
7430 // passing in. In particular, see the code and comments in LoadURI
7431 // where we fall back on inheriting the owner if called
7432 // from chrome. That would be very wrong if this code changed
7433 // anything but channels that can't provide their own security context!
7434 //
7435 // (Currently chrome URIs set the owner when they are created!
7436 // So setting a NULL owner would be bad!)
7437 //
7438 // If this code ever changes, change nsObjectLoadingContent::LoadObject
7439 // accordingly.
7440 PRBool inherit;
7441 // We expect URIInheritsSecurityContext to return success for an
7442 // about:blank URI, so don't call IsAboutBlank() if this call fails.
7446 }
7448 //
7449 // file: uri special-casing
7450 //
7451 // If this is a file: load opened from another file: then it may need
7452 // to inherit the owner from the referrer so they can script each other.
7453 // If we don't set the owner explicitly then each file: gets an owner
7454 // based on its own codebase later.
7455 //
7460 }
7464 // Allow execution against our context if the principals match
7465 scriptChannel->
7467 }
7474 PR_TRUE);
7475 }
7476 }
7480 //
7481 // If the channel load failed, we failed and nsIWebProgress just ain't
7482 // gonna happen.
7483 //
7488 }
7489 }
7492 }
7494 static NS_METHOD
7498 PRUint32 toOffset,
7499 PRUint32 count,
7501 {
7502 // aFromSegment now contains aCount bytes of data.
7507 // Indicate that we have consumed all of aFromSegment
7510 }
7512 NS_IMETHODIMP
7515 {
7519 PRUint32 numRead;
7520 nsCAutoString headersString;
7523 PR_UINT32_MAX,
7527 // used during the manipulation of the String from the InputStream
7528 nsCAutoString headerName;
7529 nsCAutoString headerValue;
7530 PRInt32 crlf;
7531 PRInt32 colon;
7533 //
7534 // Iterate over the headersString: for each "\r\n" delimited chunk,
7535 // add the value as a header to the nsIHttpChannel
7536 //
7558 //
7559 // FINALLY: we can set the header!
7560 //
7564 }
7568 }
7572 PRBool aBypassClassifier)
7573 {
7574 nsresult rv;
7575 // Mark the channel as being a document URI and allow content sniffing...
7581 // Load attributes depend on load type...
7607 // Set cache checking flags
7608 PRInt32 prefSetting;
7623 }
7624 }
7626 }
7640 }
7641 }
7644 }
7646 nsresult
7648 {
7655 // no URI classifier => ignored cases
7657 }
7663 }
7665 NS_IMETHODIMP
7668 {
7674 }
7680 }
7685 // If we failed to get the shell, or if there is no shell,
7686 // nothing left to do here.
7689 }
7691 // NOTE: we assume URIs are absolute for comparison purposes
7693 nsCAutoString currentSpec;
7695 NS_ERROR_FAILURE);
7697 nsCAutoString newSpec;
7700 // Search for hash marks in the current URI and the new URI and
7701 // take a copy of everything to the left of the hash for
7702 // comparison.
7706 // Split the new URI into a left and right part
7707 // (assume we're parsing it out right
7715 }
7718 // found it
7725 }
7727 // no hash at all
7729 }
7733 // Split the current URI in a left and right part
7740 }
7745 }
7748 }
7750 // If we have no new anchor, we do not want to scroll, unless there is a
7751 // current anchor and we are doing a history load. So return if we have no
7752 // new anchor, and there is no current anchor or the load is not a history
7753 // load.
7759 }
7761 // Compare the URIs.
7762 //
7763 // NOTE: this is a case sensitive comparison because some parts of the
7764 // URI are case sensitive, and some are not. i.e. the domain name
7765 // is case insensitive but the the paths are not.
7766 //
7767 // This means that comparing "http://www.ABC.com/" to "http://www.abc.com/"
7768 // will fail this test.
7772 }
7774 // Now we know we are dealing with an anchor
7777 // Both the new and current URIs refer to the same page. We can now
7778 // browse to the hash stored in the new URI.
7779 //
7780 // But first let's capture positions of scroller(s) that can
7781 // (and usually will) be modified by GoToAnchor() call.
7787 // anchor is there, but if it's a load from history,
7788 // we don't have any anchor jumping to do
7795 }
7797 // nsUnescape modifies the string that is passed into it.
7800 // We assume that the bytes are in UTF-8, as it says in the
7801 // spec:
7802 // http://www.w3.org/TR/html4/appendix/notes.html#h-B.2.1
7804 // We try the UTF-8 string first, and then try the document's
7805 // charset (see below). If the string is not UTF-8,
7806 // conversion will fail and give us an empty Unicode string.
7807 // In that case, we should just fall through to using the
7808 // page's charset.
7813 }
7816 // Above will fail if the anchor name is not UTF-8. Need to
7817 // convert from document charset to unicode.
7820 // Get a document charset
7834 // Unescape and convert to unicode
7835 nsXPIDLString uStr;
7842 // Ignore return value of GoToAnchor, since it will return an error
7843 // if there is no such anchor in the document, which is actually a
7844 // success condition for us (we want to update the session history
7845 // with the new URI no matter whether we actually scrolled
7846 // somewhere).
7848 }
7849 }
7852 // Tell the shell it's at an anchor, without scrolling.
7855 // An empty anchor was found, but if it's a load from history,
7856 // we don't have to jump to the top of the page. Scrollbar
7857 // position will be restored by the caller, based on positions
7858 // stored in session history.
7861 //An empty anchor. Scroll to the top of the page.
7863 }
7866 }
7868 void
7870 {
7877 }
7878 }
7879 }
7881 PRBool
7884 PRBool aAddToGlobalHistory)
7885 {
7887 #if defined(PR_LOGGING) && defined(DEBUG)
7889 nsCAutoString spec;
7892 nsCAutoString chanName;
7895 else
7901 }
7902 #endif
7908 // Get the post data from the channel
7913 // Check if the HTTPChannel is hiding under a multiPartChannel
7916 }
7922 }
7923 }
7924 }
7925 /* Create SH Entry (mLSHE) only if there is a SessionHistory object (mSessionHistory) in
7926 * the current frame or in the root docshell
7927 */
7930 // Get the handle to SH from the root docshell
7937 // Determine if this type of load should update history.
7944 // Check if the url to be loaded is the same as the one already loaded.
7948 #ifdef DEBUG
7952 #endif
7954 /* If the url to be loaded is the same as the one already there,
7955 * and the original loadType is LOAD_NORMAL, LOAD_LINK, or
7956 * LOAD_STOP_CONTENT, set loadType to LOAD_NORMAL_REPLACE so that
7957 * AddToSessionHistory() won't mess with the current SHEntry and
7958 * if this page has any frame children, it also will be handled
7959 * properly. see bug 83684
7960 *
7961 * XXX Hopefully changing the loadType at this time will not hurt
7962 * anywhere. The other way to take care of sequentially repeating
7963 * frameset pages is to add new methods to nsIDocShellTreeItem.
7964 * Hopefully I don't have to do that.
7965 */
7971 {
7973 }
7975 // If this is a refresh to the currently loaded url, we don't
7976 // have to update session or global history.
7979 }
7982 /* If the user pressed shift-reload, cache will create a new cache key
7983 * for the page. Save the new cacheKey in Session History.
7984 * see bug 90098
7985 */
7995 // Get the Cache Key and store it in SH.
7998 // If we already have a loading history entry, store the new cache key
7999 // in it. Otherwise, since we're doing a reload and won't be updating
8000 // our history entry, store the cache key in our current history entry.
8005 }
8008 // Update session history if necessary...
8010 /* This is a fresh page getting loaded for the first time
8011 *.Create a Entry for it and add it to SH, if this is the
8012 * rootDocShell
8013 */
8015 }
8017 // Update Global history
8019 // Get the referrer uri from the channel
8021 }
8022 }
8024 // If this was a history load, update the index in
8025 // SH.
8032 #ifdef DEBUG_PAGE_CACHE
8035 #endif
8036 }
8037 }
8039 aFireOnLocationChange);
8040 // Make sure to store the referrer from the channel, if any
8043 }
8045 PRBool
8047 PRBool aAddToGlobalHistory)
8048 {
8050 // If this a redirect, use the final url (uri)
8051 // else use the original url
8052 //
8053 // Note that this should match what documents do (see nsDocument::Reset).
8058 aAddToGlobalHistory);
8060 }
8062 void
8064 {
8066 }
8068 //*****************************************************************************
8069 // nsDocShell: Session History
8070 //*****************************************************************************
8071 PRBool
8073 {
8074 // I believe none of the about: urls should go in the history. But then
8075 // that could just be me... If the intent is only deny about:blank then we
8076 // should just do a spec compare, rather than two gets of the scheme and
8077 // then the path. -Gagan
8078 nsresult rv;
8079 nsCAutoString buf;
8092 }
8093 }
8095 }
8097 nsresult
8100 {
8101 #if defined(PR_LOGGING) && defined(DEBUG)
8103 nsCAutoString spec;
8106 nsCAutoString chanName;
8109 else
8115 }
8116 #endif
8120 PRBool shouldPersist;
8124 // Get a handle to the root docshell
8127 /*
8128 * If this is a LOAD_FLAGS_REPLACE_HISTORY in a subframe, we use
8129 * the existing SH entry in the page and replace the url and
8130 * other vitalities.
8131 */
8134 // This is a subframe
8140 // Remove all children of this entry
8147 }
8149 // Create a new entry if necessary.
8155 }
8156 }
8158 // Get the post data & referrer
8169 /* If there is a caching channel, get the Cache Key and store it
8170 * in SH.
8171 */
8175 }
8178 // Check if the httpChannel is hiding under a multipartChannel
8181 }
8186 }
8190 }
8192 }
8194 //Title is set in nsDocShell::SetTitle()
8203 /* If cache got a 'no-store', ask SH not to store
8204 * HistoryLayoutState. By default, SH will set this
8205 * flag to PR_TRUE and save HistoryLayoutState.
8206 */
8209 }
8211 // Check if the page has expired from cache
8214 PRUint32 expTime;
8220 }
8221 }
8227 // This is the root docshell
8229 // Replace current entry in session history.
8233 // Replace the current entry with the new entry
8236 }
8238 // Add to session history
8245 #ifdef DEBUG_PAGE_CACHE
8248 #endif
8249 }
8250 }
8252 // This is a subframe.
8254 LOAD_FLAGS_REPLACE_HISTORY))
8256 }
8258 // Return the new SH entry...
8264 }
8265 }
8268 }
8271 NS_IMETHODIMP
8273 {
8276 }
8281 nsCAutoString contentType;
8288 NS_ERROR_FAILURE);
8290 NS_ERROR_FAILURE);
8293 NS_ERROR_FAILURE);
8295 // Calling CreateAboutBlankContentViewer can set mOSHE to null, and if
8296 // that's the only thing holding a ref to aEntry that will cause aEntry to
8297 // die while we're loading it. So hold a strong ref to aEntry here, just
8298 // in case.
8300 PRBool isJS;
8303 // We're loading a URL that will execute script from inside asyncOpen.
8304 // Replace the current document with about:blank now to prevent
8305 // anything from the current document from leaking into any JavaScript
8306 // code in the URL.
8311 // The creation of the intermittent about:blank content
8312 // viewer failed for some reason (potentially because the
8313 // user prevented it). Interrupt the history load.
8315 }
8318 // Ensure that we have an owner. Otherwise javascript: URIs will
8319 // pick it up from the about:blank page we just loaded, and we
8320 // don't really want even that in this case.
8323 }
8324 }
8326 /* If there is a valid postdata *and* the user pressed
8327 * reload or shift-reload, take user's permission before we
8328 * repost the data to the server.
8329 */
8331 PRBool repost;
8335 // If the user pressed cancel in the dialog, return. We're done here.
8338 }
8341 referrerURI,
8342 owner,
8350 PR_TRUE,
8354 }
8357 {
8360 // Don't capture historystate and save it in history
8361 // if the page asked not to do so.
8363 }
8366 }
8369 {
8373 PRBool shouldSave;
8383 PR_TRUE);
8384 }
8385 }
8388 }
8390 /* static */ nsresult
8393 WalkHistoryEntriesFunc aCallback,
8395 {
8402 PRInt32 childCount;
8408 // childEntry can be null for valid reasons, for example if the
8409 // docshell at index i never loaded anything useful.
8411 }
8415 // Walk the children of aRootShell and see if one of them
8416 // has srcChild as a SHEntry.
8426 }
8427 }
8428 }
8431 }
8434 }
8436 // callback data for WalkHistoryEntries
8437 struct NS_STACK_CLASS CloneAndReplaceData
8438 {
8445 PRUint32 cloneID;
8449 };
8451 /* static */ nsresult
8454 {
8462 PRUint32 srcID;
8466 // Just replace the entry, and don't walk the children.
8470 // Clone the SHEntry...
8475 // This entry is for a subframe navigation
8478 // Walk the children
8487 }
8496 }
8498 /* static */ nsresult
8501 PRUint32 aCloneID,
8504 {
8513 }
8516 void
8518 {
8524 }
8527 struct SwapEntriesData
8528 {
8532 // whose children will correspond to aEntry
8533 };
8536 nsresult
8539 {
8553 // aEntry is a clone of some child of destTreeParent, but since the
8554 // trees aren't necessarily in sync, we'll have to locate it.
8555 // Note that we could set aShell's entry to null if we don't find a
8556 // corresponding entry under destTreeParent.
8561 // First look at the given index, since this is the common case.
8567 PRInt32 childCount;
8578 }
8579 }
8580 }
8583 }
8587 // Now handle the children of aEntry.
8591 }
8596 {
8602 }
8605 }
8608 void
8610 {
8611 // We need to sync up the docshell and session history trees for
8612 // subframe navigation. If the load was in a subframe, we forward up to
8613 // the root docshell, which will then recursively sync up all docshells
8614 // to their corresponding entries in the new session history tree.
8615 // If we don't do this, then we can cache a content viewer on the wrong
8616 // cloned entry, and subsequently restore it at the wrong time.
8620 // newRootEntry is now the new root entry.
8621 // Find the old root entry as well.
8623 // Need a strong ref. on |oldRootEntry| so it isn't destroyed when
8624 // SetChildHistoryEntry() does SwapHistoryEntries() (bug 304639).
8637 #ifdef NS_DEBUG
8638 nsresult rv =
8639 #endif
8643 }
8644 }
8645 }
8648 }
8651 nsresult
8653 {
8654 nsresult rv;
8657 //Get the root docshell
8659 // QI to nsIWebNavigation
8662 // Get the handle to SH from the root docshell
8664 }
8666 }
8668 nsresult
8670 {
8682 }
8684 }
8686 PRBool
8688 {
8689 // By default layout State will be saved.
8693 // figure out if SH should be saving layout state
8701 }
8703 //*****************************************************************************
8704 // nsDocShell: nsIEditorDocShell
8705 //*****************************************************************************
8708 {
8714 }
8717 }
8720 {
8725 }
8729 {
8733 }
8737 {
8741 {
8745 }
8746 else
8747 {
8749 }
8752 }
8755 {
8760 }
8762 nsresult
8765 {
8769 // If this is a POST request, we do not want to include this in global
8770 // history, so return early.
8773 nsCAutoString type;
8777 }
8779 PRBool visited;
8797 }
8798 }
8801 }
8803 //*****************************************************************************
8804 // nsDocShell: Helper Routines
8805 //*****************************************************************************
8807 NS_IMETHODIMP
8809 {
8812 }
8814 NS_IMETHODIMP
8816 {
8819 }
8821 nsresult
8823 {
8824 nsresult rv;
8844 nsXPIDLString brandName;
8852 }
8854 // Brand available - if the app has an override file with formatting, the app name will
8855 // be included. Without an override, the prompt will look like the generic version.
8860 }
8867 PRInt32 buttonPressed;
8877 }
8879 NS_IMETHODIMP
8882 {
8884 NS_ERROR_FAILURE);
8892 aStringBundle),
8893 NS_ERROR_FAILURE);
8896 }
8898 NS_IMETHODIMP
8901 {
8906 NS_ERROR_FAILURE);
8914 NS_ERROR_FAILURE);
8920 }
8921 }
8924 }
8926 NS_IMETHODIMP
8928 {
8936 NS_ERROR_FAILURE);
8940 }
8942 }
8944 #ifdef DEBUG
8945 class nsDebugAutoBoolTrueSetter
8946 {
8950 {
8952 }
8955 {
8957 }
8960 };
8961 #endif
8963 NS_IMETHODIMP
8965 {
8971 }
8973 #ifdef DEBUG
8975 "Infinite loop! Calling EnsureScriptEnvironment() from "
8978 // Yeah, this isn't re-entrant safe, but that's ok since if we
8979 // re-enter this method, we'll infinitely loop...
8981 #endif
8990 PRUint32 chromeFlags;
8993 PRBool isModalContentWindow =
8997 // If our window is modal and we're not opened as chrome, make
8998 // this window a modal content window.
9000 isModalContentWindow,
9007 // Ensure the script object is set to run javascript - other languages
9008 // setup on demand.
9009 // XXXmarkh - should this be setup to run the default language for this doc?
9010 nsresult rv;
9015 }
9018 NS_IMETHODIMP
9020 {
9023 // We shouldn't recreate the editor data if it already exists, or
9024 // we're shutting down, or we already have a detached editor data
9025 // stored in the session history. We should only have one editordata
9026 // per docshell.
9028 }
9031 }
9033 nsresult
9035 {
9039 }
9042 }
9046 {
9047 nsresult rv;
9049 {
9052 }
9054 // we promise that the nsIWebBrowserFind that we return has been set
9055 // up to point to the focused, or content window, so we have to
9056 // set that up each time.
9061 // default to our window
9065 // if we can, search the focused window
9071 {
9076 }
9087 }
9089 PRBool
9091 {
9099 }
9102 }
9104 NS_IMETHODIMP
9106 {
9109 }
9111 NS_IMETHODIMP
9113 {
9114 #ifdef DEBUG_DOCSHELL_FOCUS
9117 #endif
9124 }
9127 // We may be in a situation where the focus outline was shown
9128 // on this document because the user tabbed into it, but the focus
9129 // is now switching to another document via a click. In this case,
9130 // we need to make sure the focus outline is removed from this document.
9132 }
9135 }
9137 // Find an nsICanvasFrame under aFrame. Only search the principal
9138 // child lists. aFrame must be non-null.
9140 {
9144 }
9151 }
9153 }
9156 }
9158 //-------------------------------------------------------
9159 // Tells the HTMLFrame/CanvasFrame that is now has focus
9160 NS_IMETHODIMP
9162 {
9182 }
9183 }
9184 }
9186 // Look for the frame the hard way
9192 }
9193 }
9194 }
9197 }
9199 NS_IMETHODIMP
9201 {
9203 }
9205 /* boolean IsBeingDestroyed (); */
9206 NS_IMETHODIMP
9208 {
9212 }
9215 NS_IMETHODIMP
9217 {
9221 }
9223 NS_IMETHODIMP
9225 {
9229 }
9231 NS_IMETHODIMP
9233 {
9237 }
9239 //*****************************************************************************
9240 //*** nsRefreshTimer: Object Management
9241 //*****************************************************************************
9245 {
9246 }
9249 {
9250 }
9252 //*****************************************************************************
9253 // nsRefreshTimer::nsISupports
9254 //*****************************************************************************
9262 NS_INTERFACE_MAP_END_THREADSAFE
9264 ///*****************************************************************************
9265 // nsRefreshTimer::nsITimerCallback
9266 //******************************************************************************
9267 NS_IMETHODIMP
9269 {
9273 // Get the delay count to determine load type
9279 }
9281 }
9283 //*****************************************************************************
9284 //*** nsDocShellFocusController: Object Management
9285 //*****************************************************************************
9286 void
9288 {
9289 #ifdef DEBUG_DOCSHELL_FOCUS
9292 #endif
9297 }
9299 }
9301 }
9303 //--------------------------------------------------
9304 // This is need for when the document with focus goes away
9305 void
9307 {
9310 }
9311 }
9313 //*****************************************************************************
9314 // nsDocShell::InterfaceRequestorProxy
9315 //*****************************************************************************
9317 {
9320 }
9321 }
9324 {
9326 }
9330 NS_IMETHODIMP
9332 {
9337 }
9340 }
9342 nsresult
9344 {
9356 // Get the current document and set the base uri
9363 }
9364 }
9366 }
9368 //*****************************************************************************
9369 // nsDocShell::nsIAuthPromptProvider
9370 //*****************************************************************************
9372 NS_IMETHODIMP
9375 {
9376 // a priority prompt request will override a false mAllowAuth setting
9382 // we're either allowing auth, or it's a proxy request
9383 nsresult rv;
9393 // Get the an auth prompter for our window so that the parenting
9394 // of the dialogs works as it should when using tabs.
9398 }
9400 //*****************************************************************************
9401 // nsDocShell::nsIObserver
9402 //*****************************************************************************
9404 NS_IMETHODIMP
9407 {
9417 PRBool tmpbool;
9424 }
9426 }
9428 /* static */
9429 nsresult
9431 {
9432 // Note: about:blank URIs do NOT inherit the security context from the
9433 // current document, which is what this function tests for...
9436 aResult);
9437 }
9439 /* static */
9440 PRBool
9442 {
9443 PRBool isFile;
9449 isFile;
9450 }
9452 /* static */
9453 PRBool
9455 {
9458 // GetSpec can be expensive for some URIs, so check the scheme first.
9462 }
9464 nsCAutoString str;
9467 }
9469 PRBool
9471 {
9476 }
9480 }
9484 return
9485 secMan &&
9487 }
9489 //*****************************************************************************
9490 // nsClassifierCallback
9491 //*****************************************************************************
9494 nsIChannelClassifier,
9495 nsIURIClassifierCallback,
9496 nsIRunnable)
9498 NS_IMETHODIMP
9500 {
9503 }
9506 "nsClassifierCallback::Run() called while a "
9512 // Don't bother to run the classifier on a load that has already failed.
9513 // (this might happen after a redirect)
9514 PRUint32 status;
9519 // Don't bother to run the classifier on a cached load that was
9520 // previously classified.
9523 }
9529 // Don't bother checking certain types of URIs.
9530 PRBool hasFlags;
9553 PRBool expectCallback;
9558 // Suspend the channel, it will be resumed when we get the classifier
9559 // callback.
9562 // Some channels (including nsJSChannel) fail on Suspend. This
9563 // shouldn't be fatal, but will prevent malware from being
9564 // blocked on these channels.
9566 }
9569 #ifdef DEBUG
9573 #endif
9574 }
9577 }
9579 // Note in the cache entry that this URL was classified, so that future
9580 // cached loads don't need to be checked.
9581 void
9583 {
9588 }
9594 }
9600 }
9604 }
9606 PRBool
9608 {
9613 }
9615 // Only check the tag if we are loading from the cache without
9616 // validation.
9617 PRBool fromCache;
9620 }
9626 }
9632 }
9634 nsXPIDLCString tag;
9637 }
9639 NS_IMETHODIMP
9641 {
9646 #ifdef DEBUG
9650 #endif
9652 }
9653 #ifdef DEBUG
9657 #endif
9660 }
9663 }
9665 NS_IMETHODIMP
9667 {
9670 }
9672 NS_IMETHODIMP
9675 {
9678 // we call the Run() from the main loop to give the channel a
9679 // chance to AsyncOpen() before we suspend it.
9683 }
9685 NS_IMETHODIMP
9687 {
9689 #ifdef DEBUG
9693 #endif
9696 }
9700 }
9703 }