/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- * * The contents of this file are subject to the Mozilla Public * License Version 1.1 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or * implied. See the License for the specific language governing * rights and limitations under the License. * * The Original Code is the Mozilla browser. * * The Initial Developer of the Original Code is Netscape * Communications, Inc. Portions created by Netscape are * Copyright (C) 1999, Mozilla. All Rights Reserved. * * Contributor(s): * Travis Bogard * Pierre Phaneuf * Peter Annema * Dan Rosen */ #include "nsIComponentManager.h" #include "nsIContent.h" #include "nsIDocument.h" #include "nsIDOMDocument.h" #include "nsIDOMElement.h" #include "nsIDocumentViewer.h" #include "nsIDocumentLoaderFactory.h" #include "nsIPluginHost.h" #include "nsCURILoader.h" #include "nsLayoutCID.h" #include "nsDOMCID.h" #include "nsIDOMScriptObjectFactory.h" #include "nsNetUtil.h" #include "nsRect.h" #include "prprf.h" #include "nsIMarkupDocumentViewer.h" #include "nsXPIDLString.h" #include "nsIChromeEventHandler.h" #include "nsIDOMWindowInternal.h" #include "nsIWebBrowserChrome.h" #include "nsPoint.h" #include "nsGfxCIID.h" #include "nsIPrompt.h" #include "nsIAuthPrompt.h" #include "nsTextFormatter.h" #include "nsIHttpEventSink.h" #include "nsISecurityEventSink.h" #include "nsScriptSecurityManager.h" #include "nsDocumentCharsetInfoCID.h" // Local Includes #include "nsDocShell.h" #include "nsDocShellLoadInfo.h" #include "nsCDefaultURIFixup.h" #include "nsDocShellEnumerator.h" // Helper Classes #include "nsDOMError.h" #include "nsEscape.h" // Interfaces Needed #include "nsIHttpChannel.h" #include "nsIDataChannel.h" #include "nsIProgressEventSink.h" #include "nsIWebProgress.h" #include "nsILayoutHistoryState.h" #include "nsITimer.h" #include "nsIFileStream.h" #include "nsISHistoryInternal.h" #include "nsIPrincipal.h" #include "nsPIDOMWindow.h" #include "nsIDOMDocument.h" #include "nsICachingChannel.h" // The following are for bug #13871: Prevent frameset spoofing #include "nsICodebasePrincipal.h" #include "nsIHTMLDocument.h" // For reporting errors with the console service. // These can go away if error reporting is propagated up past nsDocShell. #include "nsIConsoleService.h" #include "nsIScriptError.h" // used to dispatch urls to default protocol handlers #include "nsCExternalHandlerService.h" #include "nsIExternalProtocolService.h" #include "nsIFocusController.h" #include "nsITextToSubURI.h" #include "prlog.h" // this is going away - see // http://bugzilla.mozilla.org/show_bug.cgi?id=71482 #include "nsIBrowserHistory.h" #include "nsIEventStateManager.h" #include "nsIFrame.h" #include "nsIStyleContext.h" // for embedding #include "nsIEmbeddingSiteWindow.h" #include "nsIWebBrowserChromeFocus.h" static NS_DEFINE_IID(kDeviceContextCID, NS_DEVICE_CONTEXT_CID); static NS_DEFINE_CID(kSimpleURICID, NS_SIMPLEURI_CID); static NS_DEFINE_CID(kDocumentCharsetInfoCID, NS_DOCUMENTCHARSETINFO_CID); static NS_DEFINE_CID(kPluginManagerCID, NS_PLUGINMANAGER_CID); static NS_DEFINE_CID(kDOMScriptObjectFactoryCID, NS_DOM_SCRIPT_OBJECT_FACTORY_CID); // // Local function prototypes // /** * Used in AddHeadersToChannel */ static NS_METHOD AHTC_WriteFunc(nsIInputStream * in, void *closure, const char *fromRawSegment, PRUint32 toOffset, PRUint32 count, PRUint32 * writeCount); #ifdef PR_LOGGING static PRLogModuleInfo* gDocShellLog; #endif //***************************************************************************** //*** nsDocShell: Object Management //***************************************************************************** nsDocShell::nsDocShell(): mContentListener(nsnull), mInitInfo(nsnull), mMarginWidth(0), mMarginHeight(0), mItemType(typeContent), mCurrentScrollbarPref(-1, -1), mDefaultScrollbarPref(-1, -1), mInitialPageLoad(PR_TRUE), mAllowPlugins(PR_TRUE), mAllowJavascript(PR_TRUE), mAllowMetaRedirects(PR_TRUE), mAllowSubframes(PR_TRUE), mAllowImages(PR_TRUE), mAppType(nsIDocShell::APP_TYPE_UNKNOWN), mBusyFlags(BUSY_FLAGS_NONE), mEODForCurrentDocument(PR_FALSE), mURIResultedInDocument(PR_FALSE), mUseExternalProtocolHandler(PR_FALSE), mDisallowPopupWindows(PR_FALSE), mIsBeingDestroyed(PR_FALSE), mParent(nsnull), mTreeOwner(nsnull), mChromeEventHandler(nsnull) { NS_INIT_REFCNT(); #ifdef PR_LOGGING if (! gDocShellLog) gDocShellLog = PR_NewLogModule("nsDocShell"); #endif } nsDocShell::~nsDocShell() { Destroy(); } NS_IMETHODIMP nsDocShell::DestroyChildren() { PRInt32 i, n = mChildren.Count(); nsCOMPtr shell; for (i = 0; i < n; i++) { shell = dont_AddRef((nsIDocShellTreeItem *) mChildren.ElementAt(i)); if (!NS_WARN_IF_FALSE(shell, "docshell has null child")) shell->SetParent(nsnull); shell->SetTreeOwner(nsnull); // just clear out the array. When the nsFrameFrame that holds the subshell is // destroyed, then the Destroy() method of that subshell will actually get // called. } mChildren.Clear(); return NS_OK; } //***************************************************************************** // nsDocShell::nsISupports //***************************************************************************** NS_IMPL_THREADSAFE_ADDREF(nsDocShell) NS_IMPL_THREADSAFE_RELEASE(nsDocShell) NS_INTERFACE_MAP_BEGIN(nsDocShell) NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDocShell) NS_INTERFACE_MAP_ENTRY(nsIDocShell) NS_INTERFACE_MAP_ENTRY(nsIDocShellTreeItem) NS_INTERFACE_MAP_ENTRY(nsIDocShellTreeNode) NS_INTERFACE_MAP_ENTRY(nsIDocShellHistory) NS_INTERFACE_MAP_ENTRY(nsIWebNavigation) NS_INTERFACE_MAP_ENTRY(nsIBaseWindow) NS_INTERFACE_MAP_ENTRY(nsIScrollable) NS_INTERFACE_MAP_ENTRY(nsITextScroll) NS_INTERFACE_MAP_ENTRY(nsIDocCharset) NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor) NS_INTERFACE_MAP_ENTRY(nsIScriptGlobalObjectOwner) NS_INTERFACE_MAP_ENTRY(nsIRefreshURI) NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener) NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) NS_INTERFACE_MAP_END_THREADSAFE ///***************************************************************************** // nsDocShell::nsIInterfaceRequestor //***************************************************************************** NS_IMETHODIMP nsDocShell::GetInterface(const nsIID & aIID, void **aSink) { NS_ENSURE_ARG_POINTER(aSink); if (aIID.Equals(NS_GET_IID(nsIURIContentListener)) && NS_SUCCEEDED(EnsureContentListener())) { *aSink = mContentListener; } else if (aIID.Equals(NS_GET_IID(nsIScriptGlobalObject)) && NS_SUCCEEDED(EnsureScriptEnvironment())) { *aSink = mScriptGlobal; } else if (aIID.Equals(NS_GET_IID(nsIDOMWindowInternal)) && NS_SUCCEEDED(EnsureScriptEnvironment())) { NS_ENSURE_SUCCESS(mScriptGlobal-> QueryInterface(NS_GET_IID(nsIDOMWindowInternal), aSink), NS_ERROR_FAILURE); return NS_OK; } else if (aIID.Equals(NS_GET_IID(nsIDOMWindow)) && NS_SUCCEEDED(EnsureScriptEnvironment())) { NS_ENSURE_SUCCESS(mScriptGlobal-> QueryInterface(NS_GET_IID(nsIDOMWindow), aSink), NS_ERROR_FAILURE); return NS_OK; } else if (aIID.Equals(NS_GET_IID(nsIDOMDocument)) && NS_SUCCEEDED(EnsureContentViewer())) { mContentViewer->GetDOMDocument((nsIDOMDocument **) aSink); } else if (aIID.Equals(NS_GET_IID(nsIPrompt))) { nsCOMPtr prompter(do_GetInterface(mTreeOwner)); if (prompter) { *aSink = prompter; NS_ADDREF((nsISupports *) * aSink); return NS_OK; } else return NS_NOINTERFACE; } else if (aIID.Equals(NS_GET_IID(nsIAuthPrompt))) { nsCOMPtr authPrompter(do_GetInterface(mTreeOwner)); if (authPrompter) { *aSink = authPrompter; NS_ADDREF((nsISupports *) * aSink); return NS_OK; } else return NS_NOINTERFACE; } else if (aIID.Equals(NS_GET_IID(nsIProgressEventSink)) || aIID.Equals(NS_GET_IID(nsIHttpEventSink)) || aIID.Equals(NS_GET_IID(nsIWebProgress)) || aIID.Equals(NS_GET_IID(nsISecurityEventSink))) { nsCOMPtr uriLoader(do_GetService(NS_URI_LOADER_CONTRACTID)); NS_ENSURE_TRUE(uriLoader, NS_ERROR_FAILURE); nsCOMPtr docLoader; NS_ENSURE_SUCCESS(uriLoader-> GetDocumentLoaderForContext(NS_STATIC_CAST (nsIDocShell *, this), getter_AddRefs (docLoader)), NS_ERROR_FAILURE); if (docLoader) { nsCOMPtr requestor(do_QueryInterface(docLoader)); return requestor->GetInterface(aIID, aSink); } else return NS_ERROR_FAILURE; } else if (aIID.Equals(NS_GET_IID(nsISHistory))) { nsCOMPtr shistory; nsresult rv = GetSessionHistory(getter_AddRefs(shistory)); if (NS_SUCCEEDED(rv) && shistory) { *aSink = shistory; NS_ADDREF((nsISupports *) * aSink); return NS_OK; } return NS_NOINTERFACE; } else if (aIID.Equals(NS_GET_IID(nsIWebBrowserFind))) { nsresult rv = EnsureFind(); if (NS_FAILED(rv)) return rv; *aSink = mFind; NS_ADDREF((nsISupports*)*aSink); return NS_OK; } else { return QueryInterface(aIID, aSink); } NS_IF_ADDREF(((nsISupports *) * aSink)); return NS_OK; } PRUint32 nsDocShell:: ConvertDocShellLoadInfoToLoadType(nsDocShellInfoLoadType aDocShellLoadType) { PRUint32 loadType = LOAD_NORMAL; switch (aDocShellLoadType) { case nsIDocShellLoadInfo::loadNormal: loadType = LOAD_NORMAL; break; case nsIDocShellLoadInfo::loadNormalReplace: loadType = LOAD_NORMAL_REPLACE; break; case nsIDocShellLoadInfo::loadHistory: loadType = LOAD_HISTORY; break; case nsIDocShellLoadInfo::loadReloadNormal: loadType = LOAD_RELOAD_NORMAL; break; case nsIDocShellLoadInfo::loadReloadBypassCache: loadType = LOAD_RELOAD_BYPASS_CACHE; break; case nsIDocShellLoadInfo::loadReloadBypassProxy: loadType = LOAD_RELOAD_BYPASS_PROXY; break; case nsIDocShellLoadInfo::loadReloadBypassProxyAndCache: loadType = LOAD_RELOAD_BYPASS_PROXY_AND_CACHE; break; case nsIDocShellLoadInfo::loadLink: loadType = LOAD_LINK; break; case nsIDocShellLoadInfo::loadRefresh: loadType = LOAD_REFRESH; break; } return loadType; } nsDocShellInfoLoadType nsDocShell::ConvertLoadTypeToDocShellLoadInfo(PRUint32 aLoadType) { nsDocShellInfoLoadType docShellLoadType = nsIDocShellLoadInfo::loadNormal; switch (aLoadType) { case LOAD_NORMAL: docShellLoadType = nsIDocShellLoadInfo::loadNormal; break; case LOAD_NORMAL_REPLACE: docShellLoadType = nsIDocShellLoadInfo::loadNormalReplace; break; case LOAD_HISTORY: docShellLoadType = nsIDocShellLoadInfo::loadHistory; break; case LOAD_RELOAD_NORMAL: docShellLoadType = nsIDocShellLoadInfo::loadReloadNormal; break; case LOAD_RELOAD_BYPASS_CACHE: docShellLoadType = nsIDocShellLoadInfo::loadReloadBypassCache; break; case LOAD_RELOAD_BYPASS_PROXY: docShellLoadType = nsIDocShellLoadInfo::loadReloadBypassProxy; break; case LOAD_RELOAD_BYPASS_PROXY_AND_CACHE: docShellLoadType = nsIDocShellLoadInfo::loadReloadBypassProxyAndCache; break; case LOAD_LINK: docShellLoadType = nsIDocShellLoadInfo::loadLink; break; case LOAD_REFRESH: docShellLoadType = nsIDocShellLoadInfo::loadRefresh; break; } return docShellLoadType; } //***************************************************************************** // nsDocShell::nsIDocShell //***************************************************************************** NS_IMETHODIMP nsDocShell::LoadURI(nsIURI * aURI, nsIDocShellLoadInfo * aLoadInfo, PRUint32 aLoadFlags) { nsresult rv; nsCOMPtr referrer; nsCOMPtr postStream; nsCOMPtr owner; PRBool inheritOwner = PR_FALSE; PRBool stopActiveDoc = PR_FALSE; nsCOMPtr shEntry; nsXPIDLCString target; PRUint32 loadType = MAKE_LOAD_TYPE(LOAD_NORMAL, aLoadFlags); NS_ENSURE_ARG(aURI); // Extract the info from the DocShellLoadInfo struct... if (aLoadInfo) { aLoadInfo->GetReferrer(getter_AddRefs(referrer)); nsDocShellInfoLoadType lt = nsIDocShellLoadInfo::loadNormal; aLoadInfo->GetLoadType(<); switch (lt) { case nsIDocShellLoadInfo::loadNormal: loadType = LOAD_NORMAL; break; case nsIDocShellLoadInfo::loadNormalReplace: loadType = LOAD_NORMAL_REPLACE; break; case nsIDocShellLoadInfo::loadHistory: loadType = LOAD_HISTORY; break; case nsIDocShellLoadInfo::loadReloadNormal: loadType = LOAD_RELOAD_NORMAL; break; case nsIDocShellLoadInfo::loadReloadBypassCache: loadType = LOAD_RELOAD_BYPASS_CACHE; break; case nsIDocShellLoadInfo::loadReloadBypassProxy: loadType = LOAD_RELOAD_BYPASS_PROXY; break; case nsIDocShellLoadInfo::loadReloadBypassProxyAndCache: loadType = LOAD_RELOAD_BYPASS_PROXY_AND_CACHE; break; case nsIDocShellLoadInfo::loadLink: loadType = LOAD_LINK; break; case nsIDocShellLoadInfo::loadRefresh: loadType = LOAD_REFRESH; break; } aLoadInfo->GetOwner(getter_AddRefs(owner)); aLoadInfo->GetInheritOwner(&inheritOwner); aLoadInfo->GetStopActiveDocument(&stopActiveDoc); aLoadInfo->GetSHEntry(getter_AddRefs(shEntry)); aLoadInfo->GetTarget(getter_Copies(target)); aLoadInfo->GetPostDataStream(getter_AddRefs(postStream)); } #ifdef PR_LOGGING if (PR_LOG_TEST(gDocShellLog, PR_LOG_DEBUG)) { nsXPIDLCString uristr; aURI->GetSpec(getter_Copies(uristr)); PR_LOG(gDocShellLog, PR_LOG_DEBUG, ("nsDocShell[%p]: loading %s with flags 0x%08x", this, uristr.get(), aLoadFlags)); } #endif if (!shEntry && loadType != LOAD_NORMAL_REPLACE && mCurrentURI == nsnull) { /* Check if we are in the middle of loading a subframe whose parent * was originally loaded thro' Session History. ie., you were in a frameset * page, went somewhere else and clicked 'back'. The loading of the root page * is done and we are currently loading one of its children or sub-children. */ nsCOMPtr parentAsItem; GetSameTypeParent(getter_AddRefs(parentAsItem)); // Try to get your SHEntry from your parent if (parentAsItem) { nsCOMPtr parent(do_QueryInterface(parentAsItem)); // XXX: Should we care if this QI fails? if (parent) { parent->GetChildSHEntry(mChildOffset, getter_AddRefs(shEntry)); if (shEntry) { //Get the proper loadType from the SHEntry. PRUint32 lt; shEntry->GetLoadType(<); // Convert the DocShellInfoLoadType returned by the // previous function to loadType loadType = ConvertDocShellLoadInfoToLoadType((nsDocShellInfoLoadType) lt); } } } } if (shEntry) { // Load is from SH. SH does normal load only PR_LOG(gDocShellLog, PR_LOG_DEBUG, ("nsDocShell[%p]: loading from session history", this)); rv = LoadHistoryEntry(shEntry, loadType); } // Perform the load... else { nsAutoString windowTarget; windowTarget.AssignWithConversion(target); rv = InternalLoad(aURI, referrer, owner, inheritOwner, stopActiveDoc, windowTarget.GetUnicode(), postStream, nsnull, // No headers stream loadType, nsnull); // No SHEntry } return rv; } NS_IMETHODIMP nsDocShell::LoadStream(nsIInputStream * aStream, nsIURI * aURI, const char *aContentType, PRInt32 aContentLen, nsIDocShellLoadInfo * aLoadInfo) { NS_ENSURE_ARG(aStream); NS_ENSURE_ARG(aContentType); NS_ENSURE_ARG(aContentLen); // if the caller doesn't pass in a URI we need to create a dummy URI. necko // currently requires a URI in various places during the load. Some consumers // do as well. nsCOMPtr uri = aURI; if (!uri) { // HACK ALERT nsresult rv = NS_OK; uri = do_CreateInstance(kSimpleURICID, &rv); if (NS_FAILED(rv)) return rv; // Make sure that the URI spec "looks" like a protocol and path... // For now, just use a bogus protocol called "internal" rv = uri->SetSpec("internal:load-stream"); if (NS_FAILED(rv)) return rv; } LoadType loadType = LOAD_NORMAL; if (aLoadInfo) { nsDocShellInfoLoadType lt = nsIDocShellLoadInfo::loadNormal; (void) aLoadInfo->GetLoadType(<); switch (lt) { case nsIDocShellLoadInfo::loadNormal: loadType = LOAD_NORMAL; break; case nsIDocShellLoadInfo::loadNormalReplace: loadType = LOAD_NORMAL_REPLACE; break; case nsIDocShellLoadInfo::loadHistory: loadType = LOAD_HISTORY; break; case nsIDocShellLoadInfo::loadReloadNormal: loadType = LOAD_RELOAD_NORMAL; break; case nsIDocShellLoadInfo::loadReloadBypassCache: loadType = LOAD_RELOAD_BYPASS_CACHE; break; case nsIDocShellLoadInfo::loadReloadBypassProxy: loadType = LOAD_RELOAD_BYPASS_PROXY; break; case nsIDocShellLoadInfo::loadReloadBypassProxyAndCache: loadType = LOAD_RELOAD_BYPASS_PROXY_AND_CACHE; break; case nsIDocShellLoadInfo::loadLink: loadType = LOAD_LINK; break; case nsIDocShellLoadInfo::loadRefresh: loadType = LOAD_REFRESH; break; } } NS_ENSURE_SUCCESS(StopLoad(), NS_ERROR_FAILURE); // Cancel any timers that were set for this loader. (void) CancelRefreshURITimers(); mLoadType = loadType; // build up a channel for this stream. nsCOMPtr channel; NS_ENSURE_SUCCESS(NS_NewInputStreamChannel (getter_AddRefs(channel), uri, aStream, aContentType, aContentLen), NS_ERROR_FAILURE); nsCOMPtr uriLoader(do_GetService(NS_URI_LOADER_CONTRACTID)); NS_ENSURE_TRUE(uriLoader, NS_ERROR_FAILURE); NS_ENSURE_SUCCESS(DoChannelLoad (channel, nsIURILoader::viewNormal, uriLoader), NS_ERROR_FAILURE); return NS_OK; } NS_IMETHODIMP nsDocShell::CreateLoadInfo(nsIDocShellLoadInfo ** aLoadInfo) { nsDocShellLoadInfo *loadInfo = new nsDocShellLoadInfo(); NS_ENSURE_TRUE(loadInfo, NS_ERROR_OUT_OF_MEMORY); nsCOMPtr localRef(loadInfo); *aLoadInfo = localRef; NS_ADDREF(*aLoadInfo); return NS_OK; } NS_IMETHODIMP nsDocShell::StopLoad() { // Cancel any timers that were set for this loader. CancelRefreshURITimers(); if (mLoadCookie) { nsCOMPtr uriLoader = do_GetService(NS_URI_LOADER_CONTRACTID); if (uriLoader) uriLoader->Stop(mLoadCookie); } PRInt32 n; PRInt32 count = mChildren.Count(); for (n = 0; n < count; n++) { nsIDocShellTreeItem *shellItem = (nsIDocShellTreeItem *) mChildren.ElementAt(n); nsCOMPtr shell(do_QueryInterface(shellItem)); if (shell) shell->StopLoad(); } return NS_OK; } // // Bug 13871: Prevent frameset spoofing // Check if origin document uri is the equivalent to target's principal. // This takes into account subdomain checking if document.domain is set for // Nav 4.x compatability. // // The following was derived from nsCodeBasePrincipal::Equals but in addition // to the host PL_strcmp, it accepts a subdomain (nsHTMLDocument::SetDomain) // if the document.domain was set. // static PRBool SameOrSubdomainOfTarget(nsIURI* aOriginURI, nsIURI* aTargetURI, PRBool aDocumentDomainSet) { nsXPIDLCString targetScheme; nsresult rv = aTargetURI->GetScheme(getter_Copies(targetScheme)); NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && targetScheme, PR_TRUE); nsXPIDLCString originScheme; rv = aOriginURI->GetScheme(getter_Copies(originScheme)); NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && originScheme, PR_TRUE); if (PL_strcmp(targetScheme, originScheme)) return PR_FALSE; // Different schemes - check fails if (! PL_strcmp(targetScheme, "file")) return PR_TRUE; // All file: urls are considered to have the same origin. if (! PL_strcmp(targetScheme, "imap") || ! PL_strcmp(targetScheme, "mailbox") || ! PL_strcmp(targetScheme, "news")) { // Each message is a distinct trust domain; use the whole spec for comparison nsXPIDLCString targetSpec; rv =aTargetURI->GetSpec(getter_Copies(targetSpec)); NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && targetSpec, PR_TRUE); nsXPIDLCString originSpec; rv = aOriginURI->GetSpec(getter_Copies(originSpec)); NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && originSpec, PR_TRUE); return (! PL_strcmp(targetSpec, originSpec)); // True if full spec is same, false otherwise } // Compare ports. int targetPort, originPort; rv = aTargetURI->GetPort(&targetPort); NS_ENSURE_TRUE(NS_SUCCEEDED(rv), PR_TRUE); rv = aOriginURI->GetPort(&originPort); NS_ENSURE_TRUE(NS_SUCCEEDED(rv), PR_TRUE); if (targetPort != originPort) return PR_FALSE; // Different port - check fails // Need to check the hosts nsXPIDLCString targetHost; rv = aTargetURI->GetHost(getter_Copies(targetHost)); NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && targetHost, PR_TRUE); nsXPIDLCString originHost; rv = aOriginURI->GetHost(getter_Copies(originHost)); NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && originHost, PR_TRUE); if (!PL_strcmp(targetHost, originHost)) return PR_TRUE; // Hosts are the same - check passed // If document.domain was set, do the relaxed check // Right align hostnames and compare - ensure preceeding char is . or / if (aDocumentDomainSet) { int targetHostLen = PL_strlen(targetHost); int originHostLen = PL_strlen(originHost); int prefixChar = originHostLen-targetHostLen-1; return ((originHostLen > targetHostLen) && (! PL_strcmp((originHost+prefixChar+1), targetHost)) && (originHost[prefixChar] == '.' || originHost[prefixChar] == '/')); } return PR_FALSE; // document.domain not set and hosts not same - check failed } // // Bug 13871: Prevent frameset spoofing // // This routine answers: 'Is origin's document from same domain as target's document?' // Be optimistic that domain is same - error cases all answer 'yes'. // // We have to compare the URI of the actual document loaded in the origin, // ignoring any document.domain that was set, with the principal URI of the // target (including any document.domain that was set). This puts control // of loading in the hands of the target, which is more secure. (per Nav 4.x) // static PRBool ValidateOrigin(nsIDocShellTreeItem* aOriginTreeItem, nsIDocShellTreeItem* aTargetTreeItem) { // Get origin document uri (ignoring document.domain) nsCOMPtr originWebNav(do_QueryInterface(aOriginTreeItem)); NS_ENSURE_TRUE(originWebNav, PR_TRUE); nsCOMPtr originDocumentURI; nsresult rv = originWebNav->GetCurrentURI(getter_AddRefs(originDocumentURI)); NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && originDocumentURI, PR_TRUE); // Get target principal uri (including document.domain) nsCOMPtr targetDOMDocument(do_GetInterface(aTargetTreeItem)); NS_ENSURE_TRUE(targetDOMDocument, NS_ERROR_FAILURE); nsCOMPtr targetDocument(do_QueryInterface(targetDOMDocument)); NS_ENSURE_TRUE(targetDocument, NS_ERROR_FAILURE); nsCOMPtr targetPrincipal; rv = targetDocument->GetPrincipal(getter_AddRefs(targetPrincipal)); NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && targetPrincipal, rv); nsCOMPtr targetCodebasePrincipal(do_QueryInterface(targetPrincipal)); NS_ENSURE_TRUE(targetCodebasePrincipal, PR_TRUE); nsCOMPtr targetPrincipalURI; rv = targetCodebasePrincipal->GetURI(getter_AddRefs(targetPrincipalURI)); NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && targetPrincipalURI, PR_TRUE); // Find out if document.domain was set for HTML documents PRBool documentDomainSet = PR_FALSE; nsCOMPtr targetHTMLDocument(do_QueryInterface(targetDocument)); // If we don't have an HTML document, fall through with documentDomainSet false if (targetHTMLDocument) { targetHTMLDocument->WasDomainSet(&documentDomainSet); } // Is origin same principal or a subdomain of target's document.domain // Compare actual URI of origin document, not origin principal's URI. (Per Nav 4.x) return SameOrSubdomainOfTarget(originDocumentURI, targetPrincipalURI, documentDomainSet); } nsresult nsDocShell::FindTarget(const PRUnichar *aWindowTarget, PRBool *aIsNewWindow, nsIDocShell **aResult) { nsresult rv; nsAutoString name(aWindowTarget); nsCOMPtr treeItem; PRBool mustMakeNewWindow = PR_FALSE; *aResult = nsnull; *aIsNewWindow = PR_FALSE; if(!name.Length() || name.EqualsIgnoreCase("_self")) { *aResult = this; } else if (name.EqualsIgnoreCase("_blank") || name.EqualsIgnoreCase("_new")) { mustMakeNewWindow = PR_TRUE; name.AssignWithConversion(""); } else if(name.EqualsIgnoreCase("_parent")) { GetSameTypeParent(getter_AddRefs(treeItem)); if(!treeItem) *aResult = this; } else if(name.EqualsIgnoreCase("_top")) { GetSameTypeRootTreeItem(getter_AddRefs(treeItem)); if(!treeItem) *aResult = this; } else if(name.EqualsIgnoreCase("_content")) { if (mTreeOwner) mTreeOwner->FindItemWithName(name.get(), nsnull, getter_AddRefs(treeItem)); else { NS_ERROR("Someone isn't setting up the tree owner. " "You might like to try that. " "Things will.....you know, work."); } } else { // Try to locate the target window... FindItemWithName(name.get(), nsnull, getter_AddRefs(treeItem)); // The named window cannot be found so it must be created to receive // the channel data. if (!treeItem) { mustMakeNewWindow = PR_TRUE; } // Bug 13871: Prevent frameset spoofing // See BugSplat 336170, 338737 and XP_FindNamedContextInList in // the classic codebase // Per Nav's behaviour: // - pref controlled: "browser.frame.validate_origin" // (mValidateOrigin) // - allow load if host of target or target's parent is same // as host of origin // - allow load if target is a top level window // Check to see if pref is true if (mValidateOrigin && treeItem) { // Is origin frame from the same domain as target frame? if (! ValidateOrigin(this, treeItem)) { // No. Is origin frame from the same domain as target's parent? nsCOMPtr targetParentTreeItem; rv = treeItem->GetSameTypeParent(getter_AddRefs(targetParentTreeItem)); if (NS_SUCCEEDED(rv) && targetParentTreeItem) { if (! ValidateOrigin(this, targetParentTreeItem)) { // Neither is from the origin domain, send load to a new window (_blank) mustMakeNewWindow = PR_TRUE; name.AssignWithConversion(""); } // else (target's parent from origin domain) allow this load } // else (no parent) allow this load since shell is a toplevel window } // else (target from origin domain) allow this load } // else (pref is false) allow this load } if (mustMakeNewWindow) { nsCOMPtr newWindow; nsCOMPtr parentWindow; // This DocShell is the parent window parentWindow = do_GetInterface(NS_STATIC_CAST(nsIDocShell*, this)); if (!parentWindow) { NS_ASSERTION(0, "Cant get nsIDOMWindowInternal from nsDocShell!"); return NS_ERROR_FAILURE; } rv = parentWindow->Open(NS_LITERAL_STRING(""), // URL to load name, // Window name nsDependentString(nsnull), // Window features getter_AddRefs(newWindow)); if (NS_FAILED(rv)) return rv; // Get the DocShell from the new window... nsCOMPtr sgo; sgo = do_QueryInterface(newWindow, &rv); if (NS_FAILED(rv)) return rv; // This will AddRef() aResult... rv = sgo->GetDocShell(aResult); // If all went well, indicate that a new window has been created. if (*aResult) { *aIsNewWindow = PR_TRUE; } return rv; } else { if (treeItem) { NS_ASSERTION(!*aResult, "aResult should be null if treeItem is set!"); treeItem->QueryInterface(NS_GET_IID(nsIDocShell), (void **)aResult); } else { NS_IF_ADDREF(*aResult); } } return NS_OK; } NS_IMETHODIMP nsDocShell::GetPresContext(nsIPresContext ** aPresContext) { nsresult rv = NS_OK; NS_ENSURE_ARG_POINTER(aPresContext); *aPresContext = nsnull; if (mContentViewer) { nsCOMPtr docv(do_QueryInterface(mContentViewer)); if (docv) { rv = docv->GetPresContext(*aPresContext); } } // Fail silently, if no PresContext is available... return rv; } NS_IMETHODIMP nsDocShell::GetPresShell(nsIPresShell ** aPresShell) { nsresult rv = NS_OK; NS_ENSURE_ARG_POINTER(aPresShell); *aPresShell = nsnull; nsCOMPtr presContext; (void) GetPresContext(getter_AddRefs(presContext)); if (presContext) { rv = presContext->GetShell(aPresShell); } return rv; } NS_IMETHODIMP nsDocShell::GetContentViewer(nsIContentViewer ** aContentViewer) { NS_ENSURE_ARG_POINTER(aContentViewer); *aContentViewer = mContentViewer; NS_IF_ADDREF(*aContentViewer); return NS_OK; } NS_IMETHODIMP nsDocShell::SetChromeEventHandler(nsIChromeEventHandler * aChromeEventHandler) { // Weak reference. Don't addref. mChromeEventHandler = aChromeEventHandler; return NS_OK; } NS_IMETHODIMP nsDocShell::GetChromeEventHandler(nsIChromeEventHandler ** aChromeEventHandler) { NS_ENSURE_ARG_POINTER(aChromeEventHandler); *aChromeEventHandler = mChromeEventHandler; NS_IF_ADDREF(*aChromeEventHandler); return NS_OK; } NS_IMETHODIMP nsDocShell::GetParentURIContentListener(nsIURIContentListener ** aParent) { NS_ENSURE_ARG_POINTER(aParent); NS_ENSURE_SUCCESS(EnsureContentListener(), NS_ERROR_FAILURE); return mContentListener->GetParentContentListener(aParent); } NS_IMETHODIMP nsDocShell::SetParentURIContentListener(nsIURIContentListener * aParent) { NS_ENSURE_SUCCESS(EnsureContentListener(), NS_ERROR_FAILURE); return mContentListener->SetParentContentListener(aParent); } NS_IMETHODIMP nsDocShell::GetCharset(PRUnichar** aCharset) { NS_ENSURE_ARG_POINTER(aCharset); *aCharset = nsnull; nsCOMPtr presShell; nsCOMPtr doc; GetPresShell(getter_AddRefs(presShell)); NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE); presShell->GetDocument(getter_AddRefs(doc)); NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE); nsAutoString charset; NS_ENSURE_SUCCESS(doc->GetDocumentCharacterSet(charset), NS_ERROR_FAILURE); *aCharset = charset.ToNewUnicode(); return NS_OK; } NS_IMETHODIMP nsDocShell::SetCharset(const PRUnichar* aCharset) { // set the default charset nsCOMPtr viewer; GetContentViewer(getter_AddRefs(viewer)); if (viewer) { nsCOMPtr muDV(do_QueryInterface(viewer)); if (muDV) { NS_ENSURE_SUCCESS(muDV->SetDefaultCharacterSet(aCharset), NS_ERROR_FAILURE); } } // set the charset override nsCOMPtr dcInfo; GetDocumentCharsetInfo(getter_AddRefs(dcInfo)); if (dcInfo) { nsCOMPtr csAtom; csAtom = dont_AddRef(NS_NewAtom(aCharset)); dcInfo->SetForcedCharset(csAtom); } return NS_OK; } NS_IMETHODIMP nsDocShell::GetDocumentCharsetInfo(nsIDocumentCharsetInfo ** aDocumentCharsetInfo) { NS_ENSURE_ARG_POINTER(aDocumentCharsetInfo); // if the mDocumentCharsetInfo does not exist already, we create it now if (!mDocumentCharsetInfo) { nsresult res = nsComponentManager::CreateInstance(kDocumentCharsetInfoCID, NULL, NS_GET_IID (nsIDocumentCharsetInfo), getter_AddRefs (mDocumentCharsetInfo)); if (NS_FAILED(res)) return NS_ERROR_FAILURE; } *aDocumentCharsetInfo = mDocumentCharsetInfo; NS_IF_ADDREF(*aDocumentCharsetInfo); return NS_OK; } NS_IMETHODIMP nsDocShell::SetDocumentCharsetInfo(nsIDocumentCharsetInfo * aDocumentCharsetInfo) { mDocumentCharsetInfo = aDocumentCharsetInfo; return NS_OK; } NS_IMETHODIMP nsDocShell::GetAllowPlugins(PRBool * aAllowPlugins) { NS_ENSURE_ARG_POINTER(aAllowPlugins); *aAllowPlugins = mAllowPlugins; return NS_OK; } NS_IMETHODIMP nsDocShell::SetAllowPlugins(PRBool aAllowPlugins) { mAllowPlugins = aAllowPlugins; //XXX should enable or disable a plugin host return NS_OK; } NS_IMETHODIMP nsDocShell::GetAllowJavascript(PRBool * aAllowJavascript) { NS_ENSURE_ARG_POINTER(aAllowJavascript); *aAllowJavascript = mAllowJavascript; return NS_OK; } NS_IMETHODIMP nsDocShell::SetAllowJavascript(PRBool aAllowJavascript) { mAllowJavascript = aAllowJavascript; return NS_OK; } NS_IMETHODIMP nsDocShell::GetAllowMetaRedirects(PRBool * aReturn) { NS_ENSURE_ARG_POINTER(aReturn); *aReturn = mAllowMetaRedirects; return NS_OK; } NS_IMETHODIMP nsDocShell::SetAllowMetaRedirects(PRBool aValue) { mAllowMetaRedirects = aValue; return NS_OK; } NS_IMETHODIMP nsDocShell::GetAllowSubframes(PRBool * aAllowSubframes) { NS_ENSURE_ARG_POINTER(aAllowSubframes); *aAllowSubframes = mAllowSubframes; return NS_OK; } NS_IMETHODIMP nsDocShell::SetAllowSubframes(PRBool aAllowSubframes) { mAllowSubframes = aAllowSubframes; return NS_OK; } NS_IMETHODIMP nsDocShell::GetAllowImages(PRBool * aAllowImages) { NS_ENSURE_ARG_POINTER(aAllowImages); *aAllowImages = mAllowImages; return NS_OK; } NS_IMETHODIMP nsDocShell::SetAllowImages(PRBool aAllowImages) { mAllowImages = aAllowImages; return NS_OK; } NS_IMETHODIMP nsDocShell::GetDocShellEnumerator(PRInt32 aItemType, PRInt32 aDirection, nsISimpleEnumerator **outEnum) { NS_ENSURE_ARG_POINTER(outEnum); *outEnum = nsnull; nsDocShellEnumerator* docShellEnum; if (aDirection == ENUMERATE_FORWARDS) docShellEnum = new nsDocShellForwardsEnumerator; else docShellEnum = new nsDocShellBackwardsEnumerator; if (!docShellEnum) return NS_ERROR_OUT_OF_MEMORY; nsresult rv = docShellEnum->SetEnumDocShellType(aItemType); if (NS_FAILED(rv)) return rv; rv = docShellEnum->SetEnumerationRootItem((nsIDocShellTreeItem *)this); if (NS_FAILED(rv)) return rv; rv = docShellEnum->First(); if (NS_FAILED(rv)) return rv; docShellEnum->AddRef(); // ensure we don't lose the last ref inside the QueryInterface rv = docShellEnum->QueryInterface(NS_GET_IID(nsISimpleEnumerator), (void **)outEnum); docShellEnum->Release(); return rv; } NS_IMETHODIMP nsDocShell::GetAppType(PRUint32 * aAppType) { *aAppType = mAppType; return NS_OK; } NS_IMETHODIMP nsDocShell::SetAppType(PRUint32 aAppType) { mAppType = aAppType; return NS_OK; } NS_IMETHODIMP nsDocShell::GetZoom(float *zoom) { NS_ENSURE_ARG_POINTER(zoom); NS_ENSURE_SUCCESS(EnsureDeviceContext(), NS_ERROR_FAILURE); NS_ENSURE_SUCCESS(mDeviceContext->GetZoom(*zoom), NS_ERROR_FAILURE); return NS_OK; } NS_IMETHODIMP nsDocShell::SetZoom(float zoom) { NS_ENSURE_SUCCESS(EnsureDeviceContext(), NS_ERROR_FAILURE); mDeviceContext->SetZoom(zoom); // get the pres shell nsCOMPtr presShell; NS_ENSURE_SUCCESS(GetPresShell(getter_AddRefs(presShell)), NS_ERROR_FAILURE); NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE); // get the view manager nsCOMPtr vm; NS_ENSURE_SUCCESS(presShell->GetViewManager(getter_AddRefs(vm)), NS_ERROR_FAILURE); NS_ENSURE_TRUE(vm, NS_ERROR_FAILURE); // get the root scrollable view nsIScrollableView *scrollableView = nsnull; vm->GetRootScrollableView(&scrollableView); if (scrollableView) scrollableView->ComputeScrollOffsets(); // get the root view nsIView *rootView = nsnull; // views are not ref counted vm->GetRootView(rootView); if (rootView) vm->UpdateView(rootView, 0); return NS_OK; } NS_IMETHODIMP nsDocShell::GetMarginWidth(PRInt32 * aWidth) { NS_ENSURE_ARG_POINTER(aWidth); *aWidth = mMarginWidth; return NS_OK; } NS_IMETHODIMP nsDocShell::SetMarginWidth(PRInt32 aWidth) { mMarginWidth = aWidth; return NS_OK; } NS_IMETHODIMP nsDocShell::GetMarginHeight(PRInt32 * aHeight) { NS_ENSURE_ARG_POINTER(aHeight); *aHeight = mMarginHeight; return NS_OK; } NS_IMETHODIMP nsDocShell::SetMarginHeight(PRInt32 aHeight) { mMarginHeight = aHeight; return NS_OK; } NS_IMETHODIMP nsDocShell::GetBusyFlags(PRUint32 * aBusyFlags) { NS_ENSURE_ARG_POINTER(aBusyFlags); *aBusyFlags = mBusyFlags; return NS_OK; } //***************************************************************************** // nsDocShell::nsIDocShellTreeItem //***************************************************************************** NS_IMETHODIMP nsDocShell::GetName(PRUnichar ** aName) { NS_ENSURE_ARG_POINTER(aName); *aName = mName.ToNewUnicode(); return NS_OK; } NS_IMETHODIMP nsDocShell::SetName(const PRUnichar * aName) { mName = aName; // this does a copy of aName return NS_OK; } NS_IMETHODIMP nsDocShell::GetItemType(PRInt32 * aItemType) { NS_ENSURE_ARG_POINTER(aItemType); *aItemType = mItemType; return NS_OK; } NS_IMETHODIMP nsDocShell::SetItemType(PRInt32 aItemType) { NS_ENSURE_ARG((aItemType == typeChrome) || (typeContent == aItemType)); NS_ENSURE_STATE(!mParent); mItemType = aItemType; return NS_OK; } NS_IMETHODIMP nsDocShell::GetParent(nsIDocShellTreeItem ** aParent) { NS_ENSURE_ARG_POINTER(aParent); *aParent = mParent; NS_IF_ADDREF(*aParent); return NS_OK; } NS_IMETHODIMP nsDocShell::SetParent(nsIDocShellTreeItem * aParent) { // null aParent is ok /* Note this doesn't do an addref on purpose. This is because the parent is an implied lifetime. We don't want to create a cycle by refcounting the parent. */ mParent = aParent; nsCOMPtr parentURIListener(do_GetInterface(aParent)); if (parentURIListener) SetParentURIContentListener(parentURIListener); return NS_OK; } NS_IMETHODIMP nsDocShell::GetSameTypeParent(nsIDocShellTreeItem ** aParent) { NS_ENSURE_ARG_POINTER(aParent); *aParent = nsnull; if (!mParent) return NS_OK; PRInt32 parentType; NS_ENSURE_SUCCESS(mParent->GetItemType(&parentType), NS_ERROR_FAILURE); if (parentType == mItemType) { *aParent = mParent; NS_ADDREF(*aParent); } return NS_OK; } NS_IMETHODIMP nsDocShell::GetRootTreeItem(nsIDocShellTreeItem ** aRootTreeItem) { NS_ENSURE_ARG_POINTER(aRootTreeItem); *aRootTreeItem = NS_STATIC_CAST(nsIDocShellTreeItem *, this); nsCOMPtr parent; NS_ENSURE_SUCCESS(GetParent(getter_AddRefs(parent)), NS_ERROR_FAILURE); while (parent) { *aRootTreeItem = parent; NS_ENSURE_SUCCESS((*aRootTreeItem)->GetParent(getter_AddRefs(parent)), NS_ERROR_FAILURE); } NS_ADDREF(*aRootTreeItem); return NS_OK; } NS_IMETHODIMP nsDocShell::GetSameTypeRootTreeItem(nsIDocShellTreeItem ** aRootTreeItem) { NS_ENSURE_ARG_POINTER(aRootTreeItem); *aRootTreeItem = NS_STATIC_CAST(nsIDocShellTreeItem *, this); nsCOMPtr parent; NS_ENSURE_SUCCESS(GetSameTypeParent(getter_AddRefs(parent)), NS_ERROR_FAILURE); while (parent) { *aRootTreeItem = parent; NS_ENSURE_SUCCESS((*aRootTreeItem)-> GetSameTypeParent(getter_AddRefs(parent)), NS_ERROR_FAILURE); } NS_ADDREF(*aRootTreeItem); return NS_OK; } NS_IMETHODIMP nsDocShell::FindItemWithName(const PRUnichar * aName, nsISupports * aRequestor, nsIDocShellTreeItem ** _retval) { NS_ENSURE_ARG(aName); NS_ENSURE_ARG_POINTER(_retval); *_retval = nsnull; // if we don't find one, we return NS_OK and a null result // This QI may fail, but the places where we want to compare, comparing // against nsnull serves the same purpose. nsCOMPtr reqAsTreeItem(do_QueryInterface(aRequestor)); // First we check our name. if (mName.EqualsWithConversion(aName)) { *_retval = NS_STATIC_CAST(nsIDocShellTreeItem *, this); NS_ADDREF(*_retval); return NS_OK; } // Second we check our children making sure not to ask a child if it // is the aRequestor. NS_ENSURE_SUCCESS(FindChildWithName(aName, PR_TRUE, PR_TRUE, reqAsTreeItem, _retval), NS_ERROR_FAILURE); if (*_retval) return NS_OK; // Third if we have a parent and it isn't the requestor then we should ask // it to do the search. If it is the requestor we should just stop here // and let the parent do the rest. // If we don't have a parent, then we should ask the docShellTreeOwner to do // the search. if (mParent) { if (mParent == reqAsTreeItem.get()) return NS_OK; PRInt32 parentType; mParent->GetItemType(&parentType); if (parentType == mItemType) { NS_ENSURE_SUCCESS(mParent->FindItemWithName(aName, NS_STATIC_CAST (nsIDocShellTreeItem *, this), _retval), NS_ERROR_FAILURE); return NS_OK; } // If the parent isn't of the same type fall through and ask tree owner. } // This QI may fail, but comparing against null serves the same purpose nsCOMPtr reqAsTreeOwner(do_QueryInterface(aRequestor)); if (mTreeOwner && (mTreeOwner != reqAsTreeOwner.get())) { NS_ENSURE_SUCCESS(mTreeOwner->FindItemWithName(aName, NS_STATIC_CAST (nsIDocShellTreeItem *, this), _retval), NS_ERROR_FAILURE); } return NS_OK; } NS_IMETHODIMP nsDocShell::GetTreeOwner(nsIDocShellTreeOwner ** aTreeOwner) { NS_ENSURE_ARG_POINTER(aTreeOwner); *aTreeOwner = mTreeOwner; NS_IF_ADDREF(*aTreeOwner); return NS_OK; } NS_IMETHODIMP nsDocShell::SetTreeOwner(nsIDocShellTreeOwner * aTreeOwner) { // Don't automatically set the progress based on the tree owner for frames if (!IsFrame()) { nsCOMPtr webProgress(do_QueryInterface(mLoadCookie)); if (webProgress) { nsCOMPtr oldListener(do_QueryInterface(mTreeOwner)); nsCOMPtr newListener(do_QueryInterface(aTreeOwner)); if (oldListener) { webProgress->RemoveProgressListener(oldListener); } if (newListener) { webProgress->AddProgressListener(newListener); } } } mTreeOwner = aTreeOwner; // Weak reference per API PRInt32 i, n = mChildren.Count(); for (i = 0; i < n; i++) { nsIDocShellTreeItem *child = (nsIDocShellTreeItem *) mChildren.ElementAt(i); // doesn't addref the result NS_ENSURE_TRUE(child, NS_ERROR_FAILURE); PRInt32 childType = ~mItemType; // Set it to not us in case the get fails child->GetItemType(&childType); // We don't care if this fails, if it does we won't set the owner if (childType == mItemType) child->SetTreeOwner(aTreeOwner); } return NS_OK; } NS_IMETHODIMP nsDocShell::SetChildOffset(PRInt32 aChildOffset) { mChildOffset = aChildOffset; return NS_OK; } NS_IMETHODIMP nsDocShell::GetChildOffset(PRInt32 * aChildOffset) { NS_ENSURE_ARG_POINTER(aChildOffset); *aChildOffset = mChildOffset; return NS_OK; } //***************************************************************************** // nsDocShell::nsIDocShellTreeNode //***************************************************************************** NS_IMETHODIMP nsDocShell::GetChildCount(PRInt32 * aChildCount) { NS_ENSURE_ARG_POINTER(aChildCount); *aChildCount = mChildren.Count(); return NS_OK; } NS_IMETHODIMP nsDocShell::AddChild(nsIDocShellTreeItem * aChild) { NS_ENSURE_ARG_POINTER(aChild); NS_ENSURE_SUCCESS(aChild->SetParent(this), NS_ERROR_FAILURE); mChildren.AppendElement(aChild); NS_ADDREF(aChild); // Set the child's index in the parent's children list // XXX What if the parent had different types of children? // XXX in that case docshell hierarchyand SH hierarchy won't match. PRInt32 childCount = mChildren.Count(); aChild->SetChildOffset(childCount - 1); /* Set the child's global history if the parent has one */ if (mGlobalHistory) { nsCOMPtr dsHistoryChild(do_QueryInterface(aChild)); if (dsHistoryChild) dsHistoryChild->SetGlobalHistory(mGlobalHistory); } PRInt32 childType = ~mItemType; // Set it to not us in case the get fails aChild->GetItemType(&childType); if (childType != mItemType) return NS_OK; // Everything below here is only done when the child is the same type. aChild->SetTreeOwner(mTreeOwner); nsCOMPtr childAsDocShell(do_QueryInterface(aChild)); if (!childAsDocShell) return NS_OK; // Do some docShell Specific stuff. nsXPIDLString defaultCharset; nsXPIDLString forceCharset; NS_ENSURE_TRUE(mContentViewer, NS_ERROR_FAILURE); nsCOMPtr muDV = do_QueryInterface(mContentViewer); if (muDV) { NS_ENSURE_SUCCESS(muDV-> GetDefaultCharacterSet(getter_Copies(defaultCharset)), NS_ERROR_FAILURE); NS_ENSURE_SUCCESS(muDV-> GetForceCharacterSet(getter_Copies(forceCharset)), NS_ERROR_FAILURE); } nsCOMPtr childCV; NS_ENSURE_SUCCESS(childAsDocShell-> GetContentViewer(getter_AddRefs(childCV)), NS_ERROR_FAILURE); if (childCV) { nsCOMPtr childmuDV = do_QueryInterface(childCV); if (childmuDV) { NS_ENSURE_SUCCESS(childmuDV->SetDefaultCharacterSet(defaultCharset), NS_ERROR_FAILURE); NS_ENSURE_SUCCESS(childmuDV->SetForceCharacterSet(forceCharset), NS_ERROR_FAILURE); } } // Now take this document's charset and set the parentCharset field of the // child's DocumentCharsetInfo to it. We'll later use that field, in the // loading process, for the charset choosing algorithm. // If we fail, at any point, we just return NS_OK. // This code has some performance impact. But this will be reduced when // the current charset will finally be stored as an Atom, avoiding the // alias resolution extra look-up. // we are NOT going to propagate the charset is this Chrome's docshell if (mItemType == nsIDocShellTreeItem::typeChrome) return NS_OK; nsresult res = NS_OK; // get the child's docCSInfo object nsCOMPtr dcInfo = NULL; res = childAsDocShell->GetDocumentCharsetInfo(getter_AddRefs(dcInfo)); if (NS_FAILED(res) || (!dcInfo)) return NS_OK; // get the parent's current charset nsCOMPtr docv(do_QueryInterface(mContentViewer)); if (!docv) return NS_OK; nsCOMPtr doc; res = docv->GetDocument(*getter_AddRefs(doc)); if (NS_FAILED(res) || (!doc)) return NS_OK; nsAutoString parentCS; res = doc->GetDocumentCharacterSet(parentCS); if (NS_FAILED(res)) return NS_OK; // set the child's parentCharset nsCOMPtr parentCSAtom(dont_AddRef(NS_NewAtom(parentCS))); res = dcInfo->SetParentCharset(parentCSAtom); if (NS_FAILED(res)) return NS_OK; // printf("### 1 >>> Adding child. Parent CS = %s. ItemType = %d.\n", parentCS.ToNewCString(), mItemType); return NS_OK; } NS_IMETHODIMP nsDocShell::RemoveChild(nsIDocShellTreeItem * aChild) { NS_ENSURE_ARG_POINTER(aChild); if (mChildren.RemoveElement(aChild)) { aChild->SetParent(nsnull); aChild->SetTreeOwner(nsnull); NS_RELEASE(aChild); } else NS_ENSURE_TRUE(PR_FALSE, NS_ERROR_INVALID_ARG); return NS_OK; } NS_IMETHODIMP nsDocShell::GetChildAt(PRInt32 aIndex, nsIDocShellTreeItem ** aChild) { NS_ENSURE_ARG_POINTER(aChild); *aChild = (nsIDocShellTreeItem *) mChildren.ElementAt(aIndex); NS_IF_ADDREF(*aChild); return NS_OK; } NS_IMETHODIMP nsDocShell::FindChildWithName(const PRUnichar * aName, PRBool aRecurse, PRBool aSameType, nsIDocShellTreeItem * aRequestor, nsIDocShellTreeItem ** _retval) { NS_ENSURE_ARG(aName); NS_ENSURE_ARG_POINTER(_retval); *_retval = nsnull; // if we don't find one, we return NS_OK and a null result nsAutoString name(aName); nsXPIDLString childName; PRInt32 i, n = mChildren.Count(); for (i = 0; i < n; i++) { nsIDocShellTreeItem *child = (nsIDocShellTreeItem *) mChildren.ElementAt(i); // doesn't addref the result NS_ENSURE_TRUE(child, NS_ERROR_FAILURE); PRInt32 childType; child->GetItemType(&childType); if (aSameType && (childType != mItemType)) continue; child->GetName(getter_Copies(childName)); if (name.EqualsWithConversion(childName)) { *_retval = child; NS_ADDREF(*_retval); break; } if (childType != mItemType) //Only ask it to check children if it is same type continue; if (aRecurse && (aRequestor != child)) // Only ask the child if it isn't the requestor { // See if child contains the shell with the given name nsCOMPtr childAsNode(do_QueryInterface(child)); if (child) { NS_ENSURE_SUCCESS(childAsNode->FindChildWithName(aName, PR_TRUE, aSameType, NS_STATIC_CAST (nsIDocShellTreeItem *, this), _retval), NS_ERROR_FAILURE); } } if (*_retval) // found it return NS_OK; } return NS_OK; } //***************************************************************************** // nsDocShell::nsIDocShellHistory //***************************************************************************** NS_IMETHODIMP nsDocShell::GetChildSHEntry(PRInt32 aChildOffset, nsISHEntry ** aResult) { nsresult rv = NS_OK; NS_ENSURE_ARG_POINTER(aResult); *aResult = nsnull; // // A nsISHEntry for a child is *only* available when the parent is in // the progress of loading a document too... // if (LSHE) { /* Get the parent's Load Type so that it can be set on the child too. * By default give a loadHistory value */ PRUint32 loadType = nsIDocShellLoadInfo::loadHistory; LSHE->GetLoadType(&loadType); nsCOMPtr container(do_QueryInterface(LSHE)); if (container) { rv = container->GetChildAt(aChildOffset, aResult); if (*aResult) { (*aResult)->SetLoadType(loadType); } } } return rv; } NS_IMETHODIMP nsDocShell::AddChildSHEntry(nsISHEntry * aCloneRef, nsISHEntry * aNewEntry, PRInt32 aChildOffset) { nsresult rv; if (LSHE) { /* You get here if you are currently building a * hierarchy ie.,you just visited a frameset page */ nsCOMPtr container(do_QueryInterface(LSHE, &rv)); if (container) { rv = container->AddChild(aNewEntry, aChildOffset); } } else if (mSessionHistory) { /* You are currently in the rootDocShell. * You will get here when a subframe has a new url * to load and you have walked up the tree all the * way to the top to clone the current SHEntry hierarchy * and replace the subframe where a new url was loaded with * a new entry. */ PRInt32 index = -1; nsCOMPtr currentHE; mSessionHistory->GetIndex(&index); if (index < 0) return NS_ERROR_FAILURE; rv = mSessionHistory->GetEntryAtIndex(index, PR_FALSE, getter_AddRefs(currentHE)); NS_ENSURE_TRUE(currentHE, NS_ERROR_FAILURE); nsCOMPtr currentEntry(do_QueryInterface(currentHE)); if (currentEntry) { PRUint32 cloneID = 0; nsCOMPtr nextEntry; //(do_CreateInstance(NS_SHENTRY_CONTRACTID)); // NS_ENSURE_TRUE(result, NS_ERROR_FAILURE); if (aCloneRef) aCloneRef->GetID(&cloneID); rv = CloneAndReplace(currentEntry, cloneID, aNewEntry, getter_AddRefs(nextEntry)); if (NS_SUCCEEDED(rv)) { nsCOMPtr shPrivate(do_QueryInterface(mSessionHistory)); NS_ENSURE_TRUE(shPrivate, NS_ERROR_FAILURE); rv = shPrivate->AddEntry(nextEntry, PR_TRUE); } } } else { /* You will get here when you are in a subframe and * a new url has been loaded on you. * The OSHE in this subframe will be the previous url's * OSHE. This OSHE will be used as the identification * for this subframe in the CloneAndReplace function. */ nsCOMPtr parent(do_QueryInterface(mParent, &rv)); if (parent) { if (!aCloneRef) { aCloneRef = OSHE; } rv = parent->AddChildSHEntry(aCloneRef, aNewEntry, aChildOffset); } } return rv; } NS_IMETHODIMP nsDocShell::SetGlobalHistory(nsIGlobalHistory * aGlobalHistory) { mGlobalHistory = aGlobalHistory; return NS_OK; } NS_IMETHODIMP nsDocShell::GetGlobalHistory(nsIGlobalHistory ** aGlobalHistory) { NS_ENSURE_ARG_POINTER(aGlobalHistory); *aGlobalHistory = mGlobalHistory; NS_IF_ADDREF(*aGlobalHistory); return NS_OK; } //***************************************************************************** // nsDocShell::nsIWebNavigation //***************************************************************************** NS_IMETHODIMP nsDocShell::GetCanGoBack(PRBool * aCanGoBack) { nsCOMPtr root; //Get the root docshell GetSameTypeRootTreeItem(getter_AddRefs(root)); NS_ENSURE_TRUE(root, NS_ERROR_FAILURE); // QI to nsIWebNavigation nsCOMPtr rootAsWebnav(do_QueryInterface(root)); if (rootAsWebnav) { // Get the handle to SH from the root docshell nsCOMPtr rootSH; rootAsWebnav->GetSessionHistory(getter_AddRefs(rootSH)); NS_ENSURE_TRUE(rootSH, NS_ERROR_FAILURE); // QI SH to nsIWebNavigation nsCOMPtr webNav(do_QueryInterface(rootSH)); if (webNav) return webNav->GetCanGoBack(aCanGoBack); } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDocShell::GetCanGoForward(PRBool * aCanGoForward) { nsCOMPtr root; //Get the root docshell GetSameTypeRootTreeItem(getter_AddRefs(root)); NS_ENSURE_TRUE(root, NS_ERROR_FAILURE); // QI to nsIWebNavigation nsCOMPtr rootAsWebnav(do_QueryInterface(root)); if (rootAsWebnav) { // Get the handle to SH from the root docshell nsCOMPtr rootSH; rootAsWebnav->GetSessionHistory(getter_AddRefs(rootSH)); NS_ENSURE_TRUE(rootSH, NS_ERROR_FAILURE); // QI SH to nsIWebNavigation nsCOMPtr webNav(do_QueryInterface(rootSH)); if (webNav) return webNav->GetCanGoForward(aCanGoForward); } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDocShell::GoBack() { nsCOMPtr root; //Get the root docshell GetSameTypeRootTreeItem(getter_AddRefs(root)); NS_ENSURE_TRUE(root, NS_ERROR_FAILURE); // QI to nsIWebNavigation nsCOMPtr rootAsWebnav(do_QueryInterface(root)); if (rootAsWebnav) { // Get the handle to SH from the root docshell nsCOMPtr rootSH; rootAsWebnav->GetSessionHistory(getter_AddRefs(rootSH)); NS_ENSURE_TRUE(rootSH, NS_ERROR_FAILURE); // QI SH to nsIWebNavigation nsCOMPtr webNav(do_QueryInterface(rootSH)); if (webNav) return webNav->GoBack(); } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDocShell::GoForward() { nsCOMPtr root; //Get the root docshell GetSameTypeRootTreeItem(getter_AddRefs(root)); NS_ENSURE_TRUE(root, NS_ERROR_FAILURE); // QI to nsIWebNavigation nsCOMPtr rootAsWebnav(do_QueryInterface(root)); if (rootAsWebnav) { // Get the handle to SH from the root docshell nsCOMPtr rootSH; rootAsWebnav->GetSessionHistory(getter_AddRefs(rootSH)); NS_ENSURE_TRUE(rootSH, NS_ERROR_FAILURE); // QI SH to nsIWebNavigation nsCOMPtr webNav(do_QueryInterface(rootSH)); if (webNav) return webNav->GoForward(); } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDocShell::GotoIndex(PRInt32 aIndex) { nsCOMPtr root; //Get the root docshell GetSameTypeRootTreeItem(getter_AddRefs(root)); NS_ENSURE_TRUE(root, NS_ERROR_FAILURE); // QI to nsIWebNavigation nsCOMPtr rootAsWebnav(do_QueryInterface(root)); if (rootAsWebnav) { // Get the handle to SH from the root docshell nsCOMPtr rootSH; rootAsWebnav->GetSessionHistory(getter_AddRefs(rootSH)); NS_ENSURE_TRUE(rootSH, NS_ERROR_FAILURE); // QI SH to nsIWebNavigation nsCOMPtr webNav(do_QueryInterface(rootSH)); if (webNav) return webNav->GotoIndex(aIndex); } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDocShell::LoadURI(const PRUnichar * aURI, PRUint32 aLoadFlags) { nsCOMPtr uri; nsresult rv = CreateFixupURI(aURI, getter_AddRefs(uri)); if (NS_ERROR_UNKNOWN_PROTOCOL == rv) { // we weren't able to find a protocol handler nsCOMPtr prompter; nsCOMPtr stringBundle; GetPromptAndStringBundle(getter_AddRefs(prompter), getter_AddRefs(stringBundle)); NS_ENSURE_TRUE(stringBundle, NS_ERROR_FAILURE); nsXPIDLString messageStr; NS_ENSURE_SUCCESS(stringBundle-> GetStringFromName(NS_ConvertASCIItoUCS2 ("protocolNotFound").GetUnicode(), getter_Copies(messageStr)), NS_ERROR_FAILURE); nsAutoString uriString(aURI); PRInt32 colon = uriString.FindChar(':'); // extract the scheme nsAutoString scheme; uriString.Left(scheme, colon); nsCAutoString cScheme; cScheme.AssignWithConversion(scheme); PRUnichar *msg = nsTextFormatter::smprintf(messageStr, cScheme.get()); if (!msg) return NS_ERROR_OUT_OF_MEMORY; prompter->Alert(nsnull, msg); nsTextFormatter::smprintf_free(msg); } // end unknown protocol if (!uri) return NS_ERROR_FAILURE; NS_ENSURE_SUCCESS(LoadURI(uri, nsnull, aLoadFlags), NS_ERROR_FAILURE); return NS_OK; } NS_IMETHODIMP nsDocShell::Reload(PRUint32 aReloadFlags) { NS_ASSERTION(((aReloadFlags & 0xf) == 0), "Reload command not updated to use load flags!"); // XXXTAB Convert reload type to our type LoadType type = LOAD_RELOAD_NORMAL; if (aReloadFlags & LOAD_FLAGS_BYPASS_CACHE && aReloadFlags & LOAD_FLAGS_BYPASS_PROXY) type = LOAD_RELOAD_BYPASS_PROXY_AND_CACHE; nsresult rv; /* If you change this part of code, make sure bug 45297 does not re-occur */ if (OSHE) rv = LoadHistoryEntry(OSHE, type); else if (LSHE) // In case a reload happened before the current load is done rv = LoadHistoryEntry(LSHE, type); else rv = InternalLoad(mCurrentURI, mReferrerURI, nsnull, // No owner PR_TRUE, // Inherit owner from document PR_FALSE, // Do not stop active document nsnull, // No window target nsnull, // No post data nsnull, // No headers data type, // Load type nsnull); // No SHEntry return rv; } NS_IMETHODIMP nsDocShell::Stop() { // Cancel any timers that were set for this loader. CancelRefreshURITimers(); if (mContentViewer) mContentViewer->Stop(); if (mLoadCookie) { nsCOMPtr uriLoader = do_GetService(NS_URI_LOADER_CONTRACTID); if (uriLoader) uriLoader->Stop(mLoadCookie); } PRInt32 n; PRInt32 count = mChildren.Count(); for (n = 0; n < count; n++) { nsIDocShellTreeItem *shell = (nsIDocShellTreeItem *) mChildren.ElementAt(n); nsCOMPtr shellAsNav(do_QueryInterface(shell)); if (shellAsNav) shellAsNav->Stop(); } return NS_OK; } /* NS_IMETHODIMP nsDocShell::SetDocument(nsIDOMDocument* aDocument, const PRUnichar* aContentType) { //XXX First Checkin NS_ERROR("Not Yet Implemented"); return NS_ERROR_FAILURE; } */ NS_IMETHODIMP nsDocShell::GetDocument(nsIDOMDocument ** aDocument) { NS_ENSURE_ARG_POINTER(aDocument); NS_ENSURE_STATE(mContentViewer); return mContentViewer->GetDOMDocument(aDocument); } NS_IMETHODIMP nsDocShell::GetCurrentURI(nsIURI ** aURI) { NS_ENSURE_ARG_POINTER(aURI); *aURI = mCurrentURI; NS_IF_ADDREF(*aURI); return NS_OK; } NS_IMETHODIMP nsDocShell::SetSessionHistory(nsISHistory * aSessionHistory) { NS_ENSURE_TRUE(aSessionHistory, NS_ERROR_FAILURE); // make sure that we are the root docshell and // set a handle to root docshell in SH. nsCOMPtr root; /* Get the root docshell. If *this* is the root docshell * then save a handle to *this* in SH. SH needs it to do * traversions thro' its entries */ GetSameTypeRootTreeItem(getter_AddRefs(root)); NS_ENSURE_TRUE(root, NS_ERROR_FAILURE); if (root.get() == NS_STATIC_CAST(nsIDocShellTreeItem *, this)) { mSessionHistory = aSessionHistory; nsCOMPtr shPrivate(do_QueryInterface(mSessionHistory)); NS_ENSURE_TRUE(shPrivate, NS_ERROR_FAILURE); shPrivate->SetRootDocShell(this); return NS_OK; } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDocShell::GetSessionHistory(nsISHistory ** aSessionHistory) { NS_ENSURE_ARG_POINTER(aSessionHistory); if (mSessionHistory) { *aSessionHistory = mSessionHistory; NS_IF_ADDREF(*aSessionHistory); return NS_OK; } return NS_ERROR_FAILURE; } //***************************************************************************** // nsDocShell::nsIBaseWindow //***************************************************************************** NS_IMETHODIMP nsDocShell::InitWindow(nativeWindow parentNativeWindow, nsIWidget * parentWidget, PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy) { NS_ENSURE_ARG(parentWidget); // DocShells must get a widget for a parent SetParentWidget(parentWidget); SetPositionAndSize(x, y, cx, cy, PR_FALSE); return NS_OK; } NS_IMETHODIMP nsDocShell::Create() { NS_ENSURE_STATE(!mContentViewer); mPrefs = do_GetService(NS_PREF_CONTRACTID); //GlobalHistory is now set in SetGlobalHistory // mGlobalHistory = do_GetService(NS_GLOBALHISTORY_CONTRACTID); // i don't want to read this pref in every time we load a url // so read it in once here and be done with it... mPrefs->GetBoolPref("network.protocols.useSystemDefaults", &mUseExternalProtocolHandler); mPrefs->GetBoolPref("browser.target_new_blocked", &mDisallowPopupWindows); mPrefs->GetBoolPref("browser.frames.enabled", &mAllowSubframes); // Check pref to see if we should prevent frameset spoofing mPrefs->GetBoolPref("browser.frame.validate_origin", &mValidateOrigin); return NS_OK; } NS_IMETHODIMP nsDocShell::Destroy() { mIsBeingDestroyed = PR_TRUE; // Stop any URLs that are currently being loaded... Stop(); if (mDocLoader) { mDocLoader->Destroy(); mDocLoader->SetContainer(nsnull); } // Save the state of the current document, before destroying the window. // This is needed to capture the state of a frameset when the new document // causes the frameset to be destroyed... PersistLayoutHistoryState(); // Remove this docshell from its parent's child list nsCOMPtr docShellParentAsNode(do_QueryInterface(mParent)); if (docShellParentAsNode) docShellParentAsNode->RemoveChild(this); if (mContentViewer) { mContentViewer->Destroy(); mContentViewer = nsnull; } DestroyChildren(); mDocLoader = nsnull; mParentWidget = nsnull; mPrefs = nsnull; mCurrentURI = nsnull; if (mScriptGlobal) { mScriptGlobal->SetDocShell(nsnull); mScriptGlobal = nsnull; } if (mScriptContext) { mScriptContext->SetOwner(nsnull); mScriptContext = nsnull; } mSessionHistory = nsnull; SetTreeOwner(nsnull); SetLoadCookie(nsnull); if (mInitInfo) { delete mInitInfo; mInitInfo = nsnull; } if (mContentListener) { mContentListener->DocShell(nsnull); NS_RELEASE(mContentListener); } return NS_OK; } NS_IMETHODIMP nsDocShell::SetPosition(PRInt32 x, PRInt32 y) { if (mContentViewer) NS_ENSURE_SUCCESS(mContentViewer->Move(x, y), NS_ERROR_FAILURE); else if (InitInfo()) { mInitInfo->x = x; mInitInfo->y = y; } else NS_ENSURE_TRUE(PR_FALSE, NS_ERROR_FAILURE); return NS_OK; } NS_IMETHODIMP nsDocShell::GetPosition(PRInt32 * aX, PRInt32 * aY) { PRInt32 dummyHolder; return GetPositionAndSize(aX, aY, &dummyHolder, &dummyHolder); } NS_IMETHODIMP nsDocShell::SetSize(PRInt32 aCX, PRInt32 aCY, PRBool aRepaint) { PRInt32 x = 0, y = 0; GetPosition(&x, &y); return SetPositionAndSize(x, y, aCX, aCY, aRepaint); } NS_IMETHODIMP nsDocShell::GetSize(PRInt32 * aCX, PRInt32 * aCY) { PRInt32 dummyHolder; return GetPositionAndSize(&dummyHolder, &dummyHolder, aCX, aCY); } NS_IMETHODIMP nsDocShell::SetPositionAndSize(PRInt32 x, PRInt32 y, PRInt32 cx, PRInt32 cy, PRBool fRepaint) { if (mContentViewer) { //XXX Border figured in here or is that handled elsewhere? nsRect bounds(x, y, cx, cy); NS_ENSURE_SUCCESS(mContentViewer->SetBounds(bounds), NS_ERROR_FAILURE); } else if (InitInfo()) { mInitInfo->x = x; mInitInfo->y = y; mInitInfo->cx = cx; mInitInfo->cy = cy; } else NS_ENSURE_TRUE(PR_FALSE, NS_ERROR_FAILURE); return NS_OK; } NS_IMETHODIMP nsDocShell::GetPositionAndSize(PRInt32 * x, PRInt32 * y, PRInt32 * cx, PRInt32 * cy) { if (mContentViewer) { nsRect bounds; NS_ENSURE_SUCCESS(mContentViewer->GetBounds(bounds), NS_ERROR_FAILURE); if (x) *x = bounds.x; if (y) *y = bounds.y; if (cx) *cx = bounds.width; if (cy) *cy = bounds.height; } else if (InitInfo()) { if (x) *x = mInitInfo->x; if (y) *y = mInitInfo->y; if (cx) *cx = mInitInfo->cx; if (cy) *cy = mInitInfo->cy; } else NS_ENSURE_TRUE(PR_FALSE, NS_ERROR_FAILURE); return NS_OK; } NS_IMETHODIMP nsDocShell::Repaint(PRBool aForce) { nsCOMPtr docViewer(do_QueryInterface(mContentViewer)); NS_ENSURE_TRUE(docViewer, NS_ERROR_FAILURE); nsCOMPtr context; docViewer->GetPresContext(*getter_AddRefs(context)); NS_ENSURE_TRUE(context, NS_ERROR_FAILURE); nsCOMPtr shell; context->GetShell(getter_AddRefs(shell)); NS_ENSURE_TRUE(shell, NS_ERROR_FAILURE); nsCOMPtr viewManager; shell->GetViewManager(getter_AddRefs(viewManager)); NS_ENSURE_TRUE(viewManager, NS_ERROR_FAILURE); // what about aForce ? NS_ENSURE_SUCCESS(viewManager->UpdateAllViews(0), NS_ERROR_FAILURE); return NS_OK; } NS_IMETHODIMP nsDocShell::GetParentWidget(nsIWidget ** parentWidget) { NS_ENSURE_ARG_POINTER(parentWidget); *parentWidget = mParentWidget; NS_IF_ADDREF(*parentWidget); return NS_OK; } NS_IMETHODIMP nsDocShell::SetParentWidget(nsIWidget * aParentWidget) { NS_ENSURE_STATE(!mContentViewer); mParentWidget = aParentWidget; return NS_OK; } NS_IMETHODIMP nsDocShell::GetParentNativeWindow(nativeWindow * parentNativeWindow) { NS_ENSURE_ARG_POINTER(parentNativeWindow); if (mParentWidget) *parentNativeWindow = mParentWidget->GetNativeData(NS_NATIVE_WIDGET); else *parentNativeWindow = nsnull; return NS_OK; } NS_IMETHODIMP nsDocShell::SetParentNativeWindow(nativeWindow parentNativeWindow) { return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsDocShell::GetVisibility(PRBool * aVisibility) { NS_ENSURE_ARG_POINTER(aVisibility); if (!mContentViewer) { *aVisibility = PR_FALSE; return NS_OK; } // get the pres shell nsCOMPtr presShell; NS_ENSURE_SUCCESS(GetPresShell(getter_AddRefs(presShell)), NS_ERROR_FAILURE); NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE); // get the view manager nsCOMPtr vm; NS_ENSURE_SUCCESS(presShell->GetViewManager(getter_AddRefs(vm)), NS_ERROR_FAILURE); NS_ENSURE_TRUE(vm, NS_ERROR_FAILURE); // get the root view nsIView *rootView = nsnull; // views are not ref counted NS_ENSURE_SUCCESS(vm->GetRootView(rootView), NS_ERROR_FAILURE); NS_ENSURE_TRUE(rootView, NS_ERROR_FAILURE); // convert the view's visibility attribute to a bool nsViewVisibility vis; NS_ENSURE_TRUE(rootView->GetVisibility(vis), NS_ERROR_FAILURE); *aVisibility = nsViewVisibility_kHide == vis ? PR_FALSE : PR_TRUE; return NS_OK; } NS_IMETHODIMP nsDocShell::SetVisibility(PRBool aVisibility) { if (!mContentViewer) return NS_OK; if (aVisibility) { NS_ENSURE_SUCCESS(EnsureContentViewer(), NS_ERROR_FAILURE); mContentViewer->Show(); } else if (mContentViewer) mContentViewer->Hide(); return NS_OK; } NS_IMETHODIMP nsDocShell::GetMainWidget(nsIWidget ** aMainWidget) { // We don't create our own widget, so simply return the parent one. return GetParentWidget(aMainWidget); } NS_IMETHODIMP nsDocShell::SetFocus() { nsCOMPtr presShell; nsCOMPtr document; GetPresShell(getter_AddRefs(presShell)); if (!presShell) return NS_ERROR_FAILURE; nsCOMPtr presContext; GetPresContext(getter_AddRefs(presContext)); if (!presContext) return NS_ERROR_FAILURE; /* Check to make sure the root frame for this document is not collapsed. */ nsIFrame* rootFrame; presShell->GetRootFrame(&rootFrame); nsRect frameRect; rootFrame->GetRect(frameRect); if (frameRect.IsEmpty()) { #ifdef DEBUG_bryner printf("SetFocus: empty frame rect, not accepting focus\n"); #endif return NS_ERROR_FAILURE; } nsCOMPtr esm; presContext->GetEventStateManager(getter_AddRefs(esm)); if (!esm) return NS_ERROR_FAILURE; presShell->GetDocument(getter_AddRefs(document)); nsCOMPtr rootContent(getter_AddRefs(document->GetRootContent())); if (!rootContent) return NS_ERROR_FAILURE; nsCOMPtr focusContent; esm->GetNextTabbableContent(rootContent, nsnull, PR_TRUE, getter_AddRefs(focusContent)); if (focusContent) { nsIFrame *focusFrame = nsnull; presShell->GetPrimaryFrameFor(focusContent, &focusFrame); esm->ChangeFocus(focusContent, focusFrame, PR_TRUE); } else { nsCOMPtr sgo; document->GetScriptGlobalObject(getter_AddRefs(sgo)); if (sgo) { nsCOMPtr domwin(do_QueryInterface(sgo)); if (domwin) domwin->Focus(); } } return NS_OK; } NS_IMETHODIMP nsDocShell::FocusAvailable(nsIBaseWindow * aCurrentFocus, PRBool aForward, PRBool * aTookFocus) { NS_ENSURE_ARG_POINTER(aTookFocus); nsresult ret; // Are we embedded? nsCOMPtr chromeFocus(do_GetInterface(mTreeOwner, &ret)); if (chromeFocus) { #ifdef DEBUG_dr printf("dr :: nsDocShell::FocusAvailable, embedded\n"); #endif if (aForward) ret = chromeFocus->FocusNextElement(); else ret = chromeFocus->FocusPrevElement(); return ret; } // Otherwise, first person we should call is the parent, or the // docshell tree owner. nsCOMPtr nextCallWin(do_QueryInterface(mParent)); if (!nextCallWin) nextCallWin = do_QueryInterface(mTreeOwner); //If the current focus is us, offer it to the next owner. if (aCurrentFocus == NS_STATIC_CAST(nsIBaseWindow *, this)) { if (nextCallWin) { ret = nextCallWin->FocusAvailable(aCurrentFocus, aForward, aTookFocus); if (NS_SUCCEEDED(ret) && *aTookFocus) return NS_OK; } if (!mChildren.Count()) { //If we don't have children and our parent didn't want //the focus then we should just stop now. return NS_OK; } } //Otherwise, check the chilren and offer it to the next sibling. PRInt32 i; PRInt32 n = mChildren.Count(); for (i = 0; i < n; i++) { nsCOMPtr child(do_QueryInterface((nsISupports *) mChildren.ElementAt(i))); //If we have focus we offer it to our first child. if (aCurrentFocus == NS_STATIC_CAST(nsIBaseWindow *, this)) { if (NS_SUCCEEDED(child->SetFocus())) { *aTookFocus = PR_TRUE; return NS_OK; } } //If we don't have focus, find the child that does then //offer focus to the next one. else if (child.get() == aCurrentFocus) { while (++i < n) { child = do_QueryInterface((nsISupports *) mChildren.ElementAt(i)); if (NS_SUCCEEDED(child->SetFocus())) { *aTookFocus = PR_TRUE; return NS_OK; } } break; } } //Reached the end of our child list. If we aren't currently focused, try // to accept focus. if ((aCurrentFocus != NS_STATIC_CAST(nsIBaseWindow *, this)) && NS_SUCCEEDED(SetFocus())) { *aTookFocus = PR_TRUE; return NS_OK; } // Call again to offer focus upwards and to start at the beginning of our // child list if no one above us wants focus. return FocusAvailable(this, aForward, aTookFocus); } NS_IMETHODIMP nsDocShell::GetTitle(PRUnichar ** aTitle) { NS_ENSURE_ARG_POINTER(aTitle); *aTitle = mTitle.ToNewUnicode(); return NS_OK; } NS_IMETHODIMP nsDocShell::SetTitle(const PRUnichar * aTitle) { // Store local title mTitle = aTitle; nsCOMPtr parent; GetSameTypeParent(getter_AddRefs(parent)); // When title is set on the top object it should then be passed to the // tree owner. if (!parent) { nsCOMPtr treeOwnerAsWin(do_QueryInterface(mTreeOwner)); if (treeOwnerAsWin) treeOwnerAsWin->SetTitle(aTitle); } if (mGlobalHistory && mCurrentURI) { nsXPIDLCString url; mCurrentURI->GetSpec(getter_Copies(url)); nsCOMPtr browserHistory = do_QueryInterface(mGlobalHistory); browserHistory->SetPageTitle(url, aTitle); } // Update SessionHistory too with Title. Otherwise entry for current page // has previous page's title. if (mSessionHistory) { PRInt32 index = -1; mSessionHistory->GetIndex(&index); nsCOMPtr hEntry; mSessionHistory->GetEntryAtIndex(index, PR_FALSE, getter_AddRefs(hEntry)); NS_ENSURE_TRUE(hEntry, NS_ERROR_FAILURE); nsCOMPtr shEntry(do_QueryInterface(hEntry)); if (shEntry) shEntry->SetTitle(mTitle.GetUnicode()); } return NS_OK; } //***************************************************************************** // nsDocShell::nsIScrollable //***************************************************************************** NS_IMETHODIMP nsDocShell::GetCurScrollPos(PRInt32 scrollOrientation, PRInt32 * curPos) { NS_ENSURE_ARG_POINTER(curPos); nsCOMPtr scrollView; NS_ENSURE_SUCCESS(GetRootScrollableView(getter_AddRefs(scrollView)), NS_ERROR_FAILURE); if (!scrollView) { return NS_ERROR_FAILURE; } nscoord x, y; NS_ENSURE_SUCCESS(scrollView->GetScrollPosition(x, y), NS_ERROR_FAILURE); switch (scrollOrientation) { case ScrollOrientation_X: *curPos = x; return NS_OK; case ScrollOrientation_Y: *curPos = y; return NS_OK; default: NS_ENSURE_TRUE(PR_FALSE, NS_ERROR_INVALID_ARG); } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDocShell::SetCurScrollPos(PRInt32 scrollOrientation, PRInt32 curPos) { nsCOMPtr scrollView; NS_ENSURE_SUCCESS(GetRootScrollableView(getter_AddRefs(scrollView)), NS_ERROR_FAILURE); if (!scrollView) { return NS_ERROR_FAILURE; } PRInt32 other; PRInt32 x; PRInt32 y; GetCurScrollPos(scrollOrientation, &other); switch (scrollOrientation) { case ScrollOrientation_X: x = curPos; y = other; break; case ScrollOrientation_Y: x = other; y = curPos; break; default: NS_ENSURE_TRUE(PR_FALSE, NS_ERROR_INVALID_ARG); x = 0; y = 0; // fix compiler warning, not actually executed } NS_ENSURE_SUCCESS(scrollView->ScrollTo(x, y, NS_VMREFRESH_IMMEDIATE), NS_ERROR_FAILURE); return NS_OK; } NS_IMETHODIMP nsDocShell::SetCurScrollPosEx(PRInt32 curHorizontalPos, PRInt32 curVerticalPos) { nsCOMPtr scrollView; NS_ENSURE_SUCCESS(GetRootScrollableView(getter_AddRefs(scrollView)), NS_ERROR_FAILURE); if (!scrollView) { return NS_ERROR_FAILURE; } NS_ENSURE_SUCCESS(scrollView->ScrollTo(curHorizontalPos, curVerticalPos, NS_VMREFRESH_IMMEDIATE), NS_ERROR_FAILURE); return NS_OK; } // XXX This is wrong NS_IMETHODIMP nsDocShell::GetScrollRange(PRInt32 scrollOrientation, PRInt32 * minPos, PRInt32 * maxPos) { NS_ENSURE_ARG_POINTER(minPos && maxPos); nsCOMPtr scrollView; NS_ENSURE_SUCCESS(GetRootScrollableView(getter_AddRefs(scrollView)), NS_ERROR_FAILURE); if (!scrollView) { return NS_ERROR_FAILURE; } PRInt32 cx; PRInt32 cy; NS_ENSURE_SUCCESS(scrollView->GetContainerSize(&cx, &cy), NS_ERROR_FAILURE); *minPos = 0; switch (scrollOrientation) { case ScrollOrientation_X: *maxPos = cx; return NS_OK; case ScrollOrientation_Y: *maxPos = cy; return NS_OK; default: NS_ENSURE_TRUE(PR_FALSE, NS_ERROR_INVALID_ARG); } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDocShell::SetScrollRange(PRInt32 scrollOrientation, PRInt32 minPos, PRInt32 maxPos) { //XXX First Check /* Retrieves or Sets the valid ranges for the thumb. When maxPos is set to something less than the current thumb position, curPos is set = to maxPos. @return NS_OK - Setting or Getting completed successfully. NS_ERROR_INVALID_ARG - returned when curPos is not within the minPos and maxPos. */ return NS_ERROR_FAILURE; } NS_IMETHODIMP nsDocShell::SetScrollRangeEx(PRInt32 minHorizontalPos, PRInt32 maxHorizontalPos, PRInt32 minVerticalPos, PRInt32 maxVerticalPos) { //XXX First Check /* Retrieves or Sets the valid ranges for the thumb. When maxPos is set to something less than the current thumb position, curPos is set = to maxPos. @return NS_OK - Setting or Getting completed successfully. NS_ERROR_INVALID_ARG - returned when curPos is not within the minPos and maxPos. */ return NS_ERROR_FAILURE; } // Get scroll setting for this document only // // One important client is nsCSSFrameConstructor::ConstructRootFrame() NS_IMETHODIMP nsDocShell::GetCurrentScrollbarPreferences(PRInt32 scrollOrientation, PRInt32 * scrollbarPref) { NS_ENSURE_ARG_POINTER(scrollbarPref); switch (scrollOrientation) { case ScrollOrientation_X: *scrollbarPref = mCurrentScrollbarPref.x; return NS_OK; case ScrollOrientation_Y: *scrollbarPref = mCurrentScrollbarPref.y; return NS_OK; default: NS_ENSURE_TRUE(PR_FALSE, NS_ERROR_INVALID_ARG); } return NS_ERROR_FAILURE; } // This returns setting for all documents in this webshell NS_IMETHODIMP nsDocShell::GetDefaultScrollbarPreferences(PRInt32 scrollOrientation, PRInt32 * scrollbarPref) { NS_ENSURE_ARG_POINTER(scrollbarPref); switch (scrollOrientation) { case ScrollOrientation_X: *scrollbarPref = mDefaultScrollbarPref.x; return NS_OK; case ScrollOrientation_Y: *scrollbarPref = mDefaultScrollbarPref.y; return NS_OK; default: NS_ENSURE_TRUE(PR_FALSE, NS_ERROR_INVALID_ARG); } return NS_ERROR_FAILURE; } // Set scrolling preference for this document only. // // There are three possible values stored in the shell: // 1) NS_STYLE_OVERFLOW_HIDDEN = no scrollbars // 2) NS_STYLE_OVERFLOW_AUTO = scrollbars appear if needed // 3) NS_STYLE_OVERFLOW_SCROLL = scrollbars always // // XXX Currently OVERFLOW_SCROLL isn't honored, // as it is not implemented by Gfx scrollbars // XXX setting has no effect after the root frame is created // as it is not implemented by Gfx scrollbars // // One important client is HTMLContentSink::StartLayout() NS_IMETHODIMP nsDocShell::SetCurrentScrollbarPreferences(PRInt32 scrollOrientation, PRInt32 scrollbarPref) { switch (scrollOrientation) { case ScrollOrientation_X: mCurrentScrollbarPref.x = scrollbarPref; return NS_OK; case ScrollOrientation_Y: mCurrentScrollbarPref.y = scrollbarPref; return NS_OK; default: NS_ENSURE_TRUE(PR_FALSE, NS_ERROR_INVALID_ARG); } return NS_ERROR_FAILURE; } // Set scrolling preference for all documents in this shell // One important client is nsHTMLFrameInnerFrame::CreateWebShell() NS_IMETHODIMP nsDocShell::SetDefaultScrollbarPreferences(PRInt32 scrollOrientation, PRInt32 scrollbarPref) { switch (scrollOrientation) { case ScrollOrientation_X: mDefaultScrollbarPref.x = scrollbarPref; return NS_OK; case ScrollOrientation_Y: mDefaultScrollbarPref.y = scrollbarPref; return NS_OK; default: NS_ENSURE_TRUE(PR_FALSE, NS_ERROR_INVALID_ARG); } return NS_ERROR_FAILURE; } // Reset 'current' scrollbar settings to 'default'. // This must be called before every document load or else // frameset scrollbar settings (e.g.