michael@0: /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
michael@0: /* vim: set ts=8 sts=2 et sw=2 tw=80: */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: /* A namespace class for static layout utilities. */
michael@0: 
michael@0: #include "nsContentUtils.h"
michael@0: 
michael@0: #include <algorithm>
michael@0: #include <math.h>
michael@0: 
michael@0: #include "prprf.h"
michael@0: #include "nsCxPusher.h"
michael@0: #include "DecoderTraits.h"
michael@0: #include "harfbuzz/hb.h"
michael@0: #include "imgICache.h"
michael@0: #include "imgIContainer.h"
michael@0: #include "imgINotificationObserver.h"
michael@0: #include "imgLoader.h"
michael@0: #include "imgRequestProxy.h"
michael@0: #include "jsapi.h"
michael@0: #include "jsfriendapi.h"
michael@0: #include "js/OldDebugAPI.h"
michael@0: #include "js/Value.h"
michael@0: #include "Layers.h"
michael@0: #include "MediaDecoder.h"
michael@0: // nsNPAPIPluginInstance must be included before nsIDocument.h, which is included in mozAutoDocUpdate.h.
michael@0: #include "nsNPAPIPluginInstance.h"
michael@0: #include "mozAutoDocUpdate.h"
michael@0: #include "mozilla/ArrayUtils.h"
michael@0: #include "mozilla/Attributes.h"
michael@0: #include "mozilla/AutoRestore.h"
michael@0: #include "mozilla/Base64.h"
michael@0: #include "mozilla/DebugOnly.h"
michael@0: #include "mozilla/dom/DocumentFragment.h"
michael@0: #include "mozilla/dom/Element.h"
michael@0: #include "mozilla/dom/HTMLMediaElement.h"
michael@0: #include "mozilla/dom/HTMLTemplateElement.h"
michael@0: #include "mozilla/dom/HTMLContentElement.h"
michael@0: #include "mozilla/dom/TextDecoder.h"
michael@0: #include "mozilla/dom/TouchEvent.h"
michael@0: #include "mozilla/dom/ShadowRoot.h"
michael@0: #include "mozilla/EventDispatcher.h"
michael@0: #include "mozilla/EventListenerManager.h"
michael@0: #include "mozilla/EventStateManager.h"
michael@0: #include "mozilla/IMEStateManager.h"
michael@0: #include "mozilla/InternalMutationEvent.h"
michael@0: #include "mozilla/Likely.h"
michael@0: #include "mozilla/MouseEvents.h"
michael@0: #include "mozilla/Preferences.h"
michael@0: #include "mozilla/dom/Selection.h"
michael@0: #include "mozilla/TextEvents.h"
michael@0: #include "nsAString.h"
michael@0: #include "nsAttrName.h"
michael@0: #include "nsAttrValue.h"
michael@0: #include "nsAttrValueInlines.h"
michael@0: #include "nsBindingManager.h"
michael@0: #include "nsCCUncollectableMarker.h"
michael@0: #include "nsChannelPolicy.h"
michael@0: #include "nsCharSeparatedTokenizer.h"
michael@0: #include "nsCOMPtr.h"
michael@0: #include "nsContentCreatorFunctions.h"
michael@0: #include "nsContentDLF.h"
michael@0: #include "nsContentList.h"
michael@0: #include "nsContentPolicyUtils.h"
michael@0: #include "nsCPrefetchService.h"
michael@0: #include "nsCRT.h"
michael@0: #include "nsCycleCollectionParticipant.h"
michael@0: #include "nsCycleCollector.h"
michael@0: #include "nsDataHashtable.h"
michael@0: #include "nsDocShellCID.h"
michael@0: #include "nsDocument.h"
michael@0: #include "nsDOMCID.h"
michael@0: #include "mozilla/dom/DataTransfer.h"
michael@0: #include "nsDOMJSUtils.h"
michael@0: #include "nsDOMMutationObserver.h"
michael@0: #include "nsError.h"
michael@0: #include "nsFocusManager.h"
michael@0: #include "nsGenericHTMLElement.h"
michael@0: #include "nsGenericHTMLFrameElement.h"
michael@0: #include "nsGkAtoms.h"
michael@0: #include "nsHostObjectProtocolHandler.h"
michael@0: #include "nsHtml5Module.h"
michael@0: #include "nsHtml5StringParser.h"
michael@0: #include "nsIAsyncVerifyRedirectCallback.h"
michael@0: #include "nsICategoryManager.h"
michael@0: #include "nsIChannelEventSink.h"
michael@0: #include "nsIChannelPolicy.h"
michael@0: #include "nsIChromeRegistry.h"
michael@0: #include "nsIConsoleService.h"
michael@0: #include "nsIContent.h"
michael@0: #include "nsIContentSecurityPolicy.h"
michael@0: #include "nsIContentSink.h"
michael@0: #include "nsIContentViewer.h"
michael@0: #include "nsIDocShell.h"
michael@0: #include "nsIDocument.h"
michael@0: #include "nsIDocumentEncoder.h"
michael@0: #include "nsIDOMDocument.h"
michael@0: #include "nsIDOMDocumentType.h"
michael@0: #include "nsIDOMEvent.h"
michael@0: #include "nsIDOMHTMLElement.h"
michael@0: #include "nsIDOMHTMLFormElement.h"
michael@0: #include "nsIDOMHTMLInputElement.h"
michael@0: #include "nsIDOMNode.h"
michael@0: #include "nsIDOMNodeList.h"
michael@0: #include "nsIDOMScriptObjectFactory.h"
michael@0: #include "nsIDOMUserDataHandler.h"
michael@0: #include "nsIDOMXULCommandEvent.h"
michael@0: #include "nsIDragService.h"
michael@0: #include "nsIEditor.h"
michael@0: #include "nsIFormControl.h"
michael@0: #include "nsIForm.h"
michael@0: #include "nsIFragmentContentSink.h"
michael@0: #include "nsIFrame.h"
michael@0: #include "nsIHTMLDocument.h"
michael@0: #include "nsIIdleService.h"
michael@0: #include "nsIImageLoadingContent.h"
michael@0: #include "nsIInterfaceRequestor.h"
michael@0: #include "nsIInterfaceRequestorUtils.h"
michael@0: #include "nsIIOService.h"
michael@0: #include "nsIJSRuntimeService.h"
michael@0: #include "nsILineBreaker.h"
michael@0: #include "nsILoadContext.h"
michael@0: #include "nsILoadGroup.h"
michael@0: #include "nsIMemoryReporter.h"
michael@0: #include "nsIMIMEService.h"
michael@0: #include "nsINode.h"
michael@0: #include "nsINodeInfo.h"
michael@0: #include "nsIObjectLoadingContent.h"
michael@0: #include "nsIObserver.h"
michael@0: #include "nsIObserverService.h"
michael@0: #include "nsIOfflineCacheUpdate.h"
michael@0: #include "nsIParser.h"
michael@0: #include "nsIParserService.h"
michael@0: #include "nsIPermissionManager.h"
michael@0: #include "nsIPluginHost.h"
michael@0: #include "nsIRunnable.h"
michael@0: #include "nsIScriptContext.h"
michael@0: #include "nsIScriptError.h"
michael@0: #include "nsIScriptGlobalObject.h"
michael@0: #include "nsIScriptObjectPrincipal.h"
michael@0: #include "nsIScriptSecurityManager.h"
michael@0: #include "nsIStringBundle.h"
michael@0: #include "nsIURI.h"
michael@0: #include "nsIURL.h"
michael@0: #include "nsIWebNavigation.h"
michael@0: #include "nsIWordBreaker.h"
michael@0: #include "nsIXPConnect.h"
michael@0: #include "nsJSUtils.h"
michael@0: #include "nsLWBrkCIID.h"
michael@0: #include "nsNetCID.h"
michael@0: #include "nsNetUtil.h"
michael@0: #include "nsNodeInfoManager.h"
michael@0: #include "nsNullPrincipal.h"
michael@0: #include "nsParserCIID.h"
michael@0: #include "nsParserConstants.h"
michael@0: #include "nsPIDOMWindow.h"
michael@0: #include "nsPresContext.h"
michael@0: #include "nsPrintfCString.h"
michael@0: #include "nsReferencedElement.h"
michael@0: #include "nsSandboxFlags.h"
michael@0: #include "nsScriptSecurityManager.h"
michael@0: #include "nsSVGFeatures.h"
michael@0: #include "nsTextEditorState.h"
michael@0: #include "nsTextFragment.h"
michael@0: #include "nsTextNode.h"
michael@0: #include "nsThreadUtils.h"
michael@0: #include "nsUnicharUtilCIID.h"
michael@0: #include "nsUnicodeProperties.h"
michael@0: #include "nsViewManager.h"
michael@0: #include "nsViewportInfo.h"
michael@0: #include "nsWrapperCacheInlines.h"
michael@0: #include "nsXULPopupManager.h"
michael@0: #include "xpcprivate.h" // nsXPConnect
michael@0: #include "HTMLSplitOnSpacesTokenizer.h"
michael@0: #include "nsContentTypeParser.h"
michael@0: #include "mozIThirdPartyUtil.h"
michael@0: 
michael@0: #include "nsIBidiKeyboard.h"
michael@0: 
michael@0: extern "C" int MOZ_XMLTranslateEntity(const char* ptr, const char* end,
michael@0:                                       const char** next, char16_t* result);
michael@0: extern "C" int MOZ_XMLCheckQName(const char* ptr, const char* end,
michael@0:                                  int ns_aware, const char** colon);
michael@0: 
michael@0: class imgLoader;
michael@0: 
michael@0: using namespace mozilla::dom;
michael@0: using namespace mozilla::layers;
michael@0: using namespace mozilla::widget;
michael@0: using namespace mozilla;
michael@0: 
michael@0: const char kLoadAsData[] = "loadAsData";
michael@0: 
michael@0: nsIXPConnect *nsContentUtils::sXPConnect;
michael@0: nsIScriptSecurityManager *nsContentUtils::sSecurityManager;
michael@0: nsIParserService *nsContentUtils::sParserService = nullptr;
michael@0: nsNameSpaceManager *nsContentUtils::sNameSpaceManager;
michael@0: nsIIOService *nsContentUtils::sIOService;
michael@0: nsIConsoleService *nsContentUtils::sConsoleService;
michael@0: nsDataHashtable<nsISupportsHashKey, EventNameMapping>* nsContentUtils::sAtomEventTable = nullptr;
michael@0: nsDataHashtable<nsStringHashKey, EventNameMapping>* nsContentUtils::sStringEventTable = nullptr;
michael@0: nsCOMArray<nsIAtom>* nsContentUtils::sUserDefinedEvents = nullptr;
michael@0: nsIStringBundleService *nsContentUtils::sStringBundleService;
michael@0: nsIStringBundle *nsContentUtils::sStringBundles[PropertiesFile_COUNT];
michael@0: nsIContentPolicy *nsContentUtils::sContentPolicyService;
michael@0: bool nsContentUtils::sTriedToGetContentPolicy = false;
michael@0: nsILineBreaker *nsContentUtils::sLineBreaker;
michael@0: nsIWordBreaker *nsContentUtils::sWordBreaker;
michael@0: nsIBidiKeyboard *nsContentUtils::sBidiKeyboard = nullptr;
michael@0: uint32_t nsContentUtils::sScriptBlockerCount = 0;
michael@0: #ifdef DEBUG
michael@0: uint32_t nsContentUtils::sDOMNodeRemovedSuppressCount = 0;
michael@0: #endif
michael@0: uint32_t nsContentUtils::sMicroTaskLevel = 0;
michael@0: nsTArray< nsCOMPtr<nsIRunnable> >* nsContentUtils::sBlockedScriptRunners = nullptr;
michael@0: uint32_t nsContentUtils::sRunnersCountAtFirstBlocker = 0;
michael@0: nsIInterfaceRequestor* nsContentUtils::sSameOriginChecker = nullptr;
michael@0: 
michael@0: bool nsContentUtils::sIsHandlingKeyBoardEvent = false;
michael@0: bool nsContentUtils::sAllowXULXBL_for_file = false;
michael@0: 
michael@0: nsString* nsContentUtils::sShiftText = nullptr;
michael@0: nsString* nsContentUtils::sControlText = nullptr;
michael@0: nsString* nsContentUtils::sMetaText = nullptr;
michael@0: nsString* nsContentUtils::sOSText = nullptr;
michael@0: nsString* nsContentUtils::sAltText = nullptr;
michael@0: nsString* nsContentUtils::sModifierSeparator = nullptr;
michael@0: 
michael@0: bool nsContentUtils::sInitialized = false;
michael@0: bool nsContentUtils::sIsFullScreenApiEnabled = false;
michael@0: bool nsContentUtils::sTrustedFullScreenOnly = true;
michael@0: bool nsContentUtils::sFullscreenApiIsContentOnly = false;
michael@0: bool nsContentUtils::sIsIdleObserverAPIEnabled = false;
michael@0: bool nsContentUtils::sIsPerformanceTimingEnabled = false;
michael@0: bool nsContentUtils::sIsResourceTimingEnabled = false;
michael@0: 
michael@0: uint32_t nsContentUtils::sHandlingInputTimeout = 1000;
michael@0: 
michael@0: nsHtml5StringParser* nsContentUtils::sHTMLFragmentParser = nullptr;
michael@0: nsIParser* nsContentUtils::sXMLFragmentParser = nullptr;
michael@0: nsIFragmentContentSink* nsContentUtils::sXMLFragmentSink = nullptr;
michael@0: bool nsContentUtils::sFragmentParsingActive = false;
michael@0: 
michael@0: #if !(defined(DEBUG) || defined(MOZ_ENABLE_JS_DUMP))
michael@0: bool nsContentUtils::sDOMWindowDumpEnabled;
michael@0: #endif
michael@0: 
michael@0: namespace {
michael@0: 
michael@0: static NS_DEFINE_CID(kParserServiceCID, NS_PARSERSERVICE_CID);
michael@0: static NS_DEFINE_CID(kCParserCID, NS_PARSER_CID);
michael@0: 
michael@0: static PLDHashTable sEventListenerManagersHash;
michael@0: 
michael@0: class DOMEventListenerManagersHashReporter MOZ_FINAL : public nsIMemoryReporter
michael@0: {
michael@0:   MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf)
michael@0: 
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
michael@0:                             nsISupports* aData)
michael@0:   {
michael@0:     // We don't measure the |EventListenerManager| objects pointed to by the
michael@0:     // entries because those references are non-owning.
michael@0:     int64_t amount = sEventListenerManagersHash.ops
michael@0:                    ? PL_DHashTableSizeOfExcludingThis(
michael@0:                        &sEventListenerManagersHash, nullptr, MallocSizeOf)
michael@0:                    : 0;
michael@0: 
michael@0:     return MOZ_COLLECT_REPORT(
michael@0:       "explicit/dom/event-listener-managers-hash", KIND_HEAP, UNITS_BYTES,
michael@0:       amount,
michael@0:       "Memory used by the event listener manager's hash table.");
michael@0:   }
michael@0: };
michael@0: 
michael@0: NS_IMPL_ISUPPORTS(DOMEventListenerManagersHashReporter, nsIMemoryReporter)
michael@0: 
michael@0: class EventListenerManagerMapEntry : public PLDHashEntryHdr
michael@0: {
michael@0: public:
michael@0:   EventListenerManagerMapEntry(const void *aKey)
michael@0:     : mKey(aKey)
michael@0:   {
michael@0:   }
michael@0: 
michael@0:   ~EventListenerManagerMapEntry()
michael@0:   {
michael@0:     NS_ASSERTION(!mListenerManager, "caller must release and disconnect ELM");
michael@0:   }
michael@0: 
michael@0: protected:          // declared protected to silence clang warnings
michael@0:   const void *mKey; // must be first, to look like PLDHashEntryStub
michael@0: 
michael@0: public:
michael@0:   nsRefPtr<EventListenerManager> mListenerManager;
michael@0: };
michael@0: 
michael@0: static bool
michael@0: EventListenerManagerHashInitEntry(PLDHashTable *table, PLDHashEntryHdr *entry,
michael@0:                                   const void *key)
michael@0: {
michael@0:   // Initialize the entry with placement new
michael@0:   new (entry) EventListenerManagerMapEntry(key);
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: static void
michael@0: EventListenerManagerHashClearEntry(PLDHashTable *table, PLDHashEntryHdr *entry)
michael@0: {
michael@0:   EventListenerManagerMapEntry *lm =
michael@0:     static_cast<EventListenerManagerMapEntry *>(entry);
michael@0: 
michael@0:   // Let the EventListenerManagerMapEntry clean itself up...
michael@0:   lm->~EventListenerManagerMapEntry();
michael@0: }
michael@0: 
michael@0: class SameOriginChecker MOZ_FINAL : public nsIChannelEventSink,
michael@0:                                     public nsIInterfaceRequestor
michael@0: {
michael@0:   NS_DECL_ISUPPORTS
michael@0:   NS_DECL_NSICHANNELEVENTSINK
michael@0:   NS_DECL_NSIINTERFACEREQUESTOR
michael@0: };
michael@0: 
michael@0: class CharsetDetectionObserver MOZ_FINAL : public nsICharsetDetectionObserver
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   NS_IMETHOD Notify(const char *aCharset, nsDetectionConfident aConf)
michael@0:   {
michael@0:     mCharset = aCharset;
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   const nsACString& GetResult() const
michael@0:   {
michael@0:     return mCharset;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   nsCString mCharset;
michael@0: };
michael@0: 
michael@0: } // anonymous namespace
michael@0: 
michael@0: /* static */
michael@0: TimeDuration
michael@0: nsContentUtils::HandlingUserInputTimeout()
michael@0: {
michael@0:   return TimeDuration::FromMilliseconds(sHandlingInputTimeout);
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::Init()
michael@0: {
michael@0:   if (sInitialized) {
michael@0:     NS_WARNING("Init() called twice");
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   sNameSpaceManager = nsNameSpaceManager::GetInstance();
michael@0:   NS_ENSURE_TRUE(sNameSpaceManager, NS_ERROR_OUT_OF_MEMORY);
michael@0: 
michael@0:   sXPConnect = nsXPConnect::XPConnect();
michael@0: 
michael@0:   sSecurityManager = nsScriptSecurityManager::GetScriptSecurityManager();
michael@0:   if(!sSecurityManager)
michael@0:     return NS_ERROR_FAILURE;
michael@0:   NS_ADDREF(sSecurityManager);
michael@0: 
michael@0:   // Getting the first context can trigger GC, so do this non-lazily.
michael@0:   sXPConnect->InitSafeJSContext();
michael@0: 
michael@0:   nsresult rv = CallGetService(NS_IOSERVICE_CONTRACTID, &sIOService);
michael@0:   if (NS_FAILED(rv)) {
michael@0:     // This makes life easier, but we can live without it.
michael@0: 
michael@0:     sIOService = nullptr;
michael@0:   }
michael@0: 
michael@0:   rv = CallGetService(NS_LBRK_CONTRACTID, &sLineBreaker);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   rv = CallGetService(NS_WBRK_CONTRACTID, &sWordBreaker);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   if (!InitializeEventTable())
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   if (!sEventListenerManagersHash.ops) {
michael@0:     static const PLDHashTableOps hash_table_ops =
michael@0:     {
michael@0:       PL_DHashAllocTable,
michael@0:       PL_DHashFreeTable,
michael@0:       PL_DHashVoidPtrKeyStub,
michael@0:       PL_DHashMatchEntryStub,
michael@0:       PL_DHashMoveEntryStub,
michael@0:       EventListenerManagerHashClearEntry,
michael@0:       PL_DHashFinalizeStub,
michael@0:       EventListenerManagerHashInitEntry
michael@0:     };
michael@0: 
michael@0:     PL_DHashTableInit(&sEventListenerManagersHash, &hash_table_ops,
michael@0:                       nullptr, sizeof(EventListenerManagerMapEntry), 16);
michael@0: 
michael@0:     RegisterStrongMemoryReporter(new DOMEventListenerManagersHashReporter());
michael@0:   }
michael@0: 
michael@0:   sBlockedScriptRunners = new nsTArray< nsCOMPtr<nsIRunnable> >;
michael@0: 
michael@0:   Preferences::AddBoolVarCache(&sAllowXULXBL_for_file,
michael@0:                                "dom.allow_XUL_XBL_for_file");
michael@0: 
michael@0:   Preferences::AddBoolVarCache(&sIsFullScreenApiEnabled,
michael@0:                                "full-screen-api.enabled");
michael@0: 
michael@0:   // Note: We deliberately read this pref here because this code runs
michael@0:   // before the profile loads, so users' changes to this pref in about:config
michael@0:   // won't have any effect on behaviour. We don't really want users messing
michael@0:   // with this pref, as it affects the security model of the fullscreen API.
michael@0:   sFullscreenApiIsContentOnly = Preferences::GetBool("full-screen-api.content-only", false);
michael@0: 
michael@0:   Preferences::AddBoolVarCache(&sTrustedFullScreenOnly,
michael@0:                                "full-screen-api.allow-trusted-requests-only");
michael@0: 
michael@0:   sIsIdleObserverAPIEnabled = Preferences::GetBool("dom.idle-observers-api.enabled", true);
michael@0: 
michael@0:   Preferences::AddBoolVarCache(&sIsPerformanceTimingEnabled,
michael@0:                                "dom.enable_performance", true);
michael@0: 
michael@0:   Preferences::AddBoolVarCache(&sIsResourceTimingEnabled,
michael@0:                                "dom.enable_resource_timing", true);
michael@0: 
michael@0:   Preferences::AddUintVarCache(&sHandlingInputTimeout,
michael@0:                                "dom.event.handling-user-input-time-limit",
michael@0:                                1000);
michael@0: 
michael@0: #if !(defined(DEBUG) || defined(MOZ_ENABLE_JS_DUMP))
michael@0:   Preferences::AddBoolVarCache(&sDOMWindowDumpEnabled,
michael@0:                                "browser.dom.window.dump.enabled");
michael@0: #endif
michael@0: 
michael@0:   Element::InitCCCallbacks();
michael@0: 
michael@0:   sInitialized = true;
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::GetShiftText(nsAString& text)
michael@0: {
michael@0:   if (!sShiftText)
michael@0:     InitializeModifierStrings();
michael@0:   text.Assign(*sShiftText);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::GetControlText(nsAString& text)
michael@0: {
michael@0:   if (!sControlText)
michael@0:     InitializeModifierStrings();
michael@0:   text.Assign(*sControlText);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::GetMetaText(nsAString& text)
michael@0: {
michael@0:   if (!sMetaText)
michael@0:     InitializeModifierStrings();
michael@0:   text.Assign(*sMetaText);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::GetOSText(nsAString& text)
michael@0: {
michael@0:   if (!sOSText) {
michael@0:     InitializeModifierStrings();
michael@0:   }
michael@0:   text.Assign(*sOSText);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::GetAltText(nsAString& text)
michael@0: {
michael@0:   if (!sAltText)
michael@0:     InitializeModifierStrings();
michael@0:   text.Assign(*sAltText);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::GetModifierSeparatorText(nsAString& text)
michael@0: {
michael@0:   if (!sModifierSeparator)
michael@0:     InitializeModifierStrings();
michael@0:   text.Assign(*sModifierSeparator);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::InitializeModifierStrings()
michael@0: {
michael@0:   //load the display strings for the keyboard accelerators
michael@0:   nsCOMPtr<nsIStringBundleService> bundleService =
michael@0:     mozilla::services::GetStringBundleService();
michael@0:   nsCOMPtr<nsIStringBundle> bundle;
michael@0:   DebugOnly<nsresult> rv = NS_OK;
michael@0:   if (bundleService) {
michael@0:     rv = bundleService->CreateBundle( "chrome://global-platform/locale/platformKeys.properties",
michael@0:                                       getter_AddRefs(bundle));
michael@0:   }
michael@0:   
michael@0:   NS_ASSERTION(NS_SUCCEEDED(rv) && bundle, "chrome://global/locale/platformKeys.properties could not be loaded");
michael@0:   nsXPIDLString shiftModifier;
michael@0:   nsXPIDLString metaModifier;
michael@0:   nsXPIDLString osModifier;
michael@0:   nsXPIDLString altModifier;
michael@0:   nsXPIDLString controlModifier;
michael@0:   nsXPIDLString modifierSeparator;
michael@0:   if (bundle) {
michael@0:     //macs use symbols for each modifier key, so fetch each from the bundle, which also covers i18n
michael@0:     bundle->GetStringFromName(MOZ_UTF16("VK_SHIFT"), getter_Copies(shiftModifier));
michael@0:     bundle->GetStringFromName(MOZ_UTF16("VK_META"), getter_Copies(metaModifier));
michael@0:     bundle->GetStringFromName(MOZ_UTF16("VK_WIN"), getter_Copies(osModifier));
michael@0:     bundle->GetStringFromName(MOZ_UTF16("VK_ALT"), getter_Copies(altModifier));
michael@0:     bundle->GetStringFromName(MOZ_UTF16("VK_CONTROL"), getter_Copies(controlModifier));
michael@0:     bundle->GetStringFromName(MOZ_UTF16("MODIFIER_SEPARATOR"), getter_Copies(modifierSeparator));
michael@0:   }
michael@0:   //if any of these don't exist, we get  an empty string
michael@0:   sShiftText = new nsString(shiftModifier);
michael@0:   sMetaText = new nsString(metaModifier);
michael@0:   sOSText = new nsString(osModifier);
michael@0:   sAltText = new nsString(altModifier);
michael@0:   sControlText = new nsString(controlModifier);
michael@0:   sModifierSeparator = new nsString(modifierSeparator);  
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::InitializeEventTable() {
michael@0:   NS_ASSERTION(!sAtomEventTable, "EventTable already initialized!");
michael@0:   NS_ASSERTION(!sStringEventTable, "EventTable already initialized!");
michael@0: 
michael@0:   static const EventNameMapping eventArray[] = {
michael@0: #define EVENT(name_,  _id, _type, _struct)          \
michael@0:     { nsGkAtoms::on##name_, _id, _type, _struct },
michael@0: #define WINDOW_ONLY_EVENT EVENT
michael@0: #define NON_IDL_EVENT EVENT
michael@0: #include "mozilla/EventNameList.h"
michael@0: #undef WINDOW_ONLY_EVENT
michael@0: #undef EVENT
michael@0:     { nullptr }
michael@0:   };
michael@0: 
michael@0:   sAtomEventTable = new nsDataHashtable<nsISupportsHashKey, EventNameMapping>(
michael@0:       int(ArrayLength(eventArray) / 0.75) + 1);
michael@0:   sStringEventTable = new nsDataHashtable<nsStringHashKey, EventNameMapping>(
michael@0:       int(ArrayLength(eventArray) / 0.75) + 1);
michael@0:   sUserDefinedEvents = new nsCOMArray<nsIAtom>(64);
michael@0: 
michael@0:   // Subtract one from the length because of the trailing null
michael@0:   for (uint32_t i = 0; i < ArrayLength(eventArray) - 1; ++i) {
michael@0:     sAtomEventTable->Put(eventArray[i].mAtom, eventArray[i]);
michael@0:     sStringEventTable->Put(Substring(nsDependentAtomString(eventArray[i].mAtom), 2),
michael@0:                            eventArray[i]);
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::InitializeTouchEventTable()
michael@0: {
michael@0:   static bool sEventTableInitialized = false;
michael@0:   if (!sEventTableInitialized && sAtomEventTable && sStringEventTable) {
michael@0:     sEventTableInitialized = true;
michael@0:     static const EventNameMapping touchEventArray[] = {
michael@0: #define EVENT(name_,  _id, _type, _struct)
michael@0: #define TOUCH_EVENT(name_,  _id, _type, _struct)      \
michael@0:       { nsGkAtoms::on##name_, _id, _type, _struct },
michael@0: #include "mozilla/EventNameList.h"
michael@0: #undef TOUCH_EVENT
michael@0: #undef EVENT
michael@0:       { nullptr }
michael@0:     };
michael@0:     // Subtract one from the length because of the trailing null
michael@0:     for (uint32_t i = 0; i < ArrayLength(touchEventArray) - 1; ++i) {
michael@0:       sAtomEventTable->Put(touchEventArray[i].mAtom, touchEventArray[i]);
michael@0:       sStringEventTable->Put(Substring(nsDependentAtomString(touchEventArray[i].mAtom), 2),
michael@0:                              touchEventArray[i]);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: static bool
michael@0: Is8bit(const nsAString& aString)
michael@0: {
michael@0:   static const char16_t EIGHT_BIT = char16_t(~0x00FF);
michael@0: 
michael@0:   nsAString::const_iterator done_reading;
michael@0:   aString.EndReading(done_reading);
michael@0: 
michael@0:   // for each chunk of |aString|...
michael@0:   uint32_t fragmentLength = 0;
michael@0:   nsAString::const_iterator iter;
michael@0:   for (aString.BeginReading(iter); iter != done_reading;
michael@0:        iter.advance(int32_t(fragmentLength))) {
michael@0:     fragmentLength = uint32_t(iter.size_forward());
michael@0:     const char16_t* c = iter.get();
michael@0:     const char16_t* fragmentEnd = c + fragmentLength;
michael@0: 
michael@0:     // for each character in this chunk...
michael@0:     while (c < fragmentEnd) {
michael@0:       if (*c++ & EIGHT_BIT) {
michael@0:         return false;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsContentUtils::Btoa(const nsAString& aBinaryData,
michael@0:                      nsAString& aAsciiBase64String)
michael@0: {
michael@0:   if (!Is8bit(aBinaryData)) {
michael@0:     aAsciiBase64String.Truncate();
michael@0:     return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
michael@0:   }
michael@0: 
michael@0:   return Base64Encode(aBinaryData, aAsciiBase64String);
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsContentUtils::Atob(const nsAString& aAsciiBase64String,
michael@0:                      nsAString& aBinaryData)
michael@0: {
michael@0:   if (!Is8bit(aAsciiBase64String)) {
michael@0:     aBinaryData.Truncate();
michael@0:     return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
michael@0:   }
michael@0: 
michael@0:   const char16_t* start = aAsciiBase64String.BeginReading();
michael@0:   const char16_t* end = aAsciiBase64String.EndReading();
michael@0:   nsString trimmedString;
michael@0:   if (!trimmedString.SetCapacity(aAsciiBase64String.Length(), fallible_t())) {
michael@0:     return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
michael@0:   }
michael@0:   while (start < end) {
michael@0:     if (!nsContentUtils::IsHTMLWhitespace(*start)) {
michael@0:       trimmedString.Append(*start);
michael@0:     }
michael@0:     start++;
michael@0:   }
michael@0:   nsresult rv = Base64Decode(trimmedString, aBinaryData);
michael@0:   if (NS_FAILED(rv) && rv == NS_ERROR_INVALID_ARG) {
michael@0:     return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
michael@0:   }
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsAutocompleteEnabled(nsIDOMHTMLInputElement* aInput)
michael@0: {
michael@0:   NS_PRECONDITION(aInput, "aInput should not be null!");
michael@0: 
michael@0:   nsAutoString autocomplete;
michael@0:   aInput->GetAutocomplete(autocomplete);
michael@0: 
michael@0:   if (autocomplete.IsEmpty()) {
michael@0:     nsCOMPtr<nsIDOMHTMLFormElement> form;
michael@0:     aInput->GetForm(getter_AddRefs(form));
michael@0:     if (!form) {
michael@0:       return true;
michael@0:     }
michael@0: 
michael@0:     form->GetAutocomplete(autocomplete);
michael@0:   }
michael@0: 
michael@0:   return autocomplete.EqualsLiteral("on");
michael@0: }
michael@0: 
michael@0: #define SKIP_WHITESPACE(iter, end_iter, end_res)                 \
michael@0:   while ((iter) != (end_iter) && nsCRT::IsAsciiSpace(*(iter))) { \
michael@0:     ++(iter);                                                    \
michael@0:   }                                                              \
michael@0:   if ((iter) == (end_iter)) {                                    \
michael@0:     return (end_res);                                            \
michael@0:   }
michael@0: 
michael@0: #define SKIP_ATTR_NAME(iter, end_iter)                            \
michael@0:   while ((iter) != (end_iter) && !nsCRT::IsAsciiSpace(*(iter)) && \
michael@0:          *(iter) != '=') {                                        \
michael@0:     ++(iter);                                                     \
michael@0:   }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::GetPseudoAttributeValue(const nsString& aSource, nsIAtom *aName,
michael@0:                                         nsAString& aValue)
michael@0: {
michael@0:   aValue.Truncate();
michael@0: 
michael@0:   const char16_t *start = aSource.get();
michael@0:   const char16_t *end = start + aSource.Length();
michael@0:   const char16_t *iter;
michael@0: 
michael@0:   while (start != end) {
michael@0:     SKIP_WHITESPACE(start, end, false)
michael@0:     iter = start;
michael@0:     SKIP_ATTR_NAME(iter, end)
michael@0: 
michael@0:     if (start == iter) {
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     // Remember the attr name.
michael@0:     const nsDependentSubstring & attrName = Substring(start, iter);
michael@0: 
michael@0:     // Now check whether this is a valid name="value" pair.
michael@0:     start = iter;
michael@0:     SKIP_WHITESPACE(start, end, false)
michael@0:     if (*start != '=') {
michael@0:       // No '=', so this is not a name="value" pair.  We don't know
michael@0:       // what it is, and we have no way to handle it.
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     // Have to skip the value.
michael@0:     ++start;
michael@0:     SKIP_WHITESPACE(start, end, false)
michael@0:     char16_t q = *start;
michael@0:     if (q != kQuote && q != kApostrophe) {
michael@0:       // Not a valid quoted value, so bail.
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     ++start;  // Point to the first char of the value.
michael@0:     iter = start;
michael@0: 
michael@0:     while (iter != end && *iter != q) {
michael@0:       ++iter;
michael@0:     }
michael@0: 
michael@0:     if (iter == end) {
michael@0:       // Oops, unterminated quoted string.
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     // At this point attrName holds the name of the "attribute" and
michael@0:     // the value is between start and iter.
michael@0: 
michael@0:     if (aName->Equals(attrName)) {
michael@0:       // We'll accumulate as many characters as possible (until we hit either
michael@0:       // the end of the string or the beginning of an entity). Chunks will be
michael@0:       // delimited by start and chunkEnd.
michael@0:       const char16_t *chunkEnd = start;
michael@0:       while (chunkEnd != iter) {
michael@0:         if (*chunkEnd == kLessThan) {
michael@0:           aValue.Truncate();
michael@0: 
michael@0:           return false;
michael@0:         }
michael@0: 
michael@0:         if (*chunkEnd == kAmpersand) {
michael@0:           aValue.Append(start, chunkEnd - start);
michael@0: 
michael@0:           // Point to first character after the ampersand.
michael@0:           ++chunkEnd;
michael@0: 
michael@0:           const char16_t *afterEntity = nullptr;
michael@0:           char16_t result[2];
michael@0:           uint32_t count =
michael@0:             MOZ_XMLTranslateEntity(reinterpret_cast<const char*>(chunkEnd),
michael@0:                                   reinterpret_cast<const char*>(iter),
michael@0:                                   reinterpret_cast<const char**>(&afterEntity),
michael@0:                                   result);
michael@0:           if (count == 0) {
michael@0:             aValue.Truncate();
michael@0: 
michael@0:             return false;
michael@0:           }
michael@0: 
michael@0:           aValue.Append(result, count);
michael@0: 
michael@0:           // Advance to after the entity and begin a new chunk.
michael@0:           start = chunkEnd = afterEntity;
michael@0:         }
michael@0:         else {
michael@0:           ++chunkEnd;
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       // Append remainder.
michael@0:       aValue.Append(start, iter - start);
michael@0: 
michael@0:       return true;
michael@0:     }
michael@0: 
michael@0:     // Resume scanning after the end of the attribute value (past the quote
michael@0:     // char).
michael@0:     start = iter + 1;
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsJavaScriptLanguage(const nsString& aName)
michael@0: {
michael@0:   return aName.LowerCaseEqualsLiteral("javascript") ||
michael@0:          aName.LowerCaseEqualsLiteral("livescript") ||
michael@0:          aName.LowerCaseEqualsLiteral("mocha") ||
michael@0:          aName.LowerCaseEqualsLiteral("javascript1.0") ||
michael@0:          aName.LowerCaseEqualsLiteral("javascript1.1") ||
michael@0:          aName.LowerCaseEqualsLiteral("javascript1.2") ||
michael@0:          aName.LowerCaseEqualsLiteral("javascript1.3") ||
michael@0:          aName.LowerCaseEqualsLiteral("javascript1.4") ||
michael@0:          aName.LowerCaseEqualsLiteral("javascript1.5");
michael@0: }
michael@0: 
michael@0: JSVersion
michael@0: nsContentUtils::ParseJavascriptVersion(const nsAString& aVersionStr)
michael@0: {
michael@0:   if (aVersionStr.Length() != 3 || aVersionStr[0] != '1' ||
michael@0:       aVersionStr[1] != '.') {
michael@0:     return JSVERSION_UNKNOWN;
michael@0:   }
michael@0: 
michael@0:   switch (aVersionStr[2]) {
michael@0:   case '0': /* fall through */
michael@0:   case '1': /* fall through */
michael@0:   case '2': /* fall through */
michael@0:   case '3': /* fall through */
michael@0:   case '4': /* fall through */
michael@0:   case '5': return JSVERSION_DEFAULT;
michael@0:   case '6': return JSVERSION_1_6;
michael@0:   case '7': return JSVERSION_1_7;
michael@0:   case '8': return JSVERSION_1_8;
michael@0:   default:  return JSVERSION_UNKNOWN;
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::SplitMimeType(const nsAString& aValue, nsString& aType,
michael@0:                               nsString& aParams)
michael@0: {
michael@0:   aType.Truncate();
michael@0:   aParams.Truncate();
michael@0:   int32_t semiIndex = aValue.FindChar(char16_t(';'));
michael@0:   if (-1 != semiIndex) {
michael@0:     aType = Substring(aValue, 0, semiIndex);
michael@0:     aParams = Substring(aValue, semiIndex + 1,
michael@0:                        aValue.Length() - (semiIndex + 1));
michael@0:     aParams.StripWhitespace();
michael@0:   }
michael@0:   else {
michael@0:     aType = aValue;
michael@0:   }
michael@0:   aType.StripWhitespace();
michael@0: }
michael@0: 
michael@0: nsresult 
michael@0: nsContentUtils::IsUserIdle(uint32_t aRequestedIdleTimeInMS, bool* aUserIsIdle)
michael@0: {
michael@0:   nsresult rv;
michael@0:   nsCOMPtr<nsIIdleService> idleService = 
michael@0:     do_GetService("@mozilla.org/widget/idleservice;1", &rv);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0:     
michael@0:   uint32_t idleTimeInMS;
michael@0:   rv = idleService->GetIdleTime(&idleTimeInMS);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   *aUserIsIdle = idleTimeInMS >= aRequestedIdleTimeInMS;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * Access a cached parser service. Don't addref. We need only one
michael@0:  * reference to it and this class has that one.
michael@0:  */
michael@0: /* static */
michael@0: nsIParserService*
michael@0: nsContentUtils::GetParserService()
michael@0: {
michael@0:   // XXX: This isn't accessed from several threads, is it?
michael@0:   if (!sParserService) {
michael@0:     // Lock, recheck sCachedParserService and aquire if this should be
michael@0:     // safe for multiple threads.
michael@0:     nsresult rv = CallGetService(kParserServiceCID, &sParserService);
michael@0:     if (NS_FAILED(rv)) {
michael@0:       sParserService = nullptr;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return sParserService;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * A helper function that parses a sandbox attribute (of an <iframe> or
michael@0:  * a CSP directive) and converts it to the set of flags used internally.
michael@0:  *
michael@0:  * @param sandboxAttr   the sandbox attribute
michael@0:  * @return              the set of flags (0 if sandboxAttr is null)
michael@0:  */
michael@0: uint32_t
michael@0: nsContentUtils::ParseSandboxAttributeToFlags(const nsAttrValue* sandboxAttr)
michael@0: {
michael@0:   // No sandbox attribute, no sandbox flags.
michael@0:   if (!sandboxAttr) { return 0; }
michael@0: 
michael@0:   //  Start off by setting all the restriction flags.
michael@0:   uint32_t out = SANDBOXED_NAVIGATION
michael@0:                | SANDBOXED_AUXILIARY_NAVIGATION
michael@0:                | SANDBOXED_TOPLEVEL_NAVIGATION
michael@0:                | SANDBOXED_PLUGINS
michael@0:                | SANDBOXED_ORIGIN
michael@0:                | SANDBOXED_FORMS
michael@0:                | SANDBOXED_SCRIPTS
michael@0:                | SANDBOXED_AUTOMATIC_FEATURES
michael@0:                | SANDBOXED_POINTER_LOCK
michael@0:                | SANDBOXED_DOMAIN;
michael@0: 
michael@0: // Macro for updating the flag according to the keywords
michael@0: #define IF_KEYWORD(atom, flags) \
michael@0:   if (sandboxAttr->Contains(nsGkAtoms::atom, eIgnoreCase)) { out &= ~(flags); }
michael@0: 
michael@0:   IF_KEYWORD(allowsameorigin, SANDBOXED_ORIGIN)
michael@0:   IF_KEYWORD(allowforms,  SANDBOXED_FORMS)
michael@0:   IF_KEYWORD(allowscripts, SANDBOXED_SCRIPTS | SANDBOXED_AUTOMATIC_FEATURES)
michael@0:   IF_KEYWORD(allowtopnavigation, SANDBOXED_TOPLEVEL_NAVIGATION)
michael@0:   IF_KEYWORD(allowpointerlock, SANDBOXED_POINTER_LOCK)
michael@0:   IF_KEYWORD(allowpopups, SANDBOXED_AUXILIARY_NAVIGATION)
michael@0: 
michael@0:   return out;
michael@0: #undef IF_KEYWORD
michael@0: }
michael@0: 
michael@0: nsIBidiKeyboard*
michael@0: nsContentUtils::GetBidiKeyboard()
michael@0: {
michael@0:   if (!sBidiKeyboard) {
michael@0:     nsresult rv = CallGetService("@mozilla.org/widget/bidikeyboard;1", &sBidiKeyboard);
michael@0:     if (NS_FAILED(rv)) {
michael@0:       sBidiKeyboard = nullptr;
michael@0:     }
michael@0:   }
michael@0:   return sBidiKeyboard;
michael@0: }
michael@0: 
michael@0: template <class OutputIterator>
michael@0: struct NormalizeNewlinesCharTraits {
michael@0:   public:
michael@0:     typedef typename OutputIterator::value_type value_type;
michael@0: 
michael@0:   public:
michael@0:     NormalizeNewlinesCharTraits(OutputIterator& aIterator) : mIterator(aIterator) { }
michael@0:     void writechar(typename OutputIterator::value_type aChar) {
michael@0:       *mIterator++ = aChar;
michael@0:     }
michael@0: 
michael@0:   private:
michael@0:     OutputIterator mIterator;
michael@0: };
michael@0: 
michael@0: template <class CharT>
michael@0: struct NormalizeNewlinesCharTraits<CharT*> {
michael@0:   public:
michael@0:     typedef CharT value_type;
michael@0: 
michael@0:   public:
michael@0:     NormalizeNewlinesCharTraits(CharT* aCharPtr) : mCharPtr(aCharPtr) { }
michael@0:     void writechar(CharT aChar) {
michael@0:       *mCharPtr++ = aChar;
michael@0:     }
michael@0: 
michael@0:   private:
michael@0:     CharT* mCharPtr;
michael@0: };
michael@0: 
michael@0: template <class OutputIterator>
michael@0: class CopyNormalizeNewlines
michael@0: {
michael@0:   public:
michael@0:     typedef typename OutputIterator::value_type value_type;
michael@0: 
michael@0:   public:
michael@0:     CopyNormalizeNewlines(OutputIterator* aDestination,
michael@0:                           bool aLastCharCR=false) :
michael@0:       mLastCharCR(aLastCharCR),
michael@0:       mDestination(aDestination),
michael@0:       mWritten(0)
michael@0:     { }
michael@0: 
michael@0:     uint32_t GetCharsWritten() {
michael@0:       return mWritten;
michael@0:     }
michael@0: 
michael@0:     bool IsLastCharCR() {
michael@0:       return mLastCharCR;
michael@0:     }
michael@0: 
michael@0:     void write(const typename OutputIterator::value_type* aSource, uint32_t aSourceLength) {
michael@0: 
michael@0:       const typename OutputIterator::value_type* done_writing = aSource + aSourceLength;
michael@0: 
michael@0:       // If the last source buffer ended with a CR...
michael@0:       if (mLastCharCR) {
michael@0:         // ..and if the next one is a LF, then skip it since
michael@0:         // we've already written out a newline
michael@0:         if (aSourceLength && (*aSource == value_type('\n'))) {
michael@0:           ++aSource;
michael@0:         }
michael@0:         mLastCharCR = false;
michael@0:       }
michael@0: 
michael@0:       uint32_t num_written = 0;
michael@0:       while ( aSource < done_writing ) {
michael@0:         if (*aSource == value_type('\r')) {
michael@0:           mDestination->writechar('\n');
michael@0:           ++aSource;
michael@0:           // If we've reached the end of the buffer, record
michael@0:           // that we wrote out a CR
michael@0:           if (aSource == done_writing) {
michael@0:             mLastCharCR = true;
michael@0:           }
michael@0:           // If the next character is a LF, skip it
michael@0:           else if (*aSource == value_type('\n')) {
michael@0:             ++aSource;
michael@0:           }
michael@0:         }
michael@0:         else {
michael@0:           mDestination->writechar(*aSource++);
michael@0:         }
michael@0:         ++num_written;
michael@0:       }
michael@0: 
michael@0:       mWritten += num_written;
michael@0:     }
michael@0: 
michael@0:   private:
michael@0:     bool mLastCharCR;
michael@0:     OutputIterator* mDestination;
michael@0:     uint32_t mWritten;
michael@0: };
michael@0: 
michael@0: // static
michael@0: uint32_t
michael@0: nsContentUtils::CopyNewlineNormalizedUnicodeTo(const nsAString& aSource,
michael@0:                                                uint32_t aSrcOffset,
michael@0:                                                char16_t* aDest,
michael@0:                                                uint32_t aLength,
michael@0:                                                bool& aLastCharCR)
michael@0: {
michael@0:   typedef NormalizeNewlinesCharTraits<char16_t*> sink_traits;
michael@0: 
michael@0:   sink_traits dest_traits(aDest);
michael@0:   CopyNormalizeNewlines<sink_traits> normalizer(&dest_traits,aLastCharCR);
michael@0:   nsReadingIterator<char16_t> fromBegin, fromEnd;
michael@0:   copy_string(aSource.BeginReading(fromBegin).advance( int32_t(aSrcOffset) ),
michael@0:               aSource.BeginReading(fromEnd).advance( int32_t(aSrcOffset+aLength) ),
michael@0:               normalizer);
michael@0:   aLastCharCR = normalizer.IsLastCharCR();
michael@0:   return normalizer.GetCharsWritten();
michael@0: }
michael@0: 
michael@0: // static
michael@0: uint32_t
michael@0: nsContentUtils::CopyNewlineNormalizedUnicodeTo(nsReadingIterator<char16_t>& aSrcStart, const nsReadingIterator<char16_t>& aSrcEnd, nsAString& aDest)
michael@0: {
michael@0:   typedef nsWritingIterator<char16_t> WritingIterator;
michael@0:   typedef NormalizeNewlinesCharTraits<WritingIterator> sink_traits;
michael@0: 
michael@0:   WritingIterator iter;
michael@0:   aDest.BeginWriting(iter);
michael@0:   sink_traits dest_traits(iter);
michael@0:   CopyNormalizeNewlines<sink_traits> normalizer(&dest_traits);
michael@0:   copy_string(aSrcStart, aSrcEnd, normalizer);
michael@0:   return normalizer.GetCharsWritten();
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * This is used to determine whether a character is in one of the punctuation
michael@0:  * mark classes which CSS says should be part of the first-letter.
michael@0:  * See http://www.w3.org/TR/CSS2/selector.html#first-letter and
michael@0:  *     http://www.w3.org/TR/selectors/#first-letter
michael@0:  */
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::IsFirstLetterPunctuation(uint32_t aChar)
michael@0: {
michael@0:   uint8_t cat = mozilla::unicode::GetGeneralCategory(aChar);
michael@0: 
michael@0:   return (cat == HB_UNICODE_GENERAL_CATEGORY_OPEN_PUNCTUATION ||     // Ps
michael@0:           cat == HB_UNICODE_GENERAL_CATEGORY_CLOSE_PUNCTUATION ||    // Pe
michael@0:           cat == HB_UNICODE_GENERAL_CATEGORY_INITIAL_PUNCTUATION ||  // Pi
michael@0:           cat == HB_UNICODE_GENERAL_CATEGORY_FINAL_PUNCTUATION ||    // Pf
michael@0:           cat == HB_UNICODE_GENERAL_CATEGORY_OTHER_PUNCTUATION);     // Po
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::IsFirstLetterPunctuationAt(const nsTextFragment* aFrag, uint32_t aOffset)
michael@0: {
michael@0:   char16_t h = aFrag->CharAt(aOffset);
michael@0:   if (!IS_SURROGATE(h)) {
michael@0:     return IsFirstLetterPunctuation(h);
michael@0:   }
michael@0:   if (NS_IS_HIGH_SURROGATE(h) && aOffset + 1 < aFrag->GetLength()) {
michael@0:     char16_t l = aFrag->CharAt(aOffset + 1);
michael@0:     if (NS_IS_LOW_SURROGATE(l)) {
michael@0:       return IsFirstLetterPunctuation(SURROGATE_TO_UCS4(h, l));
michael@0:     }
michael@0:   }
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool nsContentUtils::IsAlphanumeric(uint32_t aChar)
michael@0: {
michael@0:   nsIUGenCategory::nsUGenCategory cat = mozilla::unicode::GetGenCategory(aChar);
michael@0: 
michael@0:   return (cat == nsIUGenCategory::kLetter || cat == nsIUGenCategory::kNumber);
michael@0: }
michael@0:  
michael@0: // static
michael@0: bool nsContentUtils::IsAlphanumericAt(const nsTextFragment* aFrag, uint32_t aOffset)
michael@0: {
michael@0:   char16_t h = aFrag->CharAt(aOffset);
michael@0:   if (!IS_SURROGATE(h)) {
michael@0:     return IsAlphanumeric(h);
michael@0:   }
michael@0:   if (NS_IS_HIGH_SURROGATE(h) && aOffset + 1 < aFrag->GetLength()) {
michael@0:     char16_t l = aFrag->CharAt(aOffset + 1);
michael@0:     if (NS_IS_LOW_SURROGATE(l)) {
michael@0:       return IsAlphanumeric(SURROGATE_TO_UCS4(h, l));
michael@0:     }
michael@0:   }
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::IsHTMLWhitespace(char16_t aChar)
michael@0: {
michael@0:   return aChar == char16_t(0x0009) ||
michael@0:          aChar == char16_t(0x000A) ||
michael@0:          aChar == char16_t(0x000C) ||
michael@0:          aChar == char16_t(0x000D) ||
michael@0:          aChar == char16_t(0x0020);
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::IsHTMLWhitespaceOrNBSP(char16_t aChar)
michael@0: {
michael@0:   return IsHTMLWhitespace(aChar) || aChar == char16_t(0xA0);
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::IsHTMLBlock(nsIAtom* aLocalName)
michael@0: {
michael@0:   return
michael@0:     (aLocalName == nsGkAtoms::address) ||
michael@0:     (aLocalName == nsGkAtoms::article) ||
michael@0:     (aLocalName == nsGkAtoms::aside) ||
michael@0:     (aLocalName == nsGkAtoms::blockquote) ||
michael@0:     (aLocalName == nsGkAtoms::center) ||
michael@0:     (aLocalName == nsGkAtoms::dir) ||
michael@0:     (aLocalName == nsGkAtoms::div) ||
michael@0:     (aLocalName == nsGkAtoms::dl) || // XXX why not dt and dd?
michael@0:     (aLocalName == nsGkAtoms::fieldset) ||
michael@0:     (aLocalName == nsGkAtoms::figure) || // XXX shouldn't figcaption be on this list
michael@0:     (aLocalName == nsGkAtoms::footer) ||
michael@0:     (aLocalName == nsGkAtoms::form) ||
michael@0:     (aLocalName == nsGkAtoms::h1) ||
michael@0:     (aLocalName == nsGkAtoms::h2) ||
michael@0:     (aLocalName == nsGkAtoms::h3) ||
michael@0:     (aLocalName == nsGkAtoms::h4) ||
michael@0:     (aLocalName == nsGkAtoms::h5) ||
michael@0:     (aLocalName == nsGkAtoms::h6) ||
michael@0:     (aLocalName == nsGkAtoms::header) ||
michael@0:     (aLocalName == nsGkAtoms::hgroup) ||
michael@0:     (aLocalName == nsGkAtoms::hr) ||
michael@0:     (aLocalName == nsGkAtoms::li) ||
michael@0:     (aLocalName == nsGkAtoms::listing) ||
michael@0:     (aLocalName == nsGkAtoms::menu) ||
michael@0:     (aLocalName == nsGkAtoms::multicol) || // XXX get rid of this one?
michael@0:     (aLocalName == nsGkAtoms::nav) ||
michael@0:     (aLocalName == nsGkAtoms::ol) ||
michael@0:     (aLocalName == nsGkAtoms::p) ||
michael@0:     (aLocalName == nsGkAtoms::pre) ||
michael@0:     (aLocalName == nsGkAtoms::section) ||
michael@0:     (aLocalName == nsGkAtoms::table) ||
michael@0:     (aLocalName == nsGkAtoms::ul) ||
michael@0:     (aLocalName == nsGkAtoms::xmp);
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::IsHTMLVoid(nsIAtom* aLocalName)
michael@0: {
michael@0:   return
michael@0:     (aLocalName == nsGkAtoms::area) ||
michael@0:     (aLocalName == nsGkAtoms::base) ||
michael@0:     (aLocalName == nsGkAtoms::basefont) ||
michael@0:     (aLocalName == nsGkAtoms::bgsound) ||
michael@0:     (aLocalName == nsGkAtoms::br) ||
michael@0:     (aLocalName == nsGkAtoms::col) ||
michael@0:     (aLocalName == nsGkAtoms::command) ||
michael@0:     (aLocalName == nsGkAtoms::embed) ||
michael@0:     (aLocalName == nsGkAtoms::frame) ||
michael@0:     (aLocalName == nsGkAtoms::hr) ||
michael@0:     (aLocalName == nsGkAtoms::img) ||
michael@0:     (aLocalName == nsGkAtoms::input) ||
michael@0:     (aLocalName == nsGkAtoms::keygen) ||
michael@0:     (aLocalName == nsGkAtoms::link) ||
michael@0:     (aLocalName == nsGkAtoms::meta) ||
michael@0:     (aLocalName == nsGkAtoms::param) ||
michael@0:     (aLocalName == nsGkAtoms::source) ||
michael@0:     (aLocalName == nsGkAtoms::track) ||
michael@0:     (aLocalName == nsGkAtoms::wbr);
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::ParseIntMarginValue(const nsAString& aString, nsIntMargin& result)
michael@0: {
michael@0:   nsAutoString marginStr(aString);
michael@0:   marginStr.CompressWhitespace(true, true);
michael@0:   if (marginStr.IsEmpty()) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   int32_t start = 0, end = 0;
michael@0:   for (int count = 0; count < 4; count++) {
michael@0:     if ((uint32_t)end >= marginStr.Length())
michael@0:       return false;
michael@0: 
michael@0:     // top, right, bottom, left
michael@0:     if (count < 3)
michael@0:       end = Substring(marginStr, start).FindChar(',');
michael@0:     else
michael@0:       end = Substring(marginStr, start).Length();
michael@0: 
michael@0:     if (end <= 0)
michael@0:       return false;
michael@0: 
michael@0:     nsresult ec;
michael@0:     int32_t val = nsString(Substring(marginStr, start, end)).ToInteger(&ec);
michael@0:     if (NS_FAILED(ec))
michael@0:       return false;
michael@0: 
michael@0:     switch(count) {
michael@0:       case 0:
michael@0:         result.top = val;
michael@0:       break;
michael@0:       case 1:
michael@0:         result.right = val;
michael@0:       break;
michael@0:       case 2:
michael@0:         result.bottom = val;
michael@0:       break;
michael@0:       case 3:
michael@0:         result.left = val;
michael@0:       break;
michael@0:     }
michael@0:     start += end + 1;
michael@0:   }
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: // static
michael@0: int32_t
michael@0: nsContentUtils::ParseLegacyFontSize(const nsAString& aValue)
michael@0: {
michael@0:   nsAString::const_iterator iter, end;
michael@0:   aValue.BeginReading(iter);
michael@0:   aValue.EndReading(end);
michael@0: 
michael@0:   while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
michael@0:     ++iter;
michael@0:   }
michael@0: 
michael@0:   if (iter == end) {
michael@0:     return 0;
michael@0:   }
michael@0: 
michael@0:   bool relative = false;
michael@0:   bool negate = false;
michael@0:   if (*iter == char16_t('-')) {
michael@0:     relative = true;
michael@0:     negate = true;
michael@0:     ++iter;
michael@0:   } else if (*iter == char16_t('+')) {
michael@0:     relative = true;
michael@0:     ++iter;
michael@0:   }
michael@0: 
michael@0:   if (*iter < char16_t('0') || *iter > char16_t('9')) {
michael@0:     return 0;
michael@0:   }
michael@0: 
michael@0:   // We don't have to worry about overflow, since we can bail out as soon as
michael@0:   // we're bigger than 7.
michael@0:   int32_t value = 0;
michael@0:   while (iter != end && *iter >= char16_t('0') && *iter <= char16_t('9')) {
michael@0:     value = 10*value + (*iter - char16_t('0'));
michael@0:     if (value >= 7) {
michael@0:       break;
michael@0:     }
michael@0:     ++iter;
michael@0:   }
michael@0: 
michael@0:   if (relative) {
michael@0:     if (negate) {
michael@0:       value = 3 - value;
michael@0:     } else {
michael@0:       value = 3 + value;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return clamped(value, 1, 7);
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::GetOfflineAppManifest(nsIDocument *aDocument, nsIURI **aURI)
michael@0: {
michael@0:   Element* docElement = aDocument->GetRootElement();
michael@0:   if (!docElement) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   nsAutoString manifestSpec;
michael@0:   docElement->GetAttr(kNameSpaceID_None, nsGkAtoms::manifest, manifestSpec);
michael@0: 
michael@0:   // Manifest URIs can't have fragment identifiers.
michael@0:   if (manifestSpec.IsEmpty() ||
michael@0:       manifestSpec.FindChar('#') != kNotFound) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   nsContentUtils::NewURIWithDocumentCharset(aURI, manifestSpec,
michael@0:                                             aDocument,
michael@0:                                             aDocument->GetDocBaseURI());
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::OfflineAppAllowed(nsIURI *aURI)
michael@0: {
michael@0:   nsCOMPtr<nsIOfflineCacheUpdateService> updateService =
michael@0:     do_GetService(NS_OFFLINECACHEUPDATESERVICE_CONTRACTID);
michael@0:   if (!updateService) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   bool allowed;
michael@0:   nsresult rv =
michael@0:     updateService->OfflineAppAllowedForURI(aURI,
michael@0:                                            Preferences::GetRootBranch(),
michael@0:                                            &allowed);
michael@0:   return NS_SUCCEEDED(rv) && allowed;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::OfflineAppAllowed(nsIPrincipal *aPrincipal)
michael@0: {
michael@0:   nsCOMPtr<nsIOfflineCacheUpdateService> updateService =
michael@0:     do_GetService(NS_OFFLINECACHEUPDATESERVICE_CONTRACTID);
michael@0:   if (!updateService) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   bool allowed;
michael@0:   nsresult rv = updateService->OfflineAppAllowed(aPrincipal,
michael@0:                                                  Preferences::GetRootBranch(),
michael@0:                                                  &allowed);
michael@0:   return NS_SUCCEEDED(rv) && allowed;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::MaybeAllowOfflineAppByDefault(nsIPrincipal *aPrincipal,
michael@0:                                               nsIDOMWindow *aWindow)
michael@0: {
michael@0:   if (!Preferences::GetRootBranch())
michael@0:     return false;
michael@0: 
michael@0:   nsresult rv;
michael@0: 
michael@0:   bool allowedByDefault;
michael@0:   rv = Preferences::GetRootBranch()->GetBoolPref(
michael@0:     "offline-apps.allow_by_default", &allowedByDefault);
michael@0:   if (NS_FAILED(rv))
michael@0:     return false;
michael@0: 
michael@0:   if (!allowedByDefault)
michael@0:     return false;
michael@0: 
michael@0:   nsCOMPtr<nsIOfflineCacheUpdateService> updateService =
michael@0:     do_GetService(NS_OFFLINECACHEUPDATESERVICE_CONTRACTID);
michael@0:   if (!updateService) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   rv = updateService->AllowOfflineApp(aWindow, aPrincipal);
michael@0:   return NS_SUCCEEDED(rv);
michael@0: }
michael@0: 
michael@0: // static
michael@0: void
michael@0: nsContentUtils::Shutdown()
michael@0: {
michael@0:   sInitialized = false;
michael@0: 
michael@0:   NS_IF_RELEASE(sContentPolicyService);
michael@0:   sTriedToGetContentPolicy = false;
michael@0:   uint32_t i;
michael@0:   for (i = 0; i < PropertiesFile_COUNT; ++i)
michael@0:     NS_IF_RELEASE(sStringBundles[i]);
michael@0: 
michael@0:   NS_IF_RELEASE(sStringBundleService);
michael@0:   NS_IF_RELEASE(sConsoleService);
michael@0:   sXPConnect = nullptr;
michael@0:   NS_IF_RELEASE(sSecurityManager);
michael@0:   NS_IF_RELEASE(sParserService);
michael@0:   NS_IF_RELEASE(sIOService);
michael@0:   NS_IF_RELEASE(sLineBreaker);
michael@0:   NS_IF_RELEASE(sWordBreaker);
michael@0:   NS_IF_RELEASE(sBidiKeyboard);
michael@0: 
michael@0:   delete sAtomEventTable;
michael@0:   sAtomEventTable = nullptr;
michael@0:   delete sStringEventTable;
michael@0:   sStringEventTable = nullptr;
michael@0:   delete sUserDefinedEvents;
michael@0:   sUserDefinedEvents = nullptr;
michael@0: 
michael@0:   if (sEventListenerManagersHash.ops) {
michael@0:     NS_ASSERTION(sEventListenerManagersHash.entryCount == 0,
michael@0:                  "Event listener manager hash not empty at shutdown!");
michael@0: 
michael@0:     // See comment above.
michael@0: 
michael@0:     // However, we have to handle this table differently.  If it still
michael@0:     // has entries, we want to leak it too, so that we can keep it alive
michael@0:     // in case any elements are destroyed.  Because if they are, we need
michael@0:     // their event listener managers to be destroyed too, or otherwise
michael@0:     // it could leave dangling references in DOMClassInfo's preserved
michael@0:     // wrapper table.
michael@0: 
michael@0:     if (sEventListenerManagersHash.entryCount == 0) {
michael@0:       PL_DHashTableFinish(&sEventListenerManagersHash);
michael@0:       sEventListenerManagersHash.ops = nullptr;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   NS_ASSERTION(!sBlockedScriptRunners ||
michael@0:                sBlockedScriptRunners->Length() == 0,
michael@0:                "How'd this happen?");
michael@0:   delete sBlockedScriptRunners;
michael@0:   sBlockedScriptRunners = nullptr;
michael@0: 
michael@0:   delete sShiftText;
michael@0:   sShiftText = nullptr;
michael@0:   delete sControlText;  
michael@0:   sControlText = nullptr;
michael@0:   delete sMetaText;  
michael@0:   sMetaText = nullptr;
michael@0:   delete sOSText;
michael@0:   sOSText = nullptr;
michael@0:   delete sAltText;  
michael@0:   sAltText = nullptr;
michael@0:   delete sModifierSeparator;
michael@0:   sModifierSeparator = nullptr;
michael@0: 
michael@0:   NS_IF_RELEASE(sSameOriginChecker);
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * Checks whether two nodes come from the same origin. aTrustedNode is
michael@0:  * considered 'safe' in that a user can operate on it and that it isn't
michael@0:  * a js-object that implements nsIDOMNode.
michael@0:  * Never call this function with the first node provided by script, it
michael@0:  * must always be known to be a 'real' node!
michael@0:  */
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::CheckSameOrigin(const nsINode *aTrustedNode,
michael@0:                                 nsIDOMNode *aUnTrustedNode)
michael@0: {
michael@0:   MOZ_ASSERT(aTrustedNode);
michael@0: 
michael@0:   // Make sure it's a real node.
michael@0:   nsCOMPtr<nsINode> unTrustedNode = do_QueryInterface(aUnTrustedNode);
michael@0:   NS_ENSURE_TRUE(unTrustedNode, NS_ERROR_UNEXPECTED);
michael@0:   return CheckSameOrigin(aTrustedNode, unTrustedNode);
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsContentUtils::CheckSameOrigin(const nsINode* aTrustedNode,
michael@0:                                 const nsINode* unTrustedNode)
michael@0: {
michael@0:   MOZ_ASSERT(aTrustedNode);
michael@0:   MOZ_ASSERT(unTrustedNode);
michael@0: 
michael@0:   bool isSystem = false;
michael@0:   nsresult rv = sSecurityManager->SubjectPrincipalIsSystem(&isSystem);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   if (isSystem) {
michael@0:     // we're running as system, grant access to the node.
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   /*
michael@0:    * Get hold of each node's principal
michael@0:    */
michael@0: 
michael@0:   nsIPrincipal* trustedPrincipal = aTrustedNode->NodePrincipal();
michael@0:   nsIPrincipal* unTrustedPrincipal = unTrustedNode->NodePrincipal();
michael@0: 
michael@0:   if (trustedPrincipal == unTrustedPrincipal) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   bool equal;
michael@0:   // XXXbz should we actually have a Subsumes() check here instead?  Or perhaps
michael@0:   // a separate method for that, with callers using one or the other?
michael@0:   if (NS_FAILED(trustedPrincipal->Equals(unTrustedPrincipal, &equal)) ||
michael@0:       !equal) {
michael@0:     return NS_ERROR_DOM_PROP_ACCESS_DENIED;
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::CanCallerAccess(nsIPrincipal* aSubjectPrincipal,
michael@0:                                 nsIPrincipal* aPrincipal)
michael@0: {
michael@0:   bool subsumes;
michael@0:   nsresult rv = aSubjectPrincipal->Subsumes(aPrincipal, &subsumes);
michael@0:   NS_ENSURE_SUCCESS(rv, false);
michael@0: 
michael@0:   if (subsumes) {
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   // The subject doesn't subsume aPrincipal. Allow access only if the subject
michael@0:   // is chrome.
michael@0:   return IsCallerChrome();
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::CanCallerAccess(nsIDOMNode *aNode)
michael@0: {
michael@0:   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
michael@0:   NS_ENSURE_TRUE(node, false);
michael@0:   return CanCallerAccess(node);
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::CanCallerAccess(nsINode* aNode)
michael@0: {
michael@0:   // XXXbz why not check the IsCapabilityEnabled thing up front, and not bother
michael@0:   // with the system principal games?  But really, there should be a simpler
michael@0:   // API here, dammit.
michael@0:   nsCOMPtr<nsIPrincipal> subjectPrincipal;
michael@0:   nsresult rv = sSecurityManager->GetSubjectPrincipal(getter_AddRefs(subjectPrincipal));
michael@0:   NS_ENSURE_SUCCESS(rv, false);
michael@0: 
michael@0:   if (!subjectPrincipal) {
michael@0:     // we're running as system, grant access to the node.
michael@0: 
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   return CanCallerAccess(subjectPrincipal, aNode->NodePrincipal());
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::CanCallerAccess(nsPIDOMWindow* aWindow)
michael@0: {
michael@0:   // XXXbz why not check the IsCapabilityEnabled thing up front, and not bother
michael@0:   // with the system principal games?  But really, there should be a simpler
michael@0:   // API here, dammit.
michael@0:   nsCOMPtr<nsIPrincipal> subjectPrincipal;
michael@0:   nsresult rv = sSecurityManager->GetSubjectPrincipal(getter_AddRefs(subjectPrincipal));
michael@0:   NS_ENSURE_SUCCESS(rv, false);
michael@0: 
michael@0:   if (!subjectPrincipal) {
michael@0:     // we're running as system, grant access to the node.
michael@0: 
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIScriptObjectPrincipal> scriptObject =
michael@0:     do_QueryInterface(aWindow->IsOuterWindow() ?
michael@0:                       aWindow->GetCurrentInnerWindow() : aWindow);
michael@0:   NS_ENSURE_TRUE(scriptObject, false);
michael@0: 
michael@0:   return CanCallerAccess(subjectPrincipal, scriptObject->GetPrincipal());
michael@0: }
michael@0: 
michael@0: //static
michael@0: bool
michael@0: nsContentUtils::InProlog(nsINode *aNode)
michael@0: {
michael@0:   NS_PRECONDITION(aNode, "missing node to nsContentUtils::InProlog");
michael@0: 
michael@0:   nsINode* parent = aNode->GetParentNode();
michael@0:   if (!parent || !parent->IsNodeOfType(nsINode::eDOCUMENT)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   nsIDocument* doc = static_cast<nsIDocument*>(parent);
michael@0:   nsIContent* root = doc->GetRootElement();
michael@0: 
michael@0:   return !root || doc->IndexOf(aNode) < doc->IndexOf(root);
michael@0: }
michael@0: 
michael@0: JSContext *
michael@0: nsContentUtils::GetContextFromDocument(nsIDocument *aDocument)
michael@0: {
michael@0:   nsCOMPtr<nsIScriptGlobalObject> sgo =  do_QueryInterface(aDocument->GetScopeObject());
michael@0:   if (!sgo) {
michael@0:     // No script global, no context.
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   nsIScriptContext *scx = sgo->GetContext();
michael@0:   if (!scx) {
michael@0:     // No context left in the scope...
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   return scx->GetNativeContext();
michael@0: }
michael@0: 
michael@0: //static
michael@0: void
michael@0: nsContentUtils::TraceSafeJSContext(JSTracer* aTrc)
michael@0: {
michael@0:   JSContext* cx = GetSafeJSContext();
michael@0:   if (!cx) {
michael@0:     return;
michael@0:   }
michael@0:   if (JSObject* global = js::DefaultObjectForContextOrNull(cx)) {
michael@0:     JS::AssertGCThingMustBeTenured(global);
michael@0:     JS_CallObjectTracer(aTrc, &global, "safe context");
michael@0:     MOZ_ASSERT(global == js::DefaultObjectForContextOrNull(cx));
michael@0:   }
michael@0: }
michael@0: 
michael@0: nsPIDOMWindow *
michael@0: nsContentUtils::GetWindowFromCaller()
michael@0: {
michael@0:   JSContext *cx = GetCurrentJSContext();
michael@0:   if (cx) {
michael@0:     nsCOMPtr<nsPIDOMWindow> win =
michael@0:       do_QueryInterface(nsJSUtils::GetDynamicScriptGlobal(cx));
michael@0:     return win;
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: nsIDocument*
michael@0: nsContentUtils::GetDocumentFromCaller()
michael@0: {
michael@0:   AutoJSContext cx;
michael@0: 
michael@0:   nsCOMPtr<nsPIDOMWindow> win =
michael@0:     do_QueryInterface(nsJSUtils::GetStaticScriptGlobal(JS::CurrentGlobalOrNull(cx)));
michael@0:   if (!win) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   return win->GetExtantDoc();
michael@0: }
michael@0: 
michael@0: nsIDocument*
michael@0: nsContentUtils::GetDocumentFromContext()
michael@0: {
michael@0:   JSContext *cx = GetCurrentJSContext();
michael@0:   if (cx) {
michael@0:     nsIScriptGlobalObject *sgo = nsJSUtils::GetDynamicScriptGlobal(cx);
michael@0: 
michael@0:     if (sgo) {
michael@0:       nsCOMPtr<nsPIDOMWindow> pwin = do_QueryInterface(sgo);
michael@0:       if (pwin) {
michael@0:         return pwin->GetExtantDoc();
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsCallerChrome()
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   bool is_caller_chrome = false;
michael@0:   nsresult rv = sSecurityManager->SubjectPrincipalIsSystem(&is_caller_chrome);
michael@0:   if (NS_FAILED(rv)) {
michael@0:     return false;
michael@0:   }
michael@0:   if (is_caller_chrome) {
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   // If the check failed, look for UniversalXPConnect on the cx compartment.
michael@0:   return xpc::IsUniversalXPConnectEnabled(GetCurrentJSContext());
michael@0: }
michael@0: 
michael@0: namespace mozilla {
michael@0: namespace dom {
michael@0: namespace workers {
michael@0: extern bool IsCurrentThreadRunningChromeWorker();
michael@0: extern JSContext* GetCurrentThreadJSContext();
michael@0: }
michael@0: }
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::ThreadsafeIsCallerChrome()
michael@0: {
michael@0:   return NS_IsMainThread() ?
michael@0:     IsCallerChrome() :
michael@0:     mozilla::dom::workers::IsCurrentThreadRunningChromeWorker();
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsCallerXBL()
michael@0: {
michael@0:     JSContext *cx = GetCurrentJSContext();
michael@0:     if (!cx)
michael@0:         return false;
michael@0: 
michael@0:     JSCompartment *c = js::GetContextCompartment(cx);
michael@0: 
michael@0:     // For remote XUL, we run XBL in the XUL scope. Given that we care about
michael@0:     // compat and not security for remote XUL, just always claim to be XBL.
michael@0:     if (!xpc::AllowXBLScope(c)) {
michael@0:       MOZ_ASSERT(nsContentUtils::AllowXULXBLForPrincipal(xpc::GetCompartmentPrincipal(c)));
michael@0:       return true;
michael@0:     }
michael@0: 
michael@0:     return xpc::IsXBLScope(c);
michael@0: }
michael@0: 
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsImageSrcSetDisabled()
michael@0: {
michael@0:   return Preferences::GetBool("dom.disable_image_src_set") &&
michael@0:          !IsCallerChrome();
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::LookupBindingMember(JSContext* aCx, nsIContent *aContent,
michael@0:                                     JS::Handle<jsid> aId,
michael@0:                                     JS::MutableHandle<JSPropertyDescriptor> aDesc)
michael@0: {
michael@0:   nsXBLBinding* binding = aContent->GetXBLBinding();
michael@0:   if (!binding)
michael@0:     return true;
michael@0:   return binding->LookupMember(aCx, aId, aDesc);
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsINode*
michael@0: nsContentUtils::GetCrossDocParentNode(nsINode* aChild)
michael@0: {
michael@0:   NS_PRECONDITION(aChild, "The child is null!");
michael@0: 
michael@0:   nsINode* parent = aChild->GetParentNode();
michael@0:   if (parent || !aChild->IsNodeOfType(nsINode::eDOCUMENT))
michael@0:     return parent;
michael@0: 
michael@0:   nsIDocument* doc = static_cast<nsIDocument*>(aChild);
michael@0:   nsIDocument* parentDoc = doc->GetParentDocument();
michael@0:   return parentDoc ? parentDoc->FindContentForSubDocument(doc) : nullptr;
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::ContentIsDescendantOf(const nsINode* aPossibleDescendant,
michael@0:                                       const nsINode* aPossibleAncestor)
michael@0: {
michael@0:   NS_PRECONDITION(aPossibleDescendant, "The possible descendant is null!");
michael@0:   NS_PRECONDITION(aPossibleAncestor, "The possible ancestor is null!");
michael@0: 
michael@0:   do {
michael@0:     if (aPossibleDescendant == aPossibleAncestor)
michael@0:       return true;
michael@0:     aPossibleDescendant = aPossibleDescendant->GetParentNode();
michael@0:   } while (aPossibleDescendant);
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::ContentIsHostIncludingDescendantOf(
michael@0:   const nsINode* aPossibleDescendant, const nsINode* aPossibleAncestor)
michael@0: {
michael@0:   NS_PRECONDITION(aPossibleDescendant, "The possible descendant is null!");
michael@0:   NS_PRECONDITION(aPossibleAncestor, "The possible ancestor is null!");
michael@0: 
michael@0:   do {
michael@0:     if (aPossibleDescendant == aPossibleAncestor)
michael@0:       return true;
michael@0:     if (aPossibleDescendant->NodeType() == nsIDOMNode::DOCUMENT_FRAGMENT_NODE) {
michael@0:       aPossibleDescendant =
michael@0:         static_cast<const DocumentFragment*>(aPossibleDescendant)->GetHost();
michael@0:     } else {
michael@0:       aPossibleDescendant = aPossibleDescendant->GetParentNode();
michael@0:     }
michael@0:   } while (aPossibleDescendant);
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::ContentIsCrossDocDescendantOf(nsINode* aPossibleDescendant,
michael@0:                                               nsINode* aPossibleAncestor)
michael@0: {
michael@0:   NS_PRECONDITION(aPossibleDescendant, "The possible descendant is null!");
michael@0:   NS_PRECONDITION(aPossibleAncestor, "The possible ancestor is null!");
michael@0: 
michael@0:   do {
michael@0:     if (aPossibleDescendant == aPossibleAncestor)
michael@0:       return true;
michael@0:     aPossibleDescendant = GetCrossDocParentNode(aPossibleDescendant);
michael@0:   } while (aPossibleDescendant);
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::GetAncestors(nsINode* aNode,
michael@0:                              nsTArray<nsINode*>& aArray)
michael@0: {
michael@0:   while (aNode) {
michael@0:     aArray.AppendElement(aNode);
michael@0:     aNode = aNode->GetParentNode();
michael@0:   }
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::GetAncestorsAndOffsets(nsIDOMNode* aNode,
michael@0:                                        int32_t aOffset,
michael@0:                                        nsTArray<nsIContent*>* aAncestorNodes,
michael@0:                                        nsTArray<int32_t>* aAncestorOffsets)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aNode);
michael@0: 
michael@0:   nsCOMPtr<nsIContent> content(do_QueryInterface(aNode));
michael@0: 
michael@0:   if (!content) {
michael@0:     return NS_ERROR_FAILURE;
michael@0:   }
michael@0: 
michael@0:   if (!aAncestorNodes->IsEmpty()) {
michael@0:     NS_WARNING("aAncestorNodes is not empty");
michael@0:     aAncestorNodes->Clear();
michael@0:   }
michael@0: 
michael@0:   if (!aAncestorOffsets->IsEmpty()) {
michael@0:     NS_WARNING("aAncestorOffsets is not empty");
michael@0:     aAncestorOffsets->Clear();
michael@0:   }
michael@0: 
michael@0:   // insert the node itself
michael@0:   aAncestorNodes->AppendElement(content.get());
michael@0:   aAncestorOffsets->AppendElement(aOffset);
michael@0: 
michael@0:   // insert all the ancestors
michael@0:   nsIContent* child = content;
michael@0:   nsIContent* parent = child->GetParent();
michael@0:   while (parent) {
michael@0:     aAncestorNodes->AppendElement(parent);
michael@0:     aAncestorOffsets->AppendElement(parent->IndexOf(child));
michael@0:     child = parent;
michael@0:     parent = parent->GetParent();
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::GetCommonAncestor(nsIDOMNode *aNode,
michael@0:                                   nsIDOMNode *aOther,
michael@0:                                   nsIDOMNode** aCommonAncestor)
michael@0: {
michael@0:   *aCommonAncestor = nullptr;
michael@0: 
michael@0:   nsCOMPtr<nsINode> node1 = do_QueryInterface(aNode);
michael@0:   nsCOMPtr<nsINode> node2 = do_QueryInterface(aOther);
michael@0: 
michael@0:   NS_ENSURE_TRUE(node1 && node2, NS_ERROR_UNEXPECTED);
michael@0: 
michael@0:   nsINode* common = GetCommonAncestor(node1, node2);
michael@0:   NS_ENSURE_TRUE(common, NS_ERROR_NOT_AVAILABLE);
michael@0: 
michael@0:   return CallQueryInterface(common, aCommonAncestor);
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsINode*
michael@0: nsContentUtils::GetCommonAncestor(nsINode* aNode1,
michael@0:                                   nsINode* aNode2)
michael@0: {
michael@0:   if (aNode1 == aNode2) {
michael@0:     return aNode1;
michael@0:   }
michael@0: 
michael@0:   // Build the chain of parents
michael@0:   nsAutoTArray<nsINode*, 30> parents1, parents2;
michael@0:   do {
michael@0:     parents1.AppendElement(aNode1);
michael@0:     aNode1 = aNode1->GetParentNode();
michael@0:   } while (aNode1);
michael@0:   do {
michael@0:     parents2.AppendElement(aNode2);
michael@0:     aNode2 = aNode2->GetParentNode();
michael@0:   } while (aNode2);
michael@0: 
michael@0:   // Find where the parent chain differs
michael@0:   uint32_t pos1 = parents1.Length();
michael@0:   uint32_t pos2 = parents2.Length();
michael@0:   nsINode* parent = nullptr;
michael@0:   uint32_t len;
michael@0:   for (len = std::min(pos1, pos2); len > 0; --len) {
michael@0:     nsINode* child1 = parents1.ElementAt(--pos1);
michael@0:     nsINode* child2 = parents2.ElementAt(--pos2);
michael@0:     if (child1 != child2) {
michael@0:       break;
michael@0:     }
michael@0:     parent = child1;
michael@0:   }
michael@0: 
michael@0:   return parent;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::PositionIsBefore(nsINode* aNode1, nsINode* aNode2)
michael@0: {
michael@0:   return (aNode2->CompareDocumentPosition(*aNode1) &
michael@0:     (nsIDOMNode::DOCUMENT_POSITION_PRECEDING |
michael@0:      nsIDOMNode::DOCUMENT_POSITION_DISCONNECTED)) ==
michael@0:     nsIDOMNode::DOCUMENT_POSITION_PRECEDING;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: int32_t
michael@0: nsContentUtils::ComparePoints(nsINode* aParent1, int32_t aOffset1,
michael@0:                               nsINode* aParent2, int32_t aOffset2,
michael@0:                               bool* aDisconnected)
michael@0: {
michael@0:   if (aParent1 == aParent2) {
michael@0:     return aOffset1 < aOffset2 ? -1 :
michael@0:            aOffset1 > aOffset2 ? 1 :
michael@0:            0;
michael@0:   }
michael@0: 
michael@0:   nsAutoTArray<nsINode*, 32> parents1, parents2;
michael@0:   nsINode* node1 = aParent1;
michael@0:   nsINode* node2 = aParent2;
michael@0:   do {
michael@0:     parents1.AppendElement(node1);
michael@0:     node1 = node1->GetParentNode();
michael@0:   } while (node1);
michael@0:   do {
michael@0:     parents2.AppendElement(node2);
michael@0:     node2 = node2->GetParentNode();
michael@0:   } while (node2);
michael@0: 
michael@0:   uint32_t pos1 = parents1.Length() - 1;
michael@0:   uint32_t pos2 = parents2.Length() - 1;
michael@0:   
michael@0:   bool disconnected = parents1.ElementAt(pos1) != parents2.ElementAt(pos2);
michael@0:   if (aDisconnected) {
michael@0:     *aDisconnected = disconnected;
michael@0:   }
michael@0:   if (disconnected) {
michael@0:     NS_ASSERTION(aDisconnected, "unexpected disconnected nodes");
michael@0:     return 1;
michael@0:   }
michael@0: 
michael@0:   // Find where the parent chains differ
michael@0:   nsINode* parent = parents1.ElementAt(pos1);
michael@0:   uint32_t len;
michael@0:   for (len = std::min(pos1, pos2); len > 0; --len) {
michael@0:     nsINode* child1 = parents1.ElementAt(--pos1);
michael@0:     nsINode* child2 = parents2.ElementAt(--pos2);
michael@0:     if (child1 != child2) {
michael@0:       return parent->IndexOf(child1) < parent->IndexOf(child2) ? -1 : 1;
michael@0:     }
michael@0:     parent = child1;
michael@0:   }
michael@0: 
michael@0:   
michael@0:   // The parent chains never differed, so one of the nodes is an ancestor of
michael@0:   // the other
michael@0: 
michael@0:   NS_ASSERTION(!pos1 || !pos2,
michael@0:                "should have run out of parent chain for one of the nodes");
michael@0: 
michael@0:   if (!pos1) {
michael@0:     nsINode* child2 = parents2.ElementAt(--pos2);
michael@0:     return aOffset1 <= parent->IndexOf(child2) ? -1 : 1;
michael@0:   }
michael@0: 
michael@0:   nsINode* child1 = parents1.ElementAt(--pos1);
michael@0:   return parent->IndexOf(child1) < aOffset2 ? -1 : 1;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: int32_t
michael@0: nsContentUtils::ComparePoints(nsIDOMNode* aParent1, int32_t aOffset1,
michael@0:                               nsIDOMNode* aParent2, int32_t aOffset2,
michael@0:                               bool* aDisconnected)
michael@0: {
michael@0:   nsCOMPtr<nsINode> parent1 = do_QueryInterface(aParent1);
michael@0:   nsCOMPtr<nsINode> parent2 = do_QueryInterface(aParent2);
michael@0:   NS_ENSURE_TRUE(parent1 && parent2, -1);
michael@0:   return ComparePoints(parent1, aOffset1, parent2, aOffset2);
michael@0: }
michael@0: 
michael@0: inline bool
michael@0: IsCharInSet(const char* aSet,
michael@0:             const char16_t aChar)
michael@0: {
michael@0:   char16_t ch;
michael@0:   while ((ch = *aSet)) {
michael@0:     if (aChar == char16_t(ch)) {
michael@0:       return true;
michael@0:     }
michael@0:     ++aSet;
michael@0:   }
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * This method strips leading/trailing chars, in given set, from string.
michael@0:  */
michael@0: 
michael@0: // static
michael@0: const nsDependentSubstring
michael@0: nsContentUtils::TrimCharsInSet(const char* aSet,
michael@0:                                const nsAString& aValue)
michael@0: {
michael@0:   nsAString::const_iterator valueCurrent, valueEnd;
michael@0: 
michael@0:   aValue.BeginReading(valueCurrent);
michael@0:   aValue.EndReading(valueEnd);
michael@0: 
michael@0:   // Skip characters in the beginning
michael@0:   while (valueCurrent != valueEnd) {
michael@0:     if (!IsCharInSet(aSet, *valueCurrent)) {
michael@0:       break;
michael@0:     }
michael@0:     ++valueCurrent;
michael@0:   }
michael@0: 
michael@0:   if (valueCurrent != valueEnd) {
michael@0:     for (;;) {
michael@0:       --valueEnd;
michael@0:       if (!IsCharInSet(aSet, *valueEnd)) {
michael@0:         break;
michael@0:       }
michael@0:     }
michael@0:     ++valueEnd; // Step beyond the last character we want in the value.
michael@0:   }
michael@0: 
michael@0:   // valueEnd should point to the char after the last to copy
michael@0:   return Substring(valueCurrent, valueEnd);
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * This method strips leading and trailing whitespace from a string.
michael@0:  */
michael@0: 
michael@0: // static
michael@0: template<bool IsWhitespace(char16_t)>
michael@0: const nsDependentSubstring
michael@0: nsContentUtils::TrimWhitespace(const nsAString& aStr, bool aTrimTrailing)
michael@0: {
michael@0:   nsAString::const_iterator start, end;
michael@0: 
michael@0:   aStr.BeginReading(start);
michael@0:   aStr.EndReading(end);
michael@0: 
michael@0:   // Skip whitespace characters in the beginning
michael@0:   while (start != end && IsWhitespace(*start)) {
michael@0:     ++start;
michael@0:   }
michael@0: 
michael@0:   if (aTrimTrailing) {
michael@0:     // Skip whitespace characters in the end.
michael@0:     while (end != start) {
michael@0:       --end;
michael@0: 
michael@0:       if (!IsWhitespace(*end)) {
michael@0:         // Step back to the last non-whitespace character.
michael@0:         ++end;
michael@0: 
michael@0:         break;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Return a substring for the string w/o leading and/or trailing
michael@0:   // whitespace
michael@0: 
michael@0:   return Substring(start, end);
michael@0: }
michael@0: 
michael@0: // Declaring the templates we are going to use avoid linking issues without
michael@0: // inlining the method. Considering there is not so much spaces checking
michael@0: // methods we can consider this to be better than inlining.
michael@0: template
michael@0: const nsDependentSubstring
michael@0: nsContentUtils::TrimWhitespace<nsCRT::IsAsciiSpace>(const nsAString&, bool);
michael@0: template
michael@0: const nsDependentSubstring
michael@0: nsContentUtils::TrimWhitespace<nsContentUtils::IsHTMLWhitespace>(const nsAString&, bool);
michael@0: template
michael@0: const nsDependentSubstring
michael@0: nsContentUtils::TrimWhitespace<nsContentUtils::IsHTMLWhitespaceOrNBSP>(const nsAString&, bool);
michael@0: 
michael@0: static inline void KeyAppendSep(nsACString& aKey)
michael@0: {
michael@0:   if (!aKey.IsEmpty()) {
michael@0:     aKey.Append('>');
michael@0:   }
michael@0: }
michael@0: 
michael@0: static inline void KeyAppendString(const nsAString& aString, nsACString& aKey)
michael@0: {
michael@0:   KeyAppendSep(aKey);
michael@0: 
michael@0:   // Could escape separator here if collisions happen.  > is not a legal char
michael@0:   // for a name or type attribute, so we should be safe avoiding that extra work.
michael@0: 
michael@0:   AppendUTF16toUTF8(aString, aKey);
michael@0: }
michael@0: 
michael@0: static inline void KeyAppendString(const nsACString& aString, nsACString& aKey)
michael@0: {
michael@0:   KeyAppendSep(aKey);
michael@0: 
michael@0:   // Could escape separator here if collisions happen.  > is not a legal char
michael@0:   // for a name or type attribute, so we should be safe avoiding that extra work.
michael@0: 
michael@0:   aKey.Append(aString);
michael@0: }
michael@0: 
michael@0: static inline void KeyAppendInt(int32_t aInt, nsACString& aKey)
michael@0: {
michael@0:   KeyAppendSep(aKey);
michael@0: 
michael@0:   aKey.Append(nsPrintfCString("%d", aInt));
michael@0: }
michael@0: 
michael@0: static inline bool IsAutocompleteOff(const nsIContent* aElement)
michael@0: {
michael@0:   return aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::autocomplete,
michael@0:                                NS_LITERAL_STRING("off"), eIgnoreCase);
michael@0: }
michael@0: 
michael@0: /*static*/ nsresult
michael@0: nsContentUtils::GenerateStateKey(nsIContent* aContent,
michael@0:                                  const nsIDocument* aDocument,
michael@0:                                  nsACString& aKey)
michael@0: {
michael@0:   aKey.Truncate();
michael@0: 
michael@0:   uint32_t partID = aDocument ? aDocument->GetPartID() : 0;
michael@0: 
michael@0:   // We must have content if we're not using a special state id
michael@0:   NS_ENSURE_TRUE(aContent, NS_ERROR_FAILURE);
michael@0: 
michael@0:   // Don't capture state for anonymous content
michael@0:   if (aContent->IsInAnonymousSubtree()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (IsAutocompleteOff(aContent)) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIHTMLDocument> htmlDocument(do_QueryInterface(aContent->GetCurrentDoc()));
michael@0: 
michael@0:   KeyAppendInt(partID, aKey);  // first append a partID
michael@0:   bool generatedUniqueKey = false;
michael@0: 
michael@0:   if (htmlDocument) {
michael@0:     // Flush our content model so it'll be up to date
michael@0:     // If this becomes unnecessary and the following line is removed,
michael@0:     // please also remove the corresponding flush operation from
michael@0:     // nsHtml5TreeBuilderCppSupplement.h. (Look for "See bug 497861." there.)
michael@0:     aContent->GetCurrentDoc()->FlushPendingNotifications(Flush_Content);
michael@0: 
michael@0:     nsContentList *htmlForms = htmlDocument->GetForms();
michael@0:     nsContentList *htmlFormControls = htmlDocument->GetFormControls();
michael@0: 
michael@0:     NS_ENSURE_TRUE(htmlForms && htmlFormControls, NS_ERROR_OUT_OF_MEMORY);
michael@0: 
michael@0:     // If we have a form control and can calculate form information, use that
michael@0:     // as the key - it is more reliable than just recording position in the
michael@0:     // DOM.
michael@0:     // XXXbz Is it, really?  We have bugs on this, I think...
michael@0:     // Important to have a unique key, and tag/type/name may not be.
michael@0:     //
michael@0:     // If the control has a form, the format of the key is:
michael@0:     // f>type>IndOfFormInDoc>IndOfControlInForm>FormName>name
michael@0:     // else:
michael@0:     // d>type>IndOfControlInDoc>name
michael@0:     //
michael@0:     // XXX We don't need to use index if name is there
michael@0:     // XXXbz We don't?  Why not?  I don't follow.
michael@0:     //
michael@0:     nsCOMPtr<nsIFormControl> control(do_QueryInterface(aContent));
michael@0:     if (control && htmlFormControls && htmlForms) {
michael@0: 
michael@0:       // Append the control type
michael@0:       KeyAppendInt(control->GetType(), aKey);
michael@0: 
michael@0:       // If in a form, add form name / index of form / index in form
michael@0:       int32_t index = -1;
michael@0:       Element *formElement = control->GetFormElement();
michael@0:       if (formElement) {
michael@0:         if (IsAutocompleteOff(formElement)) {
michael@0:           aKey.Truncate();
michael@0:           return NS_OK;
michael@0:         }
michael@0: 
michael@0:         KeyAppendString(NS_LITERAL_CSTRING("f"), aKey);
michael@0: 
michael@0:         // Append the index of the form in the document
michael@0:         index = htmlForms->IndexOf(formElement, false);
michael@0:         if (index <= -1) {
michael@0:           //
michael@0:           // XXX HACK this uses some state that was dumped into the document
michael@0:           // specifically to fix bug 138892.  What we are trying to do is *guess*
michael@0:           // which form this control's state is found in, with the highly likely
michael@0:           // guess that the highest form parsed so far is the one.
michael@0:           // This code should not be on trunk, only branch.
michael@0:           //
michael@0:           index = htmlDocument->GetNumFormsSynchronous() - 1;
michael@0:         }
michael@0:         if (index > -1) {
michael@0:           KeyAppendInt(index, aKey);
michael@0: 
michael@0:           // Append the index of the control in the form
michael@0:           nsCOMPtr<nsIForm> form(do_QueryInterface(formElement));
michael@0:           index = form->IndexOfControl(control);
michael@0: 
michael@0:           if (index > -1) {
michael@0:             KeyAppendInt(index, aKey);
michael@0:             generatedUniqueKey = true;
michael@0:           }
michael@0:         }
michael@0: 
michael@0:         // Append the form name
michael@0:         nsAutoString formName;
michael@0:         formElement->GetAttr(kNameSpaceID_None, nsGkAtoms::name, formName);
michael@0:         KeyAppendString(formName, aKey);
michael@0: 
michael@0:       } else {
michael@0: 
michael@0:         KeyAppendString(NS_LITERAL_CSTRING("d"), aKey);
michael@0: 
michael@0:         // If not in a form, add index of control in document
michael@0:         // Less desirable than indexing by form info.
michael@0: 
michael@0:         // Hash by index of control in doc (we are not in a form)
michael@0:         // These are important as they are unique, and type/name may not be.
michael@0: 
michael@0:         // We have to flush sink notifications at this point to make
michael@0:         // sure that htmlFormControls is up to date.
michael@0:         index = htmlFormControls->IndexOf(aContent, true);
michael@0:         if (index > -1) {
michael@0:           KeyAppendInt(index, aKey);
michael@0:           generatedUniqueKey = true;
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       // Append the control name
michael@0:       nsAutoString name;
michael@0:       aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::name, name);
michael@0:       KeyAppendString(name, aKey);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (!generatedUniqueKey) {
michael@0:     // Either we didn't have a form control or we aren't in an HTML document so
michael@0:     // we can't figure out form info.  Append the tag name if it's an element
michael@0:     // to avoid restoring state for one type of element on another type.
michael@0:     if (aContent->IsElement()) {
michael@0:       KeyAppendString(nsDependentAtomString(aContent->Tag()), aKey);
michael@0:     }
michael@0:     else {
michael@0:       // Append a character that is not "d" or "f" to disambiguate from
michael@0:       // the case when we were a form control in an HTML document.
michael@0:       KeyAppendString(NS_LITERAL_CSTRING("o"), aKey);
michael@0:     }
michael@0: 
michael@0:     // Now start at aContent and append the indices of it and all its ancestors
michael@0:     // in their containers.  That should at least pin down its position in the
michael@0:     // DOM...
michael@0:     nsINode* parent = aContent->GetParentNode();
michael@0:     nsINode* content = aContent;
michael@0:     while (parent) {
michael@0:       KeyAppendInt(parent->IndexOf(content), aKey);
michael@0:       content = parent;
michael@0:       parent = content->GetParentNode();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsIPrincipal*
michael@0: nsContentUtils::GetSubjectPrincipal()
michael@0: {
michael@0:   nsCOMPtr<nsIPrincipal> subject;
michael@0:   sSecurityManager->GetSubjectPrincipal(getter_AddRefs(subject));
michael@0: 
michael@0:   // When the ssm says the subject is null, that means system principal.
michael@0:   if (!subject)
michael@0:     sSecurityManager->GetSystemPrincipal(getter_AddRefs(subject));
michael@0: 
michael@0:   return subject;
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsIPrincipal*
michael@0: nsContentUtils::GetObjectPrincipal(JSObject* aObj)
michael@0: {
michael@0:   // This is duplicated from nsScriptSecurityManager. We don't call through there
michael@0:   // because the API unnecessarily requires a JSContext for historical reasons.
michael@0:   JSCompartment *compartment = js::GetObjectCompartment(aObj);
michael@0:   JSPrincipals *principals = JS_GetCompartmentPrincipals(compartment);
michael@0:   return nsJSPrincipals::get(principals);
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::NewURIWithDocumentCharset(nsIURI** aResult,
michael@0:                                           const nsAString& aSpec,
michael@0:                                           nsIDocument* aDocument,
michael@0:                                           nsIURI* aBaseURI)
michael@0: {
michael@0:   return NS_NewURI(aResult, aSpec,
michael@0:                    aDocument ? aDocument->GetDocumentCharacterSet().get() : nullptr,
michael@0:                    aBaseURI, sIOService);
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::IsCustomElementName(nsIAtom* aName)
michael@0: {
michael@0:   // The custom element name identifies a custom element and is a sequence of
michael@0:   // alphanumeric ASCII characters that must match the NCName production and
michael@0:   // contain a U+002D HYPHEN-MINUS character.
michael@0:   nsDependentAtomString str(aName);
michael@0:   const char16_t* colon;
michael@0:   if (NS_FAILED(nsContentUtils::CheckQName(str, false, &colon)) || colon ||
michael@0:       str.FindChar('-') == -1) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   // The custom element name must not be one of the following values:
michael@0:   //  annotation-xml
michael@0:   //  color-profile
michael@0:   //  font-face
michael@0:   //  font-face-src
michael@0:   //  font-face-uri
michael@0:   //  font-face-format
michael@0:   //  font-face-name
michael@0:   //  missing-glyph
michael@0:   return aName != nsGkAtoms::annotation_xml_ &&
michael@0:          aName != nsGkAtoms::colorProfile &&
michael@0:          aName != nsGkAtoms::font_face &&
michael@0:          aName != nsGkAtoms::font_face_src &&
michael@0:          aName != nsGkAtoms::font_face_uri &&
michael@0:          aName != nsGkAtoms::font_face_format &&
michael@0:          aName != nsGkAtoms::font_face_name &&
michael@0:          aName != nsGkAtoms::missingGlyph;
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::CheckQName(const nsAString& aQualifiedName,
michael@0:                            bool aNamespaceAware,
michael@0:                            const char16_t** aColon)
michael@0: {
michael@0:   const char* colon = nullptr;
michael@0:   const char16_t* begin = aQualifiedName.BeginReading();
michael@0:   const char16_t* end = aQualifiedName.EndReading();
michael@0:   
michael@0:   int result = MOZ_XMLCheckQName(reinterpret_cast<const char*>(begin),
michael@0:                                  reinterpret_cast<const char*>(end),
michael@0:                                  aNamespaceAware, &colon);
michael@0: 
michael@0:   if (!result) {
michael@0:     if (aColon) {
michael@0:       *aColon = reinterpret_cast<const char16_t*>(colon);
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // MOZ_EXPAT_EMPTY_QNAME || MOZ_EXPAT_INVALID_CHARACTER
michael@0:   if (result == (1 << 0) || result == (1 << 1)) {
michael@0:     return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
michael@0:   }
michael@0: 
michael@0:   return NS_ERROR_DOM_NAMESPACE_ERR;
michael@0: }
michael@0: 
michael@0: //static
michael@0: nsresult
michael@0: nsContentUtils::SplitQName(const nsIContent* aNamespaceResolver,
michael@0:                            const nsAFlatString& aQName,
michael@0:                            int32_t *aNamespace, nsIAtom **aLocalName)
michael@0: {
michael@0:   const char16_t* colon;
michael@0:   nsresult rv = nsContentUtils::CheckQName(aQName, true, &colon);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   if (colon) {
michael@0:     const char16_t* end;
michael@0:     aQName.EndReading(end);
michael@0:     nsAutoString nameSpace;
michael@0:     rv = aNamespaceResolver->LookupNamespaceURIInternal(Substring(aQName.get(),
michael@0:                                                                   colon),
michael@0:                                                         nameSpace);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     *aNamespace = NameSpaceManager()->GetNameSpaceID(nameSpace);
michael@0:     if (*aNamespace == kNameSpaceID_Unknown)
michael@0:       return NS_ERROR_FAILURE;
michael@0: 
michael@0:     *aLocalName = NS_NewAtom(Substring(colon + 1, end)).take();
michael@0:   }
michael@0:   else {
michael@0:     *aNamespace = kNameSpaceID_None;
michael@0:     *aLocalName = NS_NewAtom(aQName).take();
michael@0:   }
michael@0:   NS_ENSURE_TRUE(aLocalName, NS_ERROR_OUT_OF_MEMORY);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::GetNodeInfoFromQName(const nsAString& aNamespaceURI,
michael@0:                                      const nsAString& aQualifiedName,
michael@0:                                      nsNodeInfoManager* aNodeInfoManager,
michael@0:                                      uint16_t aNodeType,
michael@0:                                      nsINodeInfo** aNodeInfo)
michael@0: {
michael@0:   const nsAFlatString& qName = PromiseFlatString(aQualifiedName);
michael@0:   const char16_t* colon;
michael@0:   nsresult rv = nsContentUtils::CheckQName(qName, true, &colon);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   int32_t nsID;
michael@0:   sNameSpaceManager->RegisterNameSpace(aNamespaceURI, nsID);
michael@0:   if (colon) {
michael@0:     const char16_t* end;
michael@0:     qName.EndReading(end);
michael@0: 
michael@0:     nsCOMPtr<nsIAtom> prefix = do_GetAtom(Substring(qName.get(), colon));
michael@0: 
michael@0:     rv = aNodeInfoManager->GetNodeInfo(Substring(colon + 1, end), prefix,
michael@0:                                        nsID, aNodeType, aNodeInfo);
michael@0:   }
michael@0:   else {
michael@0:     rv = aNodeInfoManager->GetNodeInfo(aQualifiedName, nullptr, nsID,
michael@0:                                        aNodeType, aNodeInfo);
michael@0:   }
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   return nsContentUtils::IsValidNodeName((*aNodeInfo)->NameAtom(),
michael@0:                                          (*aNodeInfo)->GetPrefixAtom(),
michael@0:                                          (*aNodeInfo)->NamespaceID()) ?
michael@0:          NS_OK : NS_ERROR_DOM_NAMESPACE_ERR;
michael@0: }
michael@0: 
michael@0: // static
michael@0: void
michael@0: nsContentUtils::SplitExpatName(const char16_t *aExpatName, nsIAtom **aPrefix,
michael@0:                                nsIAtom **aLocalName, int32_t* aNameSpaceID)
michael@0: {
michael@0:   /**
michael@0:    *  Expat can send the following:
michael@0:    *    localName
michael@0:    *    namespaceURI<separator>localName
michael@0:    *    namespaceURI<separator>localName<separator>prefix
michael@0:    *
michael@0:    *  and we use 0xFFFF for the <separator>.
michael@0:    *
michael@0:    */
michael@0: 
michael@0:   const char16_t *uriEnd = nullptr;
michael@0:   const char16_t *nameEnd = nullptr;
michael@0:   const char16_t *pos;
michael@0:   for (pos = aExpatName; *pos; ++pos) {
michael@0:     if (*pos == 0xFFFF) {
michael@0:       if (uriEnd) {
michael@0:         nameEnd = pos;
michael@0:       }
michael@0:       else {
michael@0:         uriEnd = pos;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   const char16_t *nameStart;
michael@0:   if (uriEnd) {
michael@0:     if (sNameSpaceManager) {
michael@0:       sNameSpaceManager->RegisterNameSpace(nsDependentSubstring(aExpatName,
michael@0:                                                                 uriEnd),
michael@0:                                            *aNameSpaceID);
michael@0:     }
michael@0:     else {
michael@0:       *aNameSpaceID = kNameSpaceID_Unknown;
michael@0:     }
michael@0: 
michael@0:     nameStart = (uriEnd + 1);
michael@0:     if (nameEnd)  {
michael@0:       const char16_t *prefixStart = nameEnd + 1;
michael@0:       *aPrefix = NS_NewAtom(Substring(prefixStart, pos)).take();
michael@0:     }
michael@0:     else {
michael@0:       nameEnd = pos;
michael@0:       *aPrefix = nullptr;
michael@0:     }
michael@0:   }
michael@0:   else {
michael@0:     *aNameSpaceID = kNameSpaceID_None;
michael@0:     nameStart = aExpatName;
michael@0:     nameEnd = pos;
michael@0:     *aPrefix = nullptr;
michael@0:   }
michael@0:   *aLocalName = NS_NewAtom(Substring(nameStart, nameEnd)).take();
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsPresContext*
michael@0: nsContentUtils::GetContextForContent(const nsIContent* aContent)
michael@0: {
michael@0:   nsIDocument* doc = aContent->GetCurrentDoc();
michael@0:   if (doc) {
michael@0:     nsIPresShell *presShell = doc->GetShell();
michael@0:     if (presShell) {
michael@0:       return presShell->GetPresContext();
michael@0:     }
michael@0:   }
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::CanLoadImage(nsIURI* aURI, nsISupports* aContext,
michael@0:                              nsIDocument* aLoadingDocument,
michael@0:                              nsIPrincipal* aLoadingPrincipal,
michael@0:                              int16_t* aImageBlockingStatus)
michael@0: {
michael@0:   NS_PRECONDITION(aURI, "Must have a URI");
michael@0:   NS_PRECONDITION(aLoadingDocument, "Must have a document");
michael@0:   NS_PRECONDITION(aLoadingPrincipal, "Must have a loading principal");
michael@0: 
michael@0:   nsresult rv;
michael@0: 
michael@0:   uint32_t appType = nsIDocShell::APP_TYPE_UNKNOWN;
michael@0: 
michael@0:   {
michael@0:     nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem = aLoadingDocument->GetDocShell();
michael@0:     if (docShellTreeItem) {
michael@0:       nsCOMPtr<nsIDocShellTreeItem> root;
michael@0:       docShellTreeItem->GetRootTreeItem(getter_AddRefs(root));
michael@0: 
michael@0:       nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(root));
michael@0: 
michael@0:       if (!docShell || NS_FAILED(docShell->GetAppType(&appType))) {
michael@0:         appType = nsIDocShell::APP_TYPE_UNKNOWN;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (appType != nsIDocShell::APP_TYPE_EDITOR) {
michael@0:     // Editor apps get special treatment here, editors can load images
michael@0:     // from anywhere.  This allows editor to insert images from file://
michael@0:     // into documents that are being edited.
michael@0:     rv = sSecurityManager->
michael@0:       CheckLoadURIWithPrincipal(aLoadingPrincipal, aURI,
michael@0:                                 nsIScriptSecurityManager::ALLOW_CHROME);
michael@0:     if (NS_FAILED(rv)) {
michael@0:       if (aImageBlockingStatus) {
michael@0:         // Reject the request itself, not all requests to the relevant
michael@0:         // server...
michael@0:         *aImageBlockingStatus = nsIContentPolicy::REJECT_REQUEST;
michael@0:       }
michael@0:       return false;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   int16_t decision = nsIContentPolicy::ACCEPT;
michael@0: 
michael@0:   rv = NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_IMAGE,
michael@0:                                  aURI,
michael@0:                                  aLoadingPrincipal,
michael@0:                                  aContext,
michael@0:                                  EmptyCString(), //mime guess
michael@0:                                  nullptr,         //extra
michael@0:                                  &decision,
michael@0:                                  GetContentPolicy(),
michael@0:                                  sSecurityManager);
michael@0: 
michael@0:   if (aImageBlockingStatus) {
michael@0:     *aImageBlockingStatus =
michael@0:       NS_FAILED(rv) ? nsIContentPolicy::REJECT_REQUEST : decision;
michael@0:   }
michael@0:   return NS_FAILED(rv) ? false : NS_CP_ACCEPTED(decision);
michael@0: }
michael@0: 
michael@0: imgLoader*
michael@0: nsContentUtils::GetImgLoaderForDocument(nsIDocument* aDoc)
michael@0: {
michael@0:   if (!aDoc)
michael@0:     return imgLoader::Singleton();
michael@0:   bool isPrivate = false;
michael@0:   nsCOMPtr<nsILoadGroup> loadGroup = aDoc->GetDocumentLoadGroup();
michael@0:   nsCOMPtr<nsIInterfaceRequestor> callbacks;
michael@0:   if (loadGroup) {
michael@0:     loadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks));
michael@0:     if (callbacks) {
michael@0:       nsCOMPtr<nsILoadContext> loadContext = do_GetInterface(callbacks);
michael@0:       isPrivate = loadContext && loadContext->UsePrivateBrowsing();
michael@0:     }
michael@0:   } else {
michael@0:     nsCOMPtr<nsIChannel> channel = aDoc->GetChannel();
michael@0:     isPrivate = channel && NS_UsePrivateBrowsing(channel);
michael@0:   }
michael@0:   return isPrivate ? imgLoader::PBSingleton() : imgLoader::Singleton();
michael@0: }
michael@0: 
michael@0: // static
michael@0: imgLoader*
michael@0: nsContentUtils::GetImgLoaderForChannel(nsIChannel* aChannel)
michael@0: {
michael@0:   if (!aChannel)
michael@0:     return imgLoader::Singleton();
michael@0:   nsCOMPtr<nsILoadContext> context;
michael@0:   NS_QueryNotificationCallbacks(aChannel, context);
michael@0:   return context && context->UsePrivateBrowsing() ? imgLoader::PBSingleton() : imgLoader::Singleton();
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::IsImageInCache(nsIURI* aURI, nsIDocument* aDocument)
michael@0: {
michael@0:     imgILoader* loader = GetImgLoaderForDocument(aDocument);
michael@0:     nsCOMPtr<imgICache> cache = do_QueryInterface(loader);
michael@0: 
michael@0:     // If something unexpected happened we return false, otherwise if props
michael@0:     // is set, the image is cached and we return true
michael@0:     nsCOMPtr<nsIProperties> props;
michael@0:     nsresult rv = cache->FindEntryProperties(aURI, getter_AddRefs(props));
michael@0:     return (NS_SUCCEEDED(rv) && props);
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::LoadImage(nsIURI* aURI, nsIDocument* aLoadingDocument,
michael@0:                           nsIPrincipal* aLoadingPrincipal, nsIURI* aReferrer,
michael@0:                           imgINotificationObserver* aObserver, int32_t aLoadFlags,
michael@0:                           const nsAString& initiatorType,
michael@0:                           imgRequestProxy** aRequest)
michael@0: {
michael@0:   NS_PRECONDITION(aURI, "Must have a URI");
michael@0:   NS_PRECONDITION(aLoadingDocument, "Must have a document");
michael@0:   NS_PRECONDITION(aLoadingPrincipal, "Must have a principal");
michael@0:   NS_PRECONDITION(aRequest, "Null out param");
michael@0: 
michael@0:   imgLoader* imgLoader = GetImgLoaderForDocument(aLoadingDocument);
michael@0:   if (!imgLoader) {
michael@0:     // nothing we can do here
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsILoadGroup> loadGroup = aLoadingDocument->GetDocumentLoadGroup();
michael@0: 
michael@0:   nsIURI *documentURI = aLoadingDocument->GetDocumentURI();
michael@0: 
michael@0:   NS_ASSERTION(loadGroup || IsFontTableURI(documentURI),
michael@0:                "Could not get loadgroup; onload may fire too early");
michael@0: 
michael@0:   // check for a Content Security Policy to pass down to the channel that
michael@0:   // will get created to load the image
michael@0:   nsCOMPtr<nsIChannelPolicy> channelPolicy;
michael@0:   nsCOMPtr<nsIContentSecurityPolicy> csp;
michael@0:   if (aLoadingPrincipal) {
michael@0:     nsresult rv = aLoadingPrincipal->GetCsp(getter_AddRefs(csp));
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0:     if (csp) {
michael@0:       channelPolicy = do_CreateInstance("@mozilla.org/nschannelpolicy;1");
michael@0:       channelPolicy->SetContentSecurityPolicy(csp);
michael@0:       channelPolicy->SetLoadType(nsIContentPolicy::TYPE_IMAGE);
michael@0:     }
michael@0:   }
michael@0:     
michael@0:   // Make the URI immutable so people won't change it under us
michael@0:   NS_TryToSetImmutable(aURI);
michael@0:  
michael@0:   nsCOMPtr<nsIURI> firstPartyIsolationURI;
michael@0:   nsCOMPtr<mozIThirdPartyUtil> thirdPartySvc
michael@0:                                = do_GetService(THIRDPARTYUTIL_CONTRACTID);
michael@0:   thirdPartySvc->GetFirstPartyIsolationURI(nullptr, aLoadingDocument,
michael@0:                                            getter_AddRefs(firstPartyIsolationURI));
michael@0: 
michael@0:   return imgLoader->LoadImage(aURI,                   /* uri to load */
michael@0:                               firstPartyIsolationURI, /* firstPartyIsolationURI */
michael@0:                               aReferrer,              /* referrer */
michael@0:                               aLoadingPrincipal,      /* loading principal */
michael@0:                               loadGroup,              /* loadgroup */
michael@0:                               aObserver,              /* imgINotificationObserver */
michael@0:                               aLoadingDocument,       /* uniquification key */
michael@0:                               aLoadFlags,             /* load flags */
michael@0:                               nullptr,                /* cache key */
michael@0:                               channelPolicy,          /* CSP info */
michael@0:                               initiatorType,          /* the load initiator */
michael@0:                               aRequest);
michael@0: }
michael@0: 
michael@0: // static
michael@0: already_AddRefed<imgIContainer>
michael@0: nsContentUtils::GetImageFromContent(nsIImageLoadingContent* aContent,
michael@0:                                     imgIRequest **aRequest)
michael@0: {
michael@0:   if (aRequest) {
michael@0:     *aRequest = nullptr;
michael@0:   }
michael@0: 
michael@0:   NS_ENSURE_TRUE(aContent, nullptr);
michael@0: 
michael@0:   nsCOMPtr<imgIRequest> imgRequest;
michael@0:   aContent->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
michael@0:                       getter_AddRefs(imgRequest));
michael@0:   if (!imgRequest) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<imgIContainer> imgContainer;
michael@0:   imgRequest->GetImage(getter_AddRefs(imgContainer));
michael@0: 
michael@0:   if (!imgContainer) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   if (aRequest) {
michael@0:     imgRequest.swap(*aRequest);
michael@0:   }
michael@0: 
michael@0:   return imgContainer.forget();
michael@0: }
michael@0: 
michael@0: //static
michael@0: already_AddRefed<imgRequestProxy>
michael@0: nsContentUtils::GetStaticRequest(imgRequestProxy* aRequest)
michael@0: {
michael@0:   NS_ENSURE_TRUE(aRequest, nullptr);
michael@0:   nsRefPtr<imgRequestProxy> retval;
michael@0:   aRequest->GetStaticRequest(getter_AddRefs(retval));
michael@0:   return retval.forget();
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::ContentIsDraggable(nsIContent* aContent)
michael@0: {
michael@0:   nsCOMPtr<nsIDOMHTMLElement> htmlElement = do_QueryInterface(aContent);
michael@0:   if (htmlElement) {
michael@0:     bool draggable = false;
michael@0:     htmlElement->GetDraggable(&draggable);
michael@0:     if (draggable)
michael@0:       return true;
michael@0: 
michael@0:     if (aContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::draggable,
michael@0:                               nsGkAtoms::_false, eIgnoreCase))
michael@0:       return false;
michael@0:   }
michael@0: 
michael@0:   // special handling for content area image and link dragging
michael@0:   return IsDraggableImage(aContent) || IsDraggableLink(aContent);
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::IsDraggableImage(nsIContent* aContent)
michael@0: {
michael@0:   NS_PRECONDITION(aContent, "Must have content node to test");
michael@0: 
michael@0:   nsCOMPtr<nsIImageLoadingContent> imageContent(do_QueryInterface(aContent));
michael@0:   if (!imageContent) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<imgIRequest> imgRequest;
michael@0:   imageContent->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
michael@0:                            getter_AddRefs(imgRequest));
michael@0: 
michael@0:   // XXXbz It may be draggable even if the request resulted in an error.  Why?
michael@0:   // Not sure; that's what the old nsContentAreaDragDrop/nsFrame code did.
michael@0:   return imgRequest != nullptr;
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::IsDraggableLink(const nsIContent* aContent) {
michael@0:   nsCOMPtr<nsIURI> absURI;
michael@0:   return aContent->IsLink(getter_AddRefs(absURI));
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::NameChanged(nsINodeInfo* aNodeInfo, nsIAtom* aName,
michael@0:                             nsINodeInfo** aResult)
michael@0: {
michael@0:   nsNodeInfoManager *niMgr = aNodeInfo->NodeInfoManager();
michael@0: 
michael@0:   *aResult = niMgr->GetNodeInfo(aName, aNodeInfo->GetPrefixAtom(),
michael@0:                                 aNodeInfo->NamespaceID(),
michael@0:                                 aNodeInfo->NodeType(),
michael@0:                                 aNodeInfo->GetExtraName()).take();
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: static bool
michael@0: TestSitePerm(nsIPrincipal* aPrincipal, const char* aType, uint32_t aPerm, bool aExactHostMatch)
michael@0: {
michael@0:   if (!aPrincipal) {
michael@0:     // We always deny (i.e. don't allow) the permission if we don't have a
michael@0:     // principal.
michael@0:     return aPerm != nsIPermissionManager::ALLOW_ACTION;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIPermissionManager> permMgr =
michael@0:     do_GetService("@mozilla.org/permissionmanager;1");
michael@0:   NS_ENSURE_TRUE(permMgr, false);
michael@0: 
michael@0:   uint32_t perm;
michael@0:   nsresult rv;
michael@0:   if (aExactHostMatch) {
michael@0:     rv = permMgr->TestExactPermissionFromPrincipal(aPrincipal, aType, &perm);
michael@0:   } else {
michael@0:     rv = permMgr->TestPermissionFromPrincipal(aPrincipal, aType, &perm);
michael@0:   }
michael@0:   NS_ENSURE_SUCCESS(rv, false);
michael@0: 
michael@0:   return perm == aPerm;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsSitePermAllow(nsIPrincipal* aPrincipal, const char* aType)
michael@0: {
michael@0:   return TestSitePerm(aPrincipal, aType, nsIPermissionManager::ALLOW_ACTION, false);
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsSitePermDeny(nsIPrincipal* aPrincipal, const char* aType)
michael@0: {
michael@0:   return TestSitePerm(aPrincipal, aType, nsIPermissionManager::DENY_ACTION, false);
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsExactSitePermAllow(nsIPrincipal* aPrincipal, const char* aType)
michael@0: {
michael@0:   return TestSitePerm(aPrincipal, aType, nsIPermissionManager::ALLOW_ACTION, true);
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsExactSitePermDeny(nsIPrincipal* aPrincipal, const char* aType)
michael@0: {
michael@0:   return TestSitePerm(aPrincipal, aType, nsIPermissionManager::DENY_ACTION, true);
michael@0: }
michael@0: 
michael@0: static const char *gEventNames[] = {"event"};
michael@0: static const char *gSVGEventNames[] = {"evt"};
michael@0: // for b/w compat, the first name to onerror is still 'event', even though it
michael@0: // is actually the error message.  (pre this code, the other 2 were not avail.)
michael@0: // XXXmarkh - a quick lxr shows no affected code - should we correct this?
michael@0: static const char *gOnErrorNames[] = {"event", "source", "lineno"};
michael@0: 
michael@0: // static
michael@0: void
michael@0: nsContentUtils::GetEventArgNames(int32_t aNameSpaceID,
michael@0:                                  nsIAtom *aEventName,
michael@0:                                  uint32_t *aArgCount,
michael@0:                                  const char*** aArgArray)
michael@0: {
michael@0: #define SET_EVENT_ARG_NAMES(names) \
michael@0:     *aArgCount = sizeof(names)/sizeof(names[0]); \
michael@0:     *aArgArray = names;
michael@0: 
michael@0:   // JSEventHandler is what does the arg magic for onerror, and it does
michael@0:   // not seem to take the namespace into account.  So we let onerror in all
michael@0:   // namespaces get the 3 arg names.
michael@0:   if (aEventName == nsGkAtoms::onerror) {
michael@0:     SET_EVENT_ARG_NAMES(gOnErrorNames);
michael@0:   } else if (aNameSpaceID == kNameSpaceID_SVG) {
michael@0:     SET_EVENT_ARG_NAMES(gSVGEventNames);
michael@0:   } else {
michael@0:     SET_EVENT_ARG_NAMES(gEventNames);
michael@0:   }
michael@0: }
michael@0: 
michael@0: static const char gPropertiesFiles[nsContentUtils::PropertiesFile_COUNT][56] = {
michael@0:   // Must line up with the enum values in |PropertiesFile| enum.
michael@0:   "chrome://global/locale/css.properties",
michael@0:   "chrome://global/locale/xbl.properties",
michael@0:   "chrome://global/locale/xul.properties",
michael@0:   "chrome://global/locale/layout_errors.properties",
michael@0:   "chrome://global/locale/layout/HtmlForm.properties",
michael@0:   "chrome://global/locale/printing.properties",
michael@0:   "chrome://global/locale/dom/dom.properties",
michael@0:   "chrome://global/locale/layout/htmlparser.properties",
michael@0:   "chrome://global/locale/svg/svg.properties",
michael@0:   "chrome://branding/locale/brand.properties",
michael@0:   "chrome://global/locale/commonDialogs.properties",
michael@0:   "chrome://global/locale/mathml/mathml.properties",
michael@0:   "chrome://global/locale/security/security.properties"
michael@0: };
michael@0: 
michael@0: /* static */ nsresult
michael@0: nsContentUtils::EnsureStringBundle(PropertiesFile aFile)
michael@0: {
michael@0:   if (!sStringBundles[aFile]) {
michael@0:     if (!sStringBundleService) {
michael@0:       nsresult rv =
michael@0:         CallGetService(NS_STRINGBUNDLE_CONTRACTID, &sStringBundleService);
michael@0:       NS_ENSURE_SUCCESS(rv, rv);
michael@0:     }
michael@0:     nsIStringBundle *bundle;
michael@0:     nsresult rv =
michael@0:       sStringBundleService->CreateBundle(gPropertiesFiles[aFile], &bundle);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0:     sStringBundles[aFile] = bundle; // transfer ownership
michael@0:   }
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult nsContentUtils::GetLocalizedString(PropertiesFile aFile,
michael@0:                                             const char* aKey,
michael@0:                                             nsXPIDLString& aResult)
michael@0: {
michael@0:   nsresult rv = EnsureStringBundle(aFile);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0:   nsIStringBundle *bundle = sStringBundles[aFile];
michael@0: 
michael@0:   return bundle->GetStringFromName(NS_ConvertASCIItoUTF16(aKey).get(),
michael@0:                                    getter_Copies(aResult));
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult nsContentUtils::FormatLocalizedString(PropertiesFile aFile,
michael@0:                                                const char* aKey,
michael@0:                                                const char16_t **aParams,
michael@0:                                                uint32_t aParamsLength,
michael@0:                                                nsXPIDLString& aResult)
michael@0: {
michael@0:   nsresult rv = EnsureStringBundle(aFile);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0:   nsIStringBundle *bundle = sStringBundles[aFile];
michael@0: 
michael@0:   return bundle->FormatStringFromName(NS_ConvertASCIItoUTF16(aKey).get(),
michael@0:                                       aParams, aParamsLength,
michael@0:                                       getter_Copies(aResult));
michael@0: }
michael@0: 
michael@0: /* static */ void
michael@0: nsContentUtils::LogSimpleConsoleError(const nsAString& aErrorText,
michael@0:                                       const char * classification)
michael@0: {
michael@0:   nsCOMPtr<nsIScriptError> scriptError =
michael@0:     do_CreateInstance(NS_SCRIPTERROR_CONTRACTID);
michael@0:   if (scriptError) {
michael@0:     nsCOMPtr<nsIConsoleService> console =
michael@0:       do_GetService(NS_CONSOLESERVICE_CONTRACTID);
michael@0:     if (console && NS_SUCCEEDED(scriptError->Init(aErrorText, EmptyString(),
michael@0:                                                   EmptyString(), 0, 0,
michael@0:                                                   nsIScriptError::errorFlag,
michael@0:                                                   classification))) {
michael@0:       console->LogMessage(scriptError);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */ nsresult
michael@0: nsContentUtils::ReportToConsole(uint32_t aErrorFlags,
michael@0:                                 const nsACString& aCategory,
michael@0:                                 nsIDocument* aDocument,
michael@0:                                 PropertiesFile aFile,
michael@0:                                 const char *aMessageName,
michael@0:                                 const char16_t **aParams,
michael@0:                                 uint32_t aParamsLength,
michael@0:                                 nsIURI* aURI,
michael@0:                                 const nsAFlatString& aSourceLine,
michael@0:                                 uint32_t aLineNumber,
michael@0:                                 uint32_t aColumnNumber)
michael@0: {
michael@0:   NS_ASSERTION((aParams && aParamsLength) || (!aParams && !aParamsLength),
michael@0:                "Supply either both parameters and their number or no"
michael@0:                "parameters and 0.");
michael@0: 
michael@0:   nsresult rv;
michael@0:   nsXPIDLString errorText;
michael@0:   if (aParams) {
michael@0:     rv = FormatLocalizedString(aFile, aMessageName, aParams, aParamsLength,
michael@0:                                errorText);
michael@0:   }
michael@0:   else {
michael@0:     rv = GetLocalizedString(aFile, aMessageName, errorText);
michael@0:   }
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   return ReportToConsoleNonLocalized(errorText, aErrorFlags, aCategory,
michael@0:                                      aDocument, aURI, aSourceLine,
michael@0:                                      aLineNumber, aColumnNumber);
michael@0: }
michael@0: 
michael@0: 
michael@0: /* static */ nsresult
michael@0: nsContentUtils::ReportToConsoleNonLocalized(const nsAString& aErrorText,
michael@0:                                             uint32_t aErrorFlags,
michael@0:                                             const nsACString& aCategory,
michael@0:                                             nsIDocument* aDocument,
michael@0:                                             nsIURI* aURI,
michael@0:                                             const nsAFlatString& aSourceLine,
michael@0:                                             uint32_t aLineNumber,
michael@0:                                             uint32_t aColumnNumber)
michael@0: {
michael@0:   uint64_t innerWindowID = 0;
michael@0:   if (aDocument) {
michael@0:     if (!aURI) {
michael@0:       aURI = aDocument->GetDocumentURI();
michael@0:     }
michael@0:     innerWindowID = aDocument->InnerWindowID();
michael@0:   }
michael@0: 
michael@0:   nsresult rv;
michael@0:   if (!sConsoleService) { // only need to bother null-checking here
michael@0:     rv = CallGetService(NS_CONSOLESERVICE_CONTRACTID, &sConsoleService);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0:   }
michael@0: 
michael@0:   nsAutoCString spec;
michael@0:   if (!aLineNumber) {
michael@0:     JSContext *cx = GetCurrentJSContext();
michael@0:     if (cx) {
michael@0:       const char* filename;
michael@0:       uint32_t lineno;
michael@0:       if (nsJSUtils::GetCallingLocation(cx, &filename, &lineno)) {
michael@0:         spec = filename;
michael@0:         aLineNumber = lineno;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0:   if (spec.IsEmpty() && aURI)
michael@0:     aURI->GetSpec(spec);
michael@0: 
michael@0:   nsCOMPtr<nsIScriptError> errorObject =
michael@0:       do_CreateInstance(NS_SCRIPTERROR_CONTRACTID, &rv);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   rv = errorObject->InitWithWindowID(aErrorText,
michael@0:                                      NS_ConvertUTF8toUTF16(spec), // file name
michael@0:                                      aSourceLine,
michael@0:                                      aLineNumber, aColumnNumber,
michael@0:                                      aErrorFlags, aCategory,
michael@0:                                      innerWindowID);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   return sConsoleService->LogMessage(errorObject);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::LogMessageToConsole(const char* aMsg, ...)
michael@0: {
michael@0:   if (!sConsoleService) { // only need to bother null-checking here
michael@0:     CallGetService(NS_CONSOLESERVICE_CONTRACTID, &sConsoleService);
michael@0:     if (!sConsoleService) {
michael@0:       return;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   va_list args;
michael@0:   va_start(args, aMsg);
michael@0:   char* formatted = PR_vsmprintf(aMsg, args);
michael@0:   va_end(args);
michael@0:   if (!formatted) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   sConsoleService->LogStringMessage(NS_ConvertUTF8toUTF16(formatted).get());
michael@0:   PR_smprintf_free(formatted);
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsChromeDoc(nsIDocument *aDocument)
michael@0: {
michael@0:   if (!aDocument) {
michael@0:     return false;
michael@0:   }
michael@0:   
michael@0:   nsCOMPtr<nsIPrincipal> systemPrincipal;
michael@0:   sSecurityManager->GetSystemPrincipal(getter_AddRefs(systemPrincipal));
michael@0: 
michael@0:   return aDocument->NodePrincipal() == systemPrincipal;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsChildOfSameType(nsIDocument* aDoc)
michael@0: {
michael@0:   nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(aDoc->GetDocShell());
michael@0:   nsCOMPtr<nsIDocShellTreeItem> sameTypeParent;
michael@0:   if (docShellAsItem) {
michael@0:     docShellAsItem->GetSameTypeParent(getter_AddRefs(sameTypeParent));
michael@0:   }
michael@0:   return sameTypeParent != nullptr;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsPlainTextType(const nsACString& aContentType)
michael@0: {
michael@0:   return aContentType.EqualsLiteral(TEXT_PLAIN) ||
michael@0:          aContentType.EqualsLiteral(TEXT_CSS) ||
michael@0:          aContentType.EqualsLiteral(TEXT_CACHE_MANIFEST) ||
michael@0:          aContentType.EqualsLiteral(APPLICATION_JAVASCRIPT) ||
michael@0:          aContentType.EqualsLiteral(APPLICATION_XJAVASCRIPT) ||
michael@0:          aContentType.EqualsLiteral(TEXT_ECMASCRIPT) ||
michael@0:          aContentType.EqualsLiteral(APPLICATION_ECMASCRIPT) ||
michael@0:          aContentType.EqualsLiteral(TEXT_JAVASCRIPT) ||
michael@0:          aContentType.EqualsLiteral(APPLICATION_JSON);
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::GetWrapperSafeScriptFilename(nsIDocument *aDocument,
michael@0:                                              nsIURI *aURI,
michael@0:                                              nsACString& aScriptURI)
michael@0: {
michael@0:   bool scriptFileNameModified = false;
michael@0:   aURI->GetSpec(aScriptURI);
michael@0: 
michael@0:   if (IsChromeDoc(aDocument)) {
michael@0:     nsCOMPtr<nsIChromeRegistry> chromeReg =
michael@0:       mozilla::services::GetChromeRegistryService();
michael@0: 
michael@0:     if (!chromeReg) {
michael@0:       // If we're running w/o a chrome registry we won't modify any
michael@0:       // script file names.
michael@0: 
michael@0:       return scriptFileNameModified;
michael@0:     }
michael@0: 
michael@0:     bool docWrappersEnabled =
michael@0:       chromeReg->WrappersEnabled(aDocument->GetDocumentURI());
michael@0: 
michael@0:     bool uriWrappersEnabled = chromeReg->WrappersEnabled(aURI);
michael@0: 
michael@0:     nsIURI *docURI = aDocument->GetDocumentURI();
michael@0: 
michael@0:     if (docURI && docWrappersEnabled && !uriWrappersEnabled) {
michael@0:       // aURI is a script from a URL that doesn't get wrapper
michael@0:       // automation. aDocument is a chrome document that does get
michael@0:       // wrapper automation. Prepend the chrome document's URI
michael@0:       // followed by the string " -> " to the URI of the script we're
michael@0:       // loading here so that script in that URI gets the same wrapper
michael@0:       // automation that the chrome document expects.
michael@0:       nsAutoCString spec;
michael@0:       docURI->GetSpec(spec);
michael@0:       spec.AppendLiteral(" -> ");
michael@0:       spec.Append(aScriptURI);
michael@0: 
michael@0:       aScriptURI = spec;
michael@0: 
michael@0:       scriptFileNameModified = true;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return scriptFileNameModified;
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::IsInChromeDocshell(nsIDocument *aDocument)
michael@0: {
michael@0:   if (!aDocument) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (aDocument->GetDisplayDocument()) {
michael@0:     return IsInChromeDocshell(aDocument->GetDisplayDocument());
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIDocShellTreeItem> docShell = aDocument->GetDocShell();
michael@0:   if (!docShell) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   return docShell->ItemType() == nsIDocShellTreeItem::typeChrome;
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsIContentPolicy*
michael@0: nsContentUtils::GetContentPolicy()
michael@0: {
michael@0:   if (!sTriedToGetContentPolicy) {
michael@0:     CallGetService(NS_CONTENTPOLICY_CONTRACTID, &sContentPolicyService);
michael@0:     // It's OK to not have a content policy service
michael@0:     sTriedToGetContentPolicy = true;
michael@0:   }
michael@0: 
michael@0:   return sContentPolicyService;
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::IsEventAttributeName(nsIAtom* aName, int32_t aType)
michael@0: {
michael@0:   const char16_t* name = aName->GetUTF16String();
michael@0:   if (name[0] != 'o' || name[1] != 'n')
michael@0:     return false;
michael@0: 
michael@0:   EventNameMapping mapping;
michael@0:   return (sAtomEventTable->Get(aName, &mapping) && mapping.mType & aType);
michael@0: }
michael@0: 
michael@0: // static
michael@0: uint32_t
michael@0: nsContentUtils::GetEventId(nsIAtom* aName)
michael@0: {
michael@0:   if (aName) {
michael@0:     EventNameMapping mapping;
michael@0:     if (sAtomEventTable->Get(aName, &mapping)) {
michael@0:       return mapping.mId;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return NS_USER_DEFINED_EVENT;
michael@0: }
michael@0: 
michael@0: // static
michael@0: uint32_t
michael@0: nsContentUtils::GetEventCategory(const nsAString& aName)
michael@0: {
michael@0:   EventNameMapping mapping;
michael@0:   if (sStringEventTable->Get(aName, &mapping))
michael@0:     return mapping.mStructType;
michael@0: 
michael@0:   return NS_EVENT;
michael@0: }
michael@0: 
michael@0: nsIAtom*
michael@0: nsContentUtils::GetEventIdAndAtom(const nsAString& aName,
michael@0:                                   uint32_t aEventStruct,
michael@0:                                   uint32_t* aEventID)
michael@0: {
michael@0:   EventNameMapping mapping;
michael@0:   if (sStringEventTable->Get(aName, &mapping)) {
michael@0:     *aEventID =
michael@0:       mapping.mStructType == aEventStruct ? mapping.mId : NS_USER_DEFINED_EVENT;
michael@0:     return mapping.mAtom;
michael@0:   }
michael@0: 
michael@0:   // If we have cached lots of user defined event names, clear some of them.
michael@0:   if (sUserDefinedEvents->Count() > 127) {
michael@0:     while (sUserDefinedEvents->Count() > 64) {
michael@0:       nsIAtom* first = sUserDefinedEvents->ObjectAt(0);
michael@0:       sStringEventTable->Remove(Substring(nsDependentAtomString(first), 2));
michael@0:       sUserDefinedEvents->RemoveObjectAt(0);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   *aEventID = NS_USER_DEFINED_EVENT;
michael@0:   nsCOMPtr<nsIAtom> atom = do_GetAtom(NS_LITERAL_STRING("on") + aName);
michael@0:   sUserDefinedEvents->AppendObject(atom);
michael@0:   mapping.mAtom = atom;
michael@0:   mapping.mId = NS_USER_DEFINED_EVENT;
michael@0:   mapping.mType = EventNameType_None;
michael@0:   mapping.mStructType = NS_EVENT_NULL;
michael@0:   sStringEventTable->Put(aName, mapping);
michael@0:   return mapping.mAtom;
michael@0: }
michael@0: 
michael@0: static
michael@0: nsresult GetEventAndTarget(nsIDocument* aDoc, nsISupports* aTarget,
michael@0:                            const nsAString& aEventName,
michael@0:                            bool aCanBubble, bool aCancelable,
michael@0:                            bool aTrusted, nsIDOMEvent** aEvent,
michael@0:                            EventTarget** aTargetOut)
michael@0: {
michael@0:   nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(aDoc);
michael@0:   nsCOMPtr<EventTarget> target(do_QueryInterface(aTarget));
michael@0:   NS_ENSURE_TRUE(domDoc && target, NS_ERROR_INVALID_ARG);
michael@0: 
michael@0:   nsCOMPtr<nsIDOMEvent> event;
michael@0:   nsresult rv =
michael@0:     domDoc->CreateEvent(NS_LITERAL_STRING("Events"), getter_AddRefs(event));
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   rv = event->InitEvent(aEventName, aCanBubble, aCancelable);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   event->SetTrusted(aTrusted);
michael@0: 
michael@0:   rv = event->SetTarget(target);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   event.forget(aEvent);
michael@0:   target.forget(aTargetOut);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::DispatchTrustedEvent(nsIDocument* aDoc, nsISupports* aTarget,
michael@0:                                      const nsAString& aEventName,
michael@0:                                      bool aCanBubble, bool aCancelable,
michael@0:                                      bool *aDefaultAction)
michael@0: {
michael@0:   return DispatchEvent(aDoc, aTarget, aEventName, aCanBubble, aCancelable,
michael@0:                        true, aDefaultAction);
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::DispatchUntrustedEvent(nsIDocument* aDoc, nsISupports* aTarget,
michael@0:                                        const nsAString& aEventName,
michael@0:                                        bool aCanBubble, bool aCancelable,
michael@0:                                        bool *aDefaultAction)
michael@0: {
michael@0:   return DispatchEvent(aDoc, aTarget, aEventName, aCanBubble, aCancelable,
michael@0:                        false, aDefaultAction);
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::DispatchEvent(nsIDocument* aDoc, nsISupports* aTarget,
michael@0:                               const nsAString& aEventName,
michael@0:                               bool aCanBubble, bool aCancelable,
michael@0:                               bool aTrusted, bool *aDefaultAction)
michael@0: {
michael@0:   nsCOMPtr<nsIDOMEvent> event;
michael@0:   nsCOMPtr<EventTarget> target;
michael@0:   nsresult rv = GetEventAndTarget(aDoc, aTarget, aEventName, aCanBubble,
michael@0:                                   aCancelable, aTrusted, getter_AddRefs(event),
michael@0:                                   getter_AddRefs(target));
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   bool dummy;
michael@0:   return target->DispatchEvent(event, aDefaultAction ? aDefaultAction : &dummy);
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsContentUtils::DispatchChromeEvent(nsIDocument *aDoc,
michael@0:                                     nsISupports *aTarget,
michael@0:                                     const nsAString& aEventName,
michael@0:                                     bool aCanBubble, bool aCancelable,
michael@0:                                     bool *aDefaultAction)
michael@0: {
michael@0: 
michael@0:   nsCOMPtr<nsIDOMEvent> event;
michael@0:   nsCOMPtr<EventTarget> target;
michael@0:   nsresult rv = GetEventAndTarget(aDoc, aTarget, aEventName, aCanBubble,
michael@0:                                   aCancelable, true, getter_AddRefs(event),
michael@0:                                   getter_AddRefs(target));
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   NS_ASSERTION(aDoc, "GetEventAndTarget lied?");
michael@0:   if (!aDoc->GetWindow())
michael@0:     return NS_ERROR_INVALID_ARG;
michael@0: 
michael@0:   EventTarget* piTarget = aDoc->GetWindow()->GetParentTarget();
michael@0:   if (!piTarget)
michael@0:     return NS_ERROR_INVALID_ARG;
michael@0: 
michael@0:   nsEventStatus status = nsEventStatus_eIgnore;
michael@0:   rv = piTarget->DispatchDOMEvent(nullptr, event, nullptr, &status);
michael@0:   if (aDefaultAction) {
michael@0:     *aDefaultAction = (status != nsEventStatus_eConsumeNoDefault);
michael@0:   }
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: Element*
michael@0: nsContentUtils::MatchElementId(nsIContent *aContent, const nsIAtom* aId)
michael@0: {
michael@0:   for (nsIContent* cur = aContent;
michael@0:        cur;
michael@0:        cur = cur->GetNextNode(aContent)) {
michael@0:     if (aId == cur->GetID()) {
michael@0:       return cur->AsElement();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: Element *
michael@0: nsContentUtils::MatchElementId(nsIContent *aContent, const nsAString& aId)
michael@0: {
michael@0:   NS_PRECONDITION(!aId.IsEmpty(), "Will match random elements");
michael@0:   
michael@0:   // ID attrs are generally stored as atoms, so just atomize this up front
michael@0:   nsCOMPtr<nsIAtom> id(do_GetAtom(aId));
michael@0:   if (!id) {
michael@0:     // OOM, so just bail
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   return MatchElementId(aContent, id);
michael@0: }
michael@0: 
michael@0: // Convert the string from the given encoding to Unicode.
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::ConvertStringFromEncoding(const nsACString& aEncoding,
michael@0:                                           const nsACString& aInput,
michael@0:                                           nsAString& aOutput)
michael@0: {
michael@0:   nsAutoCString encoding;
michael@0:   if (aEncoding.IsEmpty()) {
michael@0:     encoding.AssignLiteral("UTF-8");
michael@0:   } else {
michael@0:     encoding.Assign(aEncoding);
michael@0:   }
michael@0: 
michael@0:   ErrorResult rv;
michael@0:   nsAutoPtr<TextDecoder> decoder(new TextDecoder());
michael@0:   decoder->InitWithEncoding(encoding, false);
michael@0: 
michael@0:   decoder->Decode(aInput.BeginReading(), aInput.Length(), false,
michael@0:                   aOutput, rv);
michael@0:   return rv.ErrorCode();
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::CheckForBOM(const unsigned char* aBuffer, uint32_t aLength,
michael@0:                             nsACString& aCharset)
michael@0: {
michael@0:   bool found = true;
michael@0:   aCharset.Truncate();
michael@0:   if (aLength >= 3 &&
michael@0:       aBuffer[0] == 0xEF &&
michael@0:       aBuffer[1] == 0xBB &&
michael@0:       aBuffer[2] == 0xBF) {
michael@0:     aCharset = "UTF-8";
michael@0:   }
michael@0:   else if (aLength >= 2 &&
michael@0:            aBuffer[0] == 0xFE && aBuffer[1] == 0xFF) {
michael@0:     aCharset = "UTF-16BE";
michael@0:   }
michael@0:   else if (aLength >= 2 &&
michael@0:            aBuffer[0] == 0xFF && aBuffer[1] == 0xFE) {
michael@0:     aCharset = "UTF-16LE";
michael@0:   } else {
michael@0:     found = false;
michael@0:   }
michael@0: 
michael@0:   return found;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::RegisterShutdownObserver(nsIObserver* aObserver)
michael@0: {
michael@0:   nsCOMPtr<nsIObserverService> observerService =
michael@0:     mozilla::services::GetObserverService();
michael@0:   if (observerService) {
michael@0:     observerService->AddObserver(aObserver, 
michael@0:                                  NS_XPCOM_SHUTDOWN_OBSERVER_ID, 
michael@0:                                  false);
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::UnregisterShutdownObserver(nsIObserver* aObserver)
michael@0: {
michael@0:   nsCOMPtr<nsIObserverService> observerService =
michael@0:     mozilla::services::GetObserverService();
michael@0:   if (observerService) {
michael@0:     observerService->RemoveObserver(aObserver, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::HasNonEmptyAttr(const nsIContent* aContent, int32_t aNameSpaceID,
michael@0:                                 nsIAtom* aName)
michael@0: {
michael@0:   static nsIContent::AttrValuesArray strings[] = {&nsGkAtoms::_empty, nullptr};
michael@0:   return aContent->FindAttrValueIn(aNameSpaceID, aName, strings, eCaseMatters)
michael@0:     == nsIContent::ATTR_VALUE_NO_MATCH;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::HasMutationListeners(nsINode* aNode,
michael@0:                                      uint32_t aType,
michael@0:                                      nsINode* aTargetForSubtreeModified)
michael@0: {
michael@0:   nsIDocument* doc = aNode->OwnerDoc();
michael@0: 
michael@0:   // global object will be null for documents that don't have windows.
michael@0:   nsPIDOMWindow* window = doc->GetInnerWindow();
michael@0:   // This relies on EventListenerManager::AddEventListener, which sets
michael@0:   // all mutation bits when there is a listener for DOMSubtreeModified event.
michael@0:   if (window && !window->HasMutationListeners(aType)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (aNode->IsNodeOfType(nsINode::eCONTENT) &&
michael@0:       static_cast<nsIContent*>(aNode)->ChromeOnlyAccess()) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   doc->MayDispatchMutationEvent(aTargetForSubtreeModified);
michael@0: 
michael@0:   // If we have a window, we can check it for mutation listeners now.
michael@0:   if (aNode->IsInDoc()) {
michael@0:     nsCOMPtr<EventTarget> piTarget(do_QueryInterface(window));
michael@0:     if (piTarget) {
michael@0:       EventListenerManager* manager = piTarget->GetExistingListenerManager();
michael@0:       if (manager && manager->HasMutationListeners()) {
michael@0:         return true;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // If we have a window, we know a mutation listener is registered, but it
michael@0:   // might not be in our chain.  If we don't have a window, we might have a
michael@0:   // mutation listener.  Check quickly to see.
michael@0:   while (aNode) {
michael@0:     EventListenerManager* manager = aNode->GetExistingListenerManager();
michael@0:     if (manager && manager->HasMutationListeners()) {
michael@0:       return true;
michael@0:     }
michael@0: 
michael@0:     if (aNode->IsNodeOfType(nsINode::eCONTENT)) {
michael@0:       nsIContent* content = static_cast<nsIContent*>(aNode);
michael@0:       nsIContent* insertionParent = content->GetXBLInsertionParent();
michael@0:       if (insertionParent) {
michael@0:         aNode = insertionParent;
michael@0:         continue;
michael@0:       }
michael@0:     }
michael@0:     aNode = aNode->GetParentNode();
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::HasMutationListeners(nsIDocument* aDocument,
michael@0:                                      uint32_t aType)
michael@0: {
michael@0:   nsPIDOMWindow* window = aDocument ?
michael@0:     aDocument->GetInnerWindow() : nullptr;
michael@0: 
michael@0:   // This relies on EventListenerManager::AddEventListener, which sets
michael@0:   // all mutation bits when there is a listener for DOMSubtreeModified event.
michael@0:   return !window || window->HasMutationListeners(aType);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::MaybeFireNodeRemoved(nsINode* aChild, nsINode* aParent,
michael@0:                                      nsIDocument* aOwnerDoc)
michael@0: {
michael@0:   NS_PRECONDITION(aChild, "Missing child");
michael@0:   NS_PRECONDITION(aChild->GetParentNode() == aParent, "Wrong parent");
michael@0:   NS_PRECONDITION(aChild->OwnerDoc() == aOwnerDoc, "Wrong owner-doc");
michael@0: 
michael@0:   // This checks that IsSafeToRunScript is true since we don't want to fire
michael@0:   // events when that is false. We can't rely on EventDispatcher to assert
michael@0:   // this in this situation since most of the time there are no mutation
michael@0:   // event listeners, in which case we won't even attempt to dispatch events.
michael@0:   // However this also allows for two exceptions. First off, we don't assert
michael@0:   // if the mutation happens to native anonymous content since we never fire
michael@0:   // mutation events on such content anyway.
michael@0:   // Second, we don't assert if sDOMNodeRemovedSuppressCount is true since
michael@0:   // that is a know case when we'd normally fire a mutation event, but can't
michael@0:   // make that safe and so we suppress it at this time. Ideally this should
michael@0:   // go away eventually.
michael@0:   NS_ASSERTION((aChild->IsNodeOfType(nsINode::eCONTENT) &&
michael@0:                static_cast<nsIContent*>(aChild)->
michael@0:                  IsInNativeAnonymousSubtree()) ||
michael@0:                IsSafeToRunScript() ||
michael@0:                sDOMNodeRemovedSuppressCount,
michael@0:                "Want to fire DOMNodeRemoved event, but it's not safe");
michael@0: 
michael@0:   // Having an explicit check here since it's an easy mistake to fall into,
michael@0:   // and there might be existing code with problems. We'd rather be safe
michael@0:   // than fire DOMNodeRemoved in all corner cases. We also rely on it for
michael@0:   // nsAutoScriptBlockerSuppressNodeRemoved.
michael@0:   if (!IsSafeToRunScript()) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   if (HasMutationListeners(aChild,
michael@0:         NS_EVENT_BITS_MUTATION_NODEREMOVED, aParent)) {
michael@0:     InternalMutationEvent mutation(true, NS_MUTATION_NODEREMOVED);
michael@0:     mutation.mRelatedNode = do_QueryInterface(aParent);
michael@0: 
michael@0:     mozAutoSubtreeModified subtree(aOwnerDoc, aParent);
michael@0:     EventDispatcher::Dispatch(aChild, nullptr, &mutation);
michael@0:   }
michael@0: }
michael@0: 
michael@0: PLDHashOperator
michael@0: ListenerEnumerator(PLDHashTable* aTable, PLDHashEntryHdr* aEntry,
michael@0:                    uint32_t aNumber, void* aArg)
michael@0: {
michael@0:   EventListenerManagerMapEntry* entry =
michael@0:     static_cast<EventListenerManagerMapEntry*>(aEntry);
michael@0:   if (entry) {
michael@0:     nsINode* n = static_cast<nsINode*>(entry->mListenerManager->GetTarget());
michael@0:     if (n && n->IsInDoc() &&
michael@0:         nsCCUncollectableMarker::InGeneration(n->OwnerDoc()->GetMarkedCCGeneration())) {
michael@0:       entry->mListenerManager->MarkForCC();
michael@0:     }
michael@0:   }
michael@0:   return PL_DHASH_NEXT;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::UnmarkGrayJSListenersInCCGenerationDocuments(uint32_t aGeneration)
michael@0: {
michael@0:   if (sEventListenerManagersHash.ops) {
michael@0:     PL_DHashTableEnumerate(&sEventListenerManagersHash, ListenerEnumerator,
michael@0:                            &aGeneration);
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::TraverseListenerManager(nsINode *aNode,
michael@0:                                         nsCycleCollectionTraversalCallback &cb)
michael@0: {
michael@0:   if (!sEventListenerManagersHash.ops) {
michael@0:     // We're already shut down, just return.
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   EventListenerManagerMapEntry *entry =
michael@0:     static_cast<EventListenerManagerMapEntry *>
michael@0:                (PL_DHashTableOperate(&sEventListenerManagersHash, aNode,
michael@0:                                         PL_DHASH_LOOKUP));
michael@0:   if (PL_DHASH_ENTRY_IS_BUSY(entry)) {
michael@0:     CycleCollectionNoteChild(cb, entry->mListenerManager.get(),
michael@0:                              "[via hash] mListenerManager");
michael@0:   }
michael@0: }
michael@0: 
michael@0: EventListenerManager*
michael@0: nsContentUtils::GetListenerManagerForNode(nsINode *aNode)
michael@0: {
michael@0:   if (!sEventListenerManagersHash.ops) {
michael@0:     // We're already shut down, don't bother creating an event listener
michael@0:     // manager.
michael@0: 
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   EventListenerManagerMapEntry *entry =
michael@0:     static_cast<EventListenerManagerMapEntry *>
michael@0:                (PL_DHashTableOperate(&sEventListenerManagersHash, aNode,
michael@0:                                         PL_DHASH_ADD));
michael@0: 
michael@0:   if (!entry) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   if (!entry->mListenerManager) {
michael@0:     entry->mListenerManager = new EventListenerManager(aNode);
michael@0: 
michael@0:     aNode->SetFlags(NODE_HAS_LISTENERMANAGER);
michael@0:   }
michael@0: 
michael@0:   return entry->mListenerManager;
michael@0: }
michael@0: 
michael@0: EventListenerManager*
michael@0: nsContentUtils::GetExistingListenerManagerForNode(const nsINode *aNode)
michael@0: {
michael@0:   if (!aNode->HasFlag(NODE_HAS_LISTENERMANAGER)) {
michael@0:     return nullptr;
michael@0:   }
michael@0:   
michael@0:   if (!sEventListenerManagersHash.ops) {
michael@0:     // We're already shut down, don't bother creating an event listener
michael@0:     // manager.
michael@0: 
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   EventListenerManagerMapEntry *entry =
michael@0:     static_cast<EventListenerManagerMapEntry *>
michael@0:                (PL_DHashTableOperate(&sEventListenerManagersHash, aNode,
michael@0:                                         PL_DHASH_LOOKUP));
michael@0:   if (PL_DHASH_ENTRY_IS_BUSY(entry)) {
michael@0:     return entry->mListenerManager;
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::RemoveListenerManager(nsINode *aNode)
michael@0: {
michael@0:   if (sEventListenerManagersHash.ops) {
michael@0:     EventListenerManagerMapEntry *entry =
michael@0:       static_cast<EventListenerManagerMapEntry *>
michael@0:                  (PL_DHashTableOperate(&sEventListenerManagersHash, aNode,
michael@0:                                           PL_DHASH_LOOKUP));
michael@0:     if (PL_DHASH_ENTRY_IS_BUSY(entry)) {
michael@0:       nsRefPtr<EventListenerManager> listenerManager;
michael@0:       listenerManager.swap(entry->mListenerManager);
michael@0:       // Remove the entry and *then* do operations that could cause further
michael@0:       // modification of sEventListenerManagersHash.  See bug 334177.
michael@0:       PL_DHashTableRawRemove(&sEventListenerManagersHash, entry);
michael@0:       if (listenerManager) {
michael@0:         listenerManager->Disconnect();
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::IsValidNodeName(nsIAtom *aLocalName, nsIAtom *aPrefix,
michael@0:                                 int32_t aNamespaceID)
michael@0: {
michael@0:   if (aNamespaceID == kNameSpaceID_Unknown) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (!aPrefix) {
michael@0:     // If the prefix is null, then either the QName must be xmlns or the
michael@0:     // namespace must not be XMLNS.
michael@0:     return (aLocalName == nsGkAtoms::xmlns) ==
michael@0:            (aNamespaceID == kNameSpaceID_XMLNS);
michael@0:   }
michael@0: 
michael@0:   // If the prefix is non-null then the namespace must not be null.
michael@0:   if (aNamespaceID == kNameSpaceID_None) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   // If the namespace is the XMLNS namespace then the prefix must be xmlns,
michael@0:   // but the localname must not be xmlns.
michael@0:   if (aNamespaceID == kNameSpaceID_XMLNS) {
michael@0:     return aPrefix == nsGkAtoms::xmlns && aLocalName != nsGkAtoms::xmlns;
michael@0:   }
michael@0: 
michael@0:   // If the namespace is not the XMLNS namespace then the prefix must not be
michael@0:   // xmlns.
michael@0:   // If the namespace is the XML namespace then the prefix can be anything.
michael@0:   // If the namespace is not the XML namespace then the prefix must not be xml.
michael@0:   return aPrefix != nsGkAtoms::xmlns &&
michael@0:          (aNamespaceID == kNameSpaceID_XML || aPrefix != nsGkAtoms::xml);
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::CreateContextualFragment(nsINode* aContextNode,
michael@0:                                          const nsAString& aFragment,
michael@0:                                          bool aPreventScriptExecution,
michael@0:                                          nsIDOMDocumentFragment** aReturn)
michael@0: {
michael@0:   ErrorResult rv;
michael@0:   *aReturn = CreateContextualFragment(aContextNode, aFragment,
michael@0:                                       aPreventScriptExecution, rv).take();
michael@0:   return rv.ErrorCode();
michael@0: }
michael@0: 
michael@0: already_AddRefed<DocumentFragment>
michael@0: nsContentUtils::CreateContextualFragment(nsINode* aContextNode,
michael@0:                                          const nsAString& aFragment,
michael@0:                                          bool aPreventScriptExecution,
michael@0:                                          ErrorResult& aRv)
michael@0: {
michael@0:   if (!aContextNode) {
michael@0:     aRv.Throw(NS_ERROR_INVALID_ARG);
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   // If we don't have a document here, we can't get the right security context
michael@0:   // for compiling event handlers... so just bail out.
michael@0:   nsCOMPtr<nsIDocument> document = aContextNode->OwnerDoc();
michael@0:   bool isHTML = document->IsHTML();
michael@0: #ifdef DEBUG
michael@0:   nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(document);
michael@0:   NS_ASSERTION(!isHTML || htmlDoc, "Should have HTMLDocument here!");
michael@0: #endif
michael@0: 
michael@0:   if (isHTML) {
michael@0:     nsRefPtr<DocumentFragment> frag =
michael@0:       new DocumentFragment(document->NodeInfoManager());
michael@0:     
michael@0:     nsCOMPtr<nsIContent> contextAsContent = do_QueryInterface(aContextNode);
michael@0:     if (contextAsContent && !contextAsContent->IsElement()) {
michael@0:       contextAsContent = contextAsContent->GetParent();
michael@0:       if (contextAsContent && !contextAsContent->IsElement()) {
michael@0:         // can this even happen?
michael@0:         contextAsContent = nullptr;
michael@0:       }
michael@0:     }
michael@0:     
michael@0:     if (contextAsContent && !contextAsContent->IsHTML(nsGkAtoms::html)) {
michael@0:       aRv = ParseFragmentHTML(aFragment, frag,
michael@0:                               contextAsContent->Tag(),
michael@0:                               contextAsContent->GetNameSpaceID(),
michael@0:                               (document->GetCompatibilityMode() ==
michael@0:                                eCompatibility_NavQuirks),
michael@0:                               aPreventScriptExecution);
michael@0:     } else {
michael@0:       aRv = ParseFragmentHTML(aFragment, frag,
michael@0:                               nsGkAtoms::body,
michael@0:                               kNameSpaceID_XHTML,
michael@0:                               (document->GetCompatibilityMode() ==
michael@0:                                eCompatibility_NavQuirks),
michael@0:                               aPreventScriptExecution);
michael@0:     }
michael@0: 
michael@0:     return frag.forget();
michael@0:   }
michael@0: 
michael@0:   nsAutoTArray<nsString, 32> tagStack;
michael@0:   nsAutoString uriStr, nameStr;
michael@0:   nsCOMPtr<nsIContent> content = do_QueryInterface(aContextNode);
michael@0:   // just in case we have a text node
michael@0:   if (content && !content->IsElement())
michael@0:     content = content->GetParent();
michael@0: 
michael@0:   while (content && content->IsElement()) {
michael@0:     nsString& tagName = *tagStack.AppendElement();
michael@0:     if (!&tagName) {
michael@0:       aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
michael@0:       return nullptr;
michael@0:     }
michael@0: 
michael@0:     tagName = content->NodeInfo()->QualifiedName();
michael@0: 
michael@0:     // see if we need to add xmlns declarations
michael@0:     uint32_t count = content->GetAttrCount();
michael@0:     bool setDefaultNamespace = false;
michael@0:     if (count > 0) {
michael@0:       uint32_t index;
michael@0: 
michael@0:       for (index = 0; index < count; index++) {
michael@0:         const nsAttrName* name = content->GetAttrNameAt(index);
michael@0:         if (name->NamespaceEquals(kNameSpaceID_XMLNS)) {
michael@0:           content->GetAttr(kNameSpaceID_XMLNS, name->LocalName(), uriStr);
michael@0: 
michael@0:           // really want something like nsXMLContentSerializer::SerializeAttr
michael@0:           tagName.Append(NS_LITERAL_STRING(" xmlns")); // space important
michael@0:           if (name->GetPrefix()) {
michael@0:             tagName.Append(char16_t(':'));
michael@0:             name->LocalName()->ToString(nameStr);
michael@0:             tagName.Append(nameStr);
michael@0:           } else {
michael@0:             setDefaultNamespace = true;
michael@0:           }
michael@0:           tagName.Append(NS_LITERAL_STRING("=\"") + uriStr +
michael@0:             NS_LITERAL_STRING("\""));
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     if (!setDefaultNamespace) {
michael@0:       nsINodeInfo* info = content->NodeInfo();
michael@0:       if (!info->GetPrefixAtom() &&
michael@0:           info->NamespaceID() != kNameSpaceID_None) {
michael@0:         // We have no namespace prefix, but have a namespace ID.  Push
michael@0:         // default namespace attr in, so that our kids will be in our
michael@0:         // namespace.
michael@0:         info->GetNamespaceURI(uriStr);
michael@0:         tagName.Append(NS_LITERAL_STRING(" xmlns=\"") + uriStr +
michael@0:                        NS_LITERAL_STRING("\""));
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     content = content->GetParent();
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIDOMDocumentFragment> frag;
michael@0:   aRv = ParseFragmentXML(aFragment, document, tagStack,
michael@0:                          aPreventScriptExecution, getter_AddRefs(frag));
michael@0:   return frag.forget().downcast<DocumentFragment>();
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::DropFragmentParsers()
michael@0: {
michael@0:   NS_IF_RELEASE(sHTMLFragmentParser);
michael@0:   NS_IF_RELEASE(sXMLFragmentParser);
michael@0:   NS_IF_RELEASE(sXMLFragmentSink);
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::XPCOMShutdown()
michael@0: {
michael@0:   nsContentUtils::DropFragmentParsers();
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::ParseFragmentHTML(const nsAString& aSourceBuffer,
michael@0:                                   nsIContent* aTargetNode,
michael@0:                                   nsIAtom* aContextLocalName,
michael@0:                                   int32_t aContextNamespace,
michael@0:                                   bool aQuirks,
michael@0:                                   bool aPreventScriptExecution)
michael@0: {
michael@0:   if (nsContentUtils::sFragmentParsingActive) {
michael@0:     NS_NOTREACHED("Re-entrant fragment parsing attempted.");
michael@0:     return NS_ERROR_DOM_INVALID_STATE_ERR;
michael@0:   }
michael@0:   mozilla::AutoRestore<bool> guard(nsContentUtils::sFragmentParsingActive);
michael@0:   nsContentUtils::sFragmentParsingActive = true;
michael@0:   if (!sHTMLFragmentParser) {
michael@0:     NS_ADDREF(sHTMLFragmentParser = new nsHtml5StringParser());
michael@0:     // Now sHTMLFragmentParser owns the object
michael@0:   }
michael@0:   nsresult rv =
michael@0:     sHTMLFragmentParser->ParseFragment(aSourceBuffer,
michael@0:                                        aTargetNode,
michael@0:                                        aContextLocalName,
michael@0:                                        aContextNamespace,
michael@0:                                        aQuirks,
michael@0:                                        aPreventScriptExecution);
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::ParseDocumentHTML(const nsAString& aSourceBuffer,
michael@0:                                   nsIDocument* aTargetDocument,
michael@0:                                   bool aScriptingEnabledForNoscriptParsing)
michael@0: {
michael@0:   if (nsContentUtils::sFragmentParsingActive) {
michael@0:     NS_NOTREACHED("Re-entrant fragment parsing attempted.");
michael@0:     return NS_ERROR_DOM_INVALID_STATE_ERR;
michael@0:   }
michael@0:   mozilla::AutoRestore<bool> guard(nsContentUtils::sFragmentParsingActive);
michael@0:   nsContentUtils::sFragmentParsingActive = true;
michael@0:   if (!sHTMLFragmentParser) {
michael@0:     NS_ADDREF(sHTMLFragmentParser = new nsHtml5StringParser());
michael@0:     // Now sHTMLFragmentParser owns the object
michael@0:   }
michael@0:   nsresult rv =
michael@0:     sHTMLFragmentParser->ParseDocument(aSourceBuffer,
michael@0:                                        aTargetDocument,
michael@0:                                        aScriptingEnabledForNoscriptParsing);
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::ParseFragmentXML(const nsAString& aSourceBuffer,
michael@0:                                  nsIDocument* aDocument,
michael@0:                                  nsTArray<nsString>& aTagStack,
michael@0:                                  bool aPreventScriptExecution,
michael@0:                                  nsIDOMDocumentFragment** aReturn)
michael@0: {
michael@0:   if (nsContentUtils::sFragmentParsingActive) {
michael@0:     NS_NOTREACHED("Re-entrant fragment parsing attempted.");
michael@0:     return NS_ERROR_DOM_INVALID_STATE_ERR;
michael@0:   }
michael@0:   mozilla::AutoRestore<bool> guard(nsContentUtils::sFragmentParsingActive);
michael@0:   nsContentUtils::sFragmentParsingActive = true;
michael@0:   if (!sXMLFragmentParser) {
michael@0:     nsCOMPtr<nsIParser> parser = do_CreateInstance(kCParserCID);
michael@0:     parser.forget(&sXMLFragmentParser);
michael@0:     // sXMLFragmentParser now owns the parser
michael@0:   }
michael@0:   if (!sXMLFragmentSink) {
michael@0:     NS_NewXMLFragmentContentSink(&sXMLFragmentSink);
michael@0:     // sXMLFragmentSink now owns the sink
michael@0:   }
michael@0:   nsCOMPtr<nsIContentSink> contentsink = do_QueryInterface(sXMLFragmentSink);
michael@0:   NS_ABORT_IF_FALSE(contentsink, "Sink doesn't QI to nsIContentSink!");
michael@0:   sXMLFragmentParser->SetContentSink(contentsink);
michael@0: 
michael@0:   sXMLFragmentSink->SetTargetDocument(aDocument);
michael@0:   sXMLFragmentSink->SetPreventScriptExecution(aPreventScriptExecution);
michael@0: 
michael@0:   nsresult rv =
michael@0:     sXMLFragmentParser->ParseFragment(aSourceBuffer,
michael@0:                                       aTagStack);
michael@0:   if (NS_FAILED(rv)) {
michael@0:     // Drop the fragment parser and sink that might be in an inconsistent state
michael@0:     NS_IF_RELEASE(sXMLFragmentParser);
michael@0:     NS_IF_RELEASE(sXMLFragmentSink);
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   rv = sXMLFragmentSink->FinishFragmentParsing(aReturn);
michael@0: 
michael@0:   sXMLFragmentParser->Reset();
michael@0: 
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::ConvertToPlainText(const nsAString& aSourceBuffer,
michael@0:                                    nsAString& aResultBuffer,
michael@0:                                    uint32_t aFlags,
michael@0:                                    uint32_t aWrapCol)
michael@0: {
michael@0:   nsCOMPtr<nsIURI> uri;
michael@0:   NS_NewURI(getter_AddRefs(uri), "about:blank");
michael@0:   nsCOMPtr<nsIPrincipal> principal =
michael@0:     do_CreateInstance(NS_NULLPRINCIPAL_CONTRACTID);
michael@0:   nsCOMPtr<nsIDOMDocument> domDocument;
michael@0:   nsresult rv = NS_NewDOMDocument(getter_AddRefs(domDocument),
michael@0:                                   EmptyString(),
michael@0:                                   EmptyString(),
michael@0:                                   nullptr,
michael@0:                                   uri,
michael@0:                                   uri,
michael@0:                                   principal,
michael@0:                                   true,
michael@0:                                   nullptr,
michael@0:                                   DocumentFlavorHTML);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   nsCOMPtr<nsIDocument> document = do_QueryInterface(domDocument);
michael@0:   rv = nsContentUtils::ParseDocumentHTML(aSourceBuffer, document,
michael@0:     !(aFlags & nsIDocumentEncoder::OutputNoScriptContent));
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   nsCOMPtr<nsIDocumentEncoder> encoder = do_CreateInstance(
michael@0:     "@mozilla.org/layout/documentEncoder;1?type=text/plain");
michael@0: 
michael@0:   rv = encoder->Init(domDocument, NS_LITERAL_STRING("text/plain"), aFlags);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   encoder->SetWrapColumn(aWrapCol);
michael@0: 
michael@0:   return encoder->EncodeToString(aResultBuffer);
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::SetNodeTextContent(nsIContent* aContent,
michael@0:                                    const nsAString& aValue,
michael@0:                                    bool aTryReuse)
michael@0: {
michael@0:   // Fire DOMNodeRemoved mutation events before we do anything else.
michael@0:   nsCOMPtr<nsIContent> owningContent;
michael@0: 
michael@0:   // Batch possible DOMSubtreeModified events.
michael@0:   mozAutoSubtreeModified subtree(nullptr, nullptr);
michael@0: 
michael@0:   // Scope firing mutation events so that we don't carry any state that
michael@0:   // might be stale
michael@0:   {
michael@0:     // We're relying on mozAutoSubtreeModified to keep a strong reference if
michael@0:     // needed.
michael@0:     nsIDocument* doc = aContent->OwnerDoc();
michael@0: 
michael@0:     // Optimize the common case of there being no observers
michael@0:     if (HasMutationListeners(doc, NS_EVENT_BITS_MUTATION_NODEREMOVED)) {
michael@0:       subtree.UpdateTarget(doc, nullptr);
michael@0:       owningContent = aContent;
michael@0:       nsCOMPtr<nsINode> child;
michael@0:       bool skipFirst = aTryReuse;
michael@0:       for (child = aContent->GetFirstChild();
michael@0:            child && child->GetParentNode() == aContent;
michael@0:            child = child->GetNextSibling()) {
michael@0:         if (skipFirst && child->IsNodeOfType(nsINode::eTEXT)) {
michael@0:           skipFirst = false;
michael@0:           continue;
michael@0:         }
michael@0:         nsContentUtils::MaybeFireNodeRemoved(child, aContent, doc);
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Might as well stick a batch around this since we're performing several
michael@0:   // mutations.
michael@0:   mozAutoDocUpdate updateBatch(aContent->GetCurrentDoc(),
michael@0:     UPDATE_CONTENT_MODEL, true);
michael@0:   nsAutoMutationBatch mb;
michael@0: 
michael@0:   uint32_t childCount = aContent->GetChildCount();
michael@0: 
michael@0:   if (aTryReuse && !aValue.IsEmpty()) {
michael@0:     uint32_t removeIndex = 0;
michael@0: 
michael@0:     for (uint32_t i = 0; i < childCount; ++i) {
michael@0:       nsIContent* child = aContent->GetChildAt(removeIndex);
michael@0:       if (removeIndex == 0 && child && child->IsNodeOfType(nsINode::eTEXT)) {
michael@0:         nsresult rv = child->SetText(aValue, true);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:         removeIndex = 1;
michael@0:       }
michael@0:       else {
michael@0:         aContent->RemoveChildAt(removeIndex, true);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     if (removeIndex == 1) {
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0:   else {
michael@0:     mb.Init(aContent, true, false);
michael@0:     for (uint32_t i = 0; i < childCount; ++i) {
michael@0:       aContent->RemoveChildAt(0, true);
michael@0:     }
michael@0:   }
michael@0:   mb.RemovalDone();
michael@0: 
michael@0:   if (aValue.IsEmpty()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<nsTextNode> textContent =
michael@0:     new nsTextNode(aContent->NodeInfo()->NodeInfoManager());
michael@0: 
michael@0:   textContent->SetText(aValue, true);
michael@0: 
michael@0:   nsresult rv = aContent->AppendChildTo(textContent, true);
michael@0:   mb.NodesAdded();
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: AppendNodeTextContentsRecurse(nsINode* aNode, nsAString& aResult,
michael@0:                               const mozilla::fallible_t&)
michael@0: {
michael@0:   for (nsIContent* child = aNode->GetFirstChild();
michael@0:        child;
michael@0:        child = child->GetNextSibling()) {
michael@0:     if (child->IsElement()) {
michael@0:       bool ok = AppendNodeTextContentsRecurse(child, aResult,
michael@0:                                               mozilla::fallible_t());
michael@0:       if (!ok) {
michael@0:         return false;
michael@0:       }
michael@0:     }
michael@0:     else if (child->IsNodeOfType(nsINode::eTEXT)) {
michael@0:       bool ok = child->AppendTextTo(aResult, mozilla::fallible_t());
michael@0:       if (!ok) {
michael@0:         return false;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::AppendNodeTextContent(nsINode* aNode, bool aDeep,
michael@0:                                       nsAString& aResult,
michael@0:                                       const mozilla::fallible_t&)
michael@0: {
michael@0:   if (aNode->IsNodeOfType(nsINode::eTEXT)) {
michael@0:     return static_cast<nsIContent*>(aNode)->AppendTextTo(aResult,
michael@0:                                                          mozilla::fallible_t());
michael@0:   }
michael@0:   else if (aDeep) {
michael@0:     return AppendNodeTextContentsRecurse(aNode, aResult, mozilla::fallible_t());
michael@0:   }
michael@0:   else {
michael@0:     for (nsIContent* child = aNode->GetFirstChild();
michael@0:          child;
michael@0:          child = child->GetNextSibling()) {
michael@0:       if (child->IsNodeOfType(nsINode::eTEXT)) {
michael@0:         bool ok = child->AppendTextTo(aResult, mozilla::fallible_t());
michael@0:         if (!ok) {
michael@0:             return false;
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::HasNonEmptyTextContent(nsINode* aNode)
michael@0: {
michael@0:   for (nsIContent* child = aNode->GetFirstChild();
michael@0:        child;
michael@0:        child = child->GetNextSibling()) {
michael@0:     if (child->IsNodeOfType(nsINode::eTEXT) &&
michael@0:         child->TextLength() > 0) {
michael@0:       return true;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::IsInSameAnonymousTree(const nsINode* aNode,
michael@0:                                       const nsIContent* aContent)
michael@0: {
michael@0:   NS_PRECONDITION(aNode,
michael@0:                   "Must have a node to work with");
michael@0:   NS_PRECONDITION(aContent,
michael@0:                   "Must have a content to work with");
michael@0:   
michael@0:   if (!aNode->IsNodeOfType(nsINode::eCONTENT)) {
michael@0:     /**
michael@0:      * The root isn't an nsIContent, so it's a document or attribute.  The only
michael@0:      * nodes in the same anonymous subtree as it will have a null
michael@0:      * bindingParent.
michael@0:      *
michael@0:      * XXXbz strictly speaking, that's not true for attribute nodes.
michael@0:      */
michael@0:     return aContent->GetBindingParent() == nullptr;
michael@0:   }
michael@0: 
michael@0:   const nsIContent* nodeAsContent = static_cast<const nsIContent*>(aNode);
michael@0: 
michael@0:   // For nodes in a shadow tree, it is insufficient to simply compare
michael@0:   // the binding parent because a node may host multiple ShadowRoots,
michael@0:   // thus nodes in different shadow tree may have the same binding parent.
michael@0:   if (aNode->HasFlag(NODE_IS_IN_SHADOW_TREE)) {
michael@0:     return nodeAsContent->GetContainingShadow() ==
michael@0:       aContent->GetContainingShadow();
michael@0:   }
michael@0: 
michael@0:   return nodeAsContent->GetBindingParent() == aContent->GetBindingParent();
michael@0: }
michael@0: 
michael@0: class AnonymousContentDestroyer : public nsRunnable {
michael@0: public:
michael@0:   AnonymousContentDestroyer(nsCOMPtr<nsIContent>* aContent) {
michael@0:     mContent.swap(*aContent);
michael@0:     mParent = mContent->GetParent();
michael@0:     mDoc = mContent->OwnerDoc();
michael@0:   }
michael@0:   AnonymousContentDestroyer(nsCOMPtr<Element>* aElement) {
michael@0:     mContent = aElement->forget();
michael@0:     mParent = mContent->GetParent();
michael@0:     mDoc = mContent->OwnerDoc();
michael@0:   }
michael@0:   NS_IMETHOD Run() {
michael@0:     mContent->UnbindFromTree();
michael@0:     return NS_OK;
michael@0:   }
michael@0: private:
michael@0:   nsCOMPtr<nsIContent> mContent;
michael@0:   // Hold strong refs to the parent content and document so that they
michael@0:   // don't die unexpectedly
michael@0:   nsCOMPtr<nsIDocument> mDoc;
michael@0:   nsCOMPtr<nsIContent> mParent;
michael@0: };
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::DestroyAnonymousContent(nsCOMPtr<nsIContent>* aContent)
michael@0: {
michael@0:   if (*aContent) {
michael@0:     AddScriptRunner(new AnonymousContentDestroyer(aContent));
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::DestroyAnonymousContent(nsCOMPtr<Element>* aElement)
michael@0: {
michael@0:   if (*aElement) {
michael@0:     AddScriptRunner(new AnonymousContentDestroyer(aElement));
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::NotifyInstalledMenuKeyboardListener(bool aInstalling)
michael@0: {
michael@0:   IMEStateManager::OnInstalledMenuKeyboardListener(aInstalling);
michael@0: }
michael@0: 
michael@0: static bool SchemeIs(nsIURI* aURI, const char* aScheme)
michael@0: {
michael@0:   nsCOMPtr<nsIURI> baseURI = NS_GetInnermostURI(aURI);
michael@0:   NS_ENSURE_TRUE(baseURI, false);
michael@0: 
michael@0:   bool isScheme = false;
michael@0:   return NS_SUCCEEDED(baseURI->SchemeIs(aScheme, &isScheme)) && isScheme;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::CheckSecurityBeforeLoad(nsIURI* aURIToLoad,
michael@0:                                         nsIPrincipal* aLoadingPrincipal,
michael@0:                                         uint32_t aCheckLoadFlags,
michael@0:                                         bool aAllowData,
michael@0:                                         uint32_t aContentPolicyType,
michael@0:                                         nsISupports* aContext,
michael@0:                                         const nsAFlatCString& aMimeGuess,
michael@0:                                         nsISupports* aExtra)
michael@0: {
michael@0:   NS_PRECONDITION(aLoadingPrincipal, "Must have a loading principal here");
michael@0: 
michael@0:   bool isSystemPrin = false;
michael@0:   if (NS_SUCCEEDED(sSecurityManager->IsSystemPrincipal(aLoadingPrincipal,
michael@0:                                                        &isSystemPrin)) &&
michael@0:       isSystemPrin) {
michael@0:     return NS_OK;
michael@0:   }
michael@0:   
michael@0:   // XXXbz do we want to fast-path skin stylesheets loading XBL here somehow?
michael@0:   // CheckLoadURIWithPrincipal
michael@0:   nsresult rv = sSecurityManager->
michael@0:     CheckLoadURIWithPrincipal(aLoadingPrincipal, aURIToLoad, aCheckLoadFlags);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   // Content Policy
michael@0:   int16_t shouldLoad = nsIContentPolicy::ACCEPT;
michael@0:   rv = NS_CheckContentLoadPolicy(aContentPolicyType,
michael@0:                                  aURIToLoad,
michael@0:                                  aLoadingPrincipal,
michael@0:                                  aContext,
michael@0:                                  aMimeGuess,
michael@0:                                  aExtra,
michael@0:                                  &shouldLoad,
michael@0:                                  GetContentPolicy(),
michael@0:                                  sSecurityManager);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0:   if (NS_CP_REJECTED(shouldLoad)) {
michael@0:     return NS_ERROR_CONTENT_BLOCKED;
michael@0:   }
michael@0: 
michael@0:   // Same Origin
michael@0:   if ((aAllowData && SchemeIs(aURIToLoad, "data")) ||
michael@0:       ((aCheckLoadFlags & nsIScriptSecurityManager::ALLOW_CHROME) &&
michael@0:        SchemeIs(aURIToLoad, "chrome"))) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   return aLoadingPrincipal->CheckMayLoad(aURIToLoad, true, false);
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsSystemPrincipal(nsIPrincipal* aPrincipal)
michael@0: {
michael@0:   bool isSystem;
michael@0:   nsresult rv = sSecurityManager->IsSystemPrincipal(aPrincipal, &isSystem);
michael@0:   return NS_SUCCEEDED(rv) && isSystem;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsExpandedPrincipal(nsIPrincipal* aPrincipal)
michael@0: {
michael@0:   nsCOMPtr<nsIExpandedPrincipal> ep = do_QueryInterface(aPrincipal);
michael@0:   return !!ep;
michael@0: }
michael@0: 
michael@0: nsIPrincipal*
michael@0: nsContentUtils::GetSystemPrincipal()
michael@0: {
michael@0:   nsCOMPtr<nsIPrincipal> sysPrin;
michael@0:   DebugOnly<nsresult> rv =
michael@0:     sSecurityManager->GetSystemPrincipal(getter_AddRefs(sysPrin));
michael@0:   MOZ_ASSERT(NS_SUCCEEDED(rv) && sysPrin);
michael@0:   return sysPrin;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::CombineResourcePrincipals(nsCOMPtr<nsIPrincipal>* aResourcePrincipal,
michael@0:                                           nsIPrincipal* aExtraPrincipal)
michael@0: {
michael@0:   if (!aExtraPrincipal) {
michael@0:     return false;
michael@0:   }
michael@0:   if (!*aResourcePrincipal) {
michael@0:     *aResourcePrincipal = aExtraPrincipal;
michael@0:     return true;
michael@0:   }
michael@0:   if (*aResourcePrincipal == aExtraPrincipal) {
michael@0:     return false;
michael@0:   }
michael@0:   bool subsumes;
michael@0:   if (NS_SUCCEEDED((*aResourcePrincipal)->Subsumes(aExtraPrincipal, &subsumes)) &&
michael@0:       subsumes) {
michael@0:     return false;
michael@0:   }
michael@0:   sSecurityManager->GetSystemPrincipal(getter_AddRefs(*aResourcePrincipal));
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::TriggerLink(nsIContent *aContent, nsPresContext *aPresContext,
michael@0:                             nsIURI *aLinkURI, const nsString &aTargetSpec,
michael@0:                             bool aClick, bool aIsUserTriggered,
michael@0:                             bool aIsTrusted)
michael@0: {
michael@0:   NS_ASSERTION(aPresContext, "Need a nsPresContext");
michael@0:   NS_PRECONDITION(aLinkURI, "No link URI");
michael@0: 
michael@0:   if (aContent->IsEditable()) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   nsILinkHandler *handler = aPresContext->GetLinkHandler();
michael@0:   if (!handler) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   if (!aClick) {
michael@0:     handler->OnOverLink(aContent, aLinkURI, aTargetSpec.get());
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   // Check that this page is allowed to load this URI.
michael@0:   nsresult proceed = NS_OK;
michael@0: 
michael@0:   if (sSecurityManager) {
michael@0:     uint32_t flag =
michael@0:       aIsUserTriggered ?
michael@0:       (uint32_t)nsIScriptSecurityManager::STANDARD :
michael@0:       (uint32_t)nsIScriptSecurityManager::LOAD_IS_AUTOMATIC_DOCUMENT_REPLACEMENT;
michael@0:     proceed =
michael@0:       sSecurityManager->CheckLoadURIWithPrincipal(aContent->NodePrincipal(),
michael@0:                                                   aLinkURI, flag);
michael@0:   }
michael@0: 
michael@0:   // Only pass off the click event if the script security manager says it's ok.
michael@0:   // We need to rest aTargetSpec for forced downloads.
michael@0:   if (NS_SUCCEEDED(proceed)) {
michael@0: 
michael@0:     // A link/area element with a download attribute is allowed to set
michael@0:     // a pseudo Content-Disposition header.
michael@0:     // For security reasons we only allow websites to declare same-origin resources
michael@0:     // as downloadable. If this check fails we will just do the normal thing
michael@0:     // (i.e. navigate to the resource).
michael@0:     nsAutoString fileName;
michael@0:     if ((!aContent->IsHTML(nsGkAtoms::a) && !aContent->IsHTML(nsGkAtoms::area) &&
michael@0:          !aContent->IsSVG(nsGkAtoms::a)) ||
michael@0:         !aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::download, fileName) ||
michael@0:         NS_FAILED(aContent->NodePrincipal()->CheckMayLoad(aLinkURI, false, true))) {
michael@0:       fileName.SetIsVoid(true); // No actionable download attribute was found.
michael@0:     }
michael@0: 
michael@0:     handler->OnLinkClick(aContent, aLinkURI,
michael@0:                          fileName.IsVoid() ? aTargetSpec.get() : EmptyString().get(),
michael@0:                          fileName, nullptr, nullptr, aIsTrusted);
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::GetLinkLocation(Element* aElement, nsString& aLocationString)
michael@0: {
michael@0:   nsCOMPtr<nsIURI> hrefURI = aElement->GetHrefURI();
michael@0:   if (hrefURI) {
michael@0:     nsAutoCString specUTF8;
michael@0:     nsresult rv = hrefURI->GetSpec(specUTF8);
michael@0:     if (NS_SUCCEEDED(rv))
michael@0:       CopyUTF8toUTF16(specUTF8, aLocationString);
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsIWidget*
michael@0: nsContentUtils::GetTopLevelWidget(nsIWidget* aWidget)
michael@0: {
michael@0:   if (!aWidget)
michael@0:     return nullptr;
michael@0: 
michael@0:   return aWidget->GetTopLevelWidget();
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: const nsDependentString
michael@0: nsContentUtils::GetLocalizedEllipsis()
michael@0: {
michael@0:   static char16_t sBuf[4] = { 0, 0, 0, 0 };
michael@0:   if (!sBuf[0]) {
michael@0:     nsAdoptingString tmp = Preferences::GetLocalizedString("intl.ellipsis");
michael@0:     uint32_t len = std::min(uint32_t(tmp.Length()),
michael@0:                           uint32_t(ArrayLength(sBuf) - 1));
michael@0:     CopyUnicodeTo(tmp, 0, sBuf, len);
michael@0:     if (!sBuf[0])
michael@0:       sBuf[0] = char16_t(0x2026);
michael@0:   }
michael@0:   return nsDependentString(sBuf);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: HasASCIIDigit(const nsTArray<nsShortcutCandidate>& aCandidates)
michael@0: {
michael@0:   for (uint32_t i = 0; i < aCandidates.Length(); ++i) {
michael@0:     uint32_t ch = aCandidates[i].mCharCode;
michael@0:     if (ch >= '0' && ch <= '9')
michael@0:       return true;
michael@0:   }
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CharsCaseInsensitiveEqual(uint32_t aChar1, uint32_t aChar2)
michael@0: {
michael@0:   return aChar1 == aChar2 ||
michael@0:          (IS_IN_BMP(aChar1) && IS_IN_BMP(aChar2) &&
michael@0:           ToLowerCase(char16_t(aChar1)) == ToLowerCase(char16_t(aChar2)));
michael@0: }
michael@0: 
michael@0: static bool
michael@0: IsCaseChangeableChar(uint32_t aChar)
michael@0: {
michael@0:   return IS_IN_BMP(aChar) &&
michael@0:          ToLowerCase(char16_t(aChar)) != ToUpperCase(char16_t(aChar));
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::GetAccelKeyCandidates(nsIDOMKeyEvent* aDOMKeyEvent,
michael@0:                   nsTArray<nsShortcutCandidate>& aCandidates)
michael@0: {
michael@0:   NS_PRECONDITION(aCandidates.IsEmpty(), "aCandidates must be empty");
michael@0: 
michael@0:   nsAutoString eventType;
michael@0:   aDOMKeyEvent->GetType(eventType);
michael@0:   // Don't process if aDOMKeyEvent is not a keypress event.
michael@0:   if (!eventType.EqualsLiteral("keypress"))
michael@0:     return;
michael@0: 
michael@0:   WidgetKeyboardEvent* nativeKeyEvent =
michael@0:     aDOMKeyEvent->GetInternalNSEvent()->AsKeyboardEvent();
michael@0:   if (nativeKeyEvent) {
michael@0:     NS_ASSERTION(nativeKeyEvent->eventStructType == NS_KEY_EVENT,
michael@0:                  "wrong type of native event");
michael@0:     // nsShortcutCandidate::mCharCode is a candidate charCode.
michael@0:     // nsShoftcutCandidate::mIgnoreShift means the mCharCode should be tried to
michael@0:     // execute a command with/without shift key state. If this is TRUE, the
michael@0:     // shifted key state should be ignored. Otherwise, don't ignore the state.
michael@0:     // the priority of the charCodes are (shift key is not pressed):
michael@0:     //   0: charCode/false,
michael@0:     //   1: unshiftedCharCodes[0]/false, 2: unshiftedCharCodes[1]/false...
michael@0:     // the priority of the charCodes are (shift key is pressed):
michael@0:     //   0: charCode/false,
michael@0:     //   1: shiftedCharCodes[0]/false, 2: shiftedCharCodes[0]/true,
michael@0:     //   3: shiftedCharCodes[1]/false, 4: shiftedCharCodes[1]/true...
michael@0:     if (nativeKeyEvent->charCode) {
michael@0:       nsShortcutCandidate key(nativeKeyEvent->charCode, false);
michael@0:       aCandidates.AppendElement(key);
michael@0:     }
michael@0: 
michael@0:     uint32_t len = nativeKeyEvent->alternativeCharCodes.Length();
michael@0:     if (!nativeKeyEvent->IsShift()) {
michael@0:       for (uint32_t i = 0; i < len; ++i) {
michael@0:         uint32_t ch =
michael@0:           nativeKeyEvent->alternativeCharCodes[i].mUnshiftedCharCode;
michael@0:         if (!ch || ch == nativeKeyEvent->charCode)
michael@0:           continue;
michael@0: 
michael@0:         nsShortcutCandidate key(ch, false);
michael@0:         aCandidates.AppendElement(key);
michael@0:       }
michael@0:       // If unshiftedCharCodes doesn't have numeric but shiftedCharCode has it,
michael@0:       // this keyboard layout is AZERTY or similar layout, probably.
michael@0:       // In this case, Accel+[0-9] should be accessible without shift key.
michael@0:       // However, the priority should be lowest.
michael@0:       if (!HasASCIIDigit(aCandidates)) {
michael@0:         for (uint32_t i = 0; i < len; ++i) {
michael@0:           uint32_t ch =
michael@0:             nativeKeyEvent->alternativeCharCodes[i].mShiftedCharCode;
michael@0:           if (ch >= '0' && ch <= '9') {
michael@0:             nsShortcutCandidate key(ch, false);
michael@0:             aCandidates.AppendElement(key);
michael@0:             break;
michael@0:           }
michael@0:         }
michael@0:       }
michael@0:     } else {
michael@0:       for (uint32_t i = 0; i < len; ++i) {
michael@0:         uint32_t ch = nativeKeyEvent->alternativeCharCodes[i].mShiftedCharCode;
michael@0:         if (!ch)
michael@0:           continue;
michael@0: 
michael@0:         if (ch != nativeKeyEvent->charCode) {
michael@0:           nsShortcutCandidate key(ch, false);
michael@0:           aCandidates.AppendElement(key);
michael@0:         }
michael@0: 
michael@0:         // If the char is an alphabet, the shift key state should not be
michael@0:         // ignored. E.g., Ctrl+Shift+C should not execute Ctrl+C.
michael@0: 
michael@0:         // And checking the charCode is same as unshiftedCharCode too.
michael@0:         // E.g., for Ctrl+Shift+(Plus of Numpad) should not run Ctrl+Plus.
michael@0:         uint32_t unshiftCh =
michael@0:           nativeKeyEvent->alternativeCharCodes[i].mUnshiftedCharCode;
michael@0:         if (CharsCaseInsensitiveEqual(ch, unshiftCh))
michael@0:           continue;
michael@0: 
michael@0:         // On the Hebrew keyboard layout on Windows, the unshifted char is a
michael@0:         // localized character but the shifted char is a Latin alphabet,
michael@0:         // then, we should not execute without the shift state. See bug 433192.
michael@0:         if (IsCaseChangeableChar(ch))
michael@0:           continue;
michael@0: 
michael@0:         // Setting the alternative charCode candidates for retry without shift
michael@0:         // key state only when the shift key is pressed.
michael@0:         nsShortcutCandidate key(ch, true);
michael@0:         aCandidates.AppendElement(key);
michael@0:       }
michael@0:     }
michael@0:   } else {
michael@0:     uint32_t charCode;
michael@0:     aDOMKeyEvent->GetCharCode(&charCode);
michael@0:     if (charCode) {
michael@0:       nsShortcutCandidate key(charCode, false);
michael@0:       aCandidates.AppendElement(key);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::GetAccessKeyCandidates(WidgetKeyboardEvent* aNativeKeyEvent,
michael@0:                                        nsTArray<uint32_t>& aCandidates)
michael@0: {
michael@0:   NS_PRECONDITION(aCandidates.IsEmpty(), "aCandidates must be empty");
michael@0: 
michael@0:   // return the lower cased charCode candidates for access keys.
michael@0:   // the priority of the charCodes are:
michael@0:   //   0: charCode, 1: unshiftedCharCodes[0], 2: shiftedCharCodes[0]
michael@0:   //   3: unshiftedCharCodes[1], 4: shiftedCharCodes[1],...
michael@0:   if (aNativeKeyEvent->charCode) {
michael@0:     uint32_t ch = aNativeKeyEvent->charCode;
michael@0:     if (IS_IN_BMP(ch))
michael@0:       ch = ToLowerCase(char16_t(ch));
michael@0:     aCandidates.AppendElement(ch);
michael@0:   }
michael@0:   for (uint32_t i = 0;
michael@0:        i < aNativeKeyEvent->alternativeCharCodes.Length(); ++i) {
michael@0:     uint32_t ch[2] =
michael@0:       { aNativeKeyEvent->alternativeCharCodes[i].mUnshiftedCharCode,
michael@0:         aNativeKeyEvent->alternativeCharCodes[i].mShiftedCharCode };
michael@0:     for (uint32_t j = 0; j < 2; ++j) {
michael@0:       if (!ch[j])
michael@0:         continue;
michael@0:       if (IS_IN_BMP(ch[j]))
michael@0:         ch[j] = ToLowerCase(char16_t(ch[j]));
michael@0:       // Don't append the charCode that was already appended.
michael@0:       if (aCandidates.IndexOf(ch[j]) == aCandidates.NoIndex)
michael@0:         aCandidates.AppendElement(ch[j]);
michael@0:     }
michael@0:   }
michael@0:   return;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::AddScriptBlocker()
michael@0: {
michael@0:   if (!sScriptBlockerCount) {
michael@0:     NS_ASSERTION(sRunnersCountAtFirstBlocker == 0,
michael@0:                  "Should not already have a count");
michael@0:     sRunnersCountAtFirstBlocker = sBlockedScriptRunners->Length();
michael@0:   }
michael@0:   ++sScriptBlockerCount;
michael@0: }
michael@0: 
michael@0: #ifdef DEBUG
michael@0: static bool sRemovingScriptBlockers = false;
michael@0: #endif
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::RemoveScriptBlocker()
michael@0: {
michael@0:   MOZ_ASSERT(!sRemovingScriptBlockers);
michael@0:   NS_ASSERTION(sScriptBlockerCount != 0, "Negative script blockers");
michael@0:   --sScriptBlockerCount;
michael@0:   if (sScriptBlockerCount) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   uint32_t firstBlocker = sRunnersCountAtFirstBlocker;
michael@0:   uint32_t lastBlocker = sBlockedScriptRunners->Length();
michael@0:   uint32_t originalFirstBlocker = firstBlocker;
michael@0:   uint32_t blockersCount = lastBlocker - firstBlocker;
michael@0:   sRunnersCountAtFirstBlocker = 0;
michael@0:   NS_ASSERTION(firstBlocker <= lastBlocker,
michael@0:                "bad sRunnersCountAtFirstBlocker");
michael@0: 
michael@0:   while (firstBlocker < lastBlocker) {
michael@0:     nsCOMPtr<nsIRunnable> runnable;
michael@0:     runnable.swap((*sBlockedScriptRunners)[firstBlocker]);
michael@0:     ++firstBlocker;
michael@0: 
michael@0:     // Calling the runnable can reenter us
michael@0:     runnable->Run();
michael@0:     // So can dropping the reference to the runnable
michael@0:     runnable = nullptr;
michael@0: 
michael@0:     NS_ASSERTION(sRunnersCountAtFirstBlocker == 0,
michael@0:                  "Bad count");
michael@0:     NS_ASSERTION(!sScriptBlockerCount, "This is really bad");
michael@0:   }
michael@0: #ifdef DEBUG
michael@0:   AutoRestore<bool> removingScriptBlockers(sRemovingScriptBlockers);
michael@0:   sRemovingScriptBlockers = true;
michael@0: #endif
michael@0:   sBlockedScriptRunners->RemoveElementsAt(originalFirstBlocker, blockersCount);
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::AddScriptRunner(nsIRunnable* aRunnable)
michael@0: {
michael@0:   if (!aRunnable) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   if (sScriptBlockerCount) {
michael@0:     return sBlockedScriptRunners->AppendElement(aRunnable) != nullptr;
michael@0:   }
michael@0:   
michael@0:   nsCOMPtr<nsIRunnable> run = aRunnable;
michael@0:   run->Run();
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::EnterMicroTask()
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   ++sMicroTaskLevel;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::LeaveMicroTask()
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   if (--sMicroTaskLevel == 0) {
michael@0:     nsDOMMutationObserver::HandleMutations();
michael@0:     nsDocument::ProcessBaseElementQueue();
michael@0:   }
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsInMicroTask()
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   return sMicroTaskLevel != 0;
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: nsContentUtils::MicroTaskLevel()
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   return sMicroTaskLevel;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::SetMicroTaskLevel(uint32_t aLevel)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   sMicroTaskLevel = aLevel;
michael@0: }
michael@0: 
michael@0: /* 
michael@0:  * Helper function for nsContentUtils::ProcessViewportInfo.
michael@0:  *
michael@0:  * Handles a single key=value pair. If it corresponds to a valid viewport
michael@0:  * attribute, add it to the document header data. No validation is done on the
michael@0:  * value itself (this is done at display time).
michael@0:  */
michael@0: static void ProcessViewportToken(nsIDocument *aDocument, 
michael@0:                                  const nsAString &token) {
michael@0: 
michael@0:   /* Iterators. */
michael@0:   nsAString::const_iterator tip, tail, end;
michael@0:   token.BeginReading(tip);
michael@0:   tail = tip;
michael@0:   token.EndReading(end);
michael@0: 
michael@0:   /* Move tip to the '='. */
michael@0:   while ((tip != end) && (*tip != '='))
michael@0:     ++tip;
michael@0: 
michael@0:   /* If we didn't find an '=', punt. */
michael@0:   if (tip == end)
michael@0:     return;
michael@0: 
michael@0:   /* Extract the key and value. */
michael@0:   const nsAString &key =
michael@0:     nsContentUtils::TrimWhitespace<nsCRT::IsAsciiSpace>(Substring(tail, tip),
michael@0:                                                         true);
michael@0:   const nsAString &value =
michael@0:     nsContentUtils::TrimWhitespace<nsCRT::IsAsciiSpace>(Substring(++tip, end),
michael@0:                                                         true);
michael@0: 
michael@0:   /* Check for known keys. If we find a match, insert the appropriate
michael@0:    * information into the document header. */
michael@0:   nsCOMPtr<nsIAtom> key_atom = do_GetAtom(key);
michael@0:   if (key_atom == nsGkAtoms::height)
michael@0:     aDocument->SetHeaderData(nsGkAtoms::viewport_height, value);
michael@0:   else if (key_atom == nsGkAtoms::width)
michael@0:     aDocument->SetHeaderData(nsGkAtoms::viewport_width, value);
michael@0:   else if (key_atom == nsGkAtoms::initial_scale)
michael@0:     aDocument->SetHeaderData(nsGkAtoms::viewport_initial_scale, value);
michael@0:   else if (key_atom == nsGkAtoms::minimum_scale)
michael@0:     aDocument->SetHeaderData(nsGkAtoms::viewport_minimum_scale, value);
michael@0:   else if (key_atom == nsGkAtoms::maximum_scale)
michael@0:     aDocument->SetHeaderData(nsGkAtoms::viewport_maximum_scale, value);
michael@0:   else if (key_atom == nsGkAtoms::user_scalable)
michael@0:     aDocument->SetHeaderData(nsGkAtoms::viewport_user_scalable, value);
michael@0: }
michael@0: 
michael@0: #define IS_SEPARATOR(c) ((c == '=') || (c == ',') || (c == ';') || \
michael@0:                          (c == '\t') || (c == '\n') || (c == '\r'))
michael@0: 
michael@0: /* static */
michael@0: nsViewportInfo
michael@0: nsContentUtils::GetViewportInfo(nsIDocument *aDocument,
michael@0:                                 const ScreenIntSize& aDisplaySize)
michael@0: {
michael@0:   return aDocument->GetViewportInfo(aDisplaySize);
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::ProcessViewportInfo(nsIDocument *aDocument,
michael@0:                                     const nsAString &viewportInfo) {
michael@0: 
michael@0:   /* We never fail. */
michael@0:   nsresult rv = NS_OK;
michael@0: 
michael@0:   aDocument->SetHeaderData(nsGkAtoms::viewport, viewportInfo);
michael@0: 
michael@0:   /* Iterators. */
michael@0:   nsAString::const_iterator tip, tail, end;
michael@0:   viewportInfo.BeginReading(tip);
michael@0:   tail = tip;
michael@0:   viewportInfo.EndReading(end);
michael@0: 
michael@0:   /* Read the tip to the first non-separator character. */
michael@0:   while ((tip != end) && (IS_SEPARATOR(*tip) || nsCRT::IsAsciiSpace(*tip)))
michael@0:     ++tip;
michael@0: 
michael@0:   /* Read through and find tokens separated by separators. */
michael@0:   while (tip != end) {
michael@0: 
michael@0:     /* Synchronize tip and tail. */
michael@0:     tail = tip;
michael@0: 
michael@0:     /* Advance tip past non-separator characters. */
michael@0:     while ((tip != end) && !IS_SEPARATOR(*tip))
michael@0:       ++tip;
michael@0: 
michael@0:     /* Allow white spaces that surround the '=' character */
michael@0:     if ((tip != end) && (*tip == '=')) {
michael@0:       ++tip;
michael@0: 
michael@0:       while ((tip != end) && nsCRT::IsAsciiSpace(*tip))
michael@0:         ++tip;
michael@0: 
michael@0:       while ((tip != end) && !(IS_SEPARATOR(*tip) || nsCRT::IsAsciiSpace(*tip)))
michael@0:         ++tip;
michael@0:     }
michael@0: 
michael@0:     /* Our token consists of the characters between tail and tip. */
michael@0:     ProcessViewportToken(aDocument, Substring(tail, tip));
michael@0: 
michael@0:     /* Skip separators. */
michael@0:     while ((tip != end) && (IS_SEPARATOR(*tip) || nsCRT::IsAsciiSpace(*tip)))
michael@0:       ++tip;
michael@0:   }
michael@0: 
michael@0:   return rv;
michael@0: 
michael@0: }
michael@0: 
michael@0: #undef IS_SEPARATOR
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::HidePopupsInDocument(nsIDocument* aDocument)
michael@0: {
michael@0: #ifdef MOZ_XUL
michael@0:   nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
michael@0:   if (pm && aDocument) {
michael@0:     nsCOMPtr<nsIDocShellTreeItem> docShellToHide = aDocument->GetDocShell();
michael@0:     if (docShellToHide)
michael@0:       pm->HidePopupsInDocShell(docShellToHide);
michael@0:   }
michael@0: #endif
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: already_AddRefed<nsIDragSession>
michael@0: nsContentUtils::GetDragSession()
michael@0: {
michael@0:   nsCOMPtr<nsIDragSession> dragSession;
michael@0:   nsCOMPtr<nsIDragService> dragService =
michael@0:     do_GetService("@mozilla.org/widget/dragservice;1");
michael@0:   if (dragService)
michael@0:     dragService->GetCurrentSession(getter_AddRefs(dragSession));
michael@0:   return dragSession.forget();
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::SetDataTransferInEvent(WidgetDragEvent* aDragEvent)
michael@0: {
michael@0:   if (aDragEvent->dataTransfer || !aDragEvent->mFlags.mIsTrusted)
michael@0:     return NS_OK;
michael@0: 
michael@0:   // For draggesture and dragstart events, the data transfer object is
michael@0:   // created before the event fires, so it should already be set. For other
michael@0:   // drag events, get the object from the drag session.
michael@0:   NS_ASSERTION(aDragEvent->message != NS_DRAGDROP_GESTURE &&
michael@0:                aDragEvent->message != NS_DRAGDROP_START,
michael@0:                "draggesture event created without a dataTransfer");
michael@0: 
michael@0:   nsCOMPtr<nsIDragSession> dragSession = GetDragSession();
michael@0:   NS_ENSURE_TRUE(dragSession, NS_OK); // no drag in progress
michael@0: 
michael@0:   nsCOMPtr<nsIDOMDataTransfer> dataTransfer;
michael@0:   nsCOMPtr<DataTransfer> initialDataTransfer;
michael@0:   dragSession->GetDataTransfer(getter_AddRefs(dataTransfer));
michael@0:   if (dataTransfer) {
michael@0:     initialDataTransfer = do_QueryInterface(dataTransfer);
michael@0:     if (!initialDataTransfer) {
michael@0:       return NS_ERROR_FAILURE;
michael@0:     }
michael@0:   } else {
michael@0:     // A dataTransfer won't exist when a drag was started by some other
michael@0:     // means, for instance calling the drag service directly, or a drag
michael@0:     // from another application. In either case, a new dataTransfer should
michael@0:     // be created that reflects the data.
michael@0:     initialDataTransfer = new DataTransfer(aDragEvent->target, aDragEvent->message, true, -1);
michael@0: 
michael@0:     // now set it in the drag session so we don't need to create it again
michael@0:     dragSession->SetDataTransfer(initialDataTransfer);
michael@0:   }
michael@0: 
michael@0:   bool isCrossDomainSubFrameDrop = false;
michael@0:   if (aDragEvent->message == NS_DRAGDROP_DROP ||
michael@0:       aDragEvent->message == NS_DRAGDROP_DRAGDROP) {
michael@0:     isCrossDomainSubFrameDrop = CheckForSubFrameDrop(dragSession, aDragEvent);
michael@0:   }
michael@0: 
michael@0:   // each event should use a clone of the original dataTransfer.
michael@0:   initialDataTransfer->Clone(aDragEvent->target, aDragEvent->message, aDragEvent->userCancelled,
michael@0:                              isCrossDomainSubFrameDrop,
michael@0:                              getter_AddRefs(aDragEvent->dataTransfer));
michael@0:   NS_ENSURE_TRUE(aDragEvent->dataTransfer, NS_ERROR_OUT_OF_MEMORY);
michael@0: 
michael@0:   // for the dragenter and dragover events, initialize the drop effect
michael@0:   // from the drop action, which platform specific widget code sets before
michael@0:   // the event is fired based on the keyboard state.
michael@0:   if (aDragEvent->message == NS_DRAGDROP_ENTER ||
michael@0:       aDragEvent->message == NS_DRAGDROP_OVER) {
michael@0:     uint32_t action, effectAllowed;
michael@0:     dragSession->GetDragAction(&action);
michael@0:     aDragEvent->dataTransfer->GetEffectAllowedInt(&effectAllowed);
michael@0:     aDragEvent->dataTransfer->SetDropEffectInt(FilterDropEffect(action, effectAllowed));
michael@0:   }
michael@0:   else if (aDragEvent->message == NS_DRAGDROP_DROP ||
michael@0:            aDragEvent->message == NS_DRAGDROP_DRAGDROP ||
michael@0:            aDragEvent->message == NS_DRAGDROP_END) {
michael@0:     // For the drop and dragend events, set the drop effect based on the
michael@0:     // last value that the dropEffect had. This will have been set in
michael@0:     // EventStateManager::PostHandleEvent for the last dragenter or
michael@0:     // dragover event.
michael@0:     uint32_t dropEffect;
michael@0:     initialDataTransfer->GetDropEffectInt(&dropEffect);
michael@0:     aDragEvent->dataTransfer->SetDropEffectInt(dropEffect);
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: uint32_t
michael@0: nsContentUtils::FilterDropEffect(uint32_t aAction, uint32_t aEffectAllowed)
michael@0: {
michael@0:   // It is possible for the drag action to include more than one action, but
michael@0:   // the widget code which sets the action from the keyboard state should only
michael@0:   // be including one. If multiple actions were set, we just consider them in
michael@0:   //  the following order:
michael@0:   //   copy, link, move
michael@0:   if (aAction & nsIDragService::DRAGDROP_ACTION_COPY)
michael@0:     aAction = nsIDragService::DRAGDROP_ACTION_COPY;
michael@0:   else if (aAction & nsIDragService::DRAGDROP_ACTION_LINK)
michael@0:     aAction = nsIDragService::DRAGDROP_ACTION_LINK;
michael@0:   else if (aAction & nsIDragService::DRAGDROP_ACTION_MOVE)
michael@0:     aAction = nsIDragService::DRAGDROP_ACTION_MOVE;
michael@0: 
michael@0:   // Filter the action based on the effectAllowed. If the effectAllowed
michael@0:   // doesn't include the action, then that action cannot be done, so adjust
michael@0:   // the action to something that is allowed. For a copy, adjust to move or
michael@0:   // link. For a move, adjust to copy or link. For a link, adjust to move or
michael@0:   // link. Otherwise, use none.
michael@0:   if (aAction & aEffectAllowed ||
michael@0:       aEffectAllowed == nsIDragService::DRAGDROP_ACTION_UNINITIALIZED)
michael@0:     return aAction;
michael@0:   if (aEffectAllowed & nsIDragService::DRAGDROP_ACTION_MOVE)
michael@0:     return nsIDragService::DRAGDROP_ACTION_MOVE;
michael@0:   if (aEffectAllowed & nsIDragService::DRAGDROP_ACTION_COPY)
michael@0:     return nsIDragService::DRAGDROP_ACTION_COPY;
michael@0:   if (aEffectAllowed & nsIDragService::DRAGDROP_ACTION_LINK)
michael@0:     return nsIDragService::DRAGDROP_ACTION_LINK;
michael@0:   return nsIDragService::DRAGDROP_ACTION_NONE;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::CheckForSubFrameDrop(nsIDragSession* aDragSession,
michael@0:                                      WidgetDragEvent* aDropEvent)
michael@0: {
michael@0:   nsCOMPtr<nsIContent> target = do_QueryInterface(aDropEvent->originalTarget);
michael@0:   if (!target) {
michael@0:     return true;
michael@0:   }
michael@0:   
michael@0:   nsIDocument* targetDoc = target->OwnerDoc();
michael@0:   nsCOMPtr<nsIWebNavigation> twebnav = do_GetInterface(targetDoc->GetWindow());
michael@0:   nsCOMPtr<nsIDocShellTreeItem> tdsti = do_QueryInterface(twebnav);
michael@0:   if (!tdsti) {
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   // Always allow dropping onto chrome shells.
michael@0:   if (tdsti->ItemType() == nsIDocShellTreeItem::typeChrome) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   // If there is no source node, then this is a drag from another
michael@0:   // application, which should be allowed.
michael@0:   nsCOMPtr<nsIDOMDocument> sourceDocument;
michael@0:   aDragSession->GetSourceDocument(getter_AddRefs(sourceDocument));
michael@0:   nsCOMPtr<nsIDocument> doc = do_QueryInterface(sourceDocument);
michael@0:   if (doc) {
michael@0:     // Get each successive parent of the source document and compare it to
michael@0:     // the drop document. If they match, then this is a drag from a child frame.
michael@0:     do {
michael@0:       doc = doc->GetParentDocument();
michael@0:       if (doc == targetDoc) {
michael@0:         // The drag is from a child frame.
michael@0:         return true;
michael@0:       }
michael@0:     } while (doc);
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::URIIsLocalFile(nsIURI *aURI)
michael@0: {
michael@0:   bool isFile;
michael@0:   nsCOMPtr<nsINetUtil> util = do_QueryInterface(sIOService);
michael@0: 
michael@0:   // Important: we do NOT test the entire URI chain here!
michael@0:   return util && NS_SUCCEEDED(util->ProtocolHasFlags(aURI,
michael@0:                                 nsIProtocolHandler::URI_IS_LOCAL_FILE,
michael@0:                                 &isFile)) &&
michael@0:          isFile;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsContentUtils::SplitURIAtHash(nsIURI *aURI,
michael@0:                                nsACString &aBeforeHash,
michael@0:                                nsACString &aAfterHash)
michael@0: {
michael@0:   // See bug 225910 for why we can't do this using nsIURL.
michael@0: 
michael@0:   aBeforeHash.Truncate();
michael@0:   aAfterHash.Truncate();
michael@0: 
michael@0:   NS_ENSURE_ARG_POINTER(aURI);
michael@0: 
michael@0:   nsAutoCString spec;
michael@0:   nsresult rv = aURI->GetSpec(spec);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   int32_t index = spec.FindChar('#');
michael@0:   if (index == -1) {
michael@0:     index = spec.Length();
michael@0:   }
michael@0: 
michael@0:   aBeforeHash.Assign(Substring(spec, 0, index));
michael@0:   aAfterHash.Assign(Substring(spec, index));
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsIScriptContext*
michael@0: nsContentUtils::GetContextForEventHandlers(nsINode* aNode,
michael@0:                                            nsresult* aRv)
michael@0: {
michael@0:   *aRv = NS_OK;
michael@0:   bool hasHadScriptObject = true;
michael@0:   nsIScriptGlobalObject* sgo =
michael@0:     aNode->OwnerDoc()->GetScriptHandlingObject(hasHadScriptObject);
michael@0:   // It is bad if the document doesn't have event handling context,
michael@0:   // but it used to have one.
michael@0:   if (!sgo && hasHadScriptObject) {
michael@0:     *aRv = NS_ERROR_UNEXPECTED;
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   if (sgo) {
michael@0:     nsIScriptContext* scx = sgo->GetContext();
michael@0:     // Bad, no context from script global object!
michael@0:     if (!scx) {
michael@0:       *aRv = NS_ERROR_UNEXPECTED;
michael@0:       return nullptr;
michael@0:     }
michael@0:     return scx;
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: JSContext *
michael@0: nsContentUtils::GetCurrentJSContext()
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   return sXPConnect->GetCurrentJSContext();
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: JSContext *
michael@0: nsContentUtils::GetSafeJSContext()
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   return sXPConnect->GetSafeJSContext();
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: JSContext *
michael@0: nsContentUtils::GetDefaultJSContextForThread()
michael@0: {
michael@0:   if (MOZ_LIKELY(NS_IsMainThread())) {
michael@0:     return GetSafeJSContext();
michael@0:   } else {
michael@0:     return workers::GetCurrentThreadJSContext();
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: JSContext *
michael@0: nsContentUtils::GetCurrentJSContextForThread()
michael@0: {
michael@0:   if (MOZ_LIKELY(NS_IsMainThread())) {
michael@0:     return GetCurrentJSContext();
michael@0:   } else {
michael@0:     return workers::GetCurrentThreadJSContext();
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::ASCIIToLower(nsAString& aStr)
michael@0: {
michael@0:   char16_t* iter = aStr.BeginWriting();
michael@0:   char16_t* end = aStr.EndWriting();
michael@0:   if (MOZ_UNLIKELY(!iter || !end)) {
michael@0:     return NS_ERROR_OUT_OF_MEMORY;
michael@0:   }
michael@0:   while (iter != end) {
michael@0:     char16_t c = *iter;
michael@0:     if (c >= 'A' && c <= 'Z') {
michael@0:       *iter = c + ('a' - 'A');
michael@0:     }
michael@0:     ++iter;
michael@0:   }
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::ASCIIToLower(const nsAString& aSource, nsAString& aDest)
michael@0: {
michael@0:   uint32_t len = aSource.Length();
michael@0:   aDest.SetLength(len);
michael@0:   if (aDest.Length() == len) {
michael@0:     char16_t* dest = aDest.BeginWriting();
michael@0:     if (MOZ_UNLIKELY(!dest)) {
michael@0:       return NS_ERROR_OUT_OF_MEMORY;
michael@0:     }
michael@0:     const char16_t* iter = aSource.BeginReading();
michael@0:     const char16_t* end = aSource.EndReading();
michael@0:     while (iter != end) {
michael@0:       char16_t c = *iter;
michael@0:       *dest = (c >= 'A' && c <= 'Z') ?
michael@0:          c + ('a' - 'A') : c;
michael@0:       ++iter;
michael@0:       ++dest;
michael@0:     }
michael@0:     return NS_OK;
michael@0:   }
michael@0:   return NS_ERROR_OUT_OF_MEMORY;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::ASCIIToUpper(nsAString& aStr)
michael@0: {
michael@0:   char16_t* iter = aStr.BeginWriting();
michael@0:   char16_t* end = aStr.EndWriting();
michael@0:   if (MOZ_UNLIKELY(!iter || !end)) {
michael@0:     return NS_ERROR_OUT_OF_MEMORY;
michael@0:   }
michael@0:   while (iter != end) {
michael@0:     char16_t c = *iter;
michael@0:     if (c >= 'a' && c <= 'z') {
michael@0:       *iter = c + ('A' - 'a');
michael@0:     }
michael@0:     ++iter;
michael@0:   }
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::ASCIIToUpper(const nsAString& aSource, nsAString& aDest)
michael@0: {
michael@0:   uint32_t len = aSource.Length();
michael@0:   aDest.SetLength(len);
michael@0:   if (aDest.Length() == len) {
michael@0:     char16_t* dest = aDest.BeginWriting();
michael@0:     if (MOZ_UNLIKELY(!dest)) {
michael@0:       return NS_ERROR_OUT_OF_MEMORY;
michael@0:     }
michael@0:     const char16_t* iter = aSource.BeginReading();
michael@0:     const char16_t* end = aSource.EndReading();
michael@0:     while (iter != end) {
michael@0:       char16_t c = *iter;
michael@0:       *dest = (c >= 'a' && c <= 'z') ?
michael@0:          c + ('A' - 'a') : c;
michael@0:       ++iter;
michael@0:       ++dest;
michael@0:     }
michael@0:     return NS_OK;
michael@0:   }
michael@0:   return NS_ERROR_OUT_OF_MEMORY;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::EqualsIgnoreASCIICase(const nsAString& aStr1,
michael@0:                                       const nsAString& aStr2)
michael@0: {
michael@0:   uint32_t len = aStr1.Length();
michael@0:   if (len != aStr2.Length()) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   const char16_t* str1 = aStr1.BeginReading();
michael@0:   const char16_t* str2 = aStr2.BeginReading();
michael@0:   const char16_t* end = str1 + len;
michael@0: 
michael@0:   while (str1 < end) {
michael@0:     char16_t c1 = *str1++;
michael@0:     char16_t c2 = *str2++;
michael@0: 
michael@0:     // First check if any bits other than the 0x0020 differs
michael@0:     if ((c1 ^ c2) & 0xffdf) {
michael@0:       return false;
michael@0:     }
michael@0: 
michael@0:     // We know they can only differ in the 0x0020 bit.
michael@0:     // Likely the two chars are the same, so check that first
michael@0:     if (c1 != c2) {
michael@0:       // They do differ, but since it's only in the 0x0020 bit, check if it's
michael@0:       // the same ascii char, but just differing in case
michael@0:       char16_t c1Upper = c1 & 0xffdf;
michael@0:       if (!('A' <= c1Upper && c1Upper <= 'Z')) {
michael@0:         return false;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::StringContainsASCIIUpper(const nsAString& aStr)
michael@0: {
michael@0:   const char16_t* iter = aStr.BeginReading();
michael@0:   const char16_t* end = aStr.EndReading();
michael@0:   while (iter != end) {
michael@0:     char16_t c = *iter;
michael@0:     if (c >= 'A' && c <= 'Z') {
michael@0:       return true;
michael@0:     }
michael@0:     ++iter;
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsIInterfaceRequestor*
michael@0: nsContentUtils::GetSameOriginChecker()
michael@0: {
michael@0:   if (!sSameOriginChecker) {
michael@0:     sSameOriginChecker = new SameOriginChecker();
michael@0:     NS_IF_ADDREF(sSameOriginChecker);
michael@0:   }
michael@0:   return sSameOriginChecker;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::CheckSameOrigin(nsIChannel *aOldChannel, nsIChannel *aNewChannel)
michael@0: {
michael@0:   if (!nsContentUtils::GetSecurityManager())
michael@0:     return NS_ERROR_NOT_AVAILABLE;
michael@0: 
michael@0:   nsCOMPtr<nsIPrincipal> oldPrincipal;
michael@0:   nsContentUtils::GetSecurityManager()->
michael@0:     GetChannelPrincipal(aOldChannel, getter_AddRefs(oldPrincipal));
michael@0: 
michael@0:   nsCOMPtr<nsIURI> newURI;
michael@0:   aNewChannel->GetURI(getter_AddRefs(newURI));
michael@0:   nsCOMPtr<nsIURI> newOriginalURI;
michael@0:   aNewChannel->GetOriginalURI(getter_AddRefs(newOriginalURI));
michael@0: 
michael@0:   NS_ENSURE_STATE(oldPrincipal && newURI && newOriginalURI);
michael@0: 
michael@0:   nsresult rv = oldPrincipal->CheckMayLoad(newURI, false, false);
michael@0:   if (NS_SUCCEEDED(rv) && newOriginalURI != newURI) {
michael@0:     rv = oldPrincipal->CheckMayLoad(newOriginalURI, false, false);
michael@0:   }
michael@0: 
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: NS_IMPL_ISUPPORTS(SameOriginChecker,
michael@0:                   nsIChannelEventSink,
michael@0:                   nsIInterfaceRequestor)
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: SameOriginChecker::AsyncOnChannelRedirect(nsIChannel *aOldChannel,
michael@0:                                           nsIChannel *aNewChannel,
michael@0:                                           uint32_t aFlags,
michael@0:                                           nsIAsyncVerifyRedirectCallback *cb)
michael@0: {
michael@0:   NS_PRECONDITION(aNewChannel, "Redirecting to null channel?");
michael@0: 
michael@0:   nsresult rv = nsContentUtils::CheckSameOrigin(aOldChannel, aNewChannel);
michael@0:   if (NS_SUCCEEDED(rv)) {
michael@0:     cb->OnRedirectVerifyCallback(NS_OK);
michael@0:   }
michael@0: 
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: SameOriginChecker::GetInterface(const nsIID & aIID, void **aResult)
michael@0: {
michael@0:   return QueryInterface(aIID, aResult);
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::GetASCIIOrigin(nsIPrincipal* aPrincipal, nsCString& aOrigin)
michael@0: {
michael@0:   NS_PRECONDITION(aPrincipal, "missing principal");
michael@0: 
michael@0:   aOrigin.Truncate();
michael@0: 
michael@0:   nsCOMPtr<nsIURI> uri;
michael@0:   nsresult rv = aPrincipal->GetURI(getter_AddRefs(uri));
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   if (uri) {
michael@0:     return GetASCIIOrigin(uri, aOrigin);
michael@0:   }
michael@0: 
michael@0:   aOrigin.AssignLiteral("null");
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::GetASCIIOrigin(nsIURI* aURI, nsCString& aOrigin)
michael@0: {
michael@0:   NS_PRECONDITION(aURI, "missing uri");
michael@0: 
michael@0:   aOrigin.Truncate();
michael@0: 
michael@0:   nsCOMPtr<nsIURI> uri = NS_GetInnermostURI(aURI);
michael@0:   NS_ENSURE_TRUE(uri, NS_ERROR_UNEXPECTED);
michael@0: 
michael@0:   nsCString host;
michael@0:   nsresult rv = uri->GetAsciiHost(host);
michael@0: 
michael@0:   if (NS_SUCCEEDED(rv) && !host.IsEmpty()) {
michael@0:     nsCString scheme;
michael@0:     rv = uri->GetScheme(scheme);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     int32_t port = -1;
michael@0:     uri->GetPort(&port);
michael@0:     if (port != -1 && port == NS_GetDefaultPort(scheme.get()))
michael@0:       port = -1;
michael@0: 
michael@0:     nsCString hostPort;
michael@0:     rv = NS_GenerateHostPort(host, port, hostPort);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     aOrigin = scheme + NS_LITERAL_CSTRING("://") + hostPort;
michael@0:   }
michael@0:   else {
michael@0:     aOrigin.AssignLiteral("null");
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::GetUTFOrigin(nsIPrincipal* aPrincipal, nsString& aOrigin)
michael@0: {
michael@0:   NS_PRECONDITION(aPrincipal, "missing principal");
michael@0: 
michael@0:   aOrigin.Truncate();
michael@0: 
michael@0:   nsCOMPtr<nsIURI> uri;
michael@0:   nsresult rv = aPrincipal->GetURI(getter_AddRefs(uri));
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   if (uri) {
michael@0:     return GetUTFOrigin(uri, aOrigin);
michael@0:   }
michael@0: 
michael@0:   aOrigin.AssignLiteral("null");
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsresult
michael@0: nsContentUtils::GetUTFOrigin(nsIURI* aURI, nsString& aOrigin)
michael@0: {
michael@0:   NS_PRECONDITION(aURI, "missing uri");
michael@0: 
michael@0:   aOrigin.Truncate();
michael@0: 
michael@0:   nsCOMPtr<nsIURI> uri = NS_GetInnermostURI(aURI);
michael@0:   NS_ENSURE_TRUE(uri, NS_ERROR_UNEXPECTED);
michael@0: 
michael@0:   nsCString host;
michael@0:   nsresult rv = uri->GetHost(host);
michael@0: 
michael@0:   if (NS_SUCCEEDED(rv) && !host.IsEmpty()) {
michael@0:     nsCString scheme;
michael@0:     rv = uri->GetScheme(scheme);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     int32_t port = -1;
michael@0:     uri->GetPort(&port);
michael@0:     if (port != -1 && port == NS_GetDefaultPort(scheme.get()))
michael@0:       port = -1;
michael@0: 
michael@0:     nsCString hostPort;
michael@0:     rv = NS_GenerateHostPort(host, port, hostPort);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     aOrigin = NS_ConvertUTF8toUTF16(
michael@0:       scheme + NS_LITERAL_CSTRING("://") + hostPort);
michael@0:   }
michael@0:   else {
michael@0:     aOrigin.AssignLiteral("null");
michael@0:   }
michael@0:   
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::GetUTFNonNullOrigin(nsIURI* aURI, nsString& aOrigin)
michael@0: {
michael@0:   aOrigin.Truncate();
michael@0: 
michael@0:   nsString origin;
michael@0:   nsresult rv = GetUTFOrigin(aURI, origin);
michael@0:   if (NS_SUCCEEDED(rv) && !origin.EqualsLiteral("null")) {
michael@0:     aOrigin.Assign(origin);
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsIDocument*
michael@0: nsContentUtils::GetDocumentFromScriptContext(nsIScriptContext *aScriptContext)
michael@0: {
michael@0:   if (!aScriptContext) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsPIDOMWindow> window =
michael@0:     do_QueryInterface(aScriptContext->GetGlobalObject());
michael@0:   if (!window) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   return window->GetDoc();
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::CheckMayLoad(nsIPrincipal* aPrincipal, nsIChannel* aChannel, bool aAllowIfInheritsPrincipal)
michael@0: {
michael@0:   nsCOMPtr<nsIURI> channelURI;
michael@0:   nsresult rv = NS_GetFinalChannelURI(aChannel, getter_AddRefs(channelURI));
michael@0:   NS_ENSURE_SUCCESS(rv, false);
michael@0: 
michael@0:   return NS_SUCCEEDED(aPrincipal->CheckMayLoad(channelURI, false, aAllowIfInheritsPrincipal));
michael@0: }
michael@0: 
michael@0: nsContentTypeParser::nsContentTypeParser(const nsAString& aString)
michael@0:   : mString(aString), mService(nullptr)
michael@0: {
michael@0:   CallGetService("@mozilla.org/network/mime-hdrparam;1", &mService);
michael@0: }
michael@0: 
michael@0: nsContentTypeParser::~nsContentTypeParser()
michael@0: {
michael@0:   NS_IF_RELEASE(mService);
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsContentTypeParser::GetParameter(const char* aParameterName, nsAString& aResult)
michael@0: {
michael@0:   NS_ENSURE_TRUE(mService, NS_ERROR_FAILURE);
michael@0:   return mService->GetParameterHTTP(mString, aParameterName,
michael@0:                                     EmptyCString(), false, nullptr,
michael@0:                                     aResult);
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: 
michael@0: bool
michael@0: nsContentUtils::CanAccessNativeAnon()
michael@0: {
michael@0:   return IsCallerChrome() || IsCallerXBL();
michael@0: }
michael@0: 
michael@0: /* static */ nsresult
michael@0: nsContentUtils::DispatchXULCommand(nsIContent* aTarget,
michael@0:                                    bool aTrusted,
michael@0:                                    nsIDOMEvent* aSourceEvent,
michael@0:                                    nsIPresShell* aShell,
michael@0:                                    bool aCtrl,
michael@0:                                    bool aAlt,
michael@0:                                    bool aShift,
michael@0:                                    bool aMeta)
michael@0: {
michael@0:   NS_ENSURE_STATE(aTarget);
michael@0:   nsIDocument* doc = aTarget->OwnerDoc();
michael@0:   nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(doc);
michael@0:   NS_ENSURE_STATE(domDoc);
michael@0:   nsCOMPtr<nsIDOMEvent> event;
michael@0:   domDoc->CreateEvent(NS_LITERAL_STRING("xulcommandevent"),
michael@0:                       getter_AddRefs(event));
michael@0:   nsCOMPtr<nsIDOMXULCommandEvent> xulCommand = do_QueryInterface(event);
michael@0:   nsresult rv = xulCommand->InitCommandEvent(NS_LITERAL_STRING("command"),
michael@0:                                              true, true, doc->GetWindow(),
michael@0:                                              0, aCtrl, aAlt, aShift, aMeta,
michael@0:                                              aSourceEvent);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   if (aShell) {
michael@0:     nsEventStatus status = nsEventStatus_eIgnore;
michael@0:     nsCOMPtr<nsIPresShell> kungFuDeathGrip = aShell;
michael@0:     return aShell->HandleDOMEventWithTarget(aTarget, event, &status);
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<EventTarget> target = do_QueryInterface(aTarget);
michael@0:   NS_ENSURE_STATE(target);
michael@0:   bool dummy;
michael@0:   return target->DispatchEvent(event, &dummy);
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::WrapNative(JSContext *cx, nsISupports *native,
michael@0:                            nsWrapperCache *cache, const nsIID* aIID,
michael@0:                            JS::MutableHandle<JS::Value> vp, bool aAllowWrapping)
michael@0: {
michael@0:   if (!native) {
michael@0:     vp.setNull();
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   JSObject *wrapper = xpc_FastGetCachedWrapper(cx, cache, vp);
michael@0:   if (wrapper) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   NS_ENSURE_TRUE(sXPConnect, NS_ERROR_UNEXPECTED);
michael@0: 
michael@0:   if (!NS_IsMainThread()) {
michael@0:     MOZ_CRASH();
michael@0:   }
michael@0: 
michael@0:   nsresult rv = NS_OK;
michael@0:   JS::Rooted<JSObject*> scope(cx, JS::CurrentGlobalOrNull(cx));
michael@0:   AutoPushJSContext context(cx);
michael@0:   rv = sXPConnect->WrapNativeToJSVal(context, scope, native, cache, aIID,
michael@0:                                      aAllowWrapping, vp);
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsContentUtils::CreateArrayBuffer(JSContext *aCx, const nsACString& aData,
michael@0:                                   JSObject** aResult)
michael@0: {
michael@0:   if (!aCx) {
michael@0:     return NS_ERROR_FAILURE;
michael@0:   }
michael@0: 
michael@0:   int32_t dataLen = aData.Length();
michael@0:   *aResult = JS_NewArrayBuffer(aCx, dataLen);
michael@0:   if (!*aResult) {
michael@0:     return NS_ERROR_FAILURE;
michael@0:   }
michael@0: 
michael@0:   if (dataLen > 0) {
michael@0:     NS_ASSERTION(JS_IsArrayBufferObject(*aResult), "What happened?");
michael@0:     memcpy(JS_GetArrayBufferData(*aResult), aData.BeginReading(), dataLen);
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // Initial implementation: only stores to RAM, not file
michael@0: // TODO: bug 704447: large file support
michael@0: nsresult
michael@0: nsContentUtils::CreateBlobBuffer(JSContext* aCx,
michael@0:                                  const nsACString& aData,
michael@0:                                  JS::MutableHandle<JS::Value> aBlob)
michael@0: {
michael@0:   uint32_t blobLen = aData.Length();
michael@0:   void* blobData = moz_malloc(blobLen);
michael@0:   nsCOMPtr<nsIDOMBlob> blob;
michael@0:   if (blobData) {
michael@0:     memcpy(blobData, aData.BeginReading(), blobLen);
michael@0:     blob = new nsDOMMemoryFile(blobData, blobLen, EmptyString());
michael@0:   } else {
michael@0:     return NS_ERROR_OUT_OF_MEMORY;
michael@0:   }
michael@0:   return nsContentUtils::WrapNative(aCx, blob, aBlob);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::StripNullChars(const nsAString& aInStr, nsAString& aOutStr)
michael@0: {
michael@0:   // In common cases where we don't have nulls in the
michael@0:   // string we can simple simply bypass the checking code.
michael@0:   int32_t firstNullPos = aInStr.FindChar('\0');
michael@0:   if (firstNullPos == kNotFound) {
michael@0:     aOutStr.Assign(aInStr);
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   aOutStr.SetCapacity(aInStr.Length() - 1);
michael@0:   nsAString::const_iterator start, end;
michael@0:   aInStr.BeginReading(start);
michael@0:   aInStr.EndReading(end);
michael@0:   while (start != end) {
michael@0:     if (*start != '\0')
michael@0:       aOutStr.Append(*start);
michael@0:     ++start;
michael@0:   }
michael@0: }
michael@0: 
michael@0: struct ClassMatchingInfo {
michael@0:   nsAttrValue::AtomArray mClasses;
michael@0:   nsCaseTreatment mCaseTreatment;
michael@0: };
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::MatchClassNames(nsIContent* aContent, int32_t aNamespaceID,
michael@0:                                 nsIAtom* aAtom, void* aData)
michael@0: {
michael@0:   // We can't match if there are no class names
michael@0:   const nsAttrValue* classAttr = aContent->GetClasses();
michael@0:   if (!classAttr) {
michael@0:     return false;
michael@0:   }
michael@0:   
michael@0:   // need to match *all* of the classes
michael@0:   ClassMatchingInfo* info = static_cast<ClassMatchingInfo*>(aData);
michael@0:   uint32_t length = info->mClasses.Length();
michael@0:   if (!length) {
michael@0:     // If we actually had no classes, don't match.
michael@0:     return false;
michael@0:   }
michael@0:   uint32_t i;
michael@0:   for (i = 0; i < length; ++i) {
michael@0:     if (!classAttr->Contains(info->mClasses[i],
michael@0:                              info->mCaseTreatment)) {
michael@0:       return false;
michael@0:     }
michael@0:   }
michael@0:   
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: // static
michael@0: void
michael@0: nsContentUtils::DestroyClassNameArray(void* aData)
michael@0: {
michael@0:   ClassMatchingInfo* info = static_cast<ClassMatchingInfo*>(aData);
michael@0:   delete info;
michael@0: }
michael@0: 
michael@0: // static
michael@0: void*
michael@0: nsContentUtils::AllocClassMatchingInfo(nsINode* aRootNode,
michael@0:                                        const nsString* aClasses)
michael@0: {
michael@0:   nsAttrValue attrValue;
michael@0:   attrValue.ParseAtomArray(*aClasses);
michael@0:   // nsAttrValue::Equals is sensitive to order, so we'll send an array
michael@0:   ClassMatchingInfo* info = new ClassMatchingInfo;
michael@0:   if (attrValue.Type() == nsAttrValue::eAtomArray) {
michael@0:     info->mClasses.SwapElements(*(attrValue.GetAtomArrayValue()));
michael@0:   } else if (attrValue.Type() == nsAttrValue::eAtom) {
michael@0:     info->mClasses.AppendElement(attrValue.GetAtomValue());
michael@0:   }
michael@0: 
michael@0:   info->mCaseTreatment =
michael@0:     aRootNode->OwnerDoc()->GetCompatibilityMode() == eCompatibility_NavQuirks ?
michael@0:     eIgnoreCase : eCaseMatters;
michael@0:   return info;
michael@0: }
michael@0: 
michael@0: // static
michael@0: void
michael@0: nsContentUtils::DeferredFinalize(nsISupports* aSupports)
michael@0: {
michael@0:   cyclecollector::DeferredFinalize(aSupports);
michael@0: }
michael@0: 
michael@0: // static
michael@0: void
michael@0: nsContentUtils::DeferredFinalize(mozilla::DeferredFinalizeAppendFunction aAppendFunc,
michael@0:                                  mozilla::DeferredFinalizeFunction aFunc,
michael@0:                                  void* aThing)
michael@0: {
michael@0:   cyclecollector::DeferredFinalize(aAppendFunc, aFunc, aThing);
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::IsFocusedContent(const nsIContent* aContent)
michael@0: {
michael@0:   nsFocusManager* fm = nsFocusManager::GetFocusManager();
michael@0: 
michael@0:   return fm && fm->GetFocusedContent() == aContent;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsSubDocumentTabbable(nsIContent* aContent)
michael@0: {
michael@0:   nsIDocument* doc = aContent->GetCurrentDoc();
michael@0:   if (!doc) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   // If the subdocument lives in another process, the frame is
michael@0:   // tabbable.
michael@0:   if (EventStateManager::IsRemoteTarget(aContent)) {
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   // XXXbz should this use OwnerDoc() for GetSubDocumentFor?
michael@0:   // sXBL/XBL2 issue!
michael@0:   nsIDocument* subDoc = doc->GetSubDocumentFor(aContent);
michael@0:   if (!subDoc) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIDocShell> docShell = subDoc->GetDocShell();
michael@0:   if (!docShell) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIContentViewer> contentViewer;
michael@0:   docShell->GetContentViewer(getter_AddRefs(contentViewer));
michael@0:   if (!contentViewer) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIContentViewer> zombieViewer;
michael@0:   contentViewer->GetPreviousViewer(getter_AddRefs(zombieViewer));
michael@0: 
michael@0:   // If there are 2 viewers for the current docshell, that
michael@0:   // means the current document is a zombie document.
michael@0:   // Only navigate into the subdocument if it's not a zombie.
michael@0:   return !zombieViewer;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsUserFocusIgnored(nsINode* aNode)
michael@0: {
michael@0:   if (!nsGenericHTMLFrameElement::BrowserFramesEnabled()) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   // Check if our mozbrowser iframe ancestors has ignoreuserfocus attribute.
michael@0:   while (aNode) {
michael@0:     nsCOMPtr<nsIMozBrowserFrame> browserFrame = do_QueryInterface(aNode);
michael@0:     if (browserFrame &&
michael@0:         aNode->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::ignoreuserfocus) &&
michael@0:         browserFrame->GetReallyIsBrowserOrApp()) {
michael@0:       return true;
michael@0:     }
michael@0:     nsPIDOMWindow* win = aNode->OwnerDoc()->GetWindow();
michael@0:     aNode = win ? win->GetFrameElementInternal() : nullptr;
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::HasScrollgrab(nsIContent* aContent)
michael@0: {
michael@0:   nsGenericHTMLElement* element = nsGenericHTMLElement::FromContentOrNull(aContent);
michael@0:   return element && element->Scrollgrab();
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::FlushLayoutForTree(nsIDOMWindow* aWindow)
michael@0: {
michael@0:     nsCOMPtr<nsPIDOMWindow> piWin = do_QueryInterface(aWindow);
michael@0:     if (!piWin)
michael@0:         return;
michael@0: 
michael@0:     // Note that because FlushPendingNotifications flushes parents, this
michael@0:     // is O(N^2) in docshell tree depth.  However, the docshell tree is
michael@0:     // usually pretty shallow.
michael@0: 
michael@0:     nsCOMPtr<nsIDOMDocument> domDoc;
michael@0:     aWindow->GetDocument(getter_AddRefs(domDoc));
michael@0:     nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
michael@0:     if (doc) {
michael@0:         doc->FlushPendingNotifications(Flush_Layout);
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDocShell> docShell = piWin->GetDocShell();
michael@0:     if (docShell) {
michael@0:         int32_t i = 0, i_end;
michael@0:         docShell->GetChildCount(&i_end);
michael@0:         for (; i < i_end; ++i) {
michael@0:             nsCOMPtr<nsIDocShellTreeItem> item;
michael@0:             docShell->GetChildAt(i, getter_AddRefs(item));
michael@0:             nsCOMPtr<nsIDOMWindow> win = do_GetInterface(item);
michael@0:             if (win) {
michael@0:                 FlushLayoutForTree(win);
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: }
michael@0: 
michael@0: void nsContentUtils::RemoveNewlines(nsString &aString)
michael@0: {
michael@0:   // strip CR/LF and null
michael@0:   static const char badChars[] = {'\r', '\n', 0};
michael@0:   aString.StripChars(badChars);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::PlatformToDOMLineBreaks(nsString &aString)
michael@0: {
michael@0:   if (aString.FindChar(char16_t('\r')) != -1) {
michael@0:     // Windows linebreaks: Map CRLF to LF:
michael@0:     aString.ReplaceSubstring(MOZ_UTF16("\r\n"),
michael@0:                              MOZ_UTF16("\n"));
michael@0: 
michael@0:     // Mac linebreaks: Map any remaining CR to LF:
michael@0:     aString.ReplaceSubstring(MOZ_UTF16("\r"),
michael@0:                              MOZ_UTF16("\n"));
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::PopulateStringFromStringBuffer(nsStringBuffer* aBuf,
michael@0:                                                nsAString& aResultString)
michael@0: {
michael@0:   MOZ_ASSERT(aBuf, "Expecting a non-null string buffer");
michael@0: 
michael@0:   uint32_t stringLen = NS_strlen(static_cast<char16_t*>(aBuf->Data()));
michael@0: 
michael@0:   // SANITY CHECK: In case the nsStringBuffer isn't correctly
michael@0:   // null-terminated, let's clamp its length using the allocated size, to be
michael@0:   // sure the resulting string doesn't sample past the end of the the buffer.
michael@0:   // (Note that StorageSize() is in units of bytes, so we have to convert that
michael@0:   // to units of PRUnichars, and subtract 1 for the null-terminator.)
michael@0:   uint32_t allocStringLen = (aBuf->StorageSize() / sizeof(char16_t)) - 1;
michael@0:   MOZ_ASSERT(stringLen <= allocStringLen,
michael@0:              "string buffer lacks null terminator!");
michael@0:   stringLen = std::min(stringLen, allocStringLen);
michael@0: 
michael@0:   aBuf->ToString(stringLen, aResultString);
michael@0: }
michael@0: 
michael@0: nsIPresShell*
michael@0: nsContentUtils::FindPresShellForDocument(const nsIDocument* aDoc)
michael@0: {
michael@0:   const nsIDocument* doc = aDoc;
michael@0:   nsIDocument* displayDoc = doc->GetDisplayDocument();
michael@0:   if (displayDoc) {
michael@0:     doc = displayDoc;
michael@0:   }
michael@0: 
michael@0:   nsIPresShell* shell = doc->GetShell();
michael@0:   if (shell) {
michael@0:     return shell;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem = doc->GetDocShell();
michael@0:   while (docShellTreeItem) {
michael@0:     // We may be in a display:none subdocument, or we may not have a presshell
michael@0:     // created yet.
michael@0:     // Walk the docshell tree to find the nearest container that has a presshell,
michael@0:     // and return that.
michael@0:     nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(docShellTreeItem);
michael@0:     nsIPresShell* presShell = docShell->GetPresShell();
michael@0:     if (presShell) {
michael@0:       return presShell;
michael@0:     }
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parent;
michael@0:     docShellTreeItem->GetParent(getter_AddRefs(parent));
michael@0:     docShellTreeItem = parent;
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: nsIWidget*
michael@0: nsContentUtils::WidgetForDocument(const nsIDocument* aDoc)
michael@0: {
michael@0:   nsIPresShell* shell = FindPresShellForDocument(aDoc);
michael@0:   if (shell) {
michael@0:     nsViewManager* VM = shell->GetViewManager();
michael@0:     if (VM) {
michael@0:       nsView* rootView = VM->GetRootView();
michael@0:       if (rootView) {
michael@0:         nsView* displayRoot = nsViewManager::GetDisplayRootFor(rootView);
michael@0:         if (displayRoot) {
michael@0:           return displayRoot->GetNearestWidget(nullptr);
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: static already_AddRefed<LayerManager>
michael@0: LayerManagerForDocumentInternal(const nsIDocument *aDoc, bool aRequirePersistent,
michael@0:                                 bool* aAllowRetaining)
michael@0: {
michael@0:   nsIWidget *widget = nsContentUtils::WidgetForDocument(aDoc);
michael@0:   if (widget) {
michael@0:     nsRefPtr<LayerManager> manager =
michael@0:       widget->GetLayerManager(aRequirePersistent ? nsIWidget::LAYER_MANAGER_PERSISTENT : 
michael@0:                               nsIWidget::LAYER_MANAGER_CURRENT,
michael@0:                               aAllowRetaining);
michael@0:     return manager.forget();
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: already_AddRefed<LayerManager>
michael@0: nsContentUtils::LayerManagerForDocument(const nsIDocument *aDoc, bool *aAllowRetaining)
michael@0: {
michael@0:   return LayerManagerForDocumentInternal(aDoc, false, aAllowRetaining);
michael@0: }
michael@0: 
michael@0: already_AddRefed<LayerManager>
michael@0: nsContentUtils::PersistentLayerManagerForDocument(nsIDocument *aDoc, bool *aAllowRetaining)
michael@0: {
michael@0:   return LayerManagerForDocumentInternal(aDoc, true, aAllowRetaining);
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::AllowXULXBLForPrincipal(nsIPrincipal* aPrincipal)
michael@0: {
michael@0:   if (IsSystemPrincipal(aPrincipal)) {
michael@0:     return true;
michael@0:   }
michael@0:   
michael@0:   nsCOMPtr<nsIURI> princURI;
michael@0:   aPrincipal->GetURI(getter_AddRefs(princURI));
michael@0:   
michael@0:   return princURI &&
michael@0:          ((sAllowXULXBL_for_file && SchemeIs(princURI, "file")) ||
michael@0:           IsSitePermAllow(aPrincipal, "allowXULXBL"));
michael@0: }
michael@0: 
michael@0: already_AddRefed<nsIDocumentLoaderFactory>
michael@0: nsContentUtils::FindInternalContentViewer(const char* aType,
michael@0:                                           ContentViewerType* aLoaderType)
michael@0: {
michael@0:   if (aLoaderType) {
michael@0:     *aLoaderType = TYPE_UNSUPPORTED;
michael@0:   }
michael@0: 
michael@0:   // one helper factory, please
michael@0:   nsCOMPtr<nsICategoryManager> catMan(do_GetService(NS_CATEGORYMANAGER_CONTRACTID));
michael@0:   if (!catMan)
michael@0:     return nullptr;
michael@0: 
michael@0:   nsCOMPtr<nsIDocumentLoaderFactory> docFactory;
michael@0: 
michael@0:   nsXPIDLCString contractID;
michael@0:   nsresult rv = catMan->GetCategoryEntry("Gecko-Content-Viewers", aType, getter_Copies(contractID));
michael@0:   if (NS_SUCCEEDED(rv)) {
michael@0:     docFactory = do_GetService(contractID);
michael@0:     if (docFactory && aLoaderType) {
michael@0:       if (contractID.EqualsLiteral(CONTENT_DLF_CONTRACTID))
michael@0:         *aLoaderType = TYPE_CONTENT;
michael@0:       else if (contractID.EqualsLiteral(PLUGIN_DLF_CONTRACTID))
michael@0:         *aLoaderType = TYPE_PLUGIN;
michael@0:       else
michael@0:       *aLoaderType = TYPE_UNKNOWN;
michael@0:     }
michael@0:     return docFactory.forget();
michael@0:   }
michael@0: 
michael@0:   if (DecoderTraits::IsSupportedInVideoDocument(nsDependentCString(aType))) {
michael@0:     docFactory = do_GetService("@mozilla.org/content/document-loader-factory;1");
michael@0:     if (docFactory && aLoaderType) {
michael@0:       *aLoaderType = TYPE_CONTENT;
michael@0:     }
michael@0:     return docFactory.forget();
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::GetContentSecurityPolicy(JSContext* aCx,
michael@0:                                          nsIContentSecurityPolicy** aCSP)
michael@0: {
michael@0:   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
michael@0: 
michael@0:   // Get the security manager
michael@0:   nsCOMPtr<nsIScriptSecurityManager> ssm = nsContentUtils::GetSecurityManager();
michael@0: 
michael@0:   if (!ssm) {
michael@0:     NS_ERROR("Failed to get security manager service");
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIPrincipal> subjectPrincipal = ssm->GetCxSubjectPrincipal(aCx);
michael@0:   NS_ASSERTION(subjectPrincipal, "Failed to get subjectPrincipal");
michael@0: 
michael@0:   nsCOMPtr<nsIContentSecurityPolicy> csp;
michael@0:   nsresult rv = subjectPrincipal->GetCsp(getter_AddRefs(csp));
michael@0:   if (NS_FAILED(rv)) {
michael@0:     NS_ERROR("CSP: Failed to get CSP from principal.");
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   csp.forget(aCSP);
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::IsPatternMatching(nsAString& aValue, nsAString& aPattern,
michael@0:                                   nsIDocument* aDocument)
michael@0: {
michael@0:   NS_ASSERTION(aDocument, "aDocument should be a valid pointer (not null)");
michael@0:   nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(aDocument->GetWindow());
michael@0:   NS_ENSURE_TRUE(sgo, true);
michael@0: 
michael@0:   AutoPushJSContext cx(sgo->GetContext()->GetNativeContext());
michael@0:   NS_ENSURE_TRUE(cx, true);
michael@0: 
michael@0:   // The pattern has to match the entire value.
michael@0:   aPattern.Insert(NS_LITERAL_STRING("^(?:"), 0);
michael@0:   aPattern.Append(NS_LITERAL_STRING(")$"));
michael@0: 
michael@0:   JS::Rooted<JSObject*> re(cx,
michael@0:     JS_NewUCRegExpObjectNoStatics(cx,
michael@0:                                   static_cast<jschar*>(aPattern.BeginWriting()),
michael@0:                                   aPattern.Length(), 0));
michael@0:   if (!re) {
michael@0:     JS_ClearPendingException(cx);
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   JS::Rooted<JS::Value> rval(cx, JS::NullValue());
michael@0:   size_t idx = 0;
michael@0:   if (!JS_ExecuteRegExpNoStatics(cx, re,
michael@0:                                  static_cast<jschar*>(aValue.BeginWriting()),
michael@0:                                  aValue.Length(), &idx, true, &rval)) {
michael@0:     JS_ClearPendingException(cx);
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   return !rval.isNull();
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsContentUtils::URIInheritsSecurityContext(nsIURI *aURI, bool *aResult)
michael@0: {
michael@0:   // Note: about:blank URIs do NOT inherit the security context from the
michael@0:   // current document, which is what this function tests for...
michael@0:   return NS_URIChainHasFlags(aURI,
michael@0:                              nsIProtocolHandler::URI_INHERITS_SECURITY_CONTEXT,
michael@0:                              aResult);
michael@0: }
michael@0: 
michael@0: // static
michael@0: bool
michael@0: nsContentUtils::SetUpChannelOwner(nsIPrincipal* aLoadingPrincipal,
michael@0:                                   nsIChannel* aChannel,
michael@0:                                   nsIURI* aURI,
michael@0:                                   bool aSetUpForAboutBlank,
michael@0:                                   bool aForceOwner)
michael@0: {
michael@0:   //
michael@0:   // Set the owner of the channel, but only for channels that can't
michael@0:   // provide their own security context.
michael@0:   //
michael@0:   // XXX: It seems wrong that the owner is ignored - even if one is
michael@0:   //      supplied) unless the URI is javascript or data or about:blank.
michael@0:   // XXX: If this is ever changed, check all callers for what owners
michael@0:   //      they're passing in.  In particular, see the code and
michael@0:   //      comments in nsDocShell::LoadURI where we fall back on
michael@0:   //      inheriting the owner if called from chrome.  That would be
michael@0:   //      very wrong if this code changed anything but channels that
michael@0:   //      can't provide their own security context!
michael@0:   //
michael@0:   //      (Currently chrome URIs set the owner when they are created!
michael@0:   //      So setting a nullptr owner would be bad!)
michael@0:   //
michael@0:   // If aForceOwner is true, the owner will be set, even for a channel that
michael@0:   // can provide its own security context. This is used for the HTML5 IFRAME
michael@0:   // sandbox attribute, so we can force the channel (and its document) to
michael@0:   // explicitly have a null principal.
michael@0:   bool inherit;
michael@0:   // We expect URIInheritsSecurityContext to return success for an
michael@0:   // about:blank URI, so don't call NS_IsAboutBlank() if this call fails.
michael@0:   // This condition needs to match the one in nsDocShell::InternalLoad where
michael@0:   // we're checking for things that will use the owner.
michael@0:   if (aForceOwner || ((NS_SUCCEEDED(URIInheritsSecurityContext(aURI, &inherit)) &&
michael@0:       (inherit || (aSetUpForAboutBlank && NS_IsAboutBlank(aURI)))))) {
michael@0: #ifdef DEBUG
michael@0:     // Assert that aForceOwner is only set for null principals for non-srcdoc
michael@0:     // loads.  (Strictly speaking not all uses of about:srcdoc would be 
michael@0:     // srcdoc loads, but the URI is non-resolvable in cases where it is not).
michael@0:     if (aForceOwner) {
michael@0:       nsAutoCString uriStr;
michael@0:       aURI->GetSpec(uriStr);
michael@0:       if(!uriStr.EqualsLiteral("about:srcdoc") &&
michael@0:          !uriStr.EqualsLiteral("view-source:about:srcdoc")) {
michael@0:         nsCOMPtr<nsIURI> ownerURI;
michael@0:         nsresult rv = aLoadingPrincipal->GetURI(getter_AddRefs(ownerURI));
michael@0:         MOZ_ASSERT(NS_SUCCEEDED(rv) && SchemeIs(ownerURI, NS_NULLPRINCIPAL_SCHEME));
michael@0:       }
michael@0:     }
michael@0: #endif
michael@0:     aChannel->SetOwner(aLoadingPrincipal);
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   //
michael@0:   // file: uri special-casing
michael@0:   //
michael@0:   // If this is a file: load opened from another file: then it may need
michael@0:   // to inherit the owner from the referrer so they can script each other.
michael@0:   // If we don't set the owner explicitly then each file: gets an owner
michael@0:   // based on its own codebase later.
michael@0:   //
michael@0:   if (URIIsLocalFile(aURI) && aLoadingPrincipal &&
michael@0:       NS_SUCCEEDED(aLoadingPrincipal->CheckMayLoad(aURI, false, false)) &&
michael@0:       // One more check here.  CheckMayLoad will always return true for the
michael@0:       // system principal, but we do NOT want to inherit in that case.
michael@0:       !IsSystemPrincipal(aLoadingPrincipal)) {
michael@0:     aChannel->SetOwner(aLoadingPrincipal);
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::IsFullScreenApiEnabled()
michael@0: {
michael@0:   return sIsFullScreenApiEnabled;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::IsRequestFullScreenAllowed()
michael@0: {
michael@0:   return !sTrustedFullScreenOnly ||
michael@0:          EventStateManager::IsHandlingUserInput() ||
michael@0:          IsCallerChrome();
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::IsFullscreenApiContentOnly()
michael@0: {
michael@0:   return sFullscreenApiIsContentOnly;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::HaveEqualPrincipals(nsIDocument* aDoc1, nsIDocument* aDoc2)
michael@0: {
michael@0:   if (!aDoc1 || !aDoc2) {
michael@0:     return false;
michael@0:   }
michael@0:   bool principalsEqual = false;
michael@0:   aDoc1->NodePrincipal()->Equals(aDoc2->NodePrincipal(), &principalsEqual);
michael@0:   return principalsEqual;
michael@0: }
michael@0: 
michael@0: static void
michael@0: CheckForWindowedPlugins(nsIContent* aContent, void* aResult)
michael@0: {
michael@0:   if (!aContent->IsInDoc()) {
michael@0:     return;
michael@0:   }
michael@0:   nsCOMPtr<nsIObjectLoadingContent> olc(do_QueryInterface(aContent));
michael@0:   if (!olc) {
michael@0:     return;
michael@0:   }
michael@0:   nsRefPtr<nsNPAPIPluginInstance> plugin;
michael@0:   olc->GetPluginInstance(getter_AddRefs(plugin));
michael@0:   if (!plugin) {
michael@0:     return;
michael@0:   }
michael@0:   bool isWindowless = false;
michael@0:   nsresult res = plugin->IsWindowless(&isWindowless);
michael@0:   if (NS_SUCCEEDED(res) && !isWindowless) {
michael@0:     *static_cast<bool*>(aResult) = true;
michael@0:   }
michael@0: }
michael@0: 
michael@0: static bool
michael@0: DocTreeContainsWindowedPlugins(nsIDocument* aDoc, void* aResult)
michael@0: {
michael@0:   if (!nsContentUtils::IsChromeDoc(aDoc)) {
michael@0:     aDoc->EnumerateFreezableElements(CheckForWindowedPlugins, aResult);
michael@0:   }
michael@0:   if (*static_cast<bool*>(aResult)) {
michael@0:     // Return false to stop iteration, we found a windowed plugin.
michael@0:     return false;
michael@0:   }
michael@0:   aDoc->EnumerateSubDocuments(DocTreeContainsWindowedPlugins, aResult);
michael@0:   // Return false to stop iteration if we found a windowed plugin in
michael@0:   // the sub documents.
michael@0:   return !*static_cast<bool*>(aResult);
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::HasPluginWithUncontrolledEventDispatch(nsIDocument* aDoc)
michael@0: {
michael@0: #ifdef XP_MACOSX
michael@0:   // We control dispatch to all mac plugins.
michael@0:   return false;
michael@0: #endif
michael@0:   bool result = false;
michael@0:   
michael@0:   // Find the top of the document's branch, the child of the chrome document.
michael@0:   nsIDocument* doc = aDoc;
michael@0:   nsIDocument* parent = nullptr;
michael@0:   while (doc && (parent = doc->GetParentDocument()) && !IsChromeDoc(parent)) {
michael@0:     doc = parent;
michael@0:   }
michael@0: 
michael@0:   DocTreeContainsWindowedPlugins(doc, &result);
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::HasPluginWithUncontrolledEventDispatch(nsIContent* aContent)
michael@0: {
michael@0: #ifdef XP_MACOSX
michael@0:   // We control dispatch to all mac plugins.
michael@0:   return false;
michael@0: #endif
michael@0:   bool result = false;
michael@0:   CheckForWindowedPlugins(aContent, &result);
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsContentUtils::FireMutationEventsForDirectParsing(nsIDocument* aDoc,
michael@0:                                                    nsIContent* aDest,
michael@0:                                                    int32_t aOldChildCount)
michael@0: {
michael@0:   // Fire mutation events. Optimize for the case when there are no listeners
michael@0:   int32_t newChildCount = aDest->GetChildCount();
michael@0:   if (newChildCount && nsContentUtils::
michael@0:         HasMutationListeners(aDoc, NS_EVENT_BITS_MUTATION_NODEINSERTED)) {
michael@0:     nsAutoTArray<nsCOMPtr<nsIContent>, 50> childNodes;
michael@0:     NS_ASSERTION(newChildCount - aOldChildCount >= 0,
michael@0:                  "What, some unexpected dom mutation has happened?");
michael@0:     childNodes.SetCapacity(newChildCount - aOldChildCount);
michael@0:     for (nsIContent* child = aDest->GetFirstChild();
michael@0:          child;
michael@0:          child = child->GetNextSibling()) {
michael@0:       childNodes.AppendElement(child);
michael@0:     }
michael@0:     FragmentOrElement::FireNodeInserted(aDoc, aDest, childNodes);
michael@0:   }
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: nsIDocument*
michael@0: nsContentUtils::GetFullscreenAncestor(nsIDocument* aDoc)
michael@0: {
michael@0:   nsIDocument* doc = aDoc;
michael@0:   while (doc) {
michael@0:     if (doc->IsFullScreenDoc()) {
michael@0:       return doc;
michael@0:     }
michael@0:     doc = doc->GetParentDocument();
michael@0:   }
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsContentUtils::IsInPointerLockContext(nsIDOMWindow* aWin)
michael@0: {
michael@0:   if (!aWin) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIDocument> pointerLockedDoc =
michael@0:     do_QueryReferent(EventStateManager::sPointerLockedDoc);
michael@0:   if (!pointerLockedDoc || !pointerLockedDoc->GetWindow()) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIDOMWindow> lockTop;
michael@0:   pointerLockedDoc->GetWindow()->GetScriptableTop(getter_AddRefs(lockTop));
michael@0: 
michael@0:   nsCOMPtr<nsIDOMWindow> top;
michael@0:   aWin->GetScriptableTop(getter_AddRefs(top));
michael@0: 
michael@0:   return top == lockTop;
michael@0: }
michael@0: 
michael@0: // static
michael@0: int32_t
michael@0: nsContentUtils::GetAdjustedOffsetInTextControl(nsIFrame* aOffsetFrame,
michael@0:                                                int32_t aOffset)
michael@0: {
michael@0:   // The structure of the anonymous frames within a text control frame is
michael@0:   // an optional block frame, followed by an optional br frame.
michael@0: 
michael@0:   // If the offset frame has a child, then this frame is the block which
michael@0:   // has the text frames (containing the content) as its children. This will
michael@0:   // be the case if we click to the right of any of the text frames, or at the
michael@0:   // bottom of the text area.
michael@0:   nsIFrame* firstChild = aOffsetFrame->GetFirstPrincipalChild();
michael@0:   if (firstChild) {
michael@0:     // In this case, the passed-in offset is incorrect, and we want the length
michael@0:     // of the entire content in the text control frame.
michael@0:     return firstChild->GetContent()->Length();
michael@0:   }
michael@0: 
michael@0:   if (aOffsetFrame->GetPrevSibling() &&
michael@0:       !aOffsetFrame->GetNextSibling()) {
michael@0:     // In this case, we're actually within the last frame, which is a br
michael@0:     // frame. Our offset should therefore be the length of the first child of
michael@0:     // our parent.
michael@0:     int32_t aOutOffset =
michael@0:       aOffsetFrame->GetParent()->GetFirstPrincipalChild()->GetContent()->Length();
michael@0:     return aOutOffset;
michael@0:   }
michael@0: 
michael@0:   // Otherwise, we're within one of the text frames, in which case our offset
michael@0:   // has already been correctly calculated.
michael@0:   return aOffset;
michael@0: }
michael@0: 
michael@0: // static
michael@0: void
michael@0: nsContentUtils::GetSelectionInTextControl(Selection* aSelection,
michael@0:                                           Element* aRoot,
michael@0:                                           int32_t& aOutStartOffset,
michael@0:                                           int32_t& aOutEndOffset)
michael@0: {
michael@0:   MOZ_ASSERT(aSelection && aRoot);
michael@0: 
michael@0:   if (!aSelection->GetRangeCount()) {
michael@0:     // Nothing selected
michael@0:     aOutStartOffset = aOutEndOffset = 0;
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsINode> anchorNode = aSelection->GetAnchorNode();
michael@0:   uint32_t anchorOffset = aSelection->AnchorOffset();
michael@0:   nsCOMPtr<nsINode> focusNode = aSelection->GetFocusNode();
michael@0:   uint32_t focusOffset = aSelection->FocusOffset();
michael@0: 
michael@0:   // We have at most two children, consisting of an optional text node followed
michael@0:   // by an optional <br>.
michael@0:   NS_ASSERTION(aRoot->GetChildCount() <= 2, "Unexpected children");
michael@0:   nsCOMPtr<nsIContent> firstChild = aRoot->GetFirstChild();
michael@0: #ifdef DEBUG
michael@0:   nsCOMPtr<nsIContent> lastChild = aRoot->GetLastChild();
michael@0:   NS_ASSERTION(anchorNode == aRoot || anchorNode == firstChild ||
michael@0:                anchorNode == lastChild, "Unexpected anchorNode");
michael@0:   NS_ASSERTION(focusNode == aRoot || focusNode == firstChild ||
michael@0:                focusNode == lastChild, "Unexpected focusNode");
michael@0: #endif
michael@0:   if (!firstChild || !firstChild->IsNodeOfType(nsINode::eTEXT)) {
michael@0:     // No text node, so everything is 0
michael@0:     anchorOffset = focusOffset = 0;
michael@0:   } else {
michael@0:     // First child is text.  If the anchor/focus is already in the text node,
michael@0:     // or the start of the root node, no change needed.  If it's in the root
michael@0:     // node but not the start, or in the trailing <br>, we need to set the
michael@0:     // offset to the end.
michael@0:     if ((anchorNode == aRoot && anchorOffset != 0) ||
michael@0:         (anchorNode != aRoot && anchorNode != firstChild)) {
michael@0:       anchorOffset = firstChild->Length();
michael@0:     }
michael@0:     if ((focusNode == aRoot && focusOffset != 0) ||
michael@0:         (focusNode != aRoot && focusNode != firstChild)) {
michael@0:       focusOffset = firstChild->Length();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Make sure aOutStartOffset <= aOutEndOffset.
michael@0:   aOutStartOffset = std::min(anchorOffset, focusOffset);
michael@0:   aOutEndOffset = std::max(anchorOffset, focusOffset);
michael@0: }
michael@0: 
michael@0: nsIEditor*
michael@0: nsContentUtils::GetHTMLEditor(nsPresContext* aPresContext)
michael@0: {
michael@0:   nsCOMPtr<nsIDocShell> docShell(aPresContext->GetDocShell());
michael@0:   bool isEditable;
michael@0:   if (!docShell ||
michael@0:       NS_FAILED(docShell->GetEditable(&isEditable)) || !isEditable)
michael@0:     return nullptr;
michael@0: 
michael@0:   nsCOMPtr<nsIEditor> editor;
michael@0:   docShell->GetEditor(getter_AddRefs(editor));
michael@0:   return editor;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::InternalIsSupported(nsISupports* aObject,
michael@0:                                     const nsAString& aFeature,
michael@0:                                     const nsAString& aVersion)
michael@0: {
michael@0:   // If it looks like an SVG feature string, forward to nsSVGFeatures
michael@0:   if (StringBeginsWith(aFeature,
michael@0:                        NS_LITERAL_STRING("http://www.w3.org/TR/SVG"),
michael@0:                        nsASCIICaseInsensitiveStringComparator()) ||
michael@0:       StringBeginsWith(aFeature, NS_LITERAL_STRING("org.w3c.dom.svg"),
michael@0:                        nsASCIICaseInsensitiveStringComparator()) ||
michael@0:       StringBeginsWith(aFeature, NS_LITERAL_STRING("org.w3c.svg"),
michael@0:                        nsASCIICaseInsensitiveStringComparator())) {
michael@0:     return (aVersion.IsEmpty() || aVersion.EqualsLiteral("1.0") ||
michael@0:             aVersion.EqualsLiteral("1.1")) &&
michael@0:            nsSVGFeatures::HasFeature(aObject, aFeature);
michael@0:   }
michael@0: 
michael@0:   // Otherwise, we claim to support everything
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsContentInsertionPoint(const nsIContent* aContent)
michael@0: {
michael@0:   // Check if the content is a XBL insertion point.
michael@0:   if (aContent->IsActiveChildrenElement()) {
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   // Check if the content is a web components content insertion point.
michael@0:   if (aContent->IsHTML(nsGkAtoms::content)) {
michael@0:     return static_cast<const HTMLContentElement*>(aContent)->IsInsertionPoint();
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::DOMWindowDumpEnabled()
michael@0: {
michael@0: #if !(defined(DEBUG) || defined(MOZ_ENABLE_JS_DUMP))
michael@0:   // In optimized builds we check a pref that controls if we should
michael@0:   // enable output from dump() or not, in debug builds it's always
michael@0:   // enabled.
michael@0:   return nsContentUtils::sDOMWindowDumpEnabled;
michael@0: #else
michael@0:   return true;
michael@0: #endif
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::GetNodeTextContent(nsINode* aNode, bool aDeep, nsAString& aResult)
michael@0: {
michael@0:   aResult.Truncate();
michael@0:   return AppendNodeTextContent(aNode, aDeep, aResult, mozilla::fallible_t());
michael@0: }
michael@0: 
michael@0: void
michael@0: nsContentUtils::DestroyMatchString(void* aData)
michael@0: {
michael@0:   if (aData) {
michael@0:     nsString* matchString = static_cast<nsString*>(aData);
michael@0:     delete matchString;
michael@0:   }
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsContentUtils::IsJavascriptMIMEType(const nsAString& aMIMEType)
michael@0: {
michael@0:   // Table ordered from most to least likely JS MIME types.
michael@0:   static const char* jsTypes[] = {
michael@0:     "text/javascript",
michael@0:     "text/ecmascript",
michael@0:     "application/javascript",
michael@0:     "application/ecmascript",
michael@0:     "application/x-javascript",
michael@0:     "application/x-ecmascript",
michael@0:     "text/javascript1.0",
michael@0:     "text/javascript1.1",
michael@0:     "text/javascript1.2",
michael@0:     "text/javascript1.3",
michael@0:     "text/javascript1.4",
michael@0:     "text/javascript1.5",
michael@0:     "text/jscript",
michael@0:     "text/livescript",
michael@0:     "text/x-ecmascript",
michael@0:     "text/x-javascript",
michael@0:     nullptr
michael@0:   };
michael@0: 
michael@0:   for (uint32_t i = 0; jsTypes[i]; ++i) {
michael@0:     if (aMIMEType.LowerCaseEqualsASCII(jsTypes[i])) {
michael@0:       return true;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }