summaryrefslogtreecommitdiffstats
path: root/dom/base/nsContentUtils.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/base/nsContentUtils.cpp')
-rw-r--r--dom/base/nsContentUtils.cpp9783
1 files changed, 9783 insertions, 0 deletions
diff --git a/dom/base/nsContentUtils.cpp b/dom/base/nsContentUtils.cpp
new file mode 100644
index 000000000..29d28f8ce
--- /dev/null
+++ b/dom/base/nsContentUtils.cpp
@@ -0,0 +1,9783 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* A namespace class for static layout utilities. */
+
+#include "nsContentUtils.h"
+
+#include <algorithm>
+#include <math.h>
+
+#include "DecoderTraits.h"
+#include "harfbuzz/hb.h"
+#include "imgICache.h"
+#include "imgIContainer.h"
+#include "imgINotificationObserver.h"
+#include "imgLoader.h"
+#include "imgRequestProxy.h"
+#include "jsapi.h"
+#include "jsfriendapi.h"
+#include "js/Value.h"
+#include "Layers.h"
+#include "MediaDecoder.h"
+// nsNPAPIPluginInstance must be included before nsIDocument.h, which is included in mozAutoDocUpdate.h.
+#include "nsNPAPIPluginInstance.h"
+#include "gfxDrawable.h"
+#include "gfxPrefs.h"
+#include "ImageOps.h"
+#include "mozAutoDocUpdate.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/AutoRestore.h"
+#include "mozilla/AutoTimelineMarker.h"
+#include "mozilla/Base64.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/LoadInfo.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/CustomElementRegistry.h"
+#include "mozilla/dom/DocumentFragment.h"
+#include "mozilla/dom/DOMTypes.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/FileSystemSecurity.h"
+#include "mozilla/dom/HTMLMediaElement.h"
+#include "mozilla/dom/HTMLTemplateElement.h"
+#include "mozilla/dom/HTMLContentElement.h"
+#include "mozilla/dom/HTMLShadowElement.h"
+#include "mozilla/dom/ipc/BlobChild.h"
+#include "mozilla/dom/ipc/BlobParent.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/dom/TabParent.h"
+#include "mozilla/dom/TextDecoder.h"
+#include "mozilla/dom/TouchEvent.h"
+#include "mozilla/dom/ShadowRoot.h"
+#include "mozilla/dom/WorkerPrivate.h"
+#include "mozilla/dom/workers/ServiceWorkerManager.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/EventListenerManager.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/gfx/DataSurfaceHelpers.h"
+#include "mozilla/IMEStateManager.h"
+#include "mozilla/InternalMutationEvent.h"
+#include "mozilla/Likely.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/dom/Selection.h"
+#include "mozilla/TextEvents.h"
+#include "nsArrayUtils.h"
+#include "nsAString.h"
+#include "nsAttrName.h"
+#include "nsAttrValue.h"
+#include "nsAttrValueInlines.h"
+#include "nsBindingManager.h"
+#include "nsCaret.h"
+#include "nsCCUncollectableMarker.h"
+#include "nsCharSeparatedTokenizer.h"
+#include "nsCOMPtr.h"
+#include "nsContentCreatorFunctions.h"
+#include "nsContentDLF.h"
+#include "nsContentList.h"
+#include "nsContentPolicyUtils.h"
+#include "nsContentSecurityManager.h"
+#include "nsCPrefetchService.h"
+#include "nsCRT.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsCycleCollector.h"
+#include "nsDataHashtable.h"
+#include "nsDocShellCID.h"
+#include "nsDocument.h"
+#include "nsDOMCID.h"
+#include "mozilla/dom/DataTransfer.h"
+#include "nsDOMJSUtils.h"
+#include "nsDOMMutationObserver.h"
+#include "nsError.h"
+#include "nsFocusManager.h"
+#include "nsGenericHTMLElement.h"
+#include "nsGenericHTMLFrameElement.h"
+#include "nsGkAtoms.h"
+#include "nsHostObjectProtocolHandler.h"
+#include "nsHtml5Module.h"
+#include "nsHtml5StringParser.h"
+#include "nsIAddonPolicyService.h"
+#include "nsIAsyncVerifyRedirectCallback.h"
+#include "nsICategoryManager.h"
+#include "nsIChannelEventSink.h"
+#include "nsICharsetDetectionObserver.h"
+#include "nsIChromeRegistry.h"
+#include "nsIConsoleService.h"
+#include "nsIContent.h"
+#include "nsIContentInlines.h"
+#include "nsIContentSecurityPolicy.h"
+#include "nsIContentSink.h"
+#include "nsIContentViewer.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellTreeOwner.h"
+#include "nsIDocument.h"
+#include "nsIDocumentEncoder.h"
+#include "nsIDOMChromeWindow.h"
+#include "nsIDOMDocument.h"
+#include "nsIDOMDocumentType.h"
+#include "nsIDOMEvent.h"
+#include "nsIDOMElement.h"
+#include "nsIDOMHTMLElement.h"
+#include "nsIDOMHTMLFormElement.h"
+#include "nsIDOMHTMLInputElement.h"
+#include "nsIDOMNode.h"
+#include "nsIDOMNodeList.h"
+#include "nsIDOMWindowUtils.h"
+#include "nsIDOMXULCommandEvent.h"
+#include "nsIDragService.h"
+#include "nsIEditor.h"
+#include "nsIFormControl.h"
+#include "nsIForm.h"
+#include "nsIFragmentContentSink.h"
+#include "nsContainerFrame.h"
+#include "nsIHTMLDocument.h"
+#include "nsIIdleService.h"
+#include "nsIImageLoadingContent.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIIOService.h"
+#include "nsILineBreaker.h"
+#include "nsILoadContext.h"
+#include "nsILoadGroup.h"
+#include "nsIMemoryReporter.h"
+#include "nsIMIMEHeaderParam.h"
+#include "nsIMIMEService.h"
+#include "nsINode.h"
+#include "mozilla/dom/NodeInfo.h"
+#include "nsIObjectLoadingContent.h"
+#include "nsIObserver.h"
+#include "nsIObserverService.h"
+#include "nsIOfflineCacheUpdate.h"
+#include "nsIParser.h"
+#include "nsIParserService.h"
+#include "nsIPermissionManager.h"
+#include "nsIPluginHost.h"
+#include "nsIRequest.h"
+#include "nsIRunnable.h"
+#include "nsIScriptContext.h"
+#include "nsIScriptError.h"
+#include "nsIScriptGlobalObject.h"
+#include "nsIScriptObjectPrincipal.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsIScrollable.h"
+#include "nsIStreamConverterService.h"
+#include "nsIStringBundle.h"
+#include "nsIURI.h"
+#include "nsIURIWithPrincipal.h"
+#include "nsIURL.h"
+#include "nsIWebNavigation.h"
+#include "nsIWindowMediator.h"
+#include "nsIWordBreaker.h"
+#include "nsIXPConnect.h"
+#include "nsJSUtils.h"
+#include "nsLWBrkCIID.h"
+#include "nsNetCID.h"
+#include "nsNetUtil.h"
+#include "nsNodeInfoManager.h"
+#include "nsNullPrincipal.h"
+#include "nsParserCIID.h"
+#include "nsParserConstants.h"
+#include "nsPIDOMWindow.h"
+#include "nsPresContext.h"
+#include "nsPrintfCString.h"
+#include "nsReferencedElement.h"
+#include "nsSandboxFlags.h"
+#include "nsScriptSecurityManager.h"
+#include "nsStreamUtils.h"
+#include "nsTextEditorState.h"
+#include "nsTextFragment.h"
+#include "nsTextNode.h"
+#include "nsThreadUtils.h"
+#include "nsUnicharUtilCIID.h"
+#include "nsUnicodeProperties.h"
+#include "nsViewManager.h"
+#include "nsViewportInfo.h"
+#include "nsWidgetsCID.h"
+#include "nsIWindowProvider.h"
+#include "nsWrapperCacheInlines.h"
+#include "nsXULPopupManager.h"
+#include "xpcprivate.h" // nsXPConnect
+#include "HTMLSplitOnSpacesTokenizer.h"
+#include "nsContentTypeParser.h"
+#include "nsICookiePermission.h"
+#include "mozIThirdPartyUtil.h"
+#include "nsICookieService.h"
+#include "mozilla/EnumSet.h"
+#include "mozilla/BloomFilter.h"
+#include "TabChild.h"
+#include "mozilla/dom/DocGroup.h"
+#include "mozilla/dom/TabGroup.h"
+
+#include "nsIBidiKeyboard.h"
+
+#if defined(XP_WIN)
+// Undefine LoadImage to prevent naming conflict with Windows.
+#undef LoadImage
+#endif
+
+extern "C" int MOZ_XMLTranslateEntity(const char* ptr, const char* end,
+ const char** next, char16_t* result);
+extern "C" int MOZ_XMLCheckQName(const char* ptr, const char* end,
+ int ns_aware, const char** colon);
+
+class imgLoader;
+
+using namespace mozilla::dom;
+using namespace mozilla::ipc;
+using namespace mozilla::gfx;
+using namespace mozilla::layers;
+using namespace mozilla::widget;
+using namespace mozilla;
+
+const char kLoadAsData[] = "loadAsData";
+
+nsIXPConnect *nsContentUtils::sXPConnect;
+nsIScriptSecurityManager *nsContentUtils::sSecurityManager;
+nsIPrincipal *nsContentUtils::sSystemPrincipal;
+nsIPrincipal *nsContentUtils::sNullSubjectPrincipal;
+nsIParserService *nsContentUtils::sParserService = nullptr;
+nsNameSpaceManager *nsContentUtils::sNameSpaceManager;
+nsIIOService *nsContentUtils::sIOService;
+nsIUUIDGenerator *nsContentUtils::sUUIDGenerator;
+nsIConsoleService *nsContentUtils::sConsoleService;
+nsDataHashtable<nsISupportsHashKey, EventNameMapping>* nsContentUtils::sAtomEventTable = nullptr;
+nsDataHashtable<nsStringHashKey, EventNameMapping>* nsContentUtils::sStringEventTable = nullptr;
+nsCOMArray<nsIAtom>* nsContentUtils::sUserDefinedEvents = nullptr;
+nsIStringBundleService *nsContentUtils::sStringBundleService;
+nsIStringBundle *nsContentUtils::sStringBundles[PropertiesFile_COUNT];
+nsIContentPolicy *nsContentUtils::sContentPolicyService;
+bool nsContentUtils::sTriedToGetContentPolicy = false;
+nsILineBreaker *nsContentUtils::sLineBreaker;
+nsIWordBreaker *nsContentUtils::sWordBreaker;
+nsIBidiKeyboard *nsContentUtils::sBidiKeyboard = nullptr;
+uint32_t nsContentUtils::sScriptBlockerCount = 0;
+uint32_t nsContentUtils::sDOMNodeRemovedSuppressCount = 0;
+uint32_t nsContentUtils::sMicroTaskLevel = 0;
+AutoTArray<nsCOMPtr<nsIRunnable>, 8>* nsContentUtils::sBlockedScriptRunners = nullptr;
+uint32_t nsContentUtils::sRunnersCountAtFirstBlocker = 0;
+nsIInterfaceRequestor* nsContentUtils::sSameOriginChecker = nullptr;
+
+bool nsContentUtils::sIsHandlingKeyBoardEvent = false;
+bool nsContentUtils::sAllowXULXBL_for_file = false;
+
+nsString* nsContentUtils::sShiftText = nullptr;
+nsString* nsContentUtils::sControlText = nullptr;
+nsString* nsContentUtils::sMetaText = nullptr;
+nsString* nsContentUtils::sOSText = nullptr;
+nsString* nsContentUtils::sAltText = nullptr;
+nsString* nsContentUtils::sModifierSeparator = nullptr;
+
+bool nsContentUtils::sInitialized = false;
+bool nsContentUtils::sIsFullScreenApiEnabled = false;
+bool nsContentUtils::sIsUnprefixedFullscreenApiEnabled = false;
+bool nsContentUtils::sTrustedFullScreenOnly = true;
+bool nsContentUtils::sIsCutCopyAllowed = true;
+bool nsContentUtils::sIsFrameTimingPrefEnabled = false;
+bool nsContentUtils::sIsPerformanceTimingEnabled = false;
+bool nsContentUtils::sIsResourceTimingEnabled = false;
+bool nsContentUtils::sIsUserTimingLoggingEnabled = false;
+bool nsContentUtils::sIsExperimentalAutocompleteEnabled = false;
+bool nsContentUtils::sEncodeDecodeURLHash = false;
+bool nsContentUtils::sGettersDecodeURLHash = false;
+bool nsContentUtils::sPrivacyResistFingerprinting = false;
+bool nsContentUtils::sSendPerformanceTimingNotifications = false;
+bool nsContentUtils::sUseActivityCursor = false;
+
+uint32_t nsContentUtils::sHandlingInputTimeout = 1000;
+
+uint32_t nsContentUtils::sCookiesLifetimePolicy = nsICookieService::ACCEPT_NORMALLY;
+uint32_t nsContentUtils::sCookiesBehavior = nsICookieService::BEHAVIOR_ACCEPT;
+
+nsHtml5StringParser* nsContentUtils::sHTMLFragmentParser = nullptr;
+nsIParser* nsContentUtils::sXMLFragmentParser = nullptr;
+nsIFragmentContentSink* nsContentUtils::sXMLFragmentSink = nullptr;
+bool nsContentUtils::sFragmentParsingActive = false;
+
+#if !(defined(DEBUG) || defined(MOZ_ENABLE_JS_DUMP))
+bool nsContentUtils::sDOMWindowDumpEnabled;
+#endif
+
+bool nsContentUtils::sDoNotTrackEnabled = false;
+
+mozilla::LazyLogModule nsContentUtils::sDOMDumpLog("Dump");
+
+// Subset of http://www.whatwg.org/specs/web-apps/current-work/#autofill-field-name
+enum AutocompleteFieldName : uint8_t
+{
+ #define AUTOCOMPLETE_FIELD_NAME(name_, value_) \
+ eAutocompleteFieldName_##name_,
+ #define AUTOCOMPLETE_CONTACT_FIELD_NAME(name_, value_) \
+ AUTOCOMPLETE_FIELD_NAME(name_, value_)
+ #include "AutocompleteFieldList.h"
+ #undef AUTOCOMPLETE_FIELD_NAME
+ #undef AUTOCOMPLETE_CONTACT_FIELD_NAME
+};
+
+enum AutocompleteFieldHint : uint8_t
+{
+ #define AUTOCOMPLETE_FIELD_HINT(name_, value_) \
+ eAutocompleteFieldHint_##name_,
+ #include "AutocompleteFieldList.h"
+ #undef AUTOCOMPLETE_FIELD_HINT
+};
+
+enum AutocompleteFieldContactHint : uint8_t
+{
+ #define AUTOCOMPLETE_FIELD_CONTACT_HINT(name_, value_) \
+ eAutocompleteFieldContactHint_##name_,
+ #include "AutocompleteFieldList.h"
+ #undef AUTOCOMPLETE_FIELD_CONTACT_HINT
+};
+
+enum AutocompleteCategory
+{
+ #define AUTOCOMPLETE_CATEGORY(name_, value_) eAutocompleteCategory_##name_,
+ #include "AutocompleteFieldList.h"
+ #undef AUTOCOMPLETE_CATEGORY
+};
+
+static const nsAttrValue::EnumTable kAutocompleteFieldNameTable[] = {
+ #define AUTOCOMPLETE_FIELD_NAME(name_, value_) \
+ { value_, eAutocompleteFieldName_##name_ },
+ #include "AutocompleteFieldList.h"
+ #undef AUTOCOMPLETE_FIELD_NAME
+ { nullptr, 0 }
+};
+
+static const nsAttrValue::EnumTable kAutocompleteContactFieldNameTable[] = {
+ #define AUTOCOMPLETE_CONTACT_FIELD_NAME(name_, value_) \
+ { value_, eAutocompleteFieldName_##name_ },
+ #include "AutocompleteFieldList.h"
+ #undef AUTOCOMPLETE_CONTACT_FIELD_NAME
+ { nullptr, 0 }
+};
+
+static const nsAttrValue::EnumTable kAutocompleteFieldHintTable[] = {
+ #define AUTOCOMPLETE_FIELD_HINT(name_, value_) \
+ { value_, eAutocompleteFieldHint_##name_ },
+ #include "AutocompleteFieldList.h"
+ #undef AUTOCOMPLETE_FIELD_HINT
+ { nullptr, 0 }
+};
+
+static const nsAttrValue::EnumTable kAutocompleteContactFieldHintTable[] = {
+ #define AUTOCOMPLETE_FIELD_CONTACT_HINT(name_, value_) \
+ { value_, eAutocompleteFieldContactHint_##name_ },
+ #include "AutocompleteFieldList.h"
+ #undef AUTOCOMPLETE_FIELD_CONTACT_HINT
+ { nullptr, 0 }
+};
+
+namespace {
+
+static NS_DEFINE_CID(kParserServiceCID, NS_PARSERSERVICE_CID);
+static NS_DEFINE_CID(kCParserCID, NS_PARSER_CID);
+
+static PLDHashTable* sEventListenerManagersHash;
+
+class DOMEventListenerManagersHashReporter final : public nsIMemoryReporter
+{
+ MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf)
+
+ ~DOMEventListenerManagersHashReporter() {}
+
+public:
+ NS_DECL_ISUPPORTS
+
+ NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
+ nsISupports* aData, bool aAnonymize) override
+ {
+ // We don't measure the |EventListenerManager| objects pointed to by the
+ // entries because those references are non-owning.
+ int64_t amount = sEventListenerManagersHash
+ ? sEventListenerManagersHash->ShallowSizeOfIncludingThis(
+ MallocSizeOf)
+ : 0;
+
+ MOZ_COLLECT_REPORT(
+ "explicit/dom/event-listener-managers-hash", KIND_HEAP, UNITS_BYTES,
+ amount,
+ "Memory used by the event listener manager's hash table.");
+
+ return NS_OK;
+ }
+};
+
+NS_IMPL_ISUPPORTS(DOMEventListenerManagersHashReporter, nsIMemoryReporter)
+
+class EventListenerManagerMapEntry : public PLDHashEntryHdr
+{
+public:
+ explicit EventListenerManagerMapEntry(const void* aKey)
+ : mKey(aKey)
+ {
+ }
+
+ ~EventListenerManagerMapEntry()
+ {
+ NS_ASSERTION(!mListenerManager, "caller must release and disconnect ELM");
+ }
+
+protected: // declared protected to silence clang warnings
+ const void *mKey; // must be first, to look like PLDHashEntryStub
+
+public:
+ RefPtr<EventListenerManager> mListenerManager;
+};
+
+static void
+EventListenerManagerHashInitEntry(PLDHashEntryHdr *entry, const void *key)
+{
+ // Initialize the entry with placement new
+ new (entry) EventListenerManagerMapEntry(key);
+}
+
+static void
+EventListenerManagerHashClearEntry(PLDHashTable *table, PLDHashEntryHdr *entry)
+{
+ EventListenerManagerMapEntry *lm =
+ static_cast<EventListenerManagerMapEntry *>(entry);
+
+ // Let the EventListenerManagerMapEntry clean itself up...
+ lm->~EventListenerManagerMapEntry();
+}
+
+class SameOriginCheckerImpl final : public nsIChannelEventSink,
+ public nsIInterfaceRequestor
+{
+ ~SameOriginCheckerImpl() {}
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSICHANNELEVENTSINK
+ NS_DECL_NSIINTERFACEREQUESTOR
+};
+
+class CharsetDetectionObserver final : public nsICharsetDetectionObserver
+{
+public:
+ NS_DECL_ISUPPORTS
+
+ NS_IMETHOD Notify(const char *aCharset, nsDetectionConfident aConf) override
+ {
+ mCharset = aCharset;
+ return NS_OK;
+ }
+
+ const nsACString& GetResult() const
+ {
+ return mCharset;
+ }
+
+private:
+ nsCString mCharset;
+};
+
+} // namespace
+
+/* static */
+TimeDuration
+nsContentUtils::HandlingUserInputTimeout()
+{
+ return TimeDuration::FromMilliseconds(sHandlingInputTimeout);
+}
+
+// static
+nsresult
+nsContentUtils::Init()
+{
+ if (sInitialized) {
+ NS_WARNING("Init() called twice");
+
+ return NS_OK;
+ }
+
+ sNameSpaceManager = nsNameSpaceManager::GetInstance();
+ NS_ENSURE_TRUE(sNameSpaceManager, NS_ERROR_OUT_OF_MEMORY);
+
+ sXPConnect = nsXPConnect::XPConnect();
+
+ sSecurityManager = nsScriptSecurityManager::GetScriptSecurityManager();
+ if(!sSecurityManager)
+ return NS_ERROR_FAILURE;
+ NS_ADDREF(sSecurityManager);
+
+ sSecurityManager->GetSystemPrincipal(&sSystemPrincipal);
+ MOZ_ASSERT(sSystemPrincipal);
+
+ // We use the constructor here because we want infallible initialization; we
+ // apparently don't care whether sNullSubjectPrincipal has a sane URI or not.
+ RefPtr<nsNullPrincipal> nullPrincipal = new nsNullPrincipal();
+ nullPrincipal->Init();
+ nullPrincipal.forget(&sNullSubjectPrincipal);
+
+ nsresult rv = CallGetService(NS_IOSERVICE_CONTRACTID, &sIOService);
+ if (NS_FAILED(rv)) {
+ // This makes life easier, but we can live without it.
+
+ sIOService = nullptr;
+ }
+
+ rv = CallGetService(NS_LBRK_CONTRACTID, &sLineBreaker);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = CallGetService(NS_WBRK_CONTRACTID, &sWordBreaker);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!InitializeEventTable())
+ return NS_ERROR_FAILURE;
+
+ if (!sEventListenerManagersHash) {
+ static const PLDHashTableOps hash_table_ops =
+ {
+ PLDHashTable::HashVoidPtrKeyStub,
+ PLDHashTable::MatchEntryStub,
+ PLDHashTable::MoveEntryStub,
+ EventListenerManagerHashClearEntry,
+ EventListenerManagerHashInitEntry
+ };
+
+ sEventListenerManagersHash =
+ new PLDHashTable(&hash_table_ops, sizeof(EventListenerManagerMapEntry));
+
+ RegisterStrongMemoryReporter(new DOMEventListenerManagersHashReporter());
+ }
+
+ sBlockedScriptRunners = new AutoTArray<nsCOMPtr<nsIRunnable>, 8>;
+
+ Preferences::AddBoolVarCache(&sAllowXULXBL_for_file,
+ "dom.allow_XUL_XBL_for_file");
+
+ Preferences::AddBoolVarCache(&sIsFullScreenApiEnabled,
+ "full-screen-api.enabled");
+
+ Preferences::AddBoolVarCache(&sIsUnprefixedFullscreenApiEnabled,
+ "full-screen-api.unprefix.enabled");
+
+ Preferences::AddBoolVarCache(&sTrustedFullScreenOnly,
+ "full-screen-api.allow-trusted-requests-only");
+
+ Preferences::AddBoolVarCache(&sIsCutCopyAllowed,
+ "dom.allow_cut_copy", true);
+
+ Preferences::AddBoolVarCache(&sIsPerformanceTimingEnabled,
+ "dom.enable_performance", true);
+
+ Preferences::AddBoolVarCache(&sIsResourceTimingEnabled,
+ "dom.enable_resource_timing", true);
+
+ Preferences::AddBoolVarCache(&sIsUserTimingLoggingEnabled,
+ "dom.performance.enable_user_timing_logging", false);
+
+ Preferences::AddBoolVarCache(&sIsFrameTimingPrefEnabled,
+ "dom.enable_frame_timing", false);
+
+ Preferences::AddBoolVarCache(&sIsExperimentalAutocompleteEnabled,
+ "dom.forms.autocomplete.experimental", false);
+
+ Preferences::AddBoolVarCache(&sEncodeDecodeURLHash,
+ "dom.url.encode_decode_hash", false);
+
+ Preferences::AddBoolVarCache(&sGettersDecodeURLHash,
+ "dom.url.getters_decode_hash", false);
+
+ Preferences::AddBoolVarCache(&sPrivacyResistFingerprinting,
+ "privacy.resistFingerprinting", false);
+
+ Preferences::AddUintVarCache(&sHandlingInputTimeout,
+ "dom.event.handling-user-input-time-limit",
+ 1000);
+
+ Preferences::AddBoolVarCache(&sSendPerformanceTimingNotifications,
+ "dom.performance.enable_notify_performance_timing", false);
+
+ Preferences::AddUintVarCache(&sCookiesLifetimePolicy,
+ "network.cookie.lifetimePolicy",
+ nsICookieService::ACCEPT_NORMALLY);
+
+ Preferences::AddUintVarCache(&sCookiesBehavior,
+ "network.cookie.cookieBehavior",
+ nsICookieService::BEHAVIOR_ACCEPT);
+
+#if !(defined(DEBUG) || defined(MOZ_ENABLE_JS_DUMP))
+ Preferences::AddBoolVarCache(&sDOMWindowDumpEnabled,
+ "browser.dom.window.dump.enabled");
+#endif
+
+ Preferences::AddBoolVarCache(&sDoNotTrackEnabled,
+ "privacy.donottrackheader.enabled", false);
+
+ Preferences::AddBoolVarCache(&sUseActivityCursor,
+ "ui.use_activity_cursor", false);
+
+ Element::InitCCCallbacks();
+
+ nsCOMPtr<nsIUUIDGenerator> uuidGenerator =
+ do_GetService("@mozilla.org/uuid-generator;1", &rv);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+ uuidGenerator.forget(&sUUIDGenerator);
+
+ sInitialized = true;
+
+ return NS_OK;
+}
+
+void
+nsContentUtils::GetShiftText(nsAString& text)
+{
+ if (!sShiftText)
+ InitializeModifierStrings();
+ text.Assign(*sShiftText);
+}
+
+void
+nsContentUtils::GetControlText(nsAString& text)
+{
+ if (!sControlText)
+ InitializeModifierStrings();
+ text.Assign(*sControlText);
+}
+
+void
+nsContentUtils::GetMetaText(nsAString& text)
+{
+ if (!sMetaText)
+ InitializeModifierStrings();
+ text.Assign(*sMetaText);
+}
+
+void
+nsContentUtils::GetOSText(nsAString& text)
+{
+ if (!sOSText) {
+ InitializeModifierStrings();
+ }
+ text.Assign(*sOSText);
+}
+
+void
+nsContentUtils::GetAltText(nsAString& text)
+{
+ if (!sAltText)
+ InitializeModifierStrings();
+ text.Assign(*sAltText);
+}
+
+void
+nsContentUtils::GetModifierSeparatorText(nsAString& text)
+{
+ if (!sModifierSeparator)
+ InitializeModifierStrings();
+ text.Assign(*sModifierSeparator);
+}
+
+void
+nsContentUtils::InitializeModifierStrings()
+{
+ //load the display strings for the keyboard accelerators
+ nsCOMPtr<nsIStringBundleService> bundleService =
+ mozilla::services::GetStringBundleService();
+ nsCOMPtr<nsIStringBundle> bundle;
+ DebugOnly<nsresult> rv = NS_OK;
+ if (bundleService) {
+ rv = bundleService->CreateBundle( "chrome://global-platform/locale/platformKeys.properties",
+ getter_AddRefs(bundle));
+ }
+
+ NS_ASSERTION(NS_SUCCEEDED(rv) && bundle, "chrome://global/locale/platformKeys.properties could not be loaded");
+ nsXPIDLString shiftModifier;
+ nsXPIDLString metaModifier;
+ nsXPIDLString osModifier;
+ nsXPIDLString altModifier;
+ nsXPIDLString controlModifier;
+ nsXPIDLString modifierSeparator;
+ if (bundle) {
+ //macs use symbols for each modifier key, so fetch each from the bundle, which also covers i18n
+ bundle->GetStringFromName(u"VK_SHIFT", getter_Copies(shiftModifier));
+ bundle->GetStringFromName(u"VK_META", getter_Copies(metaModifier));
+ bundle->GetStringFromName(u"VK_WIN", getter_Copies(osModifier));
+ bundle->GetStringFromName(u"VK_ALT", getter_Copies(altModifier));
+ bundle->GetStringFromName(u"VK_CONTROL", getter_Copies(controlModifier));
+ bundle->GetStringFromName(u"MODIFIER_SEPARATOR", getter_Copies(modifierSeparator));
+ }
+ //if any of these don't exist, we get an empty string
+ sShiftText = new nsString(shiftModifier);
+ sMetaText = new nsString(metaModifier);
+ sOSText = new nsString(osModifier);
+ sAltText = new nsString(altModifier);
+ sControlText = new nsString(controlModifier);
+ sModifierSeparator = new nsString(modifierSeparator);
+}
+
+// Because of SVG/SMIL we have several atoms mapped to the same
+// id, but we can rely on MESSAGE_TO_EVENT to map id to only one atom.
+static bool
+ShouldAddEventToStringEventTable(const EventNameMapping& aMapping)
+{
+ switch(aMapping.mMessage) {
+#define MESSAGE_TO_EVENT(name_, message_, type_, struct_) \
+ case message_: return nsGkAtoms::on##name_ == aMapping.mAtom;
+#include "mozilla/EventNameList.h"
+#undef MESSAGE_TO_EVENT
+ default:
+ break;
+ }
+ return false;
+}
+
+bool
+nsContentUtils::InitializeEventTable() {
+ NS_ASSERTION(!sAtomEventTable, "EventTable already initialized!");
+ NS_ASSERTION(!sStringEventTable, "EventTable already initialized!");
+
+ static const EventNameMapping eventArray[] = {
+#define EVENT(name_, _message, _type, _class) \
+ { nsGkAtoms::on##name_, _type, _message, _class, false },
+#define WINDOW_ONLY_EVENT EVENT
+#define NON_IDL_EVENT EVENT
+#include "mozilla/EventNameList.h"
+#undef WINDOW_ONLY_EVENT
+#undef NON_IDL_EVENT
+#undef EVENT
+ { nullptr }
+ };
+
+ sAtomEventTable = new nsDataHashtable<nsISupportsHashKey, EventNameMapping>(
+ ArrayLength(eventArray));
+ sStringEventTable = new nsDataHashtable<nsStringHashKey, EventNameMapping>(
+ ArrayLength(eventArray));
+ sUserDefinedEvents = new nsCOMArray<nsIAtom>(64);
+
+ // Subtract one from the length because of the trailing null
+ for (uint32_t i = 0; i < ArrayLength(eventArray) - 1; ++i) {
+ sAtomEventTable->Put(eventArray[i].mAtom, eventArray[i]);
+ if (ShouldAddEventToStringEventTable(eventArray[i])) {
+ sStringEventTable->Put(
+ Substring(nsDependentAtomString(eventArray[i].mAtom), 2),
+ eventArray[i]);
+ }
+ }
+
+ return true;
+}
+
+void
+nsContentUtils::InitializeTouchEventTable()
+{
+ static bool sEventTableInitialized = false;
+ if (!sEventTableInitialized && sAtomEventTable && sStringEventTable) {
+ sEventTableInitialized = true;
+ static const EventNameMapping touchEventArray[] = {
+#define EVENT(name_, _message, _type, _class)
+#define TOUCH_EVENT(name_, _message, _type, _class) \
+ { nsGkAtoms::on##name_, _type, _message, _class },
+#include "mozilla/EventNameList.h"
+#undef TOUCH_EVENT
+#undef EVENT
+ { nullptr }
+ };
+ // Subtract one from the length because of the trailing null
+ for (uint32_t i = 0; i < ArrayLength(touchEventArray) - 1; ++i) {
+ sAtomEventTable->Put(touchEventArray[i].mAtom, touchEventArray[i]);
+ sStringEventTable->Put(Substring(nsDependentAtomString(touchEventArray[i].mAtom), 2),
+ touchEventArray[i]);
+ }
+ }
+}
+
+static bool
+Is8bit(const nsAString& aString)
+{
+ static const char16_t EIGHT_BIT = char16_t(~0x00FF);
+
+ for (nsAString::const_char_iterator start = aString.BeginReading(),
+ end = aString.EndReading();
+ start != end;
+ ++start) {
+ if (*start & EIGHT_BIT) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+nsresult
+nsContentUtils::Btoa(const nsAString& aBinaryData,
+ nsAString& aAsciiBase64String)
+{
+ if (!Is8bit(aBinaryData)) {
+ aAsciiBase64String.Truncate();
+ return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
+ }
+
+ return Base64Encode(aBinaryData, aAsciiBase64String);
+}
+
+nsresult
+nsContentUtils::Atob(const nsAString& aAsciiBase64String,
+ nsAString& aBinaryData)
+{
+ if (!Is8bit(aAsciiBase64String)) {
+ aBinaryData.Truncate();
+ return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
+ }
+
+ const char16_t* start = aAsciiBase64String.BeginReading();
+ const char16_t* end = aAsciiBase64String.EndReading();
+ nsString trimmedString;
+ if (!trimmedString.SetCapacity(aAsciiBase64String.Length(), fallible)) {
+ return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
+ }
+ while (start < end) {
+ if (!nsContentUtils::IsHTMLWhitespace(*start)) {
+ trimmedString.Append(*start);
+ }
+ start++;
+ }
+ nsresult rv = Base64Decode(trimmedString, aBinaryData);
+ if (NS_FAILED(rv) && rv == NS_ERROR_INVALID_ARG) {
+ return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
+ }
+ return rv;
+}
+
+bool
+nsContentUtils::IsAutocompleteEnabled(nsIDOMHTMLInputElement* aInput)
+{
+ NS_PRECONDITION(aInput, "aInput should not be null!");
+
+ nsAutoString autocomplete;
+ aInput->GetAutocomplete(autocomplete);
+
+ if (autocomplete.IsEmpty()) {
+ nsCOMPtr<nsIDOMHTMLFormElement> form;
+ aInput->GetForm(getter_AddRefs(form));
+ if (!form) {
+ return true;
+ }
+
+ form->GetAutocomplete(autocomplete);
+ }
+
+ return !autocomplete.EqualsLiteral("off");
+}
+
+nsContentUtils::AutocompleteAttrState
+nsContentUtils::SerializeAutocompleteAttribute(const nsAttrValue* aAttr,
+ nsAString& aResult,
+ AutocompleteAttrState aCachedState)
+{
+ if (!aAttr ||
+ aCachedState == nsContentUtils::eAutocompleteAttrState_Invalid) {
+ return aCachedState;
+ }
+
+ if (aCachedState == nsContentUtils::eAutocompleteAttrState_Valid) {
+ uint32_t atomCount = aAttr->GetAtomCount();
+ for (uint32_t i = 0; i < atomCount; i++) {
+ if (i != 0) {
+ aResult.Append(' ');
+ }
+ aResult.Append(nsDependentAtomString(aAttr->AtomAt(i)));
+ }
+ nsContentUtils::ASCIIToLower(aResult);
+ return aCachedState;
+ }
+
+ aResult.Truncate();
+
+ mozilla::dom::AutocompleteInfo info;
+ AutocompleteAttrState state =
+ InternalSerializeAutocompleteAttribute(aAttr, info);
+ if (state == eAutocompleteAttrState_Valid) {
+ // Concatenate the info fields.
+ aResult = info.mSection;
+
+ if (!info.mAddressType.IsEmpty()) {
+ if (!aResult.IsEmpty()) {
+ aResult += ' ';
+ }
+ aResult += info.mAddressType;
+ }
+
+ if (!info.mContactType.IsEmpty()) {
+ if (!aResult.IsEmpty()) {
+ aResult += ' ';
+ }
+ aResult += info.mContactType;
+ }
+
+ if (!info.mFieldName.IsEmpty()) {
+ if (!aResult.IsEmpty()) {
+ aResult += ' ';
+ }
+ aResult += info.mFieldName;
+ }
+ }
+
+ return state;
+}
+
+nsContentUtils::AutocompleteAttrState
+nsContentUtils::SerializeAutocompleteAttribute(const nsAttrValue* aAttr,
+ mozilla::dom::AutocompleteInfo& aInfo,
+ AutocompleteAttrState aCachedState)
+{
+ if (!aAttr ||
+ aCachedState == nsContentUtils::eAutocompleteAttrState_Invalid) {
+ return aCachedState;
+ }
+
+ return InternalSerializeAutocompleteAttribute(aAttr, aInfo);
+}
+
+/**
+ * Helper to validate the @autocomplete tokens.
+ *
+ * @return {AutocompleteAttrState} The state of the attribute (invalid/valid).
+ */
+nsContentUtils::AutocompleteAttrState
+nsContentUtils::InternalSerializeAutocompleteAttribute(const nsAttrValue* aAttrVal,
+ mozilla::dom::AutocompleteInfo& aInfo)
+{
+ // No sandbox attribute so we are done
+ if (!aAttrVal) {
+ return eAutocompleteAttrState_Invalid;
+ }
+
+ uint32_t numTokens = aAttrVal->GetAtomCount();
+ if (!numTokens) {
+ return eAutocompleteAttrState_Invalid;
+ }
+
+ uint32_t index = numTokens - 1;
+ nsString tokenString = nsDependentAtomString(aAttrVal->AtomAt(index));
+ AutocompleteCategory category;
+ nsAttrValue enumValue;
+
+ nsAutoString str;
+ bool result = enumValue.ParseEnumValue(tokenString, kAutocompleteFieldNameTable, false);
+ if (result) {
+ // Off/Automatic/Normal categories.
+ if (enumValue.Equals(NS_LITERAL_STRING("off"), eIgnoreCase) ||
+ enumValue.Equals(NS_LITERAL_STRING("on"), eIgnoreCase)) {
+ if (numTokens > 1) {
+ return eAutocompleteAttrState_Invalid;
+ }
+ enumValue.ToString(str);
+ ASCIIToLower(str);
+ aInfo.mFieldName.Assign(str);
+ return eAutocompleteAttrState_Valid;
+ }
+
+ // Only allow on/off if experimental @autocomplete values aren't enabled.
+ if (!sIsExperimentalAutocompleteEnabled) {
+ return eAutocompleteAttrState_Invalid;
+ }
+
+ // Normal category
+ if (numTokens > 2) {
+ return eAutocompleteAttrState_Invalid;
+ }
+ category = eAutocompleteCategory_NORMAL;
+ } else { // Check if the last token is of the contact category instead.
+ // Only allow on/off if experimental @autocomplete values aren't enabled.
+ if (!sIsExperimentalAutocompleteEnabled) {
+ return eAutocompleteAttrState_Invalid;
+ }
+
+ result = enumValue.ParseEnumValue(tokenString, kAutocompleteContactFieldNameTable, false);
+ if (!result || numTokens > 3) {
+ return eAutocompleteAttrState_Invalid;
+ }
+
+ category = eAutocompleteCategory_CONTACT;
+ }
+
+ enumValue.ToString(str);
+ ASCIIToLower(str);
+ aInfo.mFieldName.Assign(str);
+
+ // We are done if this was the only token.
+ if (numTokens == 1) {
+ return eAutocompleteAttrState_Valid;
+ }
+
+ --index;
+ tokenString = nsDependentAtomString(aAttrVal->AtomAt(index));
+
+ if (category == eAutocompleteCategory_CONTACT) {
+ nsAttrValue contactFieldHint;
+ result = contactFieldHint.ParseEnumValue(tokenString, kAutocompleteContactFieldHintTable, false);
+ if (result) {
+ nsAutoString contactFieldHintString;
+ contactFieldHint.ToString(contactFieldHintString);
+ ASCIIToLower(contactFieldHintString);
+ aInfo.mContactType.Assign(contactFieldHintString);
+ if (index == 0) {
+ return eAutocompleteAttrState_Valid;
+ }
+ --index;
+ tokenString = nsDependentAtomString(aAttrVal->AtomAt(index));
+ }
+ }
+
+ // Check for billing/shipping tokens
+ nsAttrValue fieldHint;
+ if (fieldHint.ParseEnumValue(tokenString, kAutocompleteFieldHintTable, false)) {
+ nsString fieldHintString;
+ fieldHint.ToString(fieldHintString);
+ ASCIIToLower(fieldHintString);
+ aInfo.mAddressType.Assign(fieldHintString);
+ if (index == 0) {
+ return eAutocompleteAttrState_Valid;
+ }
+ --index;
+ }
+
+ // Clear the fields as the autocomplete attribute is invalid.
+ aInfo.mAddressType.Truncate();
+ aInfo.mContactType.Truncate();
+ aInfo.mFieldName.Truncate();
+
+ return eAutocompleteAttrState_Invalid;
+}
+
+// Parse an integer according to HTML spec
+int32_t
+nsContentUtils::ParseHTMLInteger(const nsAString& aValue,
+ ParseHTMLIntegerResultFlags *aResult)
+{
+ int result = eParseHTMLInteger_NoFlags;
+
+ nsAString::const_iterator iter, end;
+ aValue.BeginReading(iter);
+ aValue.EndReading(end);
+
+ while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
+ result |= eParseHTMLInteger_NonStandard;
+ ++iter;
+ }
+
+ if (iter == end) {
+ result |= eParseHTMLInteger_Error | eParseHTMLInteger_ErrorNoValue;
+ *aResult = (ParseHTMLIntegerResultFlags)result;
+ return 0;
+ }
+
+ int sign = 1;
+ if (*iter == char16_t('-')) {
+ sign = -1;
+ ++iter;
+ } else if (*iter == char16_t('+')) {
+ result |= eParseHTMLInteger_NonStandard;
+ ++iter;
+ }
+
+ bool foundValue = false;
+ CheckedInt32 value = 0;
+
+ // Check for leading zeros first.
+ uint64_t leadingZeros = 0;
+ while (iter != end) {
+ if (*iter != char16_t('0')) {
+ break;
+ }
+
+ ++leadingZeros;
+ foundValue = true;
+ ++iter;
+ }
+
+ while (iter != end) {
+ if (*iter >= char16_t('0') && *iter <= char16_t('9')) {
+ value = (value * 10) + (*iter - char16_t('0')) * sign;
+ ++iter;
+ if (!value.isValid()) {
+ result |= eParseHTMLInteger_Error | eParseHTMLInteger_ErrorOverflow;
+ break;
+ } else {
+ foundValue = true;
+ }
+ } else if (*iter == char16_t('%')) {
+ ++iter;
+ result |= eParseHTMLInteger_IsPercent;
+ break;
+ } else {
+ break;
+ }
+ }
+
+ if (!foundValue) {
+ result |= eParseHTMLInteger_Error | eParseHTMLInteger_ErrorNoValue;
+ }
+
+ if (value.isValid() &&
+ ((leadingZeros > 1 || (leadingZeros == 1 && !(value == 0))) ||
+ (sign == -1 && value == 0))) {
+ result |= eParseHTMLInteger_NonStandard;
+ }
+
+ if (iter != end) {
+ result |= eParseHTMLInteger_DidNotConsumeAllInput;
+ }
+
+ *aResult = (ParseHTMLIntegerResultFlags)result;
+ return value.isValid() ? value.value() : 0;
+}
+
+#define SKIP_WHITESPACE(iter, end_iter, end_res) \
+ while ((iter) != (end_iter) && nsCRT::IsAsciiSpace(*(iter))) { \
+ ++(iter); \
+ } \
+ if ((iter) == (end_iter)) { \
+ return (end_res); \
+ }
+
+#define SKIP_ATTR_NAME(iter, end_iter) \
+ while ((iter) != (end_iter) && !nsCRT::IsAsciiSpace(*(iter)) && \
+ *(iter) != '=') { \
+ ++(iter); \
+ }
+
+bool
+nsContentUtils::GetPseudoAttributeValue(const nsString& aSource, nsIAtom *aName,
+ nsAString& aValue)
+{
+ aValue.Truncate();
+
+ const char16_t *start = aSource.get();
+ const char16_t *end = start + aSource.Length();
+ const char16_t *iter;
+
+ while (start != end) {
+ SKIP_WHITESPACE(start, end, false)
+ iter = start;
+ SKIP_ATTR_NAME(iter, end)
+
+ if (start == iter) {
+ return false;
+ }
+
+ // Remember the attr name.
+ const nsDependentSubstring & attrName = Substring(start, iter);
+
+ // Now check whether this is a valid name="value" pair.
+ start = iter;
+ SKIP_WHITESPACE(start, end, false)
+ if (*start != '=') {
+ // No '=', so this is not a name="value" pair. We don't know
+ // what it is, and we have no way to handle it.
+ return false;
+ }
+
+ // Have to skip the value.
+ ++start;
+ SKIP_WHITESPACE(start, end, false)
+ char16_t q = *start;
+ if (q != kQuote && q != kApostrophe) {
+ // Not a valid quoted value, so bail.
+ return false;
+ }
+
+ ++start; // Point to the first char of the value.
+ iter = start;
+
+ while (iter != end && *iter != q) {
+ ++iter;
+ }
+
+ if (iter == end) {
+ // Oops, unterminated quoted string.
+ return false;
+ }
+
+ // At this point attrName holds the name of the "attribute" and
+ // the value is between start and iter.
+
+ if (aName->Equals(attrName)) {
+ // We'll accumulate as many characters as possible (until we hit either
+ // the end of the string or the beginning of an entity). Chunks will be
+ // delimited by start and chunkEnd.
+ const char16_t *chunkEnd = start;
+ while (chunkEnd != iter) {
+ if (*chunkEnd == kLessThan) {
+ aValue.Truncate();
+
+ return false;
+ }
+
+ if (*chunkEnd == kAmpersand) {
+ aValue.Append(start, chunkEnd - start);
+
+ const char16_t *afterEntity = nullptr;
+ char16_t result[2];
+ uint32_t count =
+ MOZ_XMLTranslateEntity(reinterpret_cast<const char*>(chunkEnd),
+ reinterpret_cast<const char*>(iter),
+ reinterpret_cast<const char**>(&afterEntity),
+ result);
+ if (count == 0) {
+ aValue.Truncate();
+
+ return false;
+ }
+
+ aValue.Append(result, count);
+
+ // Advance to after the entity and begin a new chunk.
+ start = chunkEnd = afterEntity;
+ }
+ else {
+ ++chunkEnd;
+ }
+ }
+
+ // Append remainder.
+ aValue.Append(start, iter - start);
+
+ return true;
+ }
+
+ // Resume scanning after the end of the attribute value (past the quote
+ // char).
+ start = iter + 1;
+ }
+
+ return false;
+}
+
+bool
+nsContentUtils::IsJavaScriptLanguage(const nsString& aName)
+{
+ return aName.LowerCaseEqualsLiteral("javascript") ||
+ aName.LowerCaseEqualsLiteral("livescript") ||
+ aName.LowerCaseEqualsLiteral("mocha") ||
+ aName.LowerCaseEqualsLiteral("javascript1.0") ||
+ aName.LowerCaseEqualsLiteral("javascript1.1") ||
+ aName.LowerCaseEqualsLiteral("javascript1.2") ||
+ aName.LowerCaseEqualsLiteral("javascript1.3") ||
+ aName.LowerCaseEqualsLiteral("javascript1.4") ||
+ aName.LowerCaseEqualsLiteral("javascript1.5");
+}
+
+JSVersion
+nsContentUtils::ParseJavascriptVersion(const nsAString& aVersionStr)
+{
+ if (aVersionStr.Length() != 3 || aVersionStr[0] != '1' ||
+ aVersionStr[1] != '.') {
+ return JSVERSION_UNKNOWN;
+ }
+
+ switch (aVersionStr[2]) {
+ case '0': /* fall through */
+ case '1': /* fall through */
+ case '2': /* fall through */
+ case '3': /* fall through */
+ case '4': /* fall through */
+ case '5': return JSVERSION_DEFAULT;
+ case '6': return JSVERSION_1_6;
+ case '7': return JSVERSION_1_7;
+ case '8': return JSVERSION_1_8;
+ default: return JSVERSION_UNKNOWN;
+ }
+}
+
+void
+nsContentUtils::SplitMimeType(const nsAString& aValue, nsString& aType,
+ nsString& aParams)
+{
+ aType.Truncate();
+ aParams.Truncate();
+ int32_t semiIndex = aValue.FindChar(char16_t(';'));
+ if (-1 != semiIndex) {
+ aType = Substring(aValue, 0, semiIndex);
+ aParams = Substring(aValue, semiIndex + 1,
+ aValue.Length() - (semiIndex + 1));
+ aParams.StripWhitespace();
+ }
+ else {
+ aType = aValue;
+ }
+ aType.StripWhitespace();
+}
+
+nsresult
+nsContentUtils::IsUserIdle(uint32_t aRequestedIdleTimeInMS, bool* aUserIsIdle)
+{
+ nsresult rv;
+ nsCOMPtr<nsIIdleService> idleService =
+ do_GetService("@mozilla.org/widget/idleservice;1", &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ uint32_t idleTimeInMS;
+ rv = idleService->GetIdleTime(&idleTimeInMS);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *aUserIsIdle = idleTimeInMS >= aRequestedIdleTimeInMS;
+ return NS_OK;
+}
+
+/**
+ * Access a cached parser service. Don't addref. We need only one
+ * reference to it and this class has that one.
+ */
+/* static */
+nsIParserService*
+nsContentUtils::GetParserService()
+{
+ // XXX: This isn't accessed from several threads, is it?
+ if (!sParserService) {
+ // Lock, recheck sCachedParserService and aquire if this should be
+ // safe for multiple threads.
+ nsresult rv = CallGetService(kParserServiceCID, &sParserService);
+ if (NS_FAILED(rv)) {
+ sParserService = nullptr;
+ }
+ }
+
+ return sParserService;
+}
+
+/**
+* A helper function that parses a sandbox attribute (of an <iframe> or a CSP
+* directive) and converts it to the set of flags used internally.
+*
+* @param aSandboxAttr the sandbox attribute
+* @return the set of flags (SANDBOXED_NONE if aSandboxAttr is
+* null)
+*/
+uint32_t
+nsContentUtils::ParseSandboxAttributeToFlags(const nsAttrValue* aSandboxAttr)
+{
+ if (!aSandboxAttr) {
+ return SANDBOXED_NONE;
+ }
+
+ uint32_t out = SANDBOX_ALL_FLAGS;
+
+#define SANDBOX_KEYWORD(string, atom, flags) \
+ if (aSandboxAttr->Contains(nsGkAtoms::atom, eIgnoreCase)) { \
+ out &= ~(flags); \
+ }
+#include "IframeSandboxKeywordList.h"
+#undef SANDBOX_KEYWORD
+
+ return out;
+}
+
+/**
+* A helper function that checks if a string matches a valid sandbox flag.
+*
+* @param aFlag the potential sandbox flag.
+* @return true if the flag is a sandbox flag.
+*/
+bool
+nsContentUtils::IsValidSandboxFlag(const nsAString& aFlag)
+{
+#define SANDBOX_KEYWORD(string, atom, flags) \
+ if (EqualsIgnoreASCIICase(nsDependentAtomString(nsGkAtoms::atom), aFlag)) { \
+ return true; \
+ }
+#include "IframeSandboxKeywordList.h"
+#undef SANDBOX_KEYWORD
+ return false;
+}
+
+/**
+ * A helper function that returns a string attribute corresponding to the
+ * sandbox flags.
+ *
+ * @param aFlags the sandbox flags
+ * @param aString the attribute corresponding to the flags (null if aFlags
+ * is zero)
+ */
+void
+nsContentUtils::SandboxFlagsToString(uint32_t aFlags, nsAString& aString)
+{
+ if (!aFlags) {
+ SetDOMStringToNull(aString);
+ return;
+ }
+
+ aString.Truncate();
+
+#define SANDBOX_KEYWORD(string, atom, flags) \
+ if (!(aFlags & (flags))) { \
+ if (!aString.IsEmpty()) { \
+ aString.Append(NS_LITERAL_STRING(" ")); \
+ } \
+ aString.Append(nsDependentAtomString(nsGkAtoms::atom)); \
+ }
+#include "IframeSandboxKeywordList.h"
+#undef SANDBOX_KEYWORD
+}
+
+nsIBidiKeyboard*
+nsContentUtils::GetBidiKeyboard()
+{
+ if (!sBidiKeyboard) {
+ nsresult rv = CallGetService("@mozilla.org/widget/bidikeyboard;1", &sBidiKeyboard);
+ if (NS_FAILED(rv)) {
+ sBidiKeyboard = nullptr;
+ }
+ }
+ return sBidiKeyboard;
+}
+
+template <class OutputIterator>
+struct NormalizeNewlinesCharTraits {
+ public:
+ typedef typename OutputIterator::value_type value_type;
+
+ public:
+ explicit NormalizeNewlinesCharTraits(OutputIterator& aIterator) : mIterator(aIterator) { }
+ void writechar(typename OutputIterator::value_type aChar) {
+ *mIterator++ = aChar;
+ }
+
+ private:
+ OutputIterator mIterator;
+};
+
+template <class CharT>
+struct NormalizeNewlinesCharTraits<CharT*> {
+ public:
+ typedef CharT value_type;
+
+ public:
+ explicit NormalizeNewlinesCharTraits(CharT* aCharPtr) : mCharPtr(aCharPtr) { }
+ void writechar(CharT aChar) {
+ *mCharPtr++ = aChar;
+ }
+
+ private:
+ CharT* mCharPtr;
+};
+
+template <class OutputIterator>
+class CopyNormalizeNewlines
+{
+ public:
+ typedef typename OutputIterator::value_type value_type;
+
+ public:
+ explicit CopyNormalizeNewlines(OutputIterator* aDestination,
+ bool aLastCharCR = false) :
+ mLastCharCR(aLastCharCR),
+ mDestination(aDestination),
+ mWritten(0)
+ { }
+
+ uint32_t GetCharsWritten() {
+ return mWritten;
+ }
+
+ bool IsLastCharCR() {
+ return mLastCharCR;
+ }
+
+ void write(const typename OutputIterator::value_type* aSource, uint32_t aSourceLength) {
+
+ const typename OutputIterator::value_type* done_writing = aSource + aSourceLength;
+
+ // If the last source buffer ended with a CR...
+ if (mLastCharCR) {
+ // ..and if the next one is a LF, then skip it since
+ // we've already written out a newline
+ if (aSourceLength && (*aSource == value_type('\n'))) {
+ ++aSource;
+ }
+ mLastCharCR = false;
+ }
+
+ uint32_t num_written = 0;
+ while ( aSource < done_writing ) {
+ if (*aSource == value_type('\r')) {
+ mDestination->writechar('\n');
+ ++aSource;
+ // If we've reached the end of the buffer, record
+ // that we wrote out a CR
+ if (aSource == done_writing) {
+ mLastCharCR = true;
+ }
+ // If the next character is a LF, skip it
+ else if (*aSource == value_type('\n')) {
+ ++aSource;
+ }
+ }
+ else {
+ mDestination->writechar(*aSource++);
+ }
+ ++num_written;
+ }
+
+ mWritten += num_written;
+ }
+
+ private:
+ bool mLastCharCR;
+ OutputIterator* mDestination;
+ uint32_t mWritten;
+};
+
+// static
+uint32_t
+nsContentUtils::CopyNewlineNormalizedUnicodeTo(const nsAString& aSource,
+ uint32_t aSrcOffset,
+ char16_t* aDest,
+ uint32_t aLength,
+ bool& aLastCharCR)
+{
+ typedef NormalizeNewlinesCharTraits<char16_t*> sink_traits;
+
+ sink_traits dest_traits(aDest);
+ CopyNormalizeNewlines<sink_traits> normalizer(&dest_traits,aLastCharCR);
+ nsReadingIterator<char16_t> fromBegin, fromEnd;
+ copy_string(aSource.BeginReading(fromBegin).advance( int32_t(aSrcOffset) ),
+ aSource.BeginReading(fromEnd).advance( int32_t(aSrcOffset+aLength) ),
+ normalizer);
+ aLastCharCR = normalizer.IsLastCharCR();
+ return normalizer.GetCharsWritten();
+}
+
+// static
+uint32_t
+nsContentUtils::CopyNewlineNormalizedUnicodeTo(nsReadingIterator<char16_t>& aSrcStart, const nsReadingIterator<char16_t>& aSrcEnd, nsAString& aDest)
+{
+ typedef nsWritingIterator<char16_t> WritingIterator;
+ typedef NormalizeNewlinesCharTraits<WritingIterator> sink_traits;
+
+ WritingIterator iter;
+ aDest.BeginWriting(iter);
+ sink_traits dest_traits(iter);
+ CopyNormalizeNewlines<sink_traits> normalizer(&dest_traits);
+ copy_string(aSrcStart, aSrcEnd, normalizer);
+ return normalizer.GetCharsWritten();
+}
+
+/**
+ * This is used to determine whether a character is in one of the classes
+ * which CSS says should be part of the first-letter. Currently, that is
+ * all punctuation classes (P*). Note that this is a change from CSS2
+ * which excluded Pc and Pd.
+ *
+ * https://www.w3.org/TR/css-pseudo-4/#first-letter-pseudo
+ * "Punctuation (i.e, characters that belong to the Punctuation (P*) Unicode
+ * general category [UAX44]) [...]"
+ */
+
+// static
+bool
+nsContentUtils::IsFirstLetterPunctuation(uint32_t aChar)
+{
+ switch (mozilla::unicode::GetGeneralCategory(aChar)) {
+ case HB_UNICODE_GENERAL_CATEGORY_CONNECT_PUNCTUATION: /* Pc */
+ case HB_UNICODE_GENERAL_CATEGORY_DASH_PUNCTUATION: /* Pd */
+ case HB_UNICODE_GENERAL_CATEGORY_CLOSE_PUNCTUATION: /* Pe */
+ case HB_UNICODE_GENERAL_CATEGORY_FINAL_PUNCTUATION: /* Pf */
+ case HB_UNICODE_GENERAL_CATEGORY_INITIAL_PUNCTUATION: /* Pi */
+ case HB_UNICODE_GENERAL_CATEGORY_OTHER_PUNCTUATION: /* Po */
+ case HB_UNICODE_GENERAL_CATEGORY_OPEN_PUNCTUATION: /* Ps */
+ return true;
+ default:
+ return false;
+ }
+}
+
+// static
+bool
+nsContentUtils::IsFirstLetterPunctuationAt(const nsTextFragment* aFrag, uint32_t aOffset)
+{
+ char16_t h = aFrag->CharAt(aOffset);
+ if (!IS_SURROGATE(h)) {
+ return IsFirstLetterPunctuation(h);
+ }
+ if (NS_IS_HIGH_SURROGATE(h) && aOffset + 1 < aFrag->GetLength()) {
+ char16_t l = aFrag->CharAt(aOffset + 1);
+ if (NS_IS_LOW_SURROGATE(l)) {
+ return IsFirstLetterPunctuation(SURROGATE_TO_UCS4(h, l));
+ }
+ }
+ return false;
+}
+
+// static
+bool nsContentUtils::IsAlphanumeric(uint32_t aChar)
+{
+ nsIUGenCategory::nsUGenCategory cat = mozilla::unicode::GetGenCategory(aChar);
+
+ return (cat == nsIUGenCategory::kLetter || cat == nsIUGenCategory::kNumber);
+}
+
+// static
+bool nsContentUtils::IsAlphanumericAt(const nsTextFragment* aFrag, uint32_t aOffset)
+{
+ char16_t h = aFrag->CharAt(aOffset);
+ if (!IS_SURROGATE(h)) {
+ return IsAlphanumeric(h);
+ }
+ if (NS_IS_HIGH_SURROGATE(h) && aOffset + 1 < aFrag->GetLength()) {
+ char16_t l = aFrag->CharAt(aOffset + 1);
+ if (NS_IS_LOW_SURROGATE(l)) {
+ return IsAlphanumeric(SURROGATE_TO_UCS4(h, l));
+ }
+ }
+ return false;
+}
+
+/* static */
+bool
+nsContentUtils::IsHTMLWhitespace(char16_t aChar)
+{
+ return aChar == char16_t(0x0009) ||
+ aChar == char16_t(0x000A) ||
+ aChar == char16_t(0x000C) ||
+ aChar == char16_t(0x000D) ||
+ aChar == char16_t(0x0020);
+}
+
+/* static */
+bool
+nsContentUtils::IsHTMLWhitespaceOrNBSP(char16_t aChar)
+{
+ return IsHTMLWhitespace(aChar) || aChar == char16_t(0xA0);
+}
+
+/* static */
+bool
+nsContentUtils::IsHTMLBlock(nsIContent* aContent)
+{
+ return aContent->IsAnyOfHTMLElements(nsGkAtoms::address,
+ nsGkAtoms::article,
+ nsGkAtoms::aside,
+ nsGkAtoms::blockquote,
+ nsGkAtoms::center,
+ nsGkAtoms::dir,
+ nsGkAtoms::div,
+ nsGkAtoms::dl, // XXX why not dt and dd?
+ nsGkAtoms::fieldset,
+ nsGkAtoms::figure, // XXX shouldn't figcaption be on this list
+ nsGkAtoms::footer,
+ nsGkAtoms::form,
+ nsGkAtoms::h1,
+ nsGkAtoms::h2,
+ nsGkAtoms::h3,
+ nsGkAtoms::h4,
+ nsGkAtoms::h5,
+ nsGkAtoms::h6,
+ nsGkAtoms::header,
+ nsGkAtoms::hgroup,
+ nsGkAtoms::hr,
+ nsGkAtoms::li,
+ nsGkAtoms::listing,
+ nsGkAtoms::menu,
+ nsGkAtoms::multicol, // XXX get rid of this one?
+ nsGkAtoms::nav,
+ nsGkAtoms::ol,
+ nsGkAtoms::p,
+ nsGkAtoms::pre,
+ nsGkAtoms::section,
+ nsGkAtoms::table,
+ nsGkAtoms::ul,
+ nsGkAtoms::xmp);
+}
+
+/* static */
+bool
+nsContentUtils::ParseIntMarginValue(const nsAString& aString, nsIntMargin& result)
+{
+ nsAutoString marginStr(aString);
+ marginStr.CompressWhitespace(true, true);
+ if (marginStr.IsEmpty()) {
+ return false;
+ }
+
+ int32_t start = 0, end = 0;
+ for (int count = 0; count < 4; count++) {
+ if ((uint32_t)end >= marginStr.Length())
+ return false;
+
+ // top, right, bottom, left
+ if (count < 3)
+ end = Substring(marginStr, start).FindChar(',');
+ else
+ end = Substring(marginStr, start).Length();
+
+ if (end <= 0)
+ return false;
+
+ nsresult ec;
+ int32_t val = nsString(Substring(marginStr, start, end)).ToInteger(&ec);
+ if (NS_FAILED(ec))
+ return false;
+
+ switch(count) {
+ case 0:
+ result.top = val;
+ break;
+ case 1:
+ result.right = val;
+ break;
+ case 2:
+ result.bottom = val;
+ break;
+ case 3:
+ result.left = val;
+ break;
+ }
+ start += end + 1;
+ }
+ return true;
+}
+
+// static
+int32_t
+nsContentUtils::ParseLegacyFontSize(const nsAString& aValue)
+{
+ nsAString::const_iterator iter, end;
+ aValue.BeginReading(iter);
+ aValue.EndReading(end);
+
+ while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
+ ++iter;
+ }
+
+ if (iter == end) {
+ return 0;
+ }
+
+ bool relative = false;
+ bool negate = false;
+ if (*iter == char16_t('-')) {
+ relative = true;
+ negate = true;
+ ++iter;
+ } else if (*iter == char16_t('+')) {
+ relative = true;
+ ++iter;
+ }
+
+ if (iter == end || *iter < char16_t('0') || *iter > char16_t('9')) {
+ return 0;
+ }
+
+ // We don't have to worry about overflow, since we can bail out as soon as
+ // we're bigger than 7.
+ int32_t value = 0;
+ while (iter != end && *iter >= char16_t('0') && *iter <= char16_t('9')) {
+ value = 10*value + (*iter - char16_t('0'));
+ if (value >= 7) {
+ break;
+ }
+ ++iter;
+ }
+
+ if (relative) {
+ if (negate) {
+ value = 3 - value;
+ } else {
+ value = 3 + value;
+ }
+ }
+
+ return clamped(value, 1, 7);
+}
+
+/* static */
+bool
+nsContentUtils::IsControlledByServiceWorker(nsIDocument* aDocument)
+{
+ if (nsContentUtils::IsInPrivateBrowsing(aDocument)) {
+ return false;
+ }
+
+ RefPtr<workers::ServiceWorkerManager> swm =
+ workers::ServiceWorkerManager::GetInstance();
+ MOZ_ASSERT(swm);
+
+ ErrorResult rv;
+ bool controlled = swm->IsControlled(aDocument, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ rv.SuppressException();
+ return false;
+ }
+
+ return controlled;
+}
+
+/* static */
+void
+nsContentUtils::GetOfflineAppManifest(nsIDocument *aDocument, nsIURI **aURI)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(aDocument);
+ *aURI = nullptr;
+
+ if (IsControlledByServiceWorker(aDocument)) {
+ return;
+ }
+
+ Element* docElement = aDocument->GetRootElement();
+ if (!docElement) {
+ return;
+ }
+
+ nsAutoString manifestSpec;
+ docElement->GetAttr(kNameSpaceID_None, nsGkAtoms::manifest, manifestSpec);
+
+ // Manifest URIs can't have fragment identifiers.
+ if (manifestSpec.IsEmpty() ||
+ manifestSpec.Contains('#')) {
+ return;
+ }
+
+ nsContentUtils::NewURIWithDocumentCharset(aURI, manifestSpec,
+ aDocument,
+ aDocument->GetDocBaseURI());
+}
+
+/* static */
+bool
+nsContentUtils::OfflineAppAllowed(nsIURI *aURI)
+{
+ nsCOMPtr<nsIOfflineCacheUpdateService> updateService =
+ do_GetService(NS_OFFLINECACHEUPDATESERVICE_CONTRACTID);
+ if (!updateService) {
+ return false;
+ }
+
+ bool allowed;
+ nsresult rv =
+ updateService->OfflineAppAllowedForURI(aURI,
+ Preferences::GetRootBranch(),
+ &allowed);
+ return NS_SUCCEEDED(rv) && allowed;
+}
+
+/* static */
+bool
+nsContentUtils::OfflineAppAllowed(nsIPrincipal *aPrincipal)
+{
+ nsCOMPtr<nsIOfflineCacheUpdateService> updateService =
+ do_GetService(NS_OFFLINECACHEUPDATESERVICE_CONTRACTID);
+ if (!updateService) {
+ return false;
+ }
+
+ bool allowed;
+ nsresult rv = updateService->OfflineAppAllowed(aPrincipal,
+ Preferences::GetRootBranch(),
+ &allowed);
+ return NS_SUCCEEDED(rv) && allowed;
+}
+
+bool
+nsContentUtils::MaybeAllowOfflineAppByDefault(nsIPrincipal *aPrincipal)
+{
+ if (!Preferences::GetRootBranch())
+ return false;
+
+ nsresult rv;
+
+ bool allowedByDefault;
+ rv = Preferences::GetRootBranch()->GetBoolPref(
+ "offline-apps.allow_by_default", &allowedByDefault);
+ if (NS_FAILED(rv))
+ return false;
+
+ if (!allowedByDefault)
+ return false;
+
+ nsCOMPtr<nsIOfflineCacheUpdateService> updateService =
+ do_GetService(NS_OFFLINECACHEUPDATESERVICE_CONTRACTID);
+ if (!updateService) {
+ return false;
+ }
+
+ rv = updateService->AllowOfflineApp(aPrincipal);
+ return NS_SUCCEEDED(rv);
+}
+
+// static
+void
+nsContentUtils::Shutdown()
+{
+ sInitialized = false;
+
+ NS_IF_RELEASE(sContentPolicyService);
+ sTriedToGetContentPolicy = false;
+ uint32_t i;
+ for (i = 0; i < PropertiesFile_COUNT; ++i)
+ NS_IF_RELEASE(sStringBundles[i]);
+
+ NS_IF_RELEASE(sStringBundleService);
+ NS_IF_RELEASE(sConsoleService);
+ sXPConnect = nullptr;
+ NS_IF_RELEASE(sSecurityManager);
+ NS_IF_RELEASE(sSystemPrincipal);
+ NS_IF_RELEASE(sNullSubjectPrincipal);
+ NS_IF_RELEASE(sParserService);
+ NS_IF_RELEASE(sIOService);
+ NS_IF_RELEASE(sUUIDGenerator);
+ NS_IF_RELEASE(sLineBreaker);
+ NS_IF_RELEASE(sWordBreaker);
+ NS_IF_RELEASE(sBidiKeyboard);
+
+ delete sAtomEventTable;
+ sAtomEventTable = nullptr;
+ delete sStringEventTable;
+ sStringEventTable = nullptr;
+ delete sUserDefinedEvents;
+ sUserDefinedEvents = nullptr;
+
+ if (sEventListenerManagersHash) {
+ NS_ASSERTION(sEventListenerManagersHash->EntryCount() == 0,
+ "Event listener manager hash not empty at shutdown!");
+
+ // See comment above.
+
+ // However, we have to handle this table differently. If it still
+ // has entries, we want to leak it too, so that we can keep it alive
+ // in case any elements are destroyed. Because if they are, we need
+ // their event listener managers to be destroyed too, or otherwise
+ // it could leave dangling references in DOMClassInfo's preserved
+ // wrapper table.
+
+ if (sEventListenerManagersHash->EntryCount() == 0) {
+ delete sEventListenerManagersHash;
+ sEventListenerManagersHash = nullptr;
+ }
+ }
+
+ NS_ASSERTION(!sBlockedScriptRunners ||
+ sBlockedScriptRunners->Length() == 0,
+ "How'd this happen?");
+ delete sBlockedScriptRunners;
+ sBlockedScriptRunners = nullptr;
+
+ delete sShiftText;
+ sShiftText = nullptr;
+ delete sControlText;
+ sControlText = nullptr;
+ delete sMetaText;
+ sMetaText = nullptr;
+ delete sOSText;
+ sOSText = nullptr;
+ delete sAltText;
+ sAltText = nullptr;
+ delete sModifierSeparator;
+ sModifierSeparator = nullptr;
+
+ NS_IF_RELEASE(sSameOriginChecker);
+}
+
+/**
+ * Checks whether two nodes come from the same origin. aTrustedNode is
+ * considered 'safe' in that a user can operate on it and that it isn't
+ * a js-object that implements nsIDOMNode.
+ * Never call this function with the first node provided by script, it
+ * must always be known to be a 'real' node!
+ */
+// static
+nsresult
+nsContentUtils::CheckSameOrigin(const nsINode *aTrustedNode,
+ nsIDOMNode *aUnTrustedNode)
+{
+ MOZ_ASSERT(aTrustedNode);
+
+ // Make sure it's a real node.
+ nsCOMPtr<nsINode> unTrustedNode = do_QueryInterface(aUnTrustedNode);
+ NS_ENSURE_TRUE(unTrustedNode, NS_ERROR_UNEXPECTED);
+ return CheckSameOrigin(aTrustedNode, unTrustedNode);
+}
+
+nsresult
+nsContentUtils::CheckSameOrigin(const nsINode* aTrustedNode,
+ const nsINode* unTrustedNode)
+{
+ MOZ_ASSERT(aTrustedNode);
+ MOZ_ASSERT(unTrustedNode);
+
+ /*
+ * Get hold of each node's principal
+ */
+
+ nsIPrincipal* trustedPrincipal = aTrustedNode->NodePrincipal();
+ nsIPrincipal* unTrustedPrincipal = unTrustedNode->NodePrincipal();
+
+ if (trustedPrincipal == unTrustedPrincipal) {
+ return NS_OK;
+ }
+
+ bool equal;
+ // XXXbz should we actually have a Subsumes() check here instead? Or perhaps
+ // a separate method for that, with callers using one or the other?
+ if (NS_FAILED(trustedPrincipal->Equals(unTrustedPrincipal, &equal)) ||
+ !equal) {
+ return NS_ERROR_DOM_PROP_ACCESS_DENIED;
+ }
+
+ return NS_OK;
+}
+
+// static
+bool
+nsContentUtils::CanCallerAccess(nsIPrincipal* aSubjectPrincipal,
+ nsIPrincipal* aPrincipal)
+{
+ bool subsumes;
+ nsresult rv = aSubjectPrincipal->Subsumes(aPrincipal, &subsumes);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ if (subsumes) {
+ return true;
+ }
+
+ // The subject doesn't subsume aPrincipal. Allow access only if the subject
+ // is chrome.
+ return IsCallerChrome();
+}
+
+// static
+bool
+nsContentUtils::CanCallerAccess(nsIDOMNode *aNode)
+{
+ nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
+ NS_ENSURE_TRUE(node, false);
+ return CanCallerAccess(node);
+}
+
+// static
+bool
+nsContentUtils::CanCallerAccess(nsINode* aNode)
+{
+ return CanCallerAccess(SubjectPrincipal(), aNode->NodePrincipal());
+}
+
+// static
+bool
+nsContentUtils::CanCallerAccess(nsPIDOMWindowInner* aWindow)
+{
+ nsCOMPtr<nsIScriptObjectPrincipal> scriptObject = do_QueryInterface(aWindow);
+ NS_ENSURE_TRUE(scriptObject, false);
+
+ return CanCallerAccess(SubjectPrincipal(), scriptObject->GetPrincipal());
+}
+
+//static
+bool
+nsContentUtils::InProlog(nsINode *aNode)
+{
+ NS_PRECONDITION(aNode, "missing node to nsContentUtils::InProlog");
+
+ nsINode* parent = aNode->GetParentNode();
+ if (!parent || !parent->IsNodeOfType(nsINode::eDOCUMENT)) {
+ return false;
+ }
+
+ nsIDocument* doc = static_cast<nsIDocument*>(parent);
+ nsIContent* root = doc->GetRootElement();
+
+ return !root || doc->IndexOf(aNode) < doc->IndexOf(root);
+}
+
+nsIDocument*
+nsContentUtils::GetDocumentFromCaller()
+{
+ AutoJSContext cx;
+
+ nsCOMPtr<nsPIDOMWindowInner> win =
+ do_QueryInterface(nsJSUtils::GetStaticScriptGlobal(JS::CurrentGlobalOrNull(cx)));
+ if (!win) {
+ return nullptr;
+ }
+
+ return win->GetExtantDoc();
+}
+
+bool
+nsContentUtils::IsCallerChrome()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ if (SubjectPrincipal() == sSystemPrincipal) {
+ return true;
+ }
+
+ // If the check failed, look for UniversalXPConnect on the cx compartment.
+ return xpc::IsUniversalXPConnectEnabled(GetCurrentJSContext());
+}
+
+bool
+nsContentUtils::ShouldResistFingerprinting(nsIDocShell* aDocShell)
+{
+ if (!aDocShell) {
+ return false;
+ }
+ bool isChrome = nsContentUtils::IsChromeDoc(aDocShell->GetDocument());
+ return !isChrome && sPrivacyResistFingerprinting;
+}
+
+namespace mozilla {
+namespace dom {
+namespace workers {
+extern bool IsCurrentThreadRunningChromeWorker();
+extern JSContext* GetCurrentThreadJSContext();
+} // namespace workers
+} // namespace dom
+} // namespace mozilla
+
+bool
+nsContentUtils::ThreadsafeIsCallerChrome()
+{
+ return NS_IsMainThread() ?
+ IsCallerChrome() :
+ mozilla::dom::workers::IsCurrentThreadRunningChromeWorker();
+}
+
+bool
+nsContentUtils::IsCallerContentXBL()
+{
+ JSContext *cx = GetCurrentJSContext();
+ if (!cx)
+ return false;
+
+ JSCompartment *c = js::GetContextCompartment(cx);
+
+ // For remote XUL, we run XBL in the XUL scope. Given that we care about
+ // compat and not security for remote XUL, just always claim to be XBL.
+ if (!xpc::AllowContentXBLScope(c)) {
+ MOZ_ASSERT(nsContentUtils::AllowXULXBLForPrincipal(xpc::GetCompartmentPrincipal(c)));
+ return true;
+ }
+
+ return xpc::IsContentXBLScope(c);
+}
+
+// static
+bool
+nsContentUtils::LookupBindingMember(JSContext* aCx, nsIContent *aContent,
+ JS::Handle<jsid> aId,
+ JS::MutableHandle<JS::PropertyDescriptor> aDesc)
+{
+ nsXBLBinding* binding = aContent->GetXBLBinding();
+ if (!binding)
+ return true;
+ return binding->LookupMember(aCx, aId, aDesc);
+}
+
+// static
+nsINode*
+nsContentUtils::GetCrossDocParentNode(nsINode* aChild)
+{
+ NS_PRECONDITION(aChild, "The child is null!");
+
+ nsINode* parent = aChild->GetParentNode();
+ if (parent && parent->IsContent() && aChild->IsContent()) {
+ parent = aChild->AsContent()->GetFlattenedTreeParent();
+ }
+
+ if (parent || !aChild->IsNodeOfType(nsINode::eDOCUMENT))
+ return parent;
+
+ nsIDocument* doc = static_cast<nsIDocument*>(aChild);
+ nsIDocument* parentDoc = doc->GetParentDocument();
+ return parentDoc ? parentDoc->FindContentForSubDocument(doc) : nullptr;
+}
+
+// static
+bool
+nsContentUtils::ContentIsDescendantOf(const nsINode* aPossibleDescendant,
+ const nsINode* aPossibleAncestor)
+{
+ NS_PRECONDITION(aPossibleDescendant, "The possible descendant is null!");
+ NS_PRECONDITION(aPossibleAncestor, "The possible ancestor is null!");
+
+ do {
+ if (aPossibleDescendant == aPossibleAncestor)
+ return true;
+ aPossibleDescendant = aPossibleDescendant->GetParentNode();
+ } while (aPossibleDescendant);
+
+ return false;
+}
+
+bool
+nsContentUtils::ContentIsHostIncludingDescendantOf(
+ const nsINode* aPossibleDescendant, const nsINode* aPossibleAncestor)
+{
+ NS_PRECONDITION(aPossibleDescendant, "The possible descendant is null!");
+ NS_PRECONDITION(aPossibleAncestor, "The possible ancestor is null!");
+
+ do {
+ if (aPossibleDescendant == aPossibleAncestor)
+ return true;
+ if (aPossibleDescendant->NodeType() == nsIDOMNode::DOCUMENT_FRAGMENT_NODE) {
+ aPossibleDescendant =
+ static_cast<const DocumentFragment*>(aPossibleDescendant)->GetHost();
+ } else {
+ aPossibleDescendant = aPossibleDescendant->GetParentNode();
+ }
+ } while (aPossibleDescendant);
+
+ return false;
+}
+
+// static
+bool
+nsContentUtils::ContentIsCrossDocDescendantOf(nsINode* aPossibleDescendant,
+ nsINode* aPossibleAncestor)
+{
+ NS_PRECONDITION(aPossibleDescendant, "The possible descendant is null!");
+ NS_PRECONDITION(aPossibleAncestor, "The possible ancestor is null!");
+
+ do {
+ if (aPossibleDescendant == aPossibleAncestor)
+ return true;
+
+ aPossibleDescendant = GetCrossDocParentNode(aPossibleDescendant);
+ } while (aPossibleDescendant);
+
+ return false;
+}
+
+
+// static
+nsresult
+nsContentUtils::GetAncestors(nsINode* aNode,
+ nsTArray<nsINode*>& aArray)
+{
+ while (aNode) {
+ aArray.AppendElement(aNode);
+ aNode = aNode->GetParentNode();
+ }
+ return NS_OK;
+}
+
+// static
+nsresult
+nsContentUtils::GetAncestorsAndOffsets(nsIDOMNode* aNode,
+ int32_t aOffset,
+ nsTArray<nsIContent*>* aAncestorNodes,
+ nsTArray<int32_t>* aAncestorOffsets)
+{
+ NS_ENSURE_ARG_POINTER(aNode);
+
+ nsCOMPtr<nsIContent> content(do_QueryInterface(aNode));
+
+ if (!content) {
+ return NS_ERROR_FAILURE;
+ }
+
+ if (!aAncestorNodes->IsEmpty()) {
+ NS_WARNING("aAncestorNodes is not empty");
+ aAncestorNodes->Clear();
+ }
+
+ if (!aAncestorOffsets->IsEmpty()) {
+ NS_WARNING("aAncestorOffsets is not empty");
+ aAncestorOffsets->Clear();
+ }
+
+ // insert the node itself
+ aAncestorNodes->AppendElement(content.get());
+ aAncestorOffsets->AppendElement(aOffset);
+
+ // insert all the ancestors
+ nsIContent* child = content;
+ nsIContent* parent = child->GetParent();
+ while (parent) {
+ aAncestorNodes->AppendElement(parent);
+ aAncestorOffsets->AppendElement(parent->IndexOf(child));
+ child = parent;
+ parent = parent->GetParent();
+ }
+
+ return NS_OK;
+}
+
+// static
+nsresult
+nsContentUtils::GetCommonAncestor(nsIDOMNode *aNode,
+ nsIDOMNode *aOther,
+ nsIDOMNode** aCommonAncestor)
+{
+ *aCommonAncestor = nullptr;
+
+ nsCOMPtr<nsINode> node1 = do_QueryInterface(aNode);
+ nsCOMPtr<nsINode> node2 = do_QueryInterface(aOther);
+
+ NS_ENSURE_TRUE(node1 && node2, NS_ERROR_UNEXPECTED);
+
+ nsINode* common = GetCommonAncestor(node1, node2);
+ NS_ENSURE_TRUE(common, NS_ERROR_NOT_AVAILABLE);
+
+ return CallQueryInterface(common, aCommonAncestor);
+}
+
+// static
+nsINode*
+nsContentUtils::GetCommonAncestor(nsINode* aNode1,
+ nsINode* aNode2)
+{
+ if (aNode1 == aNode2) {
+ return aNode1;
+ }
+
+ // Build the chain of parents
+ AutoTArray<nsINode*, 30> parents1, parents2;
+ do {
+ parents1.AppendElement(aNode1);
+ aNode1 = aNode1->GetParentNode();
+ } while (aNode1);
+ do {
+ parents2.AppendElement(aNode2);
+ aNode2 = aNode2->GetParentNode();
+ } while (aNode2);
+
+ // Find where the parent chain differs
+ uint32_t pos1 = parents1.Length();
+ uint32_t pos2 = parents2.Length();
+ nsINode* parent = nullptr;
+ uint32_t len;
+ for (len = std::min(pos1, pos2); len > 0; --len) {
+ nsINode* child1 = parents1.ElementAt(--pos1);
+ nsINode* child2 = parents2.ElementAt(--pos2);
+ if (child1 != child2) {
+ break;
+ }
+ parent = child1;
+ }
+
+ return parent;
+}
+
+/* static */
+bool
+nsContentUtils::PositionIsBefore(nsINode* aNode1, nsINode* aNode2)
+{
+ return (aNode2->CompareDocumentPosition(*aNode1) &
+ (nsIDOMNode::DOCUMENT_POSITION_PRECEDING |
+ nsIDOMNode::DOCUMENT_POSITION_DISCONNECTED)) ==
+ nsIDOMNode::DOCUMENT_POSITION_PRECEDING;
+}
+
+/* static */
+int32_t
+nsContentUtils::ComparePoints(nsINode* aParent1, int32_t aOffset1,
+ nsINode* aParent2, int32_t aOffset2,
+ bool* aDisconnected)
+{
+ if (aParent1 == aParent2) {
+ return aOffset1 < aOffset2 ? -1 :
+ aOffset1 > aOffset2 ? 1 :
+ 0;
+ }
+
+ AutoTArray<nsINode*, 32> parents1, parents2;
+ nsINode* node1 = aParent1;
+ nsINode* node2 = aParent2;
+ do {
+ parents1.AppendElement(node1);
+ node1 = node1->GetParentNode();
+ } while (node1);
+ do {
+ parents2.AppendElement(node2);
+ node2 = node2->GetParentNode();
+ } while (node2);
+
+ uint32_t pos1 = parents1.Length() - 1;
+ uint32_t pos2 = parents2.Length() - 1;
+
+ bool disconnected = parents1.ElementAt(pos1) != parents2.ElementAt(pos2);
+ if (aDisconnected) {
+ *aDisconnected = disconnected;
+ }
+ if (disconnected) {
+ NS_ASSERTION(aDisconnected, "unexpected disconnected nodes");
+ return 1;
+ }
+
+ // Find where the parent chains differ
+ nsINode* parent = parents1.ElementAt(pos1);
+ uint32_t len;
+ for (len = std::min(pos1, pos2); len > 0; --len) {
+ nsINode* child1 = parents1.ElementAt(--pos1);
+ nsINode* child2 = parents2.ElementAt(--pos2);
+ if (child1 != child2) {
+ return parent->IndexOf(child1) < parent->IndexOf(child2) ? -1 : 1;
+ }
+ parent = child1;
+ }
+
+
+ // The parent chains never differed, so one of the nodes is an ancestor of
+ // the other
+
+ NS_ASSERTION(!pos1 || !pos2,
+ "should have run out of parent chain for one of the nodes");
+
+ if (!pos1) {
+ nsINode* child2 = parents2.ElementAt(--pos2);
+ return aOffset1 <= parent->IndexOf(child2) ? -1 : 1;
+ }
+
+ nsINode* child1 = parents1.ElementAt(--pos1);
+ return parent->IndexOf(child1) < aOffset2 ? -1 : 1;
+}
+
+/* static */
+int32_t
+nsContentUtils::ComparePoints(nsIDOMNode* aParent1, int32_t aOffset1,
+ nsIDOMNode* aParent2, int32_t aOffset2,
+ bool* aDisconnected)
+{
+ nsCOMPtr<nsINode> parent1 = do_QueryInterface(aParent1);
+ nsCOMPtr<nsINode> parent2 = do_QueryInterface(aParent2);
+ NS_ENSURE_TRUE(parent1 && parent2, -1);
+ return ComparePoints(parent1, aOffset1, parent2, aOffset2);
+}
+
+inline bool
+IsCharInSet(const char* aSet,
+ const char16_t aChar)
+{
+ char16_t ch;
+ while ((ch = *aSet)) {
+ if (aChar == char16_t(ch)) {
+ return true;
+ }
+ ++aSet;
+ }
+ return false;
+}
+
+/**
+ * This method strips leading/trailing chars, in given set, from string.
+ */
+
+// static
+const nsDependentSubstring
+nsContentUtils::TrimCharsInSet(const char* aSet,
+ const nsAString& aValue)
+{
+ nsAString::const_iterator valueCurrent, valueEnd;
+
+ aValue.BeginReading(valueCurrent);
+ aValue.EndReading(valueEnd);
+
+ // Skip characters in the beginning
+ while (valueCurrent != valueEnd) {
+ if (!IsCharInSet(aSet, *valueCurrent)) {
+ break;
+ }
+ ++valueCurrent;
+ }
+
+ if (valueCurrent != valueEnd) {
+ for (;;) {
+ --valueEnd;
+ if (!IsCharInSet(aSet, *valueEnd)) {
+ break;
+ }
+ }
+ ++valueEnd; // Step beyond the last character we want in the value.
+ }
+
+ // valueEnd should point to the char after the last to copy
+ return Substring(valueCurrent, valueEnd);
+}
+
+/**
+ * This method strips leading and trailing whitespace from a string.
+ */
+
+// static
+template<bool IsWhitespace(char16_t)>
+const nsDependentSubstring
+nsContentUtils::TrimWhitespace(const nsAString& aStr, bool aTrimTrailing)
+{
+ nsAString::const_iterator start, end;
+
+ aStr.BeginReading(start);
+ aStr.EndReading(end);
+
+ // Skip whitespace characters in the beginning
+ while (start != end && IsWhitespace(*start)) {
+ ++start;
+ }
+
+ if (aTrimTrailing) {
+ // Skip whitespace characters in the end.
+ while (end != start) {
+ --end;
+
+ if (!IsWhitespace(*end)) {
+ // Step back to the last non-whitespace character.
+ ++end;
+
+ break;
+ }
+ }
+ }
+
+ // Return a substring for the string w/o leading and/or trailing
+ // whitespace
+
+ return Substring(start, end);
+}
+
+// Declaring the templates we are going to use avoid linking issues without
+// inlining the method. Considering there is not so much spaces checking
+// methods we can consider this to be better than inlining.
+template
+const nsDependentSubstring
+nsContentUtils::TrimWhitespace<nsCRT::IsAsciiSpace>(const nsAString&, bool);
+template
+const nsDependentSubstring
+nsContentUtils::TrimWhitespace<nsContentUtils::IsHTMLWhitespace>(const nsAString&, bool);
+template
+const nsDependentSubstring
+nsContentUtils::TrimWhitespace<nsContentUtils::IsHTMLWhitespaceOrNBSP>(const nsAString&, bool);
+
+static inline void KeyAppendSep(nsACString& aKey)
+{
+ if (!aKey.IsEmpty()) {
+ aKey.Append('>');
+ }
+}
+
+static inline void KeyAppendString(const nsAString& aString, nsACString& aKey)
+{
+ KeyAppendSep(aKey);
+
+ // Could escape separator here if collisions happen. > is not a legal char
+ // for a name or type attribute, so we should be safe avoiding that extra work.
+
+ AppendUTF16toUTF8(aString, aKey);
+}
+
+static inline void KeyAppendString(const nsACString& aString, nsACString& aKey)
+{
+ KeyAppendSep(aKey);
+
+ // Could escape separator here if collisions happen. > is not a legal char
+ // for a name or type attribute, so we should be safe avoiding that extra work.
+
+ aKey.Append(aString);
+}
+
+static inline void KeyAppendInt(int32_t aInt, nsACString& aKey)
+{
+ KeyAppendSep(aKey);
+
+ aKey.Append(nsPrintfCString("%d", aInt));
+}
+
+static inline bool IsAutocompleteOff(const nsIContent* aElement)
+{
+ return aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::autocomplete,
+ NS_LITERAL_STRING("off"), eIgnoreCase);
+}
+
+/*static*/ nsresult
+nsContentUtils::GenerateStateKey(nsIContent* aContent,
+ const nsIDocument* aDocument,
+ nsACString& aKey)
+{
+ aKey.Truncate();
+
+ uint32_t partID = aDocument ? aDocument->GetPartID() : 0;
+
+ // We must have content if we're not using a special state id
+ NS_ENSURE_TRUE(aContent, NS_ERROR_FAILURE);
+
+ // Don't capture state for anonymous content
+ if (aContent->IsInAnonymousSubtree()) {
+ return NS_OK;
+ }
+
+ if (IsAutocompleteOff(aContent)) {
+ return NS_OK;
+ }
+
+ nsCOMPtr<nsIHTMLDocument> htmlDocument =
+ do_QueryInterface(aContent->GetUncomposedDoc());
+
+ KeyAppendInt(partID, aKey); // first append a partID
+ bool generatedUniqueKey = false;
+
+ if (htmlDocument) {
+ // Flush our content model so it'll be up to date
+ // If this becomes unnecessary and the following line is removed,
+ // please also remove the corresponding flush operation from
+ // nsHtml5TreeBuilderCppSupplement.h. (Look for "See bug 497861." there.)
+ aContent->GetUncomposedDoc()->FlushPendingNotifications(Flush_Content);
+
+ nsContentList *htmlForms = htmlDocument->GetForms();
+ nsContentList *htmlFormControls = htmlDocument->GetFormControls();
+
+ NS_ENSURE_TRUE(htmlForms && htmlFormControls, NS_ERROR_OUT_OF_MEMORY);
+
+ // If we have a form control and can calculate form information, use that
+ // as the key - it is more reliable than just recording position in the
+ // DOM.
+ // XXXbz Is it, really? We have bugs on this, I think...
+ // Important to have a unique key, and tag/type/name may not be.
+ //
+ // If the control has a form, the format of the key is:
+ // f>type>IndOfFormInDoc>IndOfControlInForm>FormName>name
+ // else:
+ // d>type>IndOfControlInDoc>name
+ //
+ // XXX We don't need to use index if name is there
+ // XXXbz We don't? Why not? I don't follow.
+ //
+ nsCOMPtr<nsIFormControl> control(do_QueryInterface(aContent));
+ if (control && htmlFormControls && htmlForms) {
+
+ // Append the control type
+ KeyAppendInt(control->GetType(), aKey);
+
+ // If in a form, add form name / index of form / index in form
+ int32_t index = -1;
+ Element *formElement = control->GetFormElement();
+ if (formElement) {
+ if (IsAutocompleteOff(formElement)) {
+ aKey.Truncate();
+ return NS_OK;
+ }
+
+ KeyAppendString(NS_LITERAL_CSTRING("f"), aKey);
+
+ // Append the index of the form in the document
+ index = htmlForms->IndexOf(formElement, false);
+ if (index <= -1) {
+ //
+ // XXX HACK this uses some state that was dumped into the document
+ // specifically to fix bug 138892. What we are trying to do is *guess*
+ // which form this control's state is found in, with the highly likely
+ // guess that the highest form parsed so far is the one.
+ // This code should not be on trunk, only branch.
+ //
+ index = htmlDocument->GetNumFormsSynchronous() - 1;
+ }
+ if (index > -1) {
+ KeyAppendInt(index, aKey);
+
+ // Append the index of the control in the form
+ nsCOMPtr<nsIForm> form(do_QueryInterface(formElement));
+ index = form->IndexOfControl(control);
+
+ if (index > -1) {
+ KeyAppendInt(index, aKey);
+ generatedUniqueKey = true;
+ }
+ }
+
+ // Append the form name
+ nsAutoString formName;
+ formElement->GetAttr(kNameSpaceID_None, nsGkAtoms::name, formName);
+ KeyAppendString(formName, aKey);
+
+ } else {
+
+ KeyAppendString(NS_LITERAL_CSTRING("d"), aKey);
+
+ // If not in a form, add index of control in document
+ // Less desirable than indexing by form info.
+
+ // Hash by index of control in doc (we are not in a form)
+ // These are important as they are unique, and type/name may not be.
+
+ // We have to flush sink notifications at this point to make
+ // sure that htmlFormControls is up to date.
+ index = htmlFormControls->IndexOf(aContent, true);
+ if (index > -1) {
+ KeyAppendInt(index, aKey);
+ generatedUniqueKey = true;
+ }
+ }
+
+ // Append the control name
+ nsAutoString name;
+ aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::name, name);
+ KeyAppendString(name, aKey);
+ }
+ }
+
+ if (!generatedUniqueKey) {
+ // Either we didn't have a form control or we aren't in an HTML document so
+ // we can't figure out form info. Append the tag name if it's an element
+ // to avoid restoring state for one type of element on another type.
+ if (aContent->IsElement()) {
+ KeyAppendString(nsDependentAtomString(aContent->NodeInfo()->NameAtom()),
+ aKey);
+ }
+ else {
+ // Append a character that is not "d" or "f" to disambiguate from
+ // the case when we were a form control in an HTML document.
+ KeyAppendString(NS_LITERAL_CSTRING("o"), aKey);
+ }
+
+ // Now start at aContent and append the indices of it and all its ancestors
+ // in their containers. That should at least pin down its position in the
+ // DOM...
+ nsINode* parent = aContent->GetParentNode();
+ nsINode* content = aContent;
+ while (parent) {
+ KeyAppendInt(parent->IndexOf(content), aKey);
+ content = parent;
+ parent = content->GetParentNode();
+ }
+ }
+
+ return NS_OK;
+}
+
+// static
+nsIPrincipal*
+nsContentUtils::SubjectPrincipal()
+{
+ MOZ_ASSERT(IsInitialized());
+ MOZ_ASSERT(NS_IsMainThread());
+ JSContext* cx = GetCurrentJSContext();
+ if (!cx) {
+ MOZ_CRASH("Accessing the Subject Principal without an AutoJSAPI on the stack is forbidden");
+ }
+
+ JSCompartment *compartment = js::GetContextCompartment(cx);
+
+ // When an AutoJSAPI is instantiated, we are in a null compartment until the
+ // first JSAutoCompartment, which is kind of a purgatory as far as permissions
+ // go. It would be nice to just hard-abort if somebody does a security check
+ // in this purgatory zone, but that would be too fragile, since it could be
+ // triggered by random IsCallerChrome() checks 20-levels deep.
+ //
+ // So we want to return _something_ here - and definitely not the System
+ // Principal, since that would make an AutoJSAPI a very dangerous thing to
+ // instantiate.
+ //
+ // The natural thing to return is a null principal. Ideally, we'd return a
+ // different null principal each time, to avoid any unexpected interactions
+ // when the principal accidentally gets inherited somewhere. But
+ // GetSubjectPrincipal doesn't return strong references, so there's no way to
+ // sanely manage the lifetime of multiple null principals.
+ //
+ // So we use a singleton null principal. To avoid it being accidentally
+ // inherited and becoming a "real" subject or object principal, we do a
+ // release-mode assert during compartment creation against using this
+ // principal on an actual global.
+ if (!compartment) {
+ return sNullSubjectPrincipal;
+ }
+
+ JSPrincipals *principals = JS_GetCompartmentPrincipals(compartment);
+ return nsJSPrincipals::get(principals);
+}
+
+// static
+nsIPrincipal*
+nsContentUtils::ObjectPrincipal(JSObject* aObj)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+#ifdef DEBUG
+ JS::AssertObjectBelongsToCurrentThread(aObj);
+#endif
+
+ // This is duplicated from nsScriptSecurityManager. We don't call through there
+ // because the API unnecessarily requires a JSContext for historical reasons.
+ JSCompartment *compartment = js::GetObjectCompartment(aObj);
+ JSPrincipals *principals = JS_GetCompartmentPrincipals(compartment);
+ return nsJSPrincipals::get(principals);
+}
+
+// static
+nsresult
+nsContentUtils::NewURIWithDocumentCharset(nsIURI** aResult,
+ const nsAString& aSpec,
+ nsIDocument* aDocument,
+ nsIURI* aBaseURI)
+{
+ return NS_NewURI(aResult, aSpec,
+ aDocument ? aDocument->GetDocumentCharacterSet().get() : nullptr,
+ aBaseURI, sIOService);
+}
+
+// static
+bool
+nsContentUtils::IsCustomElementName(nsIAtom* aName)
+{
+ // A valid custom element name is a sequence of characters name which
+ // must match the PotentialCustomElementName production:
+ // PotentialCustomElementName ::= [a-z] (PCENChar)* '-' (PCENChar)*
+ const char16_t* name = aName->GetUTF16String();
+ uint32_t len = aName->GetLength();
+ bool hasDash = false;
+
+ if (!len || name[0] < 'a' || name[0] > 'z') {
+ return false;
+ }
+
+ uint32_t i = 1;
+ while (i < len) {
+ if (NS_IS_HIGH_SURROGATE(name[i]) && i + 1 < len &&
+ NS_IS_LOW_SURROGATE(name[i + 1])) {
+ // Merged two 16-bit surrogate pairs into code point.
+ char32_t code = SURROGATE_TO_UCS4(name[i], name[i + 1]);
+
+ if (code < 0x10000 || code > 0xEFFFF) {
+ return false;
+ }
+
+ i += 2;
+ } else {
+ if (name[i] == '-') {
+ hasDash = true;
+ }
+
+ if (name[i] != '-' && name[i] != '.' &&
+ name[i] != '_' && name[i] != 0xB7 &&
+ (name[i] < '0' || name[i] > '9') &&
+ (name[i] < 'a' || name[i] > 'z') &&
+ (name[i] < 0xC0 || name[i] > 0xD6) &&
+ (name[i] < 0xF8 || name[i] > 0x37D) &&
+ (name[i] < 0x37F || name[i] > 0x1FFF) &&
+ (name[i] < 0x200C || name[i] > 0x200D) &&
+ (name[i] < 0x203F || name[i] > 0x2040) &&
+ (name[i] < 0x2070 || name[i] > 0x218F) &&
+ (name[i] < 0x2C00 || name[i] > 0x2FEF) &&
+ (name[i] < 0x3001 || name[i] > 0xD7FF) &&
+ (name[i] < 0xF900 || name[i] > 0xFDCF) &&
+ (name[i] < 0xFDF0 || name[i] > 0xFFFD)) {
+ return false;
+ }
+
+ i++;
+ }
+ }
+
+ if (!hasDash) {
+ return false;
+ }
+
+ // The custom element name must not be one of the following values:
+ // annotation-xml
+ // color-profile
+ // font-face
+ // font-face-src
+ // font-face-uri
+ // font-face-format
+ // font-face-name
+ // missing-glyph
+ return aName != nsGkAtoms::annotation_xml_ &&
+ aName != nsGkAtoms::colorProfile &&
+ aName != nsGkAtoms::font_face &&
+ aName != nsGkAtoms::font_face_src &&
+ aName != nsGkAtoms::font_face_uri &&
+ aName != nsGkAtoms::font_face_format &&
+ aName != nsGkAtoms::font_face_name &&
+ aName != nsGkAtoms::missingGlyph;
+}
+
+// static
+nsresult
+nsContentUtils::CheckQName(const nsAString& aQualifiedName,
+ bool aNamespaceAware,
+ const char16_t** aColon)
+{
+ const char* colon = nullptr;
+ const char16_t* begin = aQualifiedName.BeginReading();
+ const char16_t* end = aQualifiedName.EndReading();
+
+ int result = MOZ_XMLCheckQName(reinterpret_cast<const char*>(begin),
+ reinterpret_cast<const char*>(end),
+ aNamespaceAware, &colon);
+
+ if (!result) {
+ if (aColon) {
+ *aColon = reinterpret_cast<const char16_t*>(colon);
+ }
+
+ return NS_OK;
+ }
+
+ // MOZ_EXPAT_EMPTY_QNAME || MOZ_EXPAT_INVALID_CHARACTER
+ if (result == (1 << 0) || result == (1 << 1)) {
+ return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
+ }
+
+ return NS_ERROR_DOM_NAMESPACE_ERR;
+}
+
+//static
+nsresult
+nsContentUtils::SplitQName(const nsIContent* aNamespaceResolver,
+ const nsAFlatString& aQName,
+ int32_t *aNamespace, nsIAtom **aLocalName)
+{
+ const char16_t* colon;
+ nsresult rv = nsContentUtils::CheckQName(aQName, true, &colon);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (colon) {
+ const char16_t* end;
+ aQName.EndReading(end);
+ nsAutoString nameSpace;
+ rv = aNamespaceResolver->LookupNamespaceURIInternal(Substring(aQName.get(),
+ colon),
+ nameSpace);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *aNamespace = NameSpaceManager()->GetNameSpaceID(nameSpace,
+ nsContentUtils::IsChromeDoc(aNamespaceResolver->OwnerDoc()));
+ if (*aNamespace == kNameSpaceID_Unknown)
+ return NS_ERROR_FAILURE;
+
+ *aLocalName = NS_Atomize(Substring(colon + 1, end)).take();
+ }
+ else {
+ *aNamespace = kNameSpaceID_None;
+ *aLocalName = NS_Atomize(aQName).take();
+ }
+ NS_ENSURE_TRUE(aLocalName, NS_ERROR_OUT_OF_MEMORY);
+ return NS_OK;
+}
+
+// static
+nsresult
+nsContentUtils::GetNodeInfoFromQName(const nsAString& aNamespaceURI,
+ const nsAString& aQualifiedName,
+ nsNodeInfoManager* aNodeInfoManager,
+ uint16_t aNodeType,
+ mozilla::dom::NodeInfo** aNodeInfo)
+{
+ const nsAFlatString& qName = PromiseFlatString(aQualifiedName);
+ const char16_t* colon;
+ nsresult rv = nsContentUtils::CheckQName(qName, true, &colon);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ int32_t nsID;
+ sNameSpaceManager->RegisterNameSpace(aNamespaceURI, nsID);
+ if (colon) {
+ const char16_t* end;
+ qName.EndReading(end);
+
+ nsCOMPtr<nsIAtom> prefix = NS_Atomize(Substring(qName.get(), colon));
+
+ rv = aNodeInfoManager->GetNodeInfo(Substring(colon + 1, end), prefix,
+ nsID, aNodeType, aNodeInfo);
+ }
+ else {
+ rv = aNodeInfoManager->GetNodeInfo(aQualifiedName, nullptr, nsID,
+ aNodeType, aNodeInfo);
+ }
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return nsContentUtils::IsValidNodeName((*aNodeInfo)->NameAtom(),
+ (*aNodeInfo)->GetPrefixAtom(),
+ (*aNodeInfo)->NamespaceID()) ?
+ NS_OK : NS_ERROR_DOM_NAMESPACE_ERR;
+}
+
+// static
+void
+nsContentUtils::SplitExpatName(const char16_t *aExpatName, nsIAtom **aPrefix,
+ nsIAtom **aLocalName, int32_t* aNameSpaceID)
+{
+ /**
+ * Expat can send the following:
+ * localName
+ * namespaceURI<separator>localName
+ * namespaceURI<separator>localName<separator>prefix
+ *
+ * and we use 0xFFFF for the <separator>.
+ *
+ */
+
+ const char16_t *uriEnd = nullptr;
+ const char16_t *nameEnd = nullptr;
+ const char16_t *pos;
+ for (pos = aExpatName; *pos; ++pos) {
+ if (*pos == 0xFFFF) {
+ if (uriEnd) {
+ nameEnd = pos;
+ }
+ else {
+ uriEnd = pos;
+ }
+ }
+ }
+
+ const char16_t *nameStart;
+ if (uriEnd) {
+ if (sNameSpaceManager) {
+ sNameSpaceManager->RegisterNameSpace(nsDependentSubstring(aExpatName,
+ uriEnd),
+ *aNameSpaceID);
+ }
+ else {
+ *aNameSpaceID = kNameSpaceID_Unknown;
+ }
+
+ nameStart = (uriEnd + 1);
+ if (nameEnd) {
+ const char16_t *prefixStart = nameEnd + 1;
+ *aPrefix = NS_Atomize(Substring(prefixStart, pos)).take();
+ }
+ else {
+ nameEnd = pos;
+ *aPrefix = nullptr;
+ }
+ }
+ else {
+ *aNameSpaceID = kNameSpaceID_None;
+ nameStart = aExpatName;
+ nameEnd = pos;
+ *aPrefix = nullptr;
+ }
+ *aLocalName = NS_Atomize(Substring(nameStart, nameEnd)).take();
+}
+
+// static
+nsPresContext*
+nsContentUtils::GetContextForContent(const nsIContent* aContent)
+{
+ nsIDocument* doc = aContent->GetComposedDoc();
+ if (doc) {
+ nsIPresShell *presShell = doc->GetShell();
+ if (presShell) {
+ return presShell->GetPresContext();
+ }
+ }
+ return nullptr;
+}
+
+// static
+bool
+nsContentUtils::CanLoadImage(nsIURI* aURI, nsISupports* aContext,
+ nsIDocument* aLoadingDocument,
+ nsIPrincipal* aLoadingPrincipal,
+ int16_t* aImageBlockingStatus,
+ uint32_t aContentType)
+{
+ NS_PRECONDITION(aURI, "Must have a URI");
+ NS_PRECONDITION(aLoadingDocument, "Must have a document");
+ NS_PRECONDITION(aLoadingPrincipal, "Must have a loading principal");
+
+ nsresult rv;
+
+ uint32_t appType = nsIDocShell::APP_TYPE_UNKNOWN;
+
+ {
+ nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem = aLoadingDocument->GetDocShell();
+ if (docShellTreeItem) {
+ nsCOMPtr<nsIDocShellTreeItem> root;
+ docShellTreeItem->GetRootTreeItem(getter_AddRefs(root));
+
+ nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(root));
+
+ if (!docShell || NS_FAILED(docShell->GetAppType(&appType))) {
+ appType = nsIDocShell::APP_TYPE_UNKNOWN;
+ }
+ }
+ }
+
+ if (appType != nsIDocShell::APP_TYPE_EDITOR) {
+ // Editor apps get special treatment here, editors can load images
+ // from anywhere. This allows editor to insert images from file://
+ // into documents that are being edited.
+ rv = sSecurityManager->
+ CheckLoadURIWithPrincipal(aLoadingPrincipal, aURI,
+ nsIScriptSecurityManager::ALLOW_CHROME);
+ if (NS_FAILED(rv)) {
+ if (aImageBlockingStatus) {
+ // Reject the request itself, not all requests to the relevant
+ // server...
+ *aImageBlockingStatus = nsIContentPolicy::REJECT_REQUEST;
+ }
+ return false;
+ }
+ }
+
+ int16_t decision = nsIContentPolicy::ACCEPT;
+
+ rv = NS_CheckContentLoadPolicy(aContentType,
+ aURI,
+ aLoadingPrincipal,
+ aContext,
+ EmptyCString(), //mime guess
+ nullptr, //extra
+ &decision,
+ GetContentPolicy(),
+ sSecurityManager);
+
+ if (aImageBlockingStatus) {
+ *aImageBlockingStatus =
+ NS_FAILED(rv) ? nsIContentPolicy::REJECT_REQUEST : decision;
+ }
+ return NS_FAILED(rv) ? false : NS_CP_ACCEPTED(decision);
+}
+
+// static
+mozilla::PrincipalOriginAttributes
+nsContentUtils::GetOriginAttributes(nsIDocument* aDocument)
+{
+ if (!aDocument) {
+ return mozilla::PrincipalOriginAttributes();
+ }
+
+ nsCOMPtr<nsILoadGroup> loadGroup = aDocument->GetDocumentLoadGroup();
+ if (loadGroup) {
+ return GetOriginAttributes(loadGroup);
+ }
+
+ mozilla::PrincipalOriginAttributes attrs;
+ mozilla::NeckoOriginAttributes nattrs;
+ nsCOMPtr<nsIChannel> channel = aDocument->GetChannel();
+ if (channel && NS_GetOriginAttributes(channel, nattrs)) {
+ attrs.InheritFromNecko(nattrs);
+ }
+ return attrs;
+}
+
+// static
+mozilla::PrincipalOriginAttributes
+nsContentUtils::GetOriginAttributes(nsILoadGroup* aLoadGroup)
+{
+ if (!aLoadGroup) {
+ return mozilla::PrincipalOriginAttributes();
+ }
+ mozilla::PrincipalOriginAttributes attrs;
+ mozilla::DocShellOriginAttributes dsattrs;
+ nsCOMPtr<nsIInterfaceRequestor> callbacks;
+ aLoadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks));
+ if (callbacks) {
+ nsCOMPtr<nsILoadContext> loadContext = do_GetInterface(callbacks);
+ if (loadContext && loadContext->GetOriginAttributes(dsattrs)) {
+ attrs.InheritFromDocShellToDoc(dsattrs, nullptr);
+ }
+ }
+ return attrs;
+}
+
+// static
+bool
+nsContentUtils::IsInPrivateBrowsing(nsIDocument* aDoc)
+{
+ if (!aDoc) {
+ return false;
+ }
+
+ nsCOMPtr<nsILoadGroup> loadGroup = aDoc->GetDocumentLoadGroup();
+ if (loadGroup) {
+ return IsInPrivateBrowsing(loadGroup);
+ }
+
+ nsCOMPtr<nsIChannel> channel = aDoc->GetChannel();
+ return channel && NS_UsePrivateBrowsing(channel);
+}
+
+// static
+bool
+nsContentUtils::IsInPrivateBrowsing(nsILoadGroup* aLoadGroup)
+{
+ if (!aLoadGroup) {
+ return false;
+ }
+ bool isPrivate = false;
+ nsCOMPtr<nsIInterfaceRequestor> callbacks;
+ aLoadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks));
+ if (callbacks) {
+ nsCOMPtr<nsILoadContext> loadContext = do_GetInterface(callbacks);
+ isPrivate = loadContext && loadContext->UsePrivateBrowsing();
+ }
+ return isPrivate;
+}
+
+bool
+nsContentUtils::DocumentInactiveForImageLoads(nsIDocument* aDocument)
+{
+ if (aDocument && !IsChromeDoc(aDocument) && !aDocument->IsResourceDoc()) {
+ nsCOMPtr<nsPIDOMWindowInner> win =
+ do_QueryInterface(aDocument->GetScopeObject());
+ return !win || !win->GetDocShell();
+ }
+ return false;
+}
+
+imgLoader*
+nsContentUtils::GetImgLoaderForDocument(nsIDocument* aDoc)
+{
+ NS_ENSURE_TRUE(!DocumentInactiveForImageLoads(aDoc), nullptr);
+
+ if (!aDoc) {
+ return imgLoader::NormalLoader();
+ }
+ bool isPrivate = IsInPrivateBrowsing(aDoc);
+ return isPrivate ? imgLoader::PrivateBrowsingLoader()
+ : imgLoader::NormalLoader();
+}
+
+// static
+imgLoader*
+nsContentUtils::GetImgLoaderForChannel(nsIChannel* aChannel,
+ nsIDocument* aContext)
+{
+ NS_ENSURE_TRUE(!DocumentInactiveForImageLoads(aContext), nullptr);
+
+ if (!aChannel) {
+ return imgLoader::NormalLoader();
+ }
+ nsCOMPtr<nsILoadContext> context;
+ NS_QueryNotificationCallbacks(aChannel, context);
+ return context && context->UsePrivateBrowsing() ?
+ imgLoader::PrivateBrowsingLoader() :
+ imgLoader::NormalLoader();
+}
+
+// static
+bool
+nsContentUtils::IsImageInCache(nsIURI* aURI, nsIDocument* aDocument)
+{
+ imgILoader* loader = GetImgLoaderForDocument(aDocument);
+ nsCOMPtr<imgICache> cache = do_QueryInterface(loader);
+
+ // If something unexpected happened we return false, otherwise if props
+ // is set, the image is cached and we return true
+ nsCOMPtr<nsIProperties> props;
+ nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(aDocument);
+ nsresult rv = cache->FindEntryProperties(aURI, domDoc, getter_AddRefs(props));
+ return (NS_SUCCEEDED(rv) && props);
+}
+
+// static
+nsresult
+nsContentUtils::LoadImage(nsIURI* aURI, nsINode* aContext,
+ nsIDocument* aLoadingDocument,
+ nsIPrincipal* aLoadingPrincipal, nsIURI* aReferrer,
+ net::ReferrerPolicy aReferrerPolicy,
+ imgINotificationObserver* aObserver, int32_t aLoadFlags,
+ const nsAString& initiatorType,
+ imgRequestProxy** aRequest,
+ uint32_t aContentPolicyType)
+{
+ NS_PRECONDITION(aURI, "Must have a URI");
+ NS_PRECONDITION(aContext, "Must have a context");
+ NS_PRECONDITION(aLoadingDocument, "Must have a document");
+ NS_PRECONDITION(aLoadingPrincipal, "Must have a principal");
+ NS_PRECONDITION(aRequest, "Null out param");
+
+ imgLoader* imgLoader = GetImgLoaderForDocument(aLoadingDocument);
+ if (!imgLoader) {
+ // nothing we can do here
+ return NS_ERROR_FAILURE;
+ }
+
+ nsCOMPtr<nsILoadGroup> loadGroup = aLoadingDocument->GetDocumentLoadGroup();
+
+ nsIURI *documentURI = aLoadingDocument->GetDocumentURI();
+
+ NS_ASSERTION(loadGroup || IsFontTableURI(documentURI),
+ "Could not get loadgroup; onload may fire too early");
+
+ // Make the URI immutable so people won't change it under us
+ NS_TryToSetImmutable(aURI);
+
+ // XXXbz using "documentURI" for the initialDocumentURI is not quite
+ // right, but the best we can do here...
+ return imgLoader->LoadImage(aURI, /* uri to load */
+ documentURI, /* initialDocumentURI */
+ aReferrer, /* referrer */
+ aReferrerPolicy, /* referrer policy */
+ aLoadingPrincipal, /* loading principal */
+ loadGroup, /* loadgroup */
+ aObserver, /* imgINotificationObserver */
+ aContext, /* loading context */
+ aLoadingDocument, /* uniquification key */
+ aLoadFlags, /* load flags */
+ nullptr, /* cache key */
+ aContentPolicyType, /* content policy type */
+ initiatorType, /* the load initiator */
+ aRequest);
+}
+
+// static
+already_AddRefed<imgIContainer>
+nsContentUtils::GetImageFromContent(nsIImageLoadingContent* aContent,
+ imgIRequest **aRequest)
+{
+ if (aRequest) {
+ *aRequest = nullptr;
+ }
+
+ NS_ENSURE_TRUE(aContent, nullptr);
+
+ nsCOMPtr<imgIRequest> imgRequest;
+ aContent->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
+ getter_AddRefs(imgRequest));
+ if (!imgRequest) {
+ return nullptr;
+ }
+
+ nsCOMPtr<imgIContainer> imgContainer;
+ imgRequest->GetImage(getter_AddRefs(imgContainer));
+
+ if (!imgContainer) {
+ return nullptr;
+ }
+
+ if (aRequest) {
+ imgRequest.swap(*aRequest);
+ }
+
+ return imgContainer.forget();
+}
+
+//static
+already_AddRefed<imgRequestProxy>
+nsContentUtils::GetStaticRequest(imgRequestProxy* aRequest)
+{
+ NS_ENSURE_TRUE(aRequest, nullptr);
+ RefPtr<imgRequestProxy> retval;
+ aRequest->GetStaticRequest(getter_AddRefs(retval));
+ return retval.forget();
+}
+
+// static
+bool
+nsContentUtils::ContentIsDraggable(nsIContent* aContent)
+{
+ nsCOMPtr<nsIDOMHTMLElement> htmlElement = do_QueryInterface(aContent);
+ if (htmlElement) {
+ bool draggable = false;
+ htmlElement->GetDraggable(&draggable);
+ if (draggable)
+ return true;
+
+ if (aContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::draggable,
+ nsGkAtoms::_false, eIgnoreCase))
+ return false;
+ }
+
+ // special handling for content area image and link dragging
+ return IsDraggableImage(aContent) || IsDraggableLink(aContent);
+}
+
+// static
+bool
+nsContentUtils::IsDraggableImage(nsIContent* aContent)
+{
+ NS_PRECONDITION(aContent, "Must have content node to test");
+
+ nsCOMPtr<nsIImageLoadingContent> imageContent(do_QueryInterface(aContent));
+ if (!imageContent) {
+ return false;
+ }
+
+ nsCOMPtr<imgIRequest> imgRequest;
+ imageContent->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
+ getter_AddRefs(imgRequest));
+
+ // XXXbz It may be draggable even if the request resulted in an error. Why?
+ // Not sure; that's what the old nsContentAreaDragDrop/nsFrame code did.
+ return imgRequest != nullptr;
+}
+
+// static
+bool
+nsContentUtils::IsDraggableLink(const nsIContent* aContent) {
+ nsCOMPtr<nsIURI> absURI;
+ return aContent->IsLink(getter_AddRefs(absURI));
+}
+
+// static
+nsresult
+nsContentUtils::NameChanged(mozilla::dom::NodeInfo* aNodeInfo, nsIAtom* aName,
+ mozilla::dom::NodeInfo** aResult)
+{
+ nsNodeInfoManager *niMgr = aNodeInfo->NodeInfoManager();
+
+ *aResult = niMgr->GetNodeInfo(aName, aNodeInfo->GetPrefixAtom(),
+ aNodeInfo->NamespaceID(),
+ aNodeInfo->NodeType(),
+ aNodeInfo->GetExtraName()).take();
+ return NS_OK;
+}
+
+
+static bool
+TestSitePerm(nsIPrincipal* aPrincipal, const char* aType, uint32_t aPerm, bool aExactHostMatch)
+{
+ if (!aPrincipal) {
+ // We always deny (i.e. don't allow) the permission if we don't have a
+ // principal.
+ return aPerm != nsIPermissionManager::ALLOW_ACTION;
+ }
+
+ nsCOMPtr<nsIPermissionManager> permMgr = services::GetPermissionManager();
+ NS_ENSURE_TRUE(permMgr, false);
+
+ uint32_t perm;
+ nsresult rv;
+ if (aExactHostMatch) {
+ rv = permMgr->TestExactPermissionFromPrincipal(aPrincipal, aType, &perm);
+ } else {
+ rv = permMgr->TestPermissionFromPrincipal(aPrincipal, aType, &perm);
+ }
+ NS_ENSURE_SUCCESS(rv, false);
+
+ return perm == aPerm;
+}
+
+bool
+nsContentUtils::IsSitePermAllow(nsIPrincipal* aPrincipal, const char* aType)
+{
+ return TestSitePerm(aPrincipal, aType, nsIPermissionManager::ALLOW_ACTION, false);
+}
+
+bool
+nsContentUtils::IsSitePermDeny(nsIPrincipal* aPrincipal, const char* aType)
+{
+ return TestSitePerm(aPrincipal, aType, nsIPermissionManager::DENY_ACTION, false);
+}
+
+bool
+nsContentUtils::IsExactSitePermAllow(nsIPrincipal* aPrincipal, const char* aType)
+{
+ return TestSitePerm(aPrincipal, aType, nsIPermissionManager::ALLOW_ACTION, true);
+}
+
+bool
+nsContentUtils::IsExactSitePermDeny(nsIPrincipal* aPrincipal, const char* aType)
+{
+ return TestSitePerm(aPrincipal, aType, nsIPermissionManager::DENY_ACTION, true);
+}
+
+static const char *gEventNames[] = {"event"};
+static const char *gSVGEventNames[] = {"evt"};
+// for b/w compat, the first name to onerror is still 'event', even though it
+// is actually the error message
+static const char *gOnErrorNames[] = {"event", "source", "lineno",
+ "colno", "error"};
+
+// static
+void
+nsContentUtils::GetEventArgNames(int32_t aNameSpaceID,
+ nsIAtom *aEventName,
+ bool aIsForWindow,
+ uint32_t *aArgCount,
+ const char*** aArgArray)
+{
+#define SET_EVENT_ARG_NAMES(names) \
+ *aArgCount = sizeof(names)/sizeof(names[0]); \
+ *aArgArray = names;
+
+ // JSEventHandler is what does the arg magic for onerror, and it does
+ // not seem to take the namespace into account. So we let onerror in all
+ // namespaces get the 3 arg names.
+ if (aEventName == nsGkAtoms::onerror && aIsForWindow) {
+ SET_EVENT_ARG_NAMES(gOnErrorNames);
+ } else if (aNameSpaceID == kNameSpaceID_SVG) {
+ SET_EVENT_ARG_NAMES(gSVGEventNames);
+ } else {
+ SET_EVENT_ARG_NAMES(gEventNames);
+ }
+}
+
+static const char gPropertiesFiles[nsContentUtils::PropertiesFile_COUNT][56] = {
+ // Must line up with the enum values in |PropertiesFile| enum.
+ "chrome://global/locale/css.properties",
+ "chrome://global/locale/xbl.properties",
+ "chrome://global/locale/xul.properties",
+ "chrome://global/locale/layout_errors.properties",
+ "chrome://global/locale/layout/HtmlForm.properties",
+ "chrome://global/locale/printing.properties",
+ "chrome://global/locale/dom/dom.properties",
+ "chrome://global/locale/layout/htmlparser.properties",
+ "chrome://global/locale/svg/svg.properties",
+ "chrome://branding/locale/brand.properties",
+ "chrome://global/locale/commonDialogs.properties",
+ "chrome://global/locale/mathml/mathml.properties",
+ "chrome://global/locale/security/security.properties",
+ "chrome://necko/locale/necko.properties"
+};
+
+/* static */ nsresult
+nsContentUtils::EnsureStringBundle(PropertiesFile aFile)
+{
+ if (!sStringBundles[aFile]) {
+ if (!sStringBundleService) {
+ nsresult rv =
+ CallGetService(NS_STRINGBUNDLE_CONTRACTID, &sStringBundleService);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ nsIStringBundle *bundle;
+ nsresult rv =
+ sStringBundleService->CreateBundle(gPropertiesFiles[aFile], &bundle);
+ NS_ENSURE_SUCCESS(rv, rv);
+ sStringBundles[aFile] = bundle; // transfer ownership
+ }
+ return NS_OK;
+}
+
+/* static */
+nsresult nsContentUtils::GetLocalizedString(PropertiesFile aFile,
+ const char* aKey,
+ nsXPIDLString& aResult)
+{
+ nsresult rv = EnsureStringBundle(aFile);
+ NS_ENSURE_SUCCESS(rv, rv);
+ nsIStringBundle *bundle = sStringBundles[aFile];
+
+ return bundle->GetStringFromName(NS_ConvertASCIItoUTF16(aKey).get(),
+ getter_Copies(aResult));
+}
+
+/* static */
+nsresult nsContentUtils::FormatLocalizedString(PropertiesFile aFile,
+ const char* aKey,
+ const char16_t **aParams,
+ uint32_t aParamsLength,
+ nsXPIDLString& aResult)
+{
+ nsresult rv = EnsureStringBundle(aFile);
+ NS_ENSURE_SUCCESS(rv, rv);
+ nsIStringBundle *bundle = sStringBundles[aFile];
+
+ return bundle->FormatStringFromName(NS_ConvertASCIItoUTF16(aKey).get(),
+ aParams, aParamsLength,
+ getter_Copies(aResult));
+}
+
+/* static */
+nsresult nsContentUtils::FormatLocalizedString(
+ PropertiesFile aFile,
+ const char* aKey,
+ const nsTArray<nsString>& aParamArray,
+ nsXPIDLString& aResult)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ UniquePtr<const char16_t*[]> params;
+ uint32_t paramsLength = aParamArray.Length();
+ if (paramsLength > 0) {
+ params = MakeUnique<const char16_t*[]>(paramsLength);
+ for (uint32_t i = 0; i < paramsLength; ++i) {
+ params[i] = aParamArray[i].get();
+ }
+ }
+ return FormatLocalizedString(aFile, aKey, params.get(), paramsLength,
+ aResult);
+}
+
+
+/* static */ void
+nsContentUtils::LogSimpleConsoleError(const nsAString& aErrorText,
+ const char * classification)
+{
+ nsCOMPtr<nsIScriptError> scriptError =
+ do_CreateInstance(NS_SCRIPTERROR_CONTRACTID);
+ if (scriptError) {
+ nsCOMPtr<nsIConsoleService> console =
+ do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+ if (console && NS_SUCCEEDED(scriptError->Init(aErrorText, EmptyString(),
+ EmptyString(), 0, 0,
+ nsIScriptError::errorFlag,
+ classification))) {
+ console->LogMessage(scriptError);
+ }
+ }
+}
+
+/* static */ nsresult
+nsContentUtils::ReportToConsole(uint32_t aErrorFlags,
+ const nsACString& aCategory,
+ const nsIDocument* aDocument,
+ PropertiesFile aFile,
+ const char *aMessageName,
+ const char16_t **aParams,
+ uint32_t aParamsLength,
+ nsIURI* aURI,
+ const nsAFlatString& aSourceLine,
+ uint32_t aLineNumber,
+ uint32_t aColumnNumber)
+{
+ NS_ASSERTION((aParams && aParamsLength) || (!aParams && !aParamsLength),
+ "Supply either both parameters and their number or no"
+ "parameters and 0.");
+
+ nsresult rv;
+ nsXPIDLString errorText;
+ if (aParams) {
+ rv = FormatLocalizedString(aFile, aMessageName, aParams, aParamsLength,
+ errorText);
+ }
+ else {
+ rv = GetLocalizedString(aFile, aMessageName, errorText);
+ }
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return ReportToConsoleNonLocalized(errorText, aErrorFlags, aCategory,
+ aDocument, aURI, aSourceLine,
+ aLineNumber, aColumnNumber);
+}
+
+
+/* static */ nsresult
+nsContentUtils::ReportToConsoleNonLocalized(const nsAString& aErrorText,
+ uint32_t aErrorFlags,
+ const nsACString& aCategory,
+ const nsIDocument* aDocument,
+ nsIURI* aURI,
+ const nsAFlatString& aSourceLine,
+ uint32_t aLineNumber,
+ uint32_t aColumnNumber,
+ MissingErrorLocationMode aLocationMode)
+{
+ uint64_t innerWindowID = 0;
+ if (aDocument) {
+ if (!aURI) {
+ aURI = aDocument->GetDocumentURI();
+ }
+ innerWindowID = aDocument->InnerWindowID();
+ }
+
+ nsresult rv;
+ if (!sConsoleService) { // only need to bother null-checking here
+ rv = CallGetService(NS_CONSOLESERVICE_CONTRACTID, &sConsoleService);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ nsAutoCString spec;
+ if (!aLineNumber && aLocationMode == eUSE_CALLING_LOCATION) {
+ JSContext *cx = GetCurrentJSContext();
+ if (cx) {
+ nsJSUtils::GetCallingLocation(cx, spec, &aLineNumber, &aColumnNumber);
+ }
+ }
+ if (spec.IsEmpty() && aURI) {
+ spec = aURI->GetSpecOrDefault();
+ }
+
+ nsCOMPtr<nsIScriptError> errorObject =
+ do_CreateInstance(NS_SCRIPTERROR_CONTRACTID, &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = errorObject->InitWithWindowID(aErrorText,
+ NS_ConvertUTF8toUTF16(spec), // file name
+ aSourceLine,
+ aLineNumber, aColumnNumber,
+ aErrorFlags, aCategory,
+ innerWindowID);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return sConsoleService->LogMessage(errorObject);
+}
+
+void
+nsContentUtils::LogMessageToConsole(const char* aMsg)
+{
+ if (!sConsoleService) { // only need to bother null-checking here
+ CallGetService(NS_CONSOLESERVICE_CONTRACTID, &sConsoleService);
+ if (!sConsoleService) {
+ return;
+ }
+ }
+ sConsoleService->LogStringMessage(NS_ConvertUTF8toUTF16(aMsg).get());
+}
+
+bool
+nsContentUtils::IsChromeDoc(nsIDocument *aDocument)
+{
+ if (!aDocument) {
+ return false;
+ }
+ return aDocument->NodePrincipal() == sSystemPrincipal;
+}
+
+bool
+nsContentUtils::IsChildOfSameType(nsIDocument* aDoc)
+{
+ nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(aDoc->GetDocShell());
+ nsCOMPtr<nsIDocShellTreeItem> sameTypeParent;
+ if (docShellAsItem) {
+ docShellAsItem->GetSameTypeParent(getter_AddRefs(sameTypeParent));
+ }
+ return sameTypeParent != nullptr;
+}
+
+bool
+nsContentUtils::IsScriptType(const nsACString& aContentType)
+{
+ // NOTE: if you add a type here, add it to the CONTENTDLF_CATEGORIES
+ // define in nsContentDLF.h as well.
+ return aContentType.EqualsLiteral(APPLICATION_JAVASCRIPT) ||
+ aContentType.EqualsLiteral(APPLICATION_XJAVASCRIPT) ||
+ aContentType.EqualsLiteral(TEXT_ECMASCRIPT) ||
+ aContentType.EqualsLiteral(APPLICATION_ECMASCRIPT) ||
+ aContentType.EqualsLiteral(TEXT_JAVASCRIPT) ||
+ aContentType.EqualsLiteral(APPLICATION_JSON) ||
+ aContentType.EqualsLiteral(TEXT_JSON);
+}
+
+bool
+nsContentUtils::IsPlainTextType(const nsACString& aContentType)
+{
+ // NOTE: if you add a type here, add it to the CONTENTDLF_CATEGORIES
+ // define in nsContentDLF.h as well.
+ return aContentType.EqualsLiteral(TEXT_PLAIN) ||
+ aContentType.EqualsLiteral(TEXT_CSS) ||
+ aContentType.EqualsLiteral(TEXT_CACHE_MANIFEST) ||
+ aContentType.EqualsLiteral(TEXT_VTT) ||
+ IsScriptType(aContentType);
+}
+
+bool
+nsContentUtils::GetWrapperSafeScriptFilename(nsIDocument* aDocument,
+ nsIURI* aURI,
+ nsACString& aScriptURI,
+ nsresult* aRv)
+{
+ MOZ_ASSERT(aRv);
+ bool scriptFileNameModified = false;
+ *aRv = NS_OK;
+
+ *aRv = aURI->GetSpec(aScriptURI);
+ NS_ENSURE_SUCCESS(*aRv, false);
+
+ if (IsChromeDoc(aDocument)) {
+ nsCOMPtr<nsIChromeRegistry> chromeReg =
+ mozilla::services::GetChromeRegistryService();
+
+ if (!chromeReg) {
+ // If we're running w/o a chrome registry we won't modify any
+ // script file names.
+
+ return scriptFileNameModified;
+ }
+
+ bool docWrappersEnabled =
+ chromeReg->WrappersEnabled(aDocument->GetDocumentURI());
+
+ bool uriWrappersEnabled = chromeReg->WrappersEnabled(aURI);
+
+ nsIURI *docURI = aDocument->GetDocumentURI();
+
+ if (docURI && docWrappersEnabled && !uriWrappersEnabled) {
+ // aURI is a script from a URL that doesn't get wrapper
+ // automation. aDocument is a chrome document that does get
+ // wrapper automation. Prepend the chrome document's URI
+ // followed by the string " -> " to the URI of the script we're
+ // loading here so that script in that URI gets the same wrapper
+ // automation that the chrome document expects.
+ nsAutoCString spec;
+ *aRv = docURI->GetSpec(spec);
+ if (NS_WARN_IF(NS_FAILED(*aRv))) {
+ return false;
+ }
+
+ spec.AppendLiteral(" -> ");
+ spec.Append(aScriptURI);
+
+ aScriptURI = spec;
+
+ scriptFileNameModified = true;
+ }
+ }
+
+ return scriptFileNameModified;
+}
+
+// static
+bool
+nsContentUtils::IsInChromeDocshell(nsIDocument *aDocument)
+{
+ if (!aDocument) {
+ return false;
+ }
+
+ if (aDocument->GetDisplayDocument()) {
+ return IsInChromeDocshell(aDocument->GetDisplayDocument());
+ }
+
+ nsCOMPtr<nsIDocShellTreeItem> docShell = aDocument->GetDocShell();
+ if (!docShell) {
+ return false;
+ }
+
+ return docShell->ItemType() == nsIDocShellTreeItem::typeChrome;
+}
+
+// static
+nsIContentPolicy*
+nsContentUtils::GetContentPolicy()
+{
+ if (!sTriedToGetContentPolicy) {
+ CallGetService(NS_CONTENTPOLICY_CONTRACTID, &sContentPolicyService);
+ // It's OK to not have a content policy service
+ sTriedToGetContentPolicy = true;
+ }
+
+ return sContentPolicyService;
+}
+
+// static
+bool
+nsContentUtils::IsEventAttributeName(nsIAtom* aName, int32_t aType)
+{
+ const char16_t* name = aName->GetUTF16String();
+ if (name[0] != 'o' || name[1] != 'n')
+ return false;
+
+ EventNameMapping mapping;
+ return (sAtomEventTable->Get(aName, &mapping) && mapping.mType & aType);
+}
+
+// static
+EventMessage
+nsContentUtils::GetEventMessage(nsIAtom* aName)
+{
+ if (aName) {
+ EventNameMapping mapping;
+ if (sAtomEventTable->Get(aName, &mapping)) {
+ return mapping.mMessage;
+ }
+ }
+
+ return eUnidentifiedEvent;
+}
+
+// static
+mozilla::EventClassID
+nsContentUtils::GetEventClassID(const nsAString& aName)
+{
+ EventNameMapping mapping;
+ if (sStringEventTable->Get(aName, &mapping))
+ return mapping.mEventClassID;
+
+ return eBasicEventClass;
+}
+
+nsIAtom*
+nsContentUtils::GetEventMessageAndAtom(const nsAString& aName,
+ mozilla::EventClassID aEventClassID,
+ EventMessage* aEventMessage)
+{
+ EventNameMapping mapping;
+ if (sStringEventTable->Get(aName, &mapping)) {
+ *aEventMessage =
+ mapping.mEventClassID == aEventClassID ? mapping.mMessage :
+ eUnidentifiedEvent;
+ return mapping.mAtom;
+ }
+
+ // If we have cached lots of user defined event names, clear some of them.
+ if (sUserDefinedEvents->Count() > 127) {
+ while (sUserDefinedEvents->Count() > 64) {
+ nsIAtom* first = sUserDefinedEvents->ObjectAt(0);
+ sStringEventTable->Remove(Substring(nsDependentAtomString(first), 2));
+ sUserDefinedEvents->RemoveObjectAt(0);
+ }
+ }
+
+ *aEventMessage = eUnidentifiedEvent;
+ nsCOMPtr<nsIAtom> atom = NS_Atomize(NS_LITERAL_STRING("on") + aName);
+ sUserDefinedEvents->AppendObject(atom);
+ mapping.mAtom = atom;
+ mapping.mMessage = eUnidentifiedEvent;
+ mapping.mType = EventNameType_None;
+ mapping.mEventClassID = eBasicEventClass;
+ // This is a slow hashtable call, but at least we cache the result for the
+ // following calls. Because GetEventMessageAndAtomForListener utilizes
+ // sStringEventTable, it needs to know in which cases sStringEventTable
+ // doesn't contain the information it needs so that it can use
+ // sAtomEventTable instead.
+ mapping.mMaybeSpecialSVGorSMILEvent =
+ GetEventMessage(atom) != eUnidentifiedEvent;
+ sStringEventTable->Put(aName, mapping);
+ return mapping.mAtom;
+}
+
+// static
+EventMessage
+nsContentUtils::GetEventMessageAndAtomForListener(const nsAString& aName,
+ nsIAtom** aOnName)
+{
+ // Because of SVG/SMIL sStringEventTable contains a subset of the event names
+ // comparing to the sAtomEventTable. However, usually sStringEventTable
+ // contains the information we need, so in order to reduce hashtable
+ // lookups, start from it.
+ EventNameMapping mapping;
+ EventMessage msg = eUnidentifiedEvent;
+ nsCOMPtr<nsIAtom> atom;
+ if (sStringEventTable->Get(aName, &mapping)) {
+ if (mapping.mMaybeSpecialSVGorSMILEvent) {
+ // Try the atom version so that we should get the right message for
+ // SVG/SMIL.
+ atom = NS_Atomize(NS_LITERAL_STRING("on") + aName);
+ msg = GetEventMessage(atom);
+ } else {
+ atom = mapping.mAtom;
+ msg = mapping.mMessage;
+ }
+ atom.forget(aOnName);
+ return msg;
+ }
+
+ // GetEventMessageAndAtom will cache the event type for the future usage...
+ GetEventMessageAndAtom(aName, eBasicEventClass, &msg);
+
+ // ...and then call this method recursively to get the message and atom from
+ // now updated sStringEventTable.
+ return GetEventMessageAndAtomForListener(aName, aOnName);
+}
+
+static
+nsresult GetEventAndTarget(nsIDocument* aDoc, nsISupports* aTarget,
+ const nsAString& aEventName,
+ bool aCanBubble, bool aCancelable,
+ bool aTrusted, nsIDOMEvent** aEvent,
+ EventTarget** aTargetOut)
+{
+ nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(aDoc);
+ nsCOMPtr<EventTarget> target(do_QueryInterface(aTarget));
+ NS_ENSURE_TRUE(domDoc && target, NS_ERROR_INVALID_ARG);
+
+ nsCOMPtr<nsIDOMEvent> event;
+ nsresult rv =
+ domDoc->CreateEvent(NS_LITERAL_STRING("Events"), getter_AddRefs(event));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ event->InitEvent(aEventName, aCanBubble, aCancelable);
+ event->SetTrusted(aTrusted);
+
+ rv = event->SetTarget(target);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ event.forget(aEvent);
+ target.forget(aTargetOut);
+ return NS_OK;
+}
+
+// static
+nsresult
+nsContentUtils::DispatchTrustedEvent(nsIDocument* aDoc, nsISupports* aTarget,
+ const nsAString& aEventName,
+ bool aCanBubble, bool aCancelable,
+ bool *aDefaultAction)
+{
+ return DispatchEvent(aDoc, aTarget, aEventName, aCanBubble, aCancelable,
+ true, aDefaultAction);
+}
+
+// static
+nsresult
+nsContentUtils::DispatchUntrustedEvent(nsIDocument* aDoc, nsISupports* aTarget,
+ const nsAString& aEventName,
+ bool aCanBubble, bool aCancelable,
+ bool *aDefaultAction)
+{
+ return DispatchEvent(aDoc, aTarget, aEventName, aCanBubble, aCancelable,
+ false, aDefaultAction);
+}
+
+// static
+nsresult
+nsContentUtils::DispatchEvent(nsIDocument* aDoc, nsISupports* aTarget,
+ const nsAString& aEventName,
+ bool aCanBubble, bool aCancelable,
+ bool aTrusted, bool *aDefaultAction,
+ bool aOnlyChromeDispatch)
+{
+ nsCOMPtr<nsIDOMEvent> event;
+ nsCOMPtr<EventTarget> target;
+ nsresult rv = GetEventAndTarget(aDoc, aTarget, aEventName, aCanBubble,
+ aCancelable, aTrusted, getter_AddRefs(event),
+ getter_AddRefs(target));
+ NS_ENSURE_SUCCESS(rv, rv);
+ event->WidgetEventPtr()->mFlags.mOnlyChromeDispatch = aOnlyChromeDispatch;
+
+ bool dummy;
+ return target->DispatchEvent(event, aDefaultAction ? aDefaultAction : &dummy);
+}
+
+nsresult
+nsContentUtils::DispatchChromeEvent(nsIDocument *aDoc,
+ nsISupports *aTarget,
+ const nsAString& aEventName,
+ bool aCanBubble, bool aCancelable,
+ bool *aDefaultAction)
+{
+
+ nsCOMPtr<nsIDOMEvent> event;
+ nsCOMPtr<EventTarget> target;
+ nsresult rv = GetEventAndTarget(aDoc, aTarget, aEventName, aCanBubble,
+ aCancelable, true, getter_AddRefs(event),
+ getter_AddRefs(target));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ NS_ASSERTION(aDoc, "GetEventAndTarget lied?");
+ if (!aDoc->GetWindow())
+ return NS_ERROR_INVALID_ARG;
+
+ EventTarget* piTarget = aDoc->GetWindow()->GetParentTarget();
+ if (!piTarget)
+ return NS_ERROR_INVALID_ARG;
+
+ nsEventStatus status = nsEventStatus_eIgnore;
+ rv = piTarget->DispatchDOMEvent(nullptr, event, nullptr, &status);
+ if (aDefaultAction) {
+ *aDefaultAction = (status != nsEventStatus_eConsumeNoDefault);
+ }
+ return rv;
+}
+
+/* static */
+nsresult
+nsContentUtils::DispatchFocusChromeEvent(nsPIDOMWindowOuter* aWindow)
+{
+ MOZ_ASSERT(aWindow);
+
+ nsCOMPtr<nsIDocument> doc = aWindow->GetExtantDoc();
+ if (!doc) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return DispatchChromeEvent(doc, aWindow,
+ NS_LITERAL_STRING("DOMServiceWorkerFocusClient"),
+ true, true);
+}
+
+nsresult
+nsContentUtils::DispatchEventOnlyToChrome(nsIDocument* aDoc,
+ nsISupports* aTarget,
+ const nsAString& aEventName,
+ bool aCanBubble, bool aCancelable,
+ bool* aDefaultAction)
+{
+ return DispatchEvent(aDoc, aTarget, aEventName, aCanBubble, aCancelable,
+ true, aDefaultAction, true);
+}
+
+/* static */
+Element*
+nsContentUtils::MatchElementId(nsIContent *aContent, const nsIAtom* aId)
+{
+ for (nsIContent* cur = aContent;
+ cur;
+ cur = cur->GetNextNode(aContent)) {
+ if (aId == cur->GetID()) {
+ return cur->AsElement();
+ }
+ }
+
+ return nullptr;
+}
+
+/* static */
+Element *
+nsContentUtils::MatchElementId(nsIContent *aContent, const nsAString& aId)
+{
+ NS_PRECONDITION(!aId.IsEmpty(), "Will match random elements");
+
+ // ID attrs are generally stored as atoms, so just atomize this up front
+ nsCOMPtr<nsIAtom> id(NS_Atomize(aId));
+ if (!id) {
+ // OOM, so just bail
+ return nullptr;
+ }
+
+ return MatchElementId(aContent, id);
+}
+
+/* static */
+nsIDocument*
+nsContentUtils::GetSubdocumentWithOuterWindowId(nsIDocument *aDocument,
+ uint64_t aOuterWindowId)
+{
+ if (!aDocument || !aOuterWindowId) {
+ return nullptr;
+ }
+
+ nsCOMPtr<nsPIDOMWindowOuter> window = nsGlobalWindow::GetOuterWindowWithId(aOuterWindowId)->AsOuter();
+ if (!window) {
+ return nullptr;
+ }
+
+ nsCOMPtr<nsIDocument> foundDoc = window->GetDoc();
+ if (nsContentUtils::ContentIsCrossDocDescendantOf(foundDoc, aDocument)) {
+ // Note that ContentIsCrossDocDescendantOf will return true if
+ // foundDoc == aDocument.
+ return foundDoc;
+ }
+
+ return nullptr;
+}
+
+// Convert the string from the given encoding to Unicode.
+/* static */
+nsresult
+nsContentUtils::ConvertStringFromEncoding(const nsACString& aEncoding,
+ const nsACString& aInput,
+ nsAString& aOutput)
+{
+ nsAutoCString encoding;
+ if (aEncoding.IsEmpty()) {
+ encoding.AssignLiteral("UTF-8");
+ } else {
+ encoding.Assign(aEncoding);
+ }
+
+ ErrorResult rv;
+ nsAutoPtr<TextDecoder> decoder(new TextDecoder());
+ decoder->InitWithEncoding(encoding, false);
+
+ decoder->Decode(aInput.BeginReading(), aInput.Length(), false,
+ aOutput, rv);
+ return rv.StealNSResult();
+}
+
+/* static */
+bool
+nsContentUtils::CheckForBOM(const unsigned char* aBuffer, uint32_t aLength,
+ nsACString& aCharset)
+{
+ bool found = true;
+ aCharset.Truncate();
+ if (aLength >= 3 &&
+ aBuffer[0] == 0xEF &&
+ aBuffer[1] == 0xBB &&
+ aBuffer[2] == 0xBF) {
+ aCharset = "UTF-8";
+ }
+ else if (aLength >= 2 &&
+ aBuffer[0] == 0xFE && aBuffer[1] == 0xFF) {
+ aCharset = "UTF-16BE";
+ }
+ else if (aLength >= 2 &&
+ aBuffer[0] == 0xFF && aBuffer[1] == 0xFE) {
+ aCharset = "UTF-16LE";
+ } else {
+ found = false;
+ }
+
+ return found;
+}
+
+/* static */
+void
+nsContentUtils::RegisterShutdownObserver(nsIObserver* aObserver)
+{
+ nsCOMPtr<nsIObserverService> observerService =
+ mozilla::services::GetObserverService();
+ if (observerService) {
+ observerService->AddObserver(aObserver,
+ NS_XPCOM_SHUTDOWN_OBSERVER_ID,
+ false);
+ }
+}
+
+/* static */
+void
+nsContentUtils::UnregisterShutdownObserver(nsIObserver* aObserver)
+{
+ nsCOMPtr<nsIObserverService> observerService =
+ mozilla::services::GetObserverService();
+ if (observerService) {
+ observerService->RemoveObserver(aObserver, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+ }
+}
+
+/* static */
+bool
+nsContentUtils::HasNonEmptyAttr(const nsIContent* aContent, int32_t aNameSpaceID,
+ nsIAtom* aName)
+{
+ static nsIContent::AttrValuesArray strings[] = {&nsGkAtoms::_empty, nullptr};
+ return aContent->FindAttrValueIn(aNameSpaceID, aName, strings, eCaseMatters)
+ == nsIContent::ATTR_VALUE_NO_MATCH;
+}
+
+/* static */
+bool
+nsContentUtils::HasMutationListeners(nsINode* aNode,
+ uint32_t aType,
+ nsINode* aTargetForSubtreeModified)
+{
+ nsIDocument* doc = aNode->OwnerDoc();
+
+ // global object will be null for documents that don't have windows.
+ nsPIDOMWindowInner* window = doc->GetInnerWindow();
+ // This relies on EventListenerManager::AddEventListener, which sets
+ // all mutation bits when there is a listener for DOMSubtreeModified event.
+ if (window && !window->HasMutationListeners(aType)) {
+ return false;
+ }
+
+ if (aNode->IsNodeOfType(nsINode::eCONTENT) &&
+ static_cast<nsIContent*>(aNode)->ChromeOnlyAccess()) {
+ return false;
+ }
+
+ doc->MayDispatchMutationEvent(aTargetForSubtreeModified);
+
+ // If we have a window, we can check it for mutation listeners now.
+ if (aNode->IsInUncomposedDoc()) {
+ nsCOMPtr<EventTarget> piTarget(do_QueryInterface(window));
+ if (piTarget) {
+ EventListenerManager* manager = piTarget->GetExistingListenerManager();
+ if (manager && manager->HasMutationListeners()) {
+ return true;
+ }
+ }
+ }
+
+ // If we have a window, we know a mutation listener is registered, but it
+ // might not be in our chain. If we don't have a window, we might have a
+ // mutation listener. Check quickly to see.
+ while (aNode) {
+ EventListenerManager* manager = aNode->GetExistingListenerManager();
+ if (manager && manager->HasMutationListeners()) {
+ return true;
+ }
+
+ if (aNode->IsNodeOfType(nsINode::eCONTENT)) {
+ nsIContent* content = static_cast<nsIContent*>(aNode);
+ nsIContent* insertionParent = content->GetXBLInsertionParent();
+ if (insertionParent) {
+ aNode = insertionParent;
+ continue;
+ }
+ }
+ aNode = aNode->GetParentNode();
+ }
+
+ return false;
+}
+
+/* static */
+bool
+nsContentUtils::HasMutationListeners(nsIDocument* aDocument,
+ uint32_t aType)
+{
+ nsPIDOMWindowInner* window = aDocument ?
+ aDocument->GetInnerWindow() : nullptr;
+
+ // This relies on EventListenerManager::AddEventListener, which sets
+ // all mutation bits when there is a listener for DOMSubtreeModified event.
+ return !window || window->HasMutationListeners(aType);
+}
+
+void
+nsContentUtils::MaybeFireNodeRemoved(nsINode* aChild, nsINode* aParent,
+ nsIDocument* aOwnerDoc)
+{
+ NS_PRECONDITION(aChild, "Missing child");
+ NS_PRECONDITION(aChild->GetParentNode() == aParent, "Wrong parent");
+ NS_PRECONDITION(aChild->OwnerDoc() == aOwnerDoc, "Wrong owner-doc");
+
+ // Having an explicit check here since it's an easy mistake to fall into,
+ // and there might be existing code with problems. We'd rather be safe
+ // than fire DOMNodeRemoved in all corner cases. We also rely on it for
+ // nsAutoScriptBlockerSuppressNodeRemoved.
+ if (!IsSafeToRunScript()) {
+ // This checks that IsSafeToRunScript is true since we don't want to fire
+ // events when that is false. We can't rely on EventDispatcher to assert
+ // this in this situation since most of the time there are no mutation
+ // event listeners, in which case we won't even attempt to dispatch events.
+ // However this also allows for two exceptions. First off, we don't assert
+ // if the mutation happens to native anonymous content since we never fire
+ // mutation events on such content anyway.
+ // Second, we don't assert if sDOMNodeRemovedSuppressCount is true since
+ // that is a know case when we'd normally fire a mutation event, but can't
+ // make that safe and so we suppress it at this time. Ideally this should
+ // go away eventually.
+ if (!(aChild->IsContent() && aChild->AsContent()->IsInNativeAnonymousSubtree()) &&
+ !sDOMNodeRemovedSuppressCount) {
+ NS_ERROR("Want to fire DOMNodeRemoved event, but it's not safe");
+ WarnScriptWasIgnored(aOwnerDoc);
+ }
+ return;
+ }
+
+ if (HasMutationListeners(aChild,
+ NS_EVENT_BITS_MUTATION_NODEREMOVED, aParent)) {
+ InternalMutationEvent mutation(true, eLegacyNodeRemoved);
+ mutation.mRelatedNode = do_QueryInterface(aParent);
+
+ mozAutoSubtreeModified subtree(aOwnerDoc, aParent);
+ EventDispatcher::Dispatch(aChild, nullptr, &mutation);
+ }
+}
+
+void
+nsContentUtils::UnmarkGrayJSListenersInCCGenerationDocuments()
+{
+ if (!sEventListenerManagersHash) {
+ return;
+ }
+
+ for (auto i = sEventListenerManagersHash->Iter(); !i.Done(); i.Next()) {
+ auto entry = static_cast<EventListenerManagerMapEntry*>(i.Get());
+ nsINode* n = static_cast<nsINode*>(entry->mListenerManager->GetTarget());
+ if (n && n->IsInUncomposedDoc() &&
+ nsCCUncollectableMarker::InGeneration(n->OwnerDoc()->GetMarkedCCGeneration())) {
+ entry->mListenerManager->MarkForCC();
+ }
+ }
+}
+
+/* static */
+void
+nsContentUtils::TraverseListenerManager(nsINode *aNode,
+ nsCycleCollectionTraversalCallback &cb)
+{
+ if (!sEventListenerManagersHash) {
+ // We're already shut down, just return.
+ return;
+ }
+
+ auto entry = static_cast<EventListenerManagerMapEntry*>
+ (sEventListenerManagersHash->Search(aNode));
+ if (entry) {
+ CycleCollectionNoteChild(cb, entry->mListenerManager.get(),
+ "[via hash] mListenerManager");
+ }
+}
+
+EventListenerManager*
+nsContentUtils::GetListenerManagerForNode(nsINode *aNode)
+{
+ if (!sEventListenerManagersHash) {
+ // We're already shut down, don't bother creating an event listener
+ // manager.
+
+ return nullptr;
+ }
+
+ auto entry =
+ static_cast<EventListenerManagerMapEntry*>
+ (sEventListenerManagersHash->Add(aNode, fallible));
+
+ if (!entry) {
+ return nullptr;
+ }
+
+ if (!entry->mListenerManager) {
+ entry->mListenerManager = new EventListenerManager(aNode);
+
+ aNode->SetFlags(NODE_HAS_LISTENERMANAGER);
+ }
+
+ return entry->mListenerManager;
+}
+
+EventListenerManager*
+nsContentUtils::GetExistingListenerManagerForNode(const nsINode *aNode)
+{
+ if (!aNode->HasFlag(NODE_HAS_LISTENERMANAGER)) {
+ return nullptr;
+ }
+
+ if (!sEventListenerManagersHash) {
+ // We're already shut down, don't bother creating an event listener
+ // manager.
+
+ return nullptr;
+ }
+
+ auto entry = static_cast<EventListenerManagerMapEntry*>
+ (sEventListenerManagersHash->Search(aNode));
+ if (entry) {
+ return entry->mListenerManager;
+ }
+
+ return nullptr;
+}
+
+/* static */
+void
+nsContentUtils::RemoveListenerManager(nsINode *aNode)
+{
+ if (sEventListenerManagersHash) {
+ auto entry = static_cast<EventListenerManagerMapEntry*>
+ (sEventListenerManagersHash->Search(aNode));
+ if (entry) {
+ RefPtr<EventListenerManager> listenerManager;
+ listenerManager.swap(entry->mListenerManager);
+ // Remove the entry and *then* do operations that could cause further
+ // modification of sEventListenerManagersHash. See bug 334177.
+ sEventListenerManagersHash->RawRemove(entry);
+ if (listenerManager) {
+ listenerManager->Disconnect();
+ }
+ }
+ }
+}
+
+/* static */
+bool
+nsContentUtils::IsValidNodeName(nsIAtom *aLocalName, nsIAtom *aPrefix,
+ int32_t aNamespaceID)
+{
+ if (aNamespaceID == kNameSpaceID_Unknown) {
+ return false;
+ }
+
+ if (!aPrefix) {
+ // If the prefix is null, then either the QName must be xmlns or the
+ // namespace must not be XMLNS.
+ return (aLocalName == nsGkAtoms::xmlns) ==
+ (aNamespaceID == kNameSpaceID_XMLNS);
+ }
+
+ // If the prefix is non-null then the namespace must not be null.
+ if (aNamespaceID == kNameSpaceID_None) {
+ return false;
+ }
+
+ // If the namespace is the XMLNS namespace then the prefix must be xmlns,
+ // but the localname must not be xmlns.
+ if (aNamespaceID == kNameSpaceID_XMLNS) {
+ return aPrefix == nsGkAtoms::xmlns && aLocalName != nsGkAtoms::xmlns;
+ }
+
+ // If the namespace is not the XMLNS namespace then the prefix must not be
+ // xmlns.
+ // If the namespace is the XML namespace then the prefix can be anything.
+ // If the namespace is not the XML namespace then the prefix must not be xml.
+ return aPrefix != nsGkAtoms::xmlns &&
+ (aNamespaceID == kNameSpaceID_XML || aPrefix != nsGkAtoms::xml);
+}
+
+/* static */
+nsresult
+nsContentUtils::CreateContextualFragment(nsINode* aContextNode,
+ const nsAString& aFragment,
+ bool aPreventScriptExecution,
+ nsIDOMDocumentFragment** aReturn)
+{
+ ErrorResult rv;
+ *aReturn = CreateContextualFragment(aContextNode, aFragment,
+ aPreventScriptExecution, rv).take();
+ return rv.StealNSResult();
+}
+
+already_AddRefed<DocumentFragment>
+nsContentUtils::CreateContextualFragment(nsINode* aContextNode,
+ const nsAString& aFragment,
+ bool aPreventScriptExecution,
+ ErrorResult& aRv)
+{
+ if (!aContextNode) {
+ aRv.Throw(NS_ERROR_INVALID_ARG);
+ return nullptr;
+ }
+
+ // If we don't have a document here, we can't get the right security context
+ // for compiling event handlers... so just bail out.
+ nsCOMPtr<nsIDocument> document = aContextNode->OwnerDoc();
+ bool isHTML = document->IsHTMLDocument();
+#ifdef DEBUG
+ nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(document);
+ NS_ASSERTION(!isHTML || htmlDoc, "Should have HTMLDocument here!");
+#endif
+
+ if (isHTML) {
+ RefPtr<DocumentFragment> frag =
+ new DocumentFragment(document->NodeInfoManager());
+
+ nsCOMPtr<nsIContent> contextAsContent = do_QueryInterface(aContextNode);
+ if (contextAsContent && !contextAsContent->IsElement()) {
+ contextAsContent = contextAsContent->GetParent();
+ if (contextAsContent && !contextAsContent->IsElement()) {
+ // can this even happen?
+ contextAsContent = nullptr;
+ }
+ }
+
+ if (contextAsContent && !contextAsContent->IsHTMLElement(nsGkAtoms::html)) {
+ aRv = ParseFragmentHTML(aFragment, frag,
+ contextAsContent->NodeInfo()->NameAtom(),
+ contextAsContent->GetNameSpaceID(),
+ (document->GetCompatibilityMode() ==
+ eCompatibility_NavQuirks),
+ aPreventScriptExecution);
+ } else {
+ aRv = ParseFragmentHTML(aFragment, frag,
+ nsGkAtoms::body,
+ kNameSpaceID_XHTML,
+ (document->GetCompatibilityMode() ==
+ eCompatibility_NavQuirks),
+ aPreventScriptExecution);
+ }
+
+ return frag.forget();
+ }
+
+ AutoTArray<nsString, 32> tagStack;
+ nsAutoString uriStr, nameStr;
+ nsCOMPtr<nsIContent> content = do_QueryInterface(aContextNode);
+ // just in case we have a text node
+ if (content && !content->IsElement())
+ content = content->GetParent();
+
+ while (content && content->IsElement()) {
+ nsString& tagName = *tagStack.AppendElement();
+ tagName = content->NodeInfo()->QualifiedName();
+
+ // see if we need to add xmlns declarations
+ uint32_t count = content->GetAttrCount();
+ bool setDefaultNamespace = false;
+ if (count > 0) {
+ uint32_t index;
+
+ for (index = 0; index < count; index++) {
+ const BorrowedAttrInfo info = content->GetAttrInfoAt(index);
+ const nsAttrName* name = info.mName;
+ if (name->NamespaceEquals(kNameSpaceID_XMLNS)) {
+ info.mValue->ToString(uriStr);
+
+ // really want something like nsXMLContentSerializer::SerializeAttr
+ tagName.AppendLiteral(" xmlns"); // space important
+ if (name->GetPrefix()) {
+ tagName.Append(char16_t(':'));
+ name->LocalName()->ToString(nameStr);
+ tagName.Append(nameStr);
+ } else {
+ setDefaultNamespace = true;
+ }
+ tagName.AppendLiteral("=\"");
+ tagName.Append(uriStr);
+ tagName.Append('"');
+ }
+ }
+ }
+
+ if (!setDefaultNamespace) {
+ mozilla::dom::NodeInfo* info = content->NodeInfo();
+ if (!info->GetPrefixAtom() &&
+ info->NamespaceID() != kNameSpaceID_None) {
+ // We have no namespace prefix, but have a namespace ID. Push
+ // default namespace attr in, so that our kids will be in our
+ // namespace.
+ info->GetNamespaceURI(uriStr);
+ tagName.AppendLiteral(" xmlns=\"");
+ tagName.Append(uriStr);
+ tagName.Append('"');
+ }
+ }
+
+ content = content->GetParent();
+ }
+
+ nsCOMPtr<nsIDOMDocumentFragment> frag;
+ aRv = ParseFragmentXML(aFragment, document, tagStack,
+ aPreventScriptExecution, getter_AddRefs(frag));
+ return frag.forget().downcast<DocumentFragment>();
+}
+
+/* static */
+void
+nsContentUtils::DropFragmentParsers()
+{
+ NS_IF_RELEASE(sHTMLFragmentParser);
+ NS_IF_RELEASE(sXMLFragmentParser);
+ NS_IF_RELEASE(sXMLFragmentSink);
+}
+
+/* static */
+void
+nsContentUtils::XPCOMShutdown()
+{
+ nsContentUtils::DropFragmentParsers();
+}
+
+/* static */
+nsresult
+nsContentUtils::ParseFragmentHTML(const nsAString& aSourceBuffer,
+ nsIContent* aTargetNode,
+ nsIAtom* aContextLocalName,
+ int32_t aContextNamespace,
+ bool aQuirks,
+ bool aPreventScriptExecution)
+{
+ AutoTimelineMarker m(aTargetNode->OwnerDoc()->GetDocShell(), "Parse HTML");
+
+ if (nsContentUtils::sFragmentParsingActive) {
+ NS_NOTREACHED("Re-entrant fragment parsing attempted.");
+ return NS_ERROR_DOM_INVALID_STATE_ERR;
+ }
+ mozilla::AutoRestore<bool> guard(nsContentUtils::sFragmentParsingActive);
+ nsContentUtils::sFragmentParsingActive = true;
+ if (!sHTMLFragmentParser) {
+ NS_ADDREF(sHTMLFragmentParser = new nsHtml5StringParser());
+ // Now sHTMLFragmentParser owns the object
+ }
+ nsresult rv =
+ sHTMLFragmentParser->ParseFragment(aSourceBuffer,
+ aTargetNode,
+ aContextLocalName,
+ aContextNamespace,
+ aQuirks,
+ aPreventScriptExecution);
+ return rv;
+}
+
+/* static */
+nsresult
+nsContentUtils::ParseDocumentHTML(const nsAString& aSourceBuffer,
+ nsIDocument* aTargetDocument,
+ bool aScriptingEnabledForNoscriptParsing)
+{
+ AutoTimelineMarker m(aTargetDocument->GetDocShell(), "Parse HTML");
+
+ if (nsContentUtils::sFragmentParsingActive) {
+ NS_NOTREACHED("Re-entrant fragment parsing attempted.");
+ return NS_ERROR_DOM_INVALID_STATE_ERR;
+ }
+ mozilla::AutoRestore<bool> guard(nsContentUtils::sFragmentParsingActive);
+ nsContentUtils::sFragmentParsingActive = true;
+ if (!sHTMLFragmentParser) {
+ NS_ADDREF(sHTMLFragmentParser = new nsHtml5StringParser());
+ // Now sHTMLFragmentParser owns the object
+ }
+ nsresult rv =
+ sHTMLFragmentParser->ParseDocument(aSourceBuffer,
+ aTargetDocument,
+ aScriptingEnabledForNoscriptParsing);
+ return rv;
+}
+
+/* static */
+nsresult
+nsContentUtils::ParseFragmentXML(const nsAString& aSourceBuffer,
+ nsIDocument* aDocument,
+ nsTArray<nsString>& aTagStack,
+ bool aPreventScriptExecution,
+ nsIDOMDocumentFragment** aReturn)
+{
+ AutoTimelineMarker m(aDocument->GetDocShell(), "Parse XML");
+
+ if (nsContentUtils::sFragmentParsingActive) {
+ NS_NOTREACHED("Re-entrant fragment parsing attempted.");
+ return NS_ERROR_DOM_INVALID_STATE_ERR;
+ }
+ mozilla::AutoRestore<bool> guard(nsContentUtils::sFragmentParsingActive);
+ nsContentUtils::sFragmentParsingActive = true;
+ if (!sXMLFragmentParser) {
+ nsCOMPtr<nsIParser> parser = do_CreateInstance(kCParserCID);
+ parser.forget(&sXMLFragmentParser);
+ // sXMLFragmentParser now owns the parser
+ }
+ if (!sXMLFragmentSink) {
+ NS_NewXMLFragmentContentSink(&sXMLFragmentSink);
+ // sXMLFragmentSink now owns the sink
+ }
+ nsCOMPtr<nsIContentSink> contentsink = do_QueryInterface(sXMLFragmentSink);
+ MOZ_ASSERT(contentsink, "Sink doesn't QI to nsIContentSink!");
+ sXMLFragmentParser->SetContentSink(contentsink);
+
+ sXMLFragmentSink->SetTargetDocument(aDocument);
+ sXMLFragmentSink->SetPreventScriptExecution(aPreventScriptExecution);
+
+ nsresult rv =
+ sXMLFragmentParser->ParseFragment(aSourceBuffer,
+ aTagStack);
+ if (NS_FAILED(rv)) {
+ // Drop the fragment parser and sink that might be in an inconsistent state
+ NS_IF_RELEASE(sXMLFragmentParser);
+ NS_IF_RELEASE(sXMLFragmentSink);
+ return rv;
+ }
+
+ rv = sXMLFragmentSink->FinishFragmentParsing(aReturn);
+
+ sXMLFragmentParser->Reset();
+
+ return rv;
+}
+
+/* static */
+nsresult
+nsContentUtils::ConvertToPlainText(const nsAString& aSourceBuffer,
+ nsAString& aResultBuffer,
+ uint32_t aFlags,
+ uint32_t aWrapCol)
+{
+ nsCOMPtr<nsIURI> uri;
+ NS_NewURI(getter_AddRefs(uri), "about:blank");
+ nsCOMPtr<nsIPrincipal> principal = nsNullPrincipal::Create();
+ nsCOMPtr<nsIDOMDocument> domDocument;
+ nsresult rv = NS_NewDOMDocument(getter_AddRefs(domDocument),
+ EmptyString(),
+ EmptyString(),
+ nullptr,
+ uri,
+ uri,
+ principal,
+ true,
+ nullptr,
+ DocumentFlavorHTML);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsIDocument> document = do_QueryInterface(domDocument);
+ rv = nsContentUtils::ParseDocumentHTML(aSourceBuffer, document,
+ !(aFlags & nsIDocumentEncoder::OutputNoScriptContent));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsIDocumentEncoder> encoder = do_CreateInstance(
+ "@mozilla.org/layout/documentEncoder;1?type=text/plain");
+
+ rv = encoder->Init(domDocument, NS_LITERAL_STRING("text/plain"), aFlags);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ encoder->SetWrapColumn(aWrapCol);
+
+ return encoder->EncodeToString(aResultBuffer);
+}
+
+/* static */
+nsresult
+nsContentUtils::SetNodeTextContent(nsIContent* aContent,
+ const nsAString& aValue,
+ bool aTryReuse)
+{
+ // Fire DOMNodeRemoved mutation events before we do anything else.
+ nsCOMPtr<nsIContent> owningContent;
+
+ // Batch possible DOMSubtreeModified events.
+ mozAutoSubtreeModified subtree(nullptr, nullptr);
+
+ // Scope firing mutation events so that we don't carry any state that
+ // might be stale
+ {
+ // We're relying on mozAutoSubtreeModified to keep a strong reference if
+ // needed.
+ nsIDocument* doc = aContent->OwnerDoc();
+
+ // Optimize the common case of there being no observers
+ if (HasMutationListeners(doc, NS_EVENT_BITS_MUTATION_NODEREMOVED)) {
+ subtree.UpdateTarget(doc, nullptr);
+ owningContent = aContent;
+ nsCOMPtr<nsINode> child;
+ bool skipFirst = aTryReuse;
+ for (child = aContent->GetFirstChild();
+ child && child->GetParentNode() == aContent;
+ child = child->GetNextSibling()) {
+ if (skipFirst && child->IsNodeOfType(nsINode::eTEXT)) {
+ skipFirst = false;
+ continue;
+ }
+ nsContentUtils::MaybeFireNodeRemoved(child, aContent, doc);
+ }
+ }
+ }
+
+ // Might as well stick a batch around this since we're performing several
+ // mutations.
+ mozAutoDocUpdate updateBatch(aContent->GetComposedDoc(),
+ UPDATE_CONTENT_MODEL, true);
+ nsAutoMutationBatch mb;
+
+ uint32_t childCount = aContent->GetChildCount();
+
+ if (aTryReuse && !aValue.IsEmpty()) {
+ uint32_t removeIndex = 0;
+
+ for (uint32_t i = 0; i < childCount; ++i) {
+ nsIContent* child = aContent->GetChildAt(removeIndex);
+ if (removeIndex == 0 && child && child->IsNodeOfType(nsINode::eTEXT)) {
+ nsresult rv = child->SetText(aValue, true);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ removeIndex = 1;
+ }
+ else {
+ aContent->RemoveChildAt(removeIndex, true);
+ }
+ }
+
+ if (removeIndex == 1) {
+ return NS_OK;
+ }
+ }
+ else {
+ mb.Init(aContent, true, false);
+ for (uint32_t i = 0; i < childCount; ++i) {
+ aContent->RemoveChildAt(0, true);
+ }
+ }
+ mb.RemovalDone();
+
+ if (aValue.IsEmpty()) {
+ return NS_OK;
+ }
+
+ RefPtr<nsTextNode> textContent =
+ new nsTextNode(aContent->NodeInfo()->NodeInfoManager());
+
+ textContent->SetText(aValue, true);
+
+ nsresult rv = aContent->AppendChildTo(textContent, true);
+ mb.NodesAdded();
+ return rv;
+}
+
+static bool
+AppendNodeTextContentsRecurse(nsINode* aNode, nsAString& aResult,
+ const fallible_t& aFallible)
+{
+ for (nsIContent* child = aNode->GetFirstChild();
+ child;
+ child = child->GetNextSibling()) {
+ if (child->IsElement()) {
+ bool ok = AppendNodeTextContentsRecurse(child, aResult,
+ aFallible);
+ if (!ok) {
+ return false;
+ }
+ }
+ else if (child->IsNodeOfType(nsINode::eTEXT)) {
+ bool ok = child->AppendTextTo(aResult, aFallible);
+ if (!ok) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+}
+
+/* static */
+bool
+nsContentUtils::AppendNodeTextContent(nsINode* aNode, bool aDeep,
+ nsAString& aResult,
+ const fallible_t& aFallible)
+{
+ if (aNode->IsNodeOfType(nsINode::eTEXT)) {
+ return static_cast<nsIContent*>(aNode)->AppendTextTo(aResult,
+ aFallible);
+ }
+ else if (aDeep) {
+ return AppendNodeTextContentsRecurse(aNode, aResult, aFallible);
+ }
+ else {
+ for (nsIContent* child = aNode->GetFirstChild();
+ child;
+ child = child->GetNextSibling()) {
+ if (child->IsNodeOfType(nsINode::eTEXT)) {
+ bool ok = child->AppendTextTo(aResult, fallible);
+ if (!ok) {
+ return false;
+ }
+ }
+ }
+ }
+
+ return true;
+}
+
+bool
+nsContentUtils::HasNonEmptyTextContent(nsINode* aNode,
+ TextContentDiscoverMode aDiscoverMode)
+{
+ for (nsIContent* child = aNode->GetFirstChild();
+ child;
+ child = child->GetNextSibling()) {
+ if (child->IsNodeOfType(nsINode::eTEXT) &&
+ child->TextLength() > 0) {
+ return true;
+ }
+
+ if (aDiscoverMode == eRecurseIntoChildren &&
+ HasNonEmptyTextContent(child, aDiscoverMode)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+/* static */
+bool
+nsContentUtils::IsInSameAnonymousTree(const nsINode* aNode,
+ const nsIContent* aContent)
+{
+ NS_PRECONDITION(aNode,
+ "Must have a node to work with");
+ NS_PRECONDITION(aContent,
+ "Must have a content to work with");
+
+ if (!aNode->IsNodeOfType(nsINode::eCONTENT)) {
+ /**
+ * The root isn't an nsIContent, so it's a document or attribute. The only
+ * nodes in the same anonymous subtree as it will have a null
+ * bindingParent.
+ *
+ * XXXbz strictly speaking, that's not true for attribute nodes.
+ */
+ return aContent->GetBindingParent() == nullptr;
+ }
+
+ const nsIContent* nodeAsContent = static_cast<const nsIContent*>(aNode);
+
+ // For nodes in a shadow tree, it is insufficient to simply compare
+ // the binding parent because a node may host multiple ShadowRoots,
+ // thus nodes in different shadow tree may have the same binding parent.
+ if (aNode->IsInShadowTree()) {
+ return nodeAsContent->GetContainingShadow() ==
+ aContent->GetContainingShadow();
+ }
+
+ return nodeAsContent->GetBindingParent() == aContent->GetBindingParent();
+}
+
+class AnonymousContentDestroyer : public Runnable {
+public:
+ explicit AnonymousContentDestroyer(nsCOMPtr<nsIContent>* aContent) {
+ mContent.swap(*aContent);
+ mParent = mContent->GetParent();
+ mDoc = mContent->OwnerDoc();
+ }
+ explicit AnonymousContentDestroyer(nsCOMPtr<Element>* aElement) {
+ mContent = aElement->forget();
+ mParent = mContent->GetParent();
+ mDoc = mContent->OwnerDoc();
+ }
+ NS_IMETHOD Run() override {
+ mContent->UnbindFromTree();
+ return NS_OK;
+ }
+private:
+ nsCOMPtr<nsIContent> mContent;
+ // Hold strong refs to the parent content and document so that they
+ // don't die unexpectedly
+ nsCOMPtr<nsIDocument> mDoc;
+ nsCOMPtr<nsIContent> mParent;
+};
+
+/* static */
+void
+nsContentUtils::DestroyAnonymousContent(nsCOMPtr<nsIContent>* aContent)
+{
+ if (*aContent) {
+ AddScriptRunner(new AnonymousContentDestroyer(aContent));
+ }
+}
+
+/* static */
+void
+nsContentUtils::DestroyAnonymousContent(nsCOMPtr<Element>* aElement)
+{
+ if (*aElement) {
+ AddScriptRunner(new AnonymousContentDestroyer(aElement));
+ }
+}
+
+/* static */
+void
+nsContentUtils::NotifyInstalledMenuKeyboardListener(bool aInstalling)
+{
+ IMEStateManager::OnInstalledMenuKeyboardListener(aInstalling);
+}
+
+static bool SchemeIs(nsIURI* aURI, const char* aScheme)
+{
+ nsCOMPtr<nsIURI> baseURI = NS_GetInnermostURI(aURI);
+ NS_ENSURE_TRUE(baseURI, false);
+
+ bool isScheme = false;
+ return NS_SUCCEEDED(baseURI->SchemeIs(aScheme, &isScheme)) && isScheme;
+}
+
+bool
+nsContentUtils::IsSystemPrincipal(nsIPrincipal* aPrincipal)
+{
+ MOZ_ASSERT(IsInitialized());
+ return aPrincipal == sSystemPrincipal;
+}
+
+bool
+nsContentUtils::IsExpandedPrincipal(nsIPrincipal* aPrincipal)
+{
+ nsCOMPtr<nsIExpandedPrincipal> ep = do_QueryInterface(aPrincipal);
+ return !!ep;
+}
+
+nsIPrincipal*
+nsContentUtils::GetSystemPrincipal()
+{
+ MOZ_ASSERT(IsInitialized());
+ return sSystemPrincipal;
+}
+
+bool
+nsContentUtils::CombineResourcePrincipals(nsCOMPtr<nsIPrincipal>* aResourcePrincipal,
+ nsIPrincipal* aExtraPrincipal)
+{
+ if (!aExtraPrincipal) {
+ return false;
+ }
+ if (!*aResourcePrincipal) {
+ *aResourcePrincipal = aExtraPrincipal;
+ return true;
+ }
+ if (*aResourcePrincipal == aExtraPrincipal) {
+ return false;
+ }
+ bool subsumes;
+ if (NS_SUCCEEDED((*aResourcePrincipal)->Subsumes(aExtraPrincipal, &subsumes)) &&
+ subsumes) {
+ return false;
+ }
+ *aResourcePrincipal = sSystemPrincipal;
+ return true;
+}
+
+/* static */
+void
+nsContentUtils::TriggerLink(nsIContent *aContent, nsPresContext *aPresContext,
+ nsIURI *aLinkURI, const nsString &aTargetSpec,
+ bool aClick, bool aIsUserTriggered,
+ bool aIsTrusted)
+{
+ NS_ASSERTION(aPresContext, "Need a nsPresContext");
+ NS_PRECONDITION(aLinkURI, "No link URI");
+
+ if (aContent->IsEditable()) {
+ return;
+ }
+
+ nsILinkHandler *handler = aPresContext->GetLinkHandler();
+ if (!handler) {
+ return;
+ }
+
+ if (!aClick) {
+ handler->OnOverLink(aContent, aLinkURI, aTargetSpec.get());
+ return;
+ }
+
+ // Check that this page is allowed to load this URI.
+ nsresult proceed = NS_OK;
+
+ if (sSecurityManager) {
+ uint32_t flag =
+ aIsUserTriggered ?
+ (uint32_t)nsIScriptSecurityManager::STANDARD :
+ (uint32_t)nsIScriptSecurityManager::LOAD_IS_AUTOMATIC_DOCUMENT_REPLACEMENT;
+ proceed =
+ sSecurityManager->CheckLoadURIWithPrincipal(aContent->NodePrincipal(),
+ aLinkURI, flag);
+ }
+
+ // Only pass off the click event if the script security manager says it's ok.
+ // We need to rest aTargetSpec for forced downloads.
+ if (NS_SUCCEEDED(proceed)) {
+
+ // A link/area element with a download attribute is allowed to set
+ // a pseudo Content-Disposition header.
+ // For security reasons we only allow websites to declare same-origin resources
+ // as downloadable. If this check fails we will just do the normal thing
+ // (i.e. navigate to the resource).
+ nsAutoString fileName;
+ if ((!aContent->IsHTMLElement(nsGkAtoms::a) &&
+ !aContent->IsHTMLElement(nsGkAtoms::area) &&
+ !aContent->IsSVGElement(nsGkAtoms::a)) ||
+ !aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::download, fileName) ||
+ NS_FAILED(aContent->NodePrincipal()->CheckMayLoad(aLinkURI, false, true))) {
+ fileName.SetIsVoid(true); // No actionable download attribute was found.
+ }
+
+ handler->OnLinkClick(aContent, aLinkURI,
+ fileName.IsVoid() ? aTargetSpec.get() : EmptyString().get(),
+ fileName, nullptr, nullptr, aIsTrusted);
+ }
+}
+
+/* static */
+void
+nsContentUtils::GetLinkLocation(Element* aElement, nsString& aLocationString)
+{
+ nsCOMPtr<nsIURI> hrefURI = aElement->GetHrefURI();
+ if (hrefURI) {
+ nsAutoCString specUTF8;
+ nsresult rv = hrefURI->GetSpec(specUTF8);
+ if (NS_SUCCEEDED(rv))
+ CopyUTF8toUTF16(specUTF8, aLocationString);
+ }
+}
+
+/* static */
+nsIWidget*
+nsContentUtils::GetTopLevelWidget(nsIWidget* aWidget)
+{
+ if (!aWidget)
+ return nullptr;
+
+ return aWidget->GetTopLevelWidget();
+}
+
+/* static */
+const nsDependentString
+nsContentUtils::GetLocalizedEllipsis()
+{
+ static char16_t sBuf[4] = { 0, 0, 0, 0 };
+ if (!sBuf[0]) {
+ nsAdoptingString tmp = Preferences::GetLocalizedString("intl.ellipsis");
+ uint32_t len = std::min(uint32_t(tmp.Length()),
+ uint32_t(ArrayLength(sBuf) - 1));
+ CopyUnicodeTo(tmp, 0, sBuf, len);
+ if (!sBuf[0])
+ sBuf[0] = char16_t(0x2026);
+ }
+ return nsDependentString(sBuf);
+}
+
+/* static */
+void
+nsContentUtils::AddScriptBlocker()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ if (!sScriptBlockerCount) {
+ MOZ_ASSERT(sRunnersCountAtFirstBlocker == 0,
+ "Should not already have a count");
+ sRunnersCountAtFirstBlocker = sBlockedScriptRunners ? sBlockedScriptRunners->Length() : 0;
+ }
+ ++sScriptBlockerCount;
+}
+
+#ifdef DEBUG
+static bool sRemovingScriptBlockers = false;
+#endif
+
+/* static */
+void
+nsContentUtils::RemoveScriptBlocker()
+{
+ MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(!sRemovingScriptBlockers);
+ NS_ASSERTION(sScriptBlockerCount != 0, "Negative script blockers");
+ --sScriptBlockerCount;
+ if (sScriptBlockerCount) {
+ return;
+ }
+
+ if (!sBlockedScriptRunners) {
+ return;
+ }
+
+ uint32_t firstBlocker = sRunnersCountAtFirstBlocker;
+ uint32_t lastBlocker = sBlockedScriptRunners->Length();
+ uint32_t originalFirstBlocker = firstBlocker;
+ uint32_t blockersCount = lastBlocker - firstBlocker;
+ sRunnersCountAtFirstBlocker = 0;
+ NS_ASSERTION(firstBlocker <= lastBlocker,
+ "bad sRunnersCountAtFirstBlocker");
+
+ while (firstBlocker < lastBlocker) {
+ nsCOMPtr<nsIRunnable> runnable;
+ runnable.swap((*sBlockedScriptRunners)[firstBlocker]);
+ ++firstBlocker;
+
+ // Calling the runnable can reenter us
+ runnable->Run();
+ // So can dropping the reference to the runnable
+ runnable = nullptr;
+
+ NS_ASSERTION(sRunnersCountAtFirstBlocker == 0,
+ "Bad count");
+ NS_ASSERTION(!sScriptBlockerCount, "This is really bad");
+ }
+#ifdef DEBUG
+ AutoRestore<bool> removingScriptBlockers(sRemovingScriptBlockers);
+ sRemovingScriptBlockers = true;
+#endif
+ sBlockedScriptRunners->RemoveElementsAt(originalFirstBlocker, blockersCount);
+}
+
+/* static */
+nsIWindowProvider*
+nsContentUtils::GetWindowProviderForContentProcess()
+{
+ MOZ_ASSERT(XRE_IsContentProcess());
+ return ContentChild::GetSingleton();
+}
+
+/* static */
+already_AddRefed<nsPIDOMWindowOuter>
+nsContentUtils::GetMostRecentNonPBWindow()
+{
+ nsCOMPtr<nsIWindowMediator> windowMediator =
+ do_GetService(NS_WINDOWMEDIATOR_CONTRACTID);
+ nsCOMPtr<nsIWindowMediator_44> wm = do_QueryInterface(windowMediator);
+
+ nsCOMPtr<mozIDOMWindowProxy> window;
+ wm->GetMostRecentNonPBWindow(u"navigator:browser",
+ getter_AddRefs(window));
+ nsCOMPtr<nsPIDOMWindowOuter> pwindow;
+ pwindow = do_QueryInterface(window);
+
+ return pwindow.forget();
+}
+
+/* static */
+void
+nsContentUtils::WarnScriptWasIgnored(nsIDocument* aDocument)
+{
+ nsAutoString msg;
+ if (aDocument) {
+ nsCOMPtr<nsIURI> uri = aDocument->GetDocumentURI();
+ if (uri) {
+ msg.Append(NS_ConvertUTF8toUTF16(uri->GetSpecOrDefault()));
+ msg.AppendLiteral(" : ");
+ }
+ }
+ msg.AppendLiteral("Unable to run script because scripts are blocked internally.");
+
+ LogSimpleConsoleError(msg, "DOM");
+}
+
+/* static */
+void
+nsContentUtils::AddScriptRunner(already_AddRefed<nsIRunnable> aRunnable)
+{
+ nsCOMPtr<nsIRunnable> runnable = aRunnable;
+ if (!runnable) {
+ return;
+ }
+
+ if (sScriptBlockerCount) {
+ sBlockedScriptRunners->AppendElement(runnable.forget());
+ return;
+ }
+
+ runnable->Run();
+}
+
+/* static */
+void
+nsContentUtils::AddScriptRunner(nsIRunnable* aRunnable) {
+ nsCOMPtr<nsIRunnable> runnable = aRunnable;
+ AddScriptRunner(runnable.forget());
+}
+
+/* static */
+void
+nsContentUtils::RunInStableState(already_AddRefed<nsIRunnable> aRunnable)
+{
+ MOZ_ASSERT(CycleCollectedJSContext::Get(), "Must be on a script thread!");
+ CycleCollectedJSContext::Get()->RunInStableState(Move(aRunnable));
+}
+
+/* static */
+void
+nsContentUtils::RunInMetastableState(already_AddRefed<nsIRunnable> aRunnable)
+{
+ MOZ_ASSERT(CycleCollectedJSContext::Get(), "Must be on a script thread!");
+ CycleCollectedJSContext::Get()->RunInMetastableState(Move(aRunnable));
+}
+
+void
+nsContentUtils::EnterMicroTask()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ ++sMicroTaskLevel;
+}
+
+void
+nsContentUtils::LeaveMicroTask()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ if (--sMicroTaskLevel == 0) {
+ PerformMainThreadMicroTaskCheckpoint();
+ }
+}
+
+bool
+nsContentUtils::IsInMicroTask()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ return sMicroTaskLevel != 0;
+}
+
+uint32_t
+nsContentUtils::MicroTaskLevel()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ return sMicroTaskLevel;
+}
+
+void
+nsContentUtils::SetMicroTaskLevel(uint32_t aLevel)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ sMicroTaskLevel = aLevel;
+}
+
+void
+nsContentUtils::PerformMainThreadMicroTaskCheckpoint()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ nsDOMMutationObserver::HandleMutations();
+}
+
+/*
+ * Helper function for nsContentUtils::ProcessViewportInfo.
+ *
+ * Handles a single key=value pair. If it corresponds to a valid viewport
+ * attribute, add it to the document header data. No validation is done on the
+ * value itself (this is done at display time).
+ */
+static void ProcessViewportToken(nsIDocument *aDocument,
+ const nsAString &token) {
+
+ /* Iterators. */
+ nsAString::const_iterator tip, tail, end;
+ token.BeginReading(tip);
+ tail = tip;
+ token.EndReading(end);
+
+ /* Move tip to the '='. */
+ while ((tip != end) && (*tip != '='))
+ ++tip;
+
+ /* If we didn't find an '=', punt. */
+ if (tip == end)
+ return;
+
+ /* Extract the key and value. */
+ const nsAString &key =
+ nsContentUtils::TrimWhitespace<nsCRT::IsAsciiSpace>(Substring(tail, tip),
+ true);
+ const nsAString &value =
+ nsContentUtils::TrimWhitespace<nsCRT::IsAsciiSpace>(Substring(++tip, end),
+ true);
+
+ /* Check for known keys. If we find a match, insert the appropriate
+ * information into the document header. */
+ nsCOMPtr<nsIAtom> key_atom = NS_Atomize(key);
+ if (key_atom == nsGkAtoms::height)
+ aDocument->SetHeaderData(nsGkAtoms::viewport_height, value);
+ else if (key_atom == nsGkAtoms::width)
+ aDocument->SetHeaderData(nsGkAtoms::viewport_width, value);
+ else if (key_atom == nsGkAtoms::initial_scale)
+ aDocument->SetHeaderData(nsGkAtoms::viewport_initial_scale, value);
+ else if (key_atom == nsGkAtoms::minimum_scale)
+ aDocument->SetHeaderData(nsGkAtoms::viewport_minimum_scale, value);
+ else if (key_atom == nsGkAtoms::maximum_scale)
+ aDocument->SetHeaderData(nsGkAtoms::viewport_maximum_scale, value);
+ else if (key_atom == nsGkAtoms::user_scalable)
+ aDocument->SetHeaderData(nsGkAtoms::viewport_user_scalable, value);
+}
+
+#define IS_SEPARATOR(c) ((c == '=') || (c == ',') || (c == ';') || \
+ (c == '\t') || (c == '\n') || (c == '\r'))
+
+/* static */
+nsresult
+nsContentUtils::ProcessViewportInfo(nsIDocument *aDocument,
+ const nsAString &viewportInfo) {
+
+ /* We never fail. */
+ nsresult rv = NS_OK;
+
+ aDocument->SetHeaderData(nsGkAtoms::viewport, viewportInfo);
+
+ /* Iterators. */
+ nsAString::const_iterator tip, tail, end;
+ viewportInfo.BeginReading(tip);
+ tail = tip;
+ viewportInfo.EndReading(end);
+
+ /* Read the tip to the first non-separator character. */
+ while ((tip != end) && (IS_SEPARATOR(*tip) || nsCRT::IsAsciiSpace(*tip)))
+ ++tip;
+
+ /* Read through and find tokens separated by separators. */
+ while (tip != end) {
+
+ /* Synchronize tip and tail. */
+ tail = tip;
+
+ /* Advance tip past non-separator characters. */
+ while ((tip != end) && !IS_SEPARATOR(*tip))
+ ++tip;
+
+ /* Allow white spaces that surround the '=' character */
+ if ((tip != end) && (*tip == '=')) {
+ ++tip;
+
+ while ((tip != end) && nsCRT::IsAsciiSpace(*tip))
+ ++tip;
+
+ while ((tip != end) && !(IS_SEPARATOR(*tip) || nsCRT::IsAsciiSpace(*tip)))
+ ++tip;
+ }
+
+ /* Our token consists of the characters between tail and tip. */
+ ProcessViewportToken(aDocument, Substring(tail, tip));
+
+ /* Skip separators. */
+ while ((tip != end) && (IS_SEPARATOR(*tip) || nsCRT::IsAsciiSpace(*tip)))
+ ++tip;
+ }
+
+ return rv;
+
+}
+
+#undef IS_SEPARATOR
+
+/* static */
+void
+nsContentUtils::HidePopupsInDocument(nsIDocument* aDocument)
+{
+#ifdef MOZ_XUL
+ nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+ if (pm && aDocument) {
+ nsCOMPtr<nsIDocShellTreeItem> docShellToHide = aDocument->GetDocShell();
+ if (docShellToHide)
+ pm->HidePopupsInDocShell(docShellToHide);
+ }
+#endif
+}
+
+/* static */
+already_AddRefed<nsIDragSession>
+nsContentUtils::GetDragSession()
+{
+ nsCOMPtr<nsIDragSession> dragSession;
+ nsCOMPtr<nsIDragService> dragService =
+ do_GetService("@mozilla.org/widget/dragservice;1");
+ if (dragService)
+ dragService->GetCurrentSession(getter_AddRefs(dragSession));
+ return dragSession.forget();
+}
+
+/* static */
+nsresult
+nsContentUtils::SetDataTransferInEvent(WidgetDragEvent* aDragEvent)
+{
+ if (aDragEvent->mDataTransfer || !aDragEvent->IsTrusted()) {
+ return NS_OK;
+ }
+
+ // For dragstart events, the data transfer object is
+ // created before the event fires, so it should already be set. For other
+ // drag events, get the object from the drag session.
+ NS_ASSERTION(aDragEvent->mMessage != eDragStart,
+ "draggesture event created without a dataTransfer");
+
+ nsCOMPtr<nsIDragSession> dragSession = GetDragSession();
+ NS_ENSURE_TRUE(dragSession, NS_OK); // no drag in progress
+
+ nsCOMPtr<nsIDOMDataTransfer> dataTransfer;
+ nsCOMPtr<DataTransfer> initialDataTransfer;
+ dragSession->GetDataTransfer(getter_AddRefs(dataTransfer));
+ if (dataTransfer) {
+ initialDataTransfer = do_QueryInterface(dataTransfer);
+ if (!initialDataTransfer) {
+ return NS_ERROR_FAILURE;
+ }
+ } else {
+ // A dataTransfer won't exist when a drag was started by some other
+ // means, for instance calling the drag service directly, or a drag
+ // from another application. In either case, a new dataTransfer should
+ // be created that reflects the data.
+ initialDataTransfer =
+ new DataTransfer(aDragEvent->mTarget, aDragEvent->mMessage, true, -1);
+
+ // now set it in the drag session so we don't need to create it again
+ dragSession->SetDataTransfer(initialDataTransfer);
+ }
+
+ bool isCrossDomainSubFrameDrop = false;
+ if (aDragEvent->mMessage == eDrop) {
+ isCrossDomainSubFrameDrop = CheckForSubFrameDrop(dragSession, aDragEvent);
+ }
+
+ // each event should use a clone of the original dataTransfer.
+ initialDataTransfer->Clone(aDragEvent->mTarget, aDragEvent->mMessage,
+ aDragEvent->mUserCancelled,
+ isCrossDomainSubFrameDrop,
+ getter_AddRefs(aDragEvent->mDataTransfer));
+ if (NS_WARN_IF(!aDragEvent->mDataTransfer)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ // for the dragenter and dragover events, initialize the drop effect
+ // from the drop action, which platform specific widget code sets before
+ // the event is fired based on the keyboard state.
+ if (aDragEvent->mMessage == eDragEnter || aDragEvent->mMessage == eDragOver) {
+ uint32_t action, effectAllowed;
+ dragSession->GetDragAction(&action);
+ aDragEvent->mDataTransfer->GetEffectAllowedInt(&effectAllowed);
+ aDragEvent->mDataTransfer->SetDropEffectInt(
+ FilterDropEffect(action, effectAllowed));
+ }
+ else if (aDragEvent->mMessage == eDrop ||
+ aDragEvent->mMessage == eDragEnd) {
+ // For the drop and dragend events, set the drop effect based on the
+ // last value that the dropEffect had. This will have been set in
+ // EventStateManager::PostHandleEvent for the last dragenter or
+ // dragover event.
+ uint32_t dropEffect;
+ initialDataTransfer->GetDropEffectInt(&dropEffect);
+ aDragEvent->mDataTransfer->SetDropEffectInt(dropEffect);
+ }
+
+ return NS_OK;
+}
+
+/* static */
+uint32_t
+nsContentUtils::FilterDropEffect(uint32_t aAction, uint32_t aEffectAllowed)
+{
+ // It is possible for the drag action to include more than one action, but
+ // the widget code which sets the action from the keyboard state should only
+ // be including one. If multiple actions were set, we just consider them in
+ // the following order:
+ // copy, link, move
+ if (aAction & nsIDragService::DRAGDROP_ACTION_COPY)
+ aAction = nsIDragService::DRAGDROP_ACTION_COPY;
+ else if (aAction & nsIDragService::DRAGDROP_ACTION_LINK)
+ aAction = nsIDragService::DRAGDROP_ACTION_LINK;
+ else if (aAction & nsIDragService::DRAGDROP_ACTION_MOVE)
+ aAction = nsIDragService::DRAGDROP_ACTION_MOVE;
+
+ // Filter the action based on the effectAllowed. If the effectAllowed
+ // doesn't include the action, then that action cannot be done, so adjust
+ // the action to something that is allowed. For a copy, adjust to move or
+ // link. For a move, adjust to copy or link. For a link, adjust to move or
+ // link. Otherwise, use none.
+ if (aAction & aEffectAllowed ||
+ aEffectAllowed == nsIDragService::DRAGDROP_ACTION_UNINITIALIZED)
+ return aAction;
+ if (aEffectAllowed & nsIDragService::DRAGDROP_ACTION_MOVE)
+ return nsIDragService::DRAGDROP_ACTION_MOVE;
+ if (aEffectAllowed & nsIDragService::DRAGDROP_ACTION_COPY)
+ return nsIDragService::DRAGDROP_ACTION_COPY;
+ if (aEffectAllowed & nsIDragService::DRAGDROP_ACTION_LINK)
+ return nsIDragService::DRAGDROP_ACTION_LINK;
+ return nsIDragService::DRAGDROP_ACTION_NONE;
+}
+
+/* static */
+bool
+nsContentUtils::CheckForSubFrameDrop(nsIDragSession* aDragSession,
+ WidgetDragEvent* aDropEvent)
+{
+ nsCOMPtr<nsIContent> target = do_QueryInterface(aDropEvent->mOriginalTarget);
+ if (!target) {
+ return true;
+ }
+
+ nsIDocument* targetDoc = target->OwnerDoc();
+ nsPIDOMWindowOuter* targetWin = targetDoc->GetWindow();
+ if (!targetWin) {
+ return true;
+ }
+
+ nsCOMPtr<nsIDocShellTreeItem> tdsti = targetWin->GetDocShell();
+ if (!tdsti) {
+ return true;
+ }
+
+ // Always allow dropping onto chrome shells.
+ if (tdsti->ItemType() == nsIDocShellTreeItem::typeChrome) {
+ return false;
+ }
+
+ // If there is no source node, then this is a drag from another
+ // application, which should be allowed.
+ nsCOMPtr<nsIDOMDocument> sourceDocument;
+ aDragSession->GetSourceDocument(getter_AddRefs(sourceDocument));
+ nsCOMPtr<nsIDocument> doc = do_QueryInterface(sourceDocument);
+ if (doc) {
+ // Get each successive parent of the source document and compare it to
+ // the drop document. If they match, then this is a drag from a child frame.
+ do {
+ doc = doc->GetParentDocument();
+ if (doc == targetDoc) {
+ // The drag is from a child frame.
+ return true;
+ }
+ } while (doc);
+ }
+
+ return false;
+}
+
+/* static */
+bool
+nsContentUtils::URIIsLocalFile(nsIURI *aURI)
+{
+ bool isFile;
+ nsCOMPtr<nsINetUtil> util = do_QueryInterface(sIOService);
+
+ // Important: we do NOT test the entire URI chain here!
+ return util && NS_SUCCEEDED(util->ProtocolHasFlags(aURI,
+ nsIProtocolHandler::URI_IS_LOCAL_FILE,
+ &isFile)) &&
+ isFile;
+}
+
+/* static */
+nsIScriptContext*
+nsContentUtils::GetContextForEventHandlers(nsINode* aNode,
+ nsresult* aRv)
+{
+ *aRv = NS_OK;
+ bool hasHadScriptObject = true;
+ nsIScriptGlobalObject* sgo =
+ aNode->OwnerDoc()->GetScriptHandlingObject(hasHadScriptObject);
+ // It is bad if the document doesn't have event handling context,
+ // but it used to have one.
+ if (!sgo && hasHadScriptObject) {
+ *aRv = NS_ERROR_UNEXPECTED;
+ return nullptr;
+ }
+
+ if (sgo) {
+ nsIScriptContext* scx = sgo->GetContext();
+ // Bad, no context from script global object!
+ if (!scx) {
+ *aRv = NS_ERROR_UNEXPECTED;
+ return nullptr;
+ }
+ return scx;
+ }
+
+ return nullptr;
+}
+
+/* static */
+JSContext *
+nsContentUtils::GetCurrentJSContext()
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(IsInitialized());
+ if (!IsJSAPIActive()) {
+ return nullptr;
+ }
+ return danger::GetJSContext();
+}
+
+/* static */
+JSContext *
+nsContentUtils::GetCurrentJSContextForThread()
+{
+ MOZ_ASSERT(IsInitialized());
+ if (MOZ_LIKELY(NS_IsMainThread())) {
+ return GetCurrentJSContext();
+ } else {
+ return workers::GetCurrentThreadJSContext();
+ }
+}
+
+template<typename StringType, typename CharType>
+void
+_ASCIIToLowerInSitu(StringType& aStr)
+{
+ CharType* iter = aStr.BeginWriting();
+ CharType* end = aStr.EndWriting();
+ MOZ_ASSERT(iter && end);
+
+ while (iter != end) {
+ CharType c = *iter;
+ if (c >= 'A' && c <= 'Z') {
+ *iter = c + ('a' - 'A');
+ }
+ ++iter;
+ }
+}
+
+/* static */
+void
+nsContentUtils::ASCIIToLower(nsAString& aStr)
+{
+ return _ASCIIToLowerInSitu<nsAString, char16_t>(aStr);
+}
+
+/* static */
+void
+nsContentUtils::ASCIIToLower(nsACString& aStr)
+{
+ return _ASCIIToLowerInSitu<nsACString, char>(aStr);
+}
+
+template<typename StringType, typename CharType>
+void
+_ASCIIToLowerCopy(const StringType& aSource, StringType& aDest)
+{
+ uint32_t len = aSource.Length();
+ aDest.SetLength(len);
+ MOZ_ASSERT(aDest.Length() == len);
+
+ CharType* dest = aDest.BeginWriting();
+ MOZ_ASSERT(dest);
+
+ const CharType* iter = aSource.BeginReading();
+ const CharType* end = aSource.EndReading();
+ while (iter != end) {
+ CharType c = *iter;
+ *dest = (c >= 'A' && c <= 'Z') ?
+ c + ('a' - 'A') : c;
+ ++iter;
+ ++dest;
+ }
+}
+
+/* static */
+void
+nsContentUtils::ASCIIToLower(const nsAString& aSource, nsAString& aDest) {
+ return _ASCIIToLowerCopy<nsAString, char16_t>(aSource, aDest);
+}
+
+/* static */
+void
+nsContentUtils::ASCIIToLower(const nsACString& aSource, nsACString& aDest) {
+ return _ASCIIToLowerCopy<nsACString, char>(aSource, aDest);
+}
+
+
+template<typename StringType, typename CharType>
+void
+_ASCIIToUpperInSitu(StringType& aStr)
+{
+ CharType* iter = aStr.BeginWriting();
+ CharType* end = aStr.EndWriting();
+ MOZ_ASSERT(iter && end);
+
+ while (iter != end) {
+ CharType c = *iter;
+ if (c >= 'a' && c <= 'z') {
+ *iter = c + ('A' - 'a');
+ }
+ ++iter;
+ }
+}
+
+/* static */
+void
+nsContentUtils::ASCIIToUpper(nsAString& aStr)
+{
+ return _ASCIIToUpperInSitu<nsAString, char16_t>(aStr);
+}
+
+/* static */
+void
+nsContentUtils::ASCIIToUpper(nsACString& aStr)
+{
+ return _ASCIIToUpperInSitu<nsACString, char>(aStr);
+}
+
+template<typename StringType, typename CharType>
+void
+_ASCIIToUpperCopy(const StringType& aSource, StringType& aDest)
+{
+ uint32_t len = aSource.Length();
+ aDest.SetLength(len);
+ MOZ_ASSERT(aDest.Length() == len);
+
+ CharType* dest = aDest.BeginWriting();
+ MOZ_ASSERT(dest);
+
+ const CharType* iter = aSource.BeginReading();
+ const CharType* end = aSource.EndReading();
+ while (iter != end) {
+ CharType c = *iter;
+ *dest = (c >= 'a' && c <= 'z') ?
+ c + ('A' - 'a') : c;
+ ++iter;
+ ++dest;
+ }
+}
+
+/* static */
+void
+nsContentUtils::ASCIIToUpper(const nsAString& aSource, nsAString& aDest)
+{
+ return _ASCIIToUpperCopy<nsAString, char16_t>(aSource, aDest);
+}
+
+/* static */
+void
+nsContentUtils::ASCIIToUpper(const nsACString& aSource, nsACString& aDest)
+{
+ return _ASCIIToUpperCopy<nsACString, char>(aSource, aDest);
+}
+
+/* static */
+bool
+nsContentUtils::EqualsIgnoreASCIICase(const nsAString& aStr1,
+ const nsAString& aStr2)
+{
+ uint32_t len = aStr1.Length();
+ if (len != aStr2.Length()) {
+ return false;
+ }
+
+ const char16_t* str1 = aStr1.BeginReading();
+ const char16_t* str2 = aStr2.BeginReading();
+ const char16_t* end = str1 + len;
+
+ while (str1 < end) {
+ char16_t c1 = *str1++;
+ char16_t c2 = *str2++;
+
+ // First check if any bits other than the 0x0020 differs
+ if ((c1 ^ c2) & 0xffdf) {
+ return false;
+ }
+
+ // We know they can only differ in the 0x0020 bit.
+ // Likely the two chars are the same, so check that first
+ if (c1 != c2) {
+ // They do differ, but since it's only in the 0x0020 bit, check if it's
+ // the same ascii char, but just differing in case
+ char16_t c1Upper = c1 & 0xffdf;
+ if (!('A' <= c1Upper && c1Upper <= 'Z')) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+}
+
+/* static */
+bool
+nsContentUtils::StringContainsASCIIUpper(const nsAString& aStr)
+{
+ const char16_t* iter = aStr.BeginReading();
+ const char16_t* end = aStr.EndReading();
+ while (iter != end) {
+ char16_t c = *iter;
+ if (c >= 'A' && c <= 'Z') {
+ return true;
+ }
+ ++iter;
+ }
+
+ return false;
+}
+
+/* static */
+nsIInterfaceRequestor*
+nsContentUtils::SameOriginChecker()
+{
+ if (!sSameOriginChecker) {
+ sSameOriginChecker = new SameOriginCheckerImpl();
+ NS_ADDREF(sSameOriginChecker);
+ }
+ return sSameOriginChecker;
+}
+
+/* static */
+nsresult
+nsContentUtils::CheckSameOrigin(nsIChannel *aOldChannel, nsIChannel *aNewChannel)
+{
+ if (!nsContentUtils::GetSecurityManager())
+ return NS_ERROR_NOT_AVAILABLE;
+
+ nsCOMPtr<nsIPrincipal> oldPrincipal;
+ nsContentUtils::GetSecurityManager()->
+ GetChannelResultPrincipal(aOldChannel, getter_AddRefs(oldPrincipal));
+
+ nsCOMPtr<nsIURI> newURI;
+ aNewChannel->GetURI(getter_AddRefs(newURI));
+ nsCOMPtr<nsIURI> newOriginalURI;
+ aNewChannel->GetOriginalURI(getter_AddRefs(newOriginalURI));
+
+ NS_ENSURE_STATE(oldPrincipal && newURI && newOriginalURI);
+
+ nsresult rv = oldPrincipal->CheckMayLoad(newURI, false, false);
+ if (NS_SUCCEEDED(rv) && newOriginalURI != newURI) {
+ rv = oldPrincipal->CheckMayLoad(newOriginalURI, false, false);
+ }
+
+ return rv;
+}
+
+NS_IMPL_ISUPPORTS(SameOriginCheckerImpl,
+ nsIChannelEventSink,
+ nsIInterfaceRequestor)
+
+NS_IMETHODIMP
+SameOriginCheckerImpl::AsyncOnChannelRedirect(nsIChannel* aOldChannel,
+ nsIChannel* aNewChannel,
+ uint32_t aFlags,
+ nsIAsyncVerifyRedirectCallback* cb)
+{
+ NS_PRECONDITION(aNewChannel, "Redirecting to null channel?");
+
+ nsresult rv = nsContentUtils::CheckSameOrigin(aOldChannel, aNewChannel);
+ if (NS_SUCCEEDED(rv)) {
+ cb->OnRedirectVerifyCallback(NS_OK);
+ }
+
+ return rv;
+}
+
+NS_IMETHODIMP
+SameOriginCheckerImpl::GetInterface(const nsIID& aIID, void** aResult)
+{
+ return QueryInterface(aIID, aResult);
+}
+
+/* static */
+nsresult
+nsContentUtils::GetASCIIOrigin(nsIPrincipal* aPrincipal, nsACString& aOrigin)
+{
+ NS_PRECONDITION(aPrincipal, "missing principal");
+
+ aOrigin.Truncate();
+
+ nsCOMPtr<nsIURI> uri;
+ nsresult rv = aPrincipal->GetURI(getter_AddRefs(uri));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (uri) {
+ return GetASCIIOrigin(uri, aOrigin);
+ }
+
+ aOrigin.AssignLiteral("null");
+
+ return NS_OK;
+}
+
+/* static */
+nsresult
+nsContentUtils::GetASCIIOrigin(nsIURI* aURI, nsACString& aOrigin)
+{
+ NS_PRECONDITION(aURI, "missing uri");
+
+ // For Blob URI we have to return the origin of page using its principal.
+ nsCOMPtr<nsIURIWithPrincipal> uriWithPrincipal = do_QueryInterface(aURI);
+ if (uriWithPrincipal) {
+ nsCOMPtr<nsIPrincipal> principal;
+ uriWithPrincipal->GetPrincipal(getter_AddRefs(principal));
+
+ if (principal) {
+ nsCOMPtr<nsIURI> uri;
+ nsresult rv = principal->GetURI(getter_AddRefs(uri));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (uri && uri != aURI) {
+ return GetASCIIOrigin(uri, aOrigin);
+ }
+ }
+ }
+
+ aOrigin.Truncate();
+
+ nsCOMPtr<nsIURI> uri = NS_GetInnermostURI(aURI);
+ NS_ENSURE_TRUE(uri, NS_ERROR_UNEXPECTED);
+
+ nsCString host;
+ nsresult rv = uri->GetAsciiHost(host);
+
+ if (NS_SUCCEEDED(rv) && !host.IsEmpty()) {
+ nsCString scheme;
+ rv = uri->GetScheme(scheme);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ int32_t port = -1;
+ uri->GetPort(&port);
+ if (port != -1 && port == NS_GetDefaultPort(scheme.get()))
+ port = -1;
+
+ nsCString hostPort;
+ rv = NS_GenerateHostPort(host, port, hostPort);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aOrigin = scheme + NS_LITERAL_CSTRING("://") + hostPort;
+ }
+ else {
+ aOrigin.AssignLiteral("null");
+ }
+
+ return NS_OK;
+}
+
+/* static */
+nsresult
+nsContentUtils::GetUTFOrigin(nsIPrincipal* aPrincipal, nsAString& aOrigin)
+{
+ NS_PRECONDITION(aPrincipal, "missing principal");
+
+ aOrigin.Truncate();
+
+ nsCOMPtr<nsIURI> uri;
+ nsresult rv = aPrincipal->GetURI(getter_AddRefs(uri));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (uri) {
+ return GetUTFOrigin(uri, aOrigin);
+ }
+
+ aOrigin.AssignLiteral("null");
+
+ return NS_OK;
+}
+
+/* static */
+nsresult
+nsContentUtils::GetUTFOrigin(nsIURI* aURI, nsAString& aOrigin)
+{
+ NS_PRECONDITION(aURI, "missing uri");
+
+ // For Blob URI we have to return the origin of page using its principal.
+ nsCOMPtr<nsIURIWithPrincipal> uriWithPrincipal = do_QueryInterface(aURI);
+ if (uriWithPrincipal) {
+ nsCOMPtr<nsIPrincipal> principal;
+ uriWithPrincipal->GetPrincipal(getter_AddRefs(principal));
+
+ if (principal) {
+ nsCOMPtr<nsIURI> uri;
+ nsresult rv = principal->GetURI(getter_AddRefs(uri));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (uri && uri != aURI) {
+ return GetUTFOrigin(uri, aOrigin);
+ }
+ } else {
+ // We are probably dealing with an unknown blob URL.
+ bool isBlobURL = false;
+ nsresult rv = aURI->SchemeIs(BLOBURI_SCHEME, &isBlobURL);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (isBlobURL) {
+ nsAutoCString path;
+ rv = aURI->GetPath(path);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsIURI> uri;
+ nsresult rv = NS_NewURI(getter_AddRefs(uri), path);
+ if (NS_FAILED(rv)) {
+ aOrigin.AssignLiteral("null");
+ return NS_OK;
+ }
+
+ return GetUTFOrigin(uri, aOrigin);
+ }
+ }
+ }
+
+ aOrigin.Truncate();
+
+ nsCOMPtr<nsIURI> uri = NS_GetInnermostURI(aURI);
+ NS_ENSURE_TRUE(uri, NS_ERROR_UNEXPECTED);
+
+ nsCString host;
+ nsresult rv = uri->GetHost(host);
+
+ if (NS_SUCCEEDED(rv) && !host.IsEmpty()) {
+ nsCString scheme;
+ rv = uri->GetScheme(scheme);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ int32_t port = -1;
+ uri->GetPort(&port);
+ if (port != -1 && port == NS_GetDefaultPort(scheme.get()))
+ port = -1;
+
+ nsCString hostPort;
+ rv = NS_GenerateHostPort(host, port, hostPort);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aOrigin = NS_ConvertUTF8toUTF16(
+ scheme + NS_LITERAL_CSTRING("://") + hostPort);
+ }
+ else {
+ aOrigin.AssignLiteral("null");
+ }
+
+ return NS_OK;
+}
+
+/* static */
+bool
+nsContentUtils::CheckMayLoad(nsIPrincipal* aPrincipal, nsIChannel* aChannel, bool aAllowIfInheritsPrincipal)
+{
+ nsCOMPtr<nsIURI> channelURI;
+ nsresult rv = NS_GetFinalChannelURI(aChannel, getter_AddRefs(channelURI));
+ NS_ENSURE_SUCCESS(rv, false);
+
+ return NS_SUCCEEDED(aPrincipal->CheckMayLoad(channelURI, false, aAllowIfInheritsPrincipal));
+}
+
+nsContentTypeParser::nsContentTypeParser(const nsAString& aString)
+ : mString(aString), mService(nullptr)
+{
+ CallGetService("@mozilla.org/network/mime-hdrparam;1", &mService);
+}
+
+nsContentTypeParser::~nsContentTypeParser()
+{
+ NS_IF_RELEASE(mService);
+}
+
+nsresult
+nsContentTypeParser::GetParameter(const char* aParameterName,
+ nsAString& aResult) const
+{
+ NS_ENSURE_TRUE(mService, NS_ERROR_FAILURE);
+ return mService->GetParameterHTTP(mString, aParameterName,
+ EmptyCString(), false, nullptr,
+ aResult);
+}
+
+nsresult
+nsContentTypeParser::GetType(nsAString& aResult) const
+{
+ nsresult rv = GetParameter(nullptr, aResult);
+ NS_ENSURE_SUCCESS(rv, rv);
+ nsContentUtils::ASCIIToLower(aResult);
+ return NS_OK;
+}
+
+/* static */
+
+bool
+nsContentUtils::CanAccessNativeAnon()
+{
+ return LegacyIsCallerChromeOrNativeCode() || IsCallerContentXBL();
+}
+
+/* static */ nsresult
+nsContentUtils::DispatchXULCommand(nsIContent* aTarget,
+ bool aTrusted,
+ nsIDOMEvent* aSourceEvent,
+ nsIPresShell* aShell,
+ bool aCtrl,
+ bool aAlt,
+ bool aShift,
+ bool aMeta)
+{
+ NS_ENSURE_STATE(aTarget);
+ nsIDocument* doc = aTarget->OwnerDoc();
+ nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(doc);
+ NS_ENSURE_STATE(domDoc);
+ nsCOMPtr<nsIDOMEvent> event;
+ domDoc->CreateEvent(NS_LITERAL_STRING("xulcommandevent"),
+ getter_AddRefs(event));
+ nsCOMPtr<nsIDOMXULCommandEvent> xulCommand = do_QueryInterface(event);
+ nsresult rv = xulCommand->InitCommandEvent(NS_LITERAL_STRING("command"),
+ true, true, doc->GetInnerWindow(),
+ 0, aCtrl, aAlt, aShift, aMeta,
+ aSourceEvent);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (aShell) {
+ nsEventStatus status = nsEventStatus_eIgnore;
+ nsCOMPtr<nsIPresShell> kungFuDeathGrip = aShell;
+ return aShell->HandleDOMEventWithTarget(aTarget, event, &status);
+ }
+
+ nsCOMPtr<EventTarget> target = do_QueryInterface(aTarget);
+ NS_ENSURE_STATE(target);
+ bool dummy;
+ return target->DispatchEvent(event, &dummy);
+}
+
+// static
+nsresult
+nsContentUtils::WrapNative(JSContext *cx, nsISupports *native,
+ nsWrapperCache *cache, const nsIID* aIID,
+ JS::MutableHandle<JS::Value> vp, bool aAllowWrapping)
+{
+ MOZ_ASSERT(cx == GetCurrentJSContext());
+
+ if (!native) {
+ vp.setNull();
+
+ return NS_OK;
+ }
+
+ JSObject *wrapper = xpc_FastGetCachedWrapper(cx, cache, vp);
+ if (wrapper) {
+ return NS_OK;
+ }
+
+ NS_ENSURE_TRUE(sXPConnect, NS_ERROR_UNEXPECTED);
+
+ if (!NS_IsMainThread()) {
+ MOZ_CRASH();
+ }
+
+ nsresult rv = NS_OK;
+ JS::Rooted<JSObject*> scope(cx, JS::CurrentGlobalOrNull(cx));
+ rv = sXPConnect->WrapNativeToJSVal(cx, scope, native, cache, aIID,
+ aAllowWrapping, vp);
+ return rv;
+}
+
+nsresult
+nsContentUtils::CreateArrayBuffer(JSContext *aCx, const nsACString& aData,
+ JSObject** aResult)
+{
+ if (!aCx) {
+ return NS_ERROR_FAILURE;
+ }
+
+ int32_t dataLen = aData.Length();
+ *aResult = JS_NewArrayBuffer(aCx, dataLen);
+ if (!*aResult) {
+ return NS_ERROR_FAILURE;
+ }
+
+ if (dataLen > 0) {
+ NS_ASSERTION(JS_IsArrayBufferObject(*aResult), "What happened?");
+ JS::AutoCheckCannotGC nogc;
+ bool isShared;
+ memcpy(JS_GetArrayBufferData(*aResult, &isShared, nogc), aData.BeginReading(), dataLen);
+ MOZ_ASSERT(!isShared);
+ }
+
+ return NS_OK;
+}
+
+void
+nsContentUtils::StripNullChars(const nsAString& aInStr, nsAString& aOutStr)
+{
+ // In common cases where we don't have nulls in the
+ // string we can simple simply bypass the checking code.
+ int32_t firstNullPos = aInStr.FindChar('\0');
+ if (firstNullPos == kNotFound) {
+ aOutStr.Assign(aInStr);
+ return;
+ }
+
+ aOutStr.SetCapacity(aInStr.Length() - 1);
+ nsAString::const_iterator start, end;
+ aInStr.BeginReading(start);
+ aInStr.EndReading(end);
+ while (start != end) {
+ if (*start != '\0')
+ aOutStr.Append(*start);
+ ++start;
+ }
+}
+
+struct ClassMatchingInfo {
+ nsAttrValue::AtomArray mClasses;
+ nsCaseTreatment mCaseTreatment;
+};
+
+// static
+bool
+nsContentUtils::MatchClassNames(nsIContent* aContent, int32_t aNamespaceID,
+ nsIAtom* aAtom, void* aData)
+{
+ // We can't match if there are no class names
+ const nsAttrValue* classAttr = aContent->GetClasses();
+ if (!classAttr) {
+ return false;
+ }
+
+ // need to match *all* of the classes
+ ClassMatchingInfo* info = static_cast<ClassMatchingInfo*>(aData);
+ uint32_t length = info->mClasses.Length();
+ if (!length) {
+ // If we actually had no classes, don't match.
+ return false;
+ }
+ uint32_t i;
+ for (i = 0; i < length; ++i) {
+ if (!classAttr->Contains(info->mClasses[i],
+ info->mCaseTreatment)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// static
+void
+nsContentUtils::DestroyClassNameArray(void* aData)
+{
+ ClassMatchingInfo* info = static_cast<ClassMatchingInfo*>(aData);
+ delete info;
+}
+
+// static
+void*
+nsContentUtils::AllocClassMatchingInfo(nsINode* aRootNode,
+ const nsString* aClasses)
+{
+ nsAttrValue attrValue;
+ attrValue.ParseAtomArray(*aClasses);
+ // nsAttrValue::Equals is sensitive to order, so we'll send an array
+ ClassMatchingInfo* info = new ClassMatchingInfo;
+ if (attrValue.Type() == nsAttrValue::eAtomArray) {
+ info->mClasses.SwapElements(*(attrValue.GetAtomArrayValue()));
+ } else if (attrValue.Type() == nsAttrValue::eAtom) {
+ info->mClasses.AppendElement(attrValue.GetAtomValue());
+ }
+
+ info->mCaseTreatment =
+ aRootNode->OwnerDoc()->GetCompatibilityMode() == eCompatibility_NavQuirks ?
+ eIgnoreCase : eCaseMatters;
+ return info;
+}
+
+// static
+bool
+nsContentUtils::IsFocusedContent(const nsIContent* aContent)
+{
+ nsFocusManager* fm = nsFocusManager::GetFocusManager();
+
+ return fm && fm->GetFocusedContent() == aContent;
+}
+
+bool
+nsContentUtils::IsSubDocumentTabbable(nsIContent* aContent)
+{
+ //XXXsmaug Shadow DOM spec issue!
+ // We may need to change this to GetComposedDoc().
+ nsIDocument* doc = aContent->GetUncomposedDoc();
+ if (!doc) {
+ return false;
+ }
+
+ // If the subdocument lives in another process, the frame is
+ // tabbable.
+ if (EventStateManager::IsRemoteTarget(aContent)) {
+ return true;
+ }
+
+ // XXXbz should this use OwnerDoc() for GetSubDocumentFor?
+ // sXBL/XBL2 issue!
+ nsIDocument* subDoc = doc->GetSubDocumentFor(aContent);
+ if (!subDoc) {
+ return false;
+ }
+
+ nsCOMPtr<nsIDocShell> docShell = subDoc->GetDocShell();
+ if (!docShell) {
+ return false;
+ }
+
+ nsCOMPtr<nsIContentViewer> contentViewer;
+ docShell->GetContentViewer(getter_AddRefs(contentViewer));
+ if (!contentViewer) {
+ return false;
+ }
+
+ nsCOMPtr<nsIContentViewer> zombieViewer;
+ contentViewer->GetPreviousViewer(getter_AddRefs(zombieViewer));
+
+ // If there are 2 viewers for the current docshell, that
+ // means the current document is a zombie document.
+ // Only navigate into the subdocument if it's not a zombie.
+ return !zombieViewer;
+}
+
+bool
+nsContentUtils::IsUserFocusIgnored(nsINode* aNode)
+{
+ if (!nsGenericHTMLFrameElement::BrowserFramesEnabled()) {
+ return false;
+ }
+
+ // Check if our mozbrowser iframe ancestors has ignoreuserfocus attribute.
+ while (aNode) {
+ nsCOMPtr<nsIMozBrowserFrame> browserFrame = do_QueryInterface(aNode);
+ if (browserFrame &&
+ aNode->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::ignoreuserfocus) &&
+ browserFrame->GetReallyIsBrowserOrApp()) {
+ return true;
+ }
+ nsPIDOMWindowOuter* win = aNode->OwnerDoc()->GetWindow();
+ aNode = win ? win->GetFrameElementInternal() : nullptr;
+ }
+
+ return false;
+}
+
+bool
+nsContentUtils::HasScrollgrab(nsIContent* aContent)
+{
+ nsGenericHTMLElement* element = nsGenericHTMLElement::FromContentOrNull(aContent);
+ return element && element->Scrollgrab();
+}
+
+void
+nsContentUtils::FlushLayoutForTree(nsPIDOMWindowOuter* aWindow)
+{
+ if (!aWindow) {
+ return;
+ }
+
+ // Note that because FlushPendingNotifications flushes parents, this
+ // is O(N^2) in docshell tree depth. However, the docshell tree is
+ // usually pretty shallow.
+
+ if (nsCOMPtr<nsIDocument> doc = aWindow->GetDoc()) {
+ doc->FlushPendingNotifications(Flush_Layout);
+ }
+
+ if (nsCOMPtr<nsIDocShell> docShell = aWindow->GetDocShell()) {
+ int32_t i = 0, i_end;
+ docShell->GetChildCount(&i_end);
+ for (; i < i_end; ++i) {
+ nsCOMPtr<nsIDocShellTreeItem> item;
+ docShell->GetChildAt(i, getter_AddRefs(item));
+ if (nsCOMPtr<nsPIDOMWindowOuter> win = item->GetWindow()) {
+ FlushLayoutForTree(win);
+ }
+ }
+ }
+}
+
+void nsContentUtils::RemoveNewlines(nsString &aString)
+{
+ // strip CR/LF and null
+ static const char badChars[] = {'\r', '\n', 0};
+ aString.StripChars(badChars);
+}
+
+void
+nsContentUtils::PlatformToDOMLineBreaks(nsString &aString)
+{
+ if (!PlatformToDOMLineBreaks(aString, fallible)) {
+ aString.AllocFailed(aString.Length());
+ }
+}
+
+bool
+nsContentUtils::PlatformToDOMLineBreaks(nsString& aString, const fallible_t& aFallible)
+{
+ if (aString.FindChar(char16_t('\r')) != -1) {
+ // Windows linebreaks: Map CRLF to LF:
+ if (!aString.ReplaceSubstring(u"\r\n", u"\n", aFallible)) {
+ return false;
+ }
+
+ // Mac linebreaks: Map any remaining CR to LF:
+ if (!aString.ReplaceSubstring(u"\r", u"\n", aFallible)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+void
+nsContentUtils::PopulateStringFromStringBuffer(nsStringBuffer* aBuf,
+ nsAString& aResultString)
+{
+ MOZ_ASSERT(aBuf, "Expecting a non-null string buffer");
+
+ uint32_t stringLen = NS_strlen(static_cast<char16_t*>(aBuf->Data()));
+
+ // SANITY CHECK: In case the nsStringBuffer isn't correctly
+ // null-terminated, let's clamp its length using the allocated size, to be
+ // sure the resulting string doesn't sample past the end of the the buffer.
+ // (Note that StorageSize() is in units of bytes, so we have to convert that
+ // to units of PRUnichars, and subtract 1 for the null-terminator.)
+ uint32_t allocStringLen = (aBuf->StorageSize() / sizeof(char16_t)) - 1;
+ MOZ_ASSERT(stringLen <= allocStringLen,
+ "string buffer lacks null terminator!");
+ stringLen = std::min(stringLen, allocStringLen);
+
+ aBuf->ToString(stringLen, aResultString);
+}
+
+nsIPresShell*
+nsContentUtils::FindPresShellForDocument(const nsIDocument* aDoc)
+{
+ const nsIDocument* doc = aDoc;
+ nsIDocument* displayDoc = doc->GetDisplayDocument();
+ if (displayDoc) {
+ doc = displayDoc;
+ }
+
+ nsIPresShell* shell = doc->GetShell();
+ if (shell) {
+ return shell;
+ }
+
+ nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem = doc->GetDocShell();
+ while (docShellTreeItem) {
+ // We may be in a display:none subdocument, or we may not have a presshell
+ // created yet.
+ // Walk the docshell tree to find the nearest container that has a presshell,
+ // and return that.
+ nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(docShellTreeItem);
+ nsIPresShell* presShell = docShell->GetPresShell();
+ if (presShell) {
+ return presShell;
+ }
+ nsCOMPtr<nsIDocShellTreeItem> parent;
+ docShellTreeItem->GetParent(getter_AddRefs(parent));
+ docShellTreeItem = parent;
+ }
+
+ return nullptr;
+}
+
+nsIWidget*
+nsContentUtils::WidgetForDocument(const nsIDocument* aDoc)
+{
+ nsIPresShell* shell = FindPresShellForDocument(aDoc);
+ if (shell) {
+ nsViewManager* VM = shell->GetViewManager();
+ if (VM) {
+ nsView* rootView = VM->GetRootView();
+ if (rootView) {
+ nsView* displayRoot = nsViewManager::GetDisplayRootFor(rootView);
+ if (displayRoot) {
+ return displayRoot->GetNearestWidget(nullptr);
+ }
+ }
+ }
+ }
+
+ return nullptr;
+}
+
+static already_AddRefed<LayerManager>
+LayerManagerForDocumentInternal(const nsIDocument *aDoc, bool aRequirePersistent)
+{
+ nsIWidget *widget = nsContentUtils::WidgetForDocument(aDoc);
+ if (widget) {
+ RefPtr<LayerManager> manager =
+ widget->GetLayerManager(aRequirePersistent ? nsIWidget::LAYER_MANAGER_PERSISTENT :
+ nsIWidget::LAYER_MANAGER_CURRENT);
+ return manager.forget();
+ }
+
+ return nullptr;
+}
+
+already_AddRefed<LayerManager>
+nsContentUtils::LayerManagerForDocument(const nsIDocument *aDoc)
+{
+ return LayerManagerForDocumentInternal(aDoc, false);
+}
+
+already_AddRefed<LayerManager>
+nsContentUtils::PersistentLayerManagerForDocument(nsIDocument *aDoc)
+{
+ return LayerManagerForDocumentInternal(aDoc, true);
+}
+
+bool
+nsContentUtils::AllowXULXBLForPrincipal(nsIPrincipal* aPrincipal)
+{
+ if (IsSystemPrincipal(aPrincipal)) {
+ return true;
+ }
+
+ nsCOMPtr<nsIURI> princURI;
+ aPrincipal->GetURI(getter_AddRefs(princURI));
+
+ return princURI &&
+ ((sAllowXULXBL_for_file && SchemeIs(princURI, "file")) ||
+ IsSitePermAllow(aPrincipal, "allowXULXBL"));
+}
+
+bool
+nsContentUtils::IsPDFJSEnabled()
+{
+ nsCOMPtr<nsIStreamConverterService> convServ =
+ do_GetService("@mozilla.org/streamConverters;1");
+ nsresult rv = NS_ERROR_FAILURE;
+ bool canConvert = false;
+ if (convServ) {
+ rv = convServ->CanConvert("application/pdf", "text/html", &canConvert);
+ }
+ return NS_SUCCEEDED(rv) && canConvert;
+}
+
+bool
+nsContentUtils::IsSWFPlayerEnabled()
+{
+ nsCOMPtr<nsIStreamConverterService> convServ =
+ do_GetService("@mozilla.org/streamConverters;1");
+ nsresult rv = NS_ERROR_FAILURE;
+ bool canConvert = false;
+ if (convServ) {
+ rv = convServ->CanConvert("application/x-shockwave-flash",
+ "text/html", &canConvert);
+ }
+ return NS_SUCCEEDED(rv) && canConvert;
+}
+
+already_AddRefed<nsIDocumentLoaderFactory>
+nsContentUtils::FindInternalContentViewer(const nsACString& aType,
+ ContentViewerType* aLoaderType)
+{
+ if (aLoaderType) {
+ *aLoaderType = TYPE_UNSUPPORTED;
+ }
+
+ // one helper factory, please
+ nsCOMPtr<nsICategoryManager> catMan(do_GetService(NS_CATEGORYMANAGER_CONTRACTID));
+ if (!catMan)
+ return nullptr;
+
+ nsCOMPtr<nsIDocumentLoaderFactory> docFactory;
+
+ nsXPIDLCString contractID;
+ nsresult rv = catMan->GetCategoryEntry("Gecko-Content-Viewers",
+ PromiseFlatCString(aType).get(),
+ getter_Copies(contractID));
+ if (NS_SUCCEEDED(rv)) {
+ docFactory = do_GetService(contractID);
+ if (docFactory && aLoaderType) {
+ if (contractID.EqualsLiteral(CONTENT_DLF_CONTRACTID))
+ *aLoaderType = TYPE_CONTENT;
+ else if (contractID.EqualsLiteral(PLUGIN_DLF_CONTRACTID))
+ *aLoaderType = TYPE_PLUGIN;
+ else
+ *aLoaderType = TYPE_UNKNOWN;
+ }
+ return docFactory.forget();
+ }
+
+ if (DecoderTraits::IsSupportedInVideoDocument(aType)) {
+ docFactory = do_GetService("@mozilla.org/content/document-loader-factory;1");
+ if (docFactory && aLoaderType) {
+ *aLoaderType = TYPE_CONTENT;
+ }
+ return docFactory.forget();
+ }
+
+ return nullptr;
+}
+
+static void
+ReportPatternCompileFailure(nsAString& aPattern, nsIDocument* aDocument,
+ JSContext* cx)
+{
+ MOZ_ASSERT(JS_IsExceptionPending(cx));
+
+ JS::RootedValue exn(cx);
+ if (!JS_GetPendingException(cx, &exn)) {
+ return;
+ }
+ if (!exn.isObject()) {
+ // If pending exception is not an object, it should be OOM.
+ return;
+ }
+
+ JS::AutoSaveExceptionState savedExc(cx);
+ JS::RootedObject exnObj(cx, &exn.toObject());
+ JS::RootedValue messageVal(cx);
+ if (!JS_GetProperty(cx, exnObj, "message", &messageVal)) {
+ return;
+ }
+ MOZ_ASSERT(messageVal.isString());
+
+ JS::RootedString messageStr(cx, messageVal.toString());
+ MOZ_ASSERT(messageStr);
+
+ nsAutoString wideMessage;
+ if (!AssignJSString(cx, wideMessage, messageStr)) {
+ return;
+ }
+
+ const nsString& pattern = PromiseFlatString(aPattern);
+ const char16_t *strings[] = { pattern.get(), wideMessage.get() };
+ nsContentUtils::ReportToConsole(nsIScriptError::errorFlag,
+ NS_LITERAL_CSTRING("DOM"),
+ aDocument,
+ nsContentUtils::eDOM_PROPERTIES,
+ "PatternAttributeCompileFailure",
+ strings, ArrayLength(strings));
+ savedExc.drop();
+}
+
+// static
+bool
+nsContentUtils::IsPatternMatching(nsAString& aValue, nsAString& aPattern,
+ nsIDocument* aDocument)
+{
+ NS_ASSERTION(aDocument, "aDocument should be a valid pointer (not null)");
+
+ AutoJSAPI jsapi;
+ jsapi.Init();
+ JSContext* cx = jsapi.cx();
+
+ // We can use the junk scope here, because we're just using it for
+ // regexp evaluation, not actual script execution.
+ JSAutoCompartment ac(cx, xpc::UnprivilegedJunkScope());
+
+ // The pattern has to match the entire value.
+ aPattern.Insert(NS_LITERAL_STRING("^(?:"), 0);
+ aPattern.AppendLiteral(")$");
+
+ JS::Rooted<JSObject*> re(cx,
+ JS_NewUCRegExpObject(cx,
+ static_cast<char16_t*>(aPattern.BeginWriting()),
+ aPattern.Length(), JSREG_UNICODE));
+ if (!re) {
+ // Remove extra patterns added above to report with the original pattern.
+ aPattern.Cut(0, 4);
+ aPattern.Cut(aPattern.Length() - 2, 2);
+ ReportPatternCompileFailure(aPattern, aDocument, cx);
+ return true;
+ }
+
+ JS::Rooted<JS::Value> rval(cx, JS::NullValue());
+ size_t idx = 0;
+ if (!JS_ExecuteRegExpNoStatics(cx, re,
+ static_cast<char16_t*>(aValue.BeginWriting()),
+ aValue.Length(), &idx, true, &rval)) {
+ return true;
+ }
+
+ return !rval.isNull();
+}
+
+// static
+nsresult
+nsContentUtils::URIInheritsSecurityContext(nsIURI *aURI, bool *aResult)
+{
+ // Note: about:blank URIs do NOT inherit the security context from the
+ // current document, which is what this function tests for...
+ return NS_URIChainHasFlags(aURI,
+ nsIProtocolHandler::URI_INHERITS_SECURITY_CONTEXT,
+ aResult);
+}
+
+// static
+bool
+nsContentUtils::ChannelShouldInheritPrincipal(nsIPrincipal* aLoadingPrincipal,
+ nsIURI* aURI,
+ bool aInheritForAboutBlank,
+ bool aForceInherit)
+{
+ MOZ_ASSERT(aLoadingPrincipal, "Can not check inheritance without a principal");
+
+ // Only tell the channel to inherit if it can't provide its own security context.
+ //
+ // XXX: If this is ever changed, check all callers for what owners
+ // they're passing in. In particular, see the code and
+ // comments in nsDocShell::LoadURI where we fall back on
+ // inheriting the owner if called from chrome. That would be
+ // very wrong if this code changed anything but channels that
+ // can't provide their own security context!
+ //
+ // If aForceInherit is true, we will inherit, even for a channel that
+ // can provide its own security context. This is used for srcdoc loads.
+ bool inherit = aForceInherit;
+ if (!inherit) {
+ bool uriInherits;
+ // We expect URIInheritsSecurityContext to return success for an
+ // about:blank URI, so don't call NS_IsAboutBlank() if this call fails.
+ // This condition needs to match the one in nsDocShell::InternalLoad where
+ // we're checking for things that will use the owner.
+ inherit =
+ (NS_SUCCEEDED(URIInheritsSecurityContext(aURI, &uriInherits)) &&
+ (uriInherits || (aInheritForAboutBlank && NS_IsAboutBlank(aURI)))) ||
+ //
+ // file: uri special-casing
+ //
+ // If this is a file: load opened from another file: then it may need
+ // to inherit the owner from the referrer so they can script each other.
+ // If we don't set the owner explicitly then each file: gets an owner
+ // based on its own codebase later.
+ //
+ (URIIsLocalFile(aURI) &&
+ NS_SUCCEEDED(aLoadingPrincipal->CheckMayLoad(aURI, false, false)) &&
+ // One more check here. CheckMayLoad will always return true for the
+ // system principal, but we do NOT want to inherit in that case.
+ !IsSystemPrincipal(aLoadingPrincipal));
+ }
+ return inherit;
+}
+
+/* static */
+bool
+nsContentUtils::IsFullScreenApiEnabled()
+{
+ return sIsFullScreenApiEnabled;
+}
+
+/* static */
+bool
+nsContentUtils::IsRequestFullScreenAllowed()
+{
+ return !sTrustedFullScreenOnly ||
+ EventStateManager::IsHandlingUserInput() ||
+ IsCallerChrome();
+}
+
+/* static */
+bool
+nsContentUtils::IsCutCopyAllowed()
+{
+ if ((!IsCutCopyRestricted() && EventStateManager::IsHandlingUserInput()) ||
+ IsCallerChrome()) {
+ return true;
+ }
+
+ return BasePrincipal::Cast(SubjectPrincipal())->AddonHasPermission(NS_LITERAL_STRING("clipboardWrite"));
+}
+
+/* static */
+bool
+nsContentUtils::IsFrameTimingEnabled()
+{
+ return sIsFrameTimingPrefEnabled;
+}
+
+/* static */
+bool
+nsContentUtils::HaveEqualPrincipals(nsIDocument* aDoc1, nsIDocument* aDoc2)
+{
+ if (!aDoc1 || !aDoc2) {
+ return false;
+ }
+ bool principalsEqual = false;
+ aDoc1->NodePrincipal()->Equals(aDoc2->NodePrincipal(), &principalsEqual);
+ return principalsEqual;
+}
+
+/* static */
+bool
+nsContentUtils::HasPluginWithUncontrolledEventDispatch(nsIContent* aContent)
+{
+#ifdef XP_MACOSX
+ // We control dispatch to all mac plugins.
+ return false;
+#else
+ if (!aContent || !aContent->IsInUncomposedDoc()) {
+ return false;
+ }
+
+ nsCOMPtr<nsIObjectLoadingContent> olc = do_QueryInterface(aContent);
+ if (!olc) {
+ return false;
+ }
+
+ RefPtr<nsNPAPIPluginInstance> plugin;
+ olc->GetPluginInstance(getter_AddRefs(plugin));
+ if (!plugin) {
+ return false;
+ }
+
+ bool isWindowless = false;
+ nsresult res = plugin->IsWindowless(&isWindowless);
+ if (NS_FAILED(res)) {
+ return false;
+ }
+
+ return !isWindowless;
+#endif
+}
+
+/* static */
+void
+nsContentUtils::FireMutationEventsForDirectParsing(nsIDocument* aDoc,
+ nsIContent* aDest,
+ int32_t aOldChildCount)
+{
+ // Fire mutation events. Optimize for the case when there are no listeners
+ int32_t newChildCount = aDest->GetChildCount();
+ if (newChildCount && nsContentUtils::
+ HasMutationListeners(aDoc, NS_EVENT_BITS_MUTATION_NODEINSERTED)) {
+ AutoTArray<nsCOMPtr<nsIContent>, 50> childNodes;
+ NS_ASSERTION(newChildCount - aOldChildCount >= 0,
+ "What, some unexpected dom mutation has happened?");
+ childNodes.SetCapacity(newChildCount - aOldChildCount);
+ for (nsIContent* child = aDest->GetFirstChild();
+ child;
+ child = child->GetNextSibling()) {
+ childNodes.AppendElement(child);
+ }
+ FragmentOrElement::FireNodeInserted(aDoc, aDest, childNodes);
+ }
+}
+
+/* static */
+nsIDocument*
+nsContentUtils::GetRootDocument(nsIDocument* aDoc)
+{
+ if (!aDoc) {
+ return nullptr;
+ }
+ nsIDocument* doc = aDoc;
+ while (doc->GetParentDocument()) {
+ doc = doc->GetParentDocument();
+ }
+ return doc;
+}
+
+/* static */
+bool
+nsContentUtils::IsInPointerLockContext(nsPIDOMWindowOuter* aWin)
+{
+ if (!aWin) {
+ return false;
+ }
+
+ nsCOMPtr<nsIDocument> pointerLockedDoc =
+ do_QueryReferent(EventStateManager::sPointerLockedDoc);
+ if (!pointerLockedDoc || !pointerLockedDoc->GetWindow()) {
+ return false;
+ }
+
+ nsCOMPtr<nsPIDOMWindowOuter> lockTop =
+ pointerLockedDoc->GetWindow()->GetScriptableTop();
+ nsCOMPtr<nsPIDOMWindowOuter> top = aWin->GetScriptableTop();
+
+ return top == lockTop;
+}
+
+// static
+int32_t
+nsContentUtils::GetAdjustedOffsetInTextControl(nsIFrame* aOffsetFrame,
+ int32_t aOffset)
+{
+ // The structure of the anonymous frames within a text control frame is
+ // an optional block frame, followed by an optional br frame.
+
+ // If the offset frame has a child, then this frame is the block which
+ // has the text frames (containing the content) as its children. This will
+ // be the case if we click to the right of any of the text frames, or at the
+ // bottom of the text area.
+ nsIFrame* firstChild = aOffsetFrame->PrincipalChildList().FirstChild();
+ if (firstChild) {
+ // In this case, the passed-in offset is incorrect, and we want the length
+ // of the entire content in the text control frame.
+ return firstChild->GetContent()->Length();
+ }
+
+ if (aOffsetFrame->GetPrevSibling() &&
+ !aOffsetFrame->GetNextSibling()) {
+ // In this case, we're actually within the last frame, which is a br
+ // frame. Our offset should therefore be the length of the first child of
+ // our parent.
+ int32_t aOutOffset =
+ aOffsetFrame->GetParent()->PrincipalChildList().FirstChild()->GetContent()->Length();
+ return aOutOffset;
+ }
+
+ // Otherwise, we're within one of the text frames, in which case our offset
+ // has already been correctly calculated.
+ return aOffset;
+}
+
+// static
+void
+nsContentUtils::GetSelectionInTextControl(Selection* aSelection,
+ Element* aRoot,
+ int32_t& aOutStartOffset,
+ int32_t& aOutEndOffset)
+{
+ MOZ_ASSERT(aSelection && aRoot);
+
+ if (!aSelection->RangeCount()) {
+ // Nothing selected
+ aOutStartOffset = aOutEndOffset = 0;
+ return;
+ }
+
+ nsCOMPtr<nsINode> anchorNode = aSelection->GetAnchorNode();
+ uint32_t anchorOffset = aSelection->AnchorOffset();
+ nsCOMPtr<nsINode> focusNode = aSelection->GetFocusNode();
+ uint32_t focusOffset = aSelection->FocusOffset();
+
+ // We have at most two children, consisting of an optional text node followed
+ // by an optional <br>.
+ NS_ASSERTION(aRoot->GetChildCount() <= 2, "Unexpected children");
+ nsCOMPtr<nsIContent> firstChild = aRoot->GetFirstChild();
+#ifdef DEBUG
+ nsCOMPtr<nsIContent> lastChild = aRoot->GetLastChild();
+ NS_ASSERTION(anchorNode == aRoot || anchorNode == firstChild ||
+ anchorNode == lastChild, "Unexpected anchorNode");
+ NS_ASSERTION(focusNode == aRoot || focusNode == firstChild ||
+ focusNode == lastChild, "Unexpected focusNode");
+#endif
+ if (!firstChild || !firstChild->IsNodeOfType(nsINode::eTEXT)) {
+ // No text node, so everything is 0
+ anchorOffset = focusOffset = 0;
+ } else {
+ // First child is text. If the anchor/focus is already in the text node,
+ // or the start of the root node, no change needed. If it's in the root
+ // node but not the start, or in the trailing <br>, we need to set the
+ // offset to the end.
+ if ((anchorNode == aRoot && anchorOffset != 0) ||
+ (anchorNode != aRoot && anchorNode != firstChild)) {
+ anchorOffset = firstChild->Length();
+ }
+ if ((focusNode == aRoot && focusOffset != 0) ||
+ (focusNode != aRoot && focusNode != firstChild)) {
+ focusOffset = firstChild->Length();
+ }
+ }
+
+ // Make sure aOutStartOffset <= aOutEndOffset.
+ aOutStartOffset = std::min(anchorOffset, focusOffset);
+ aOutEndOffset = std::max(anchorOffset, focusOffset);
+}
+
+
+nsIEditor*
+nsContentUtils::GetHTMLEditor(nsPresContext* aPresContext)
+{
+ nsCOMPtr<nsIDocShell> docShell(aPresContext->GetDocShell());
+ bool isEditable;
+ if (!docShell ||
+ NS_FAILED(docShell->GetEditable(&isEditable)) || !isEditable)
+ return nullptr;
+
+ nsCOMPtr<nsIEditor> editor;
+ docShell->GetEditor(getter_AddRefs(editor));
+ return editor;
+}
+
+bool
+nsContentUtils::IsContentInsertionPoint(nsIContent* aContent)
+{
+ // Check if the content is a XBL insertion point.
+ if (aContent->IsActiveChildrenElement()) {
+ return true;
+ }
+
+ // Check if the content is a web components content insertion point.
+ HTMLContentElement* contentElement =
+ HTMLContentElement::FromContent(aContent);
+ return contentElement && contentElement->IsInsertionPoint();
+}
+
+// static
+bool
+nsContentUtils::HasDistributedChildren(nsIContent* aContent)
+{
+ if (!aContent) {
+ return false;
+ }
+
+ if (aContent->GetShadowRoot()) {
+ // Children of a shadow root host are distributed
+ // to content insertion points in the shadow root.
+ return true;
+ }
+
+ ShadowRoot* shadow = ShadowRoot::FromNode(aContent);
+ if (shadow) {
+ // Children of a shadow root are distributed to
+ // the shadow insertion point of the younger shadow root.
+ return shadow->GetYoungerShadowRoot();
+ }
+
+ HTMLShadowElement* shadowEl = HTMLShadowElement::FromContent(aContent);
+ if (shadowEl && shadowEl->IsInsertionPoint()) {
+ // Children of a shadow insertion points are distributed
+ // to the insertion points in the older shadow root.
+ return shadowEl->GetOlderShadowRoot();
+ }
+
+ HTMLContentElement* contentEl = HTMLContentElement::FromContent(aContent);
+ if (contentEl && contentEl->IsInsertionPoint()) {
+ // Children of a content insertion point are distributed to the
+ // content insertion point if the content insertion point does
+ // not match any nodes (fallback content).
+ return contentEl->MatchedNodes().IsEmpty();
+ }
+
+ return false;
+}
+
+// static
+bool
+nsContentUtils::IsForbiddenRequestHeader(const nsACString& aHeader)
+{
+ if (IsForbiddenSystemRequestHeader(aHeader)) {
+ return true;
+ }
+
+ return StringBeginsWith(aHeader, NS_LITERAL_CSTRING("proxy-"),
+ nsCaseInsensitiveCStringComparator()) ||
+ StringBeginsWith(aHeader, NS_LITERAL_CSTRING("sec-"),
+ nsCaseInsensitiveCStringComparator());
+}
+
+// static
+bool
+nsContentUtils::IsForbiddenSystemRequestHeader(const nsACString& aHeader)
+{
+ static const char *kInvalidHeaders[] = {
+ "accept-charset", "accept-encoding", "access-control-request-headers",
+ "access-control-request-method", "connection", "content-length",
+ "cookie", "cookie2", "date", "dnt", "expect", "host", "keep-alive",
+ "origin", "referer", "te", "trailer", "transfer-encoding", "upgrade", "via"
+ };
+ for (uint32_t i = 0; i < ArrayLength(kInvalidHeaders); ++i) {
+ if (aHeader.LowerCaseEqualsASCII(kInvalidHeaders[i])) {
+ return true;
+ }
+ }
+ return false;
+}
+
+// static
+bool
+nsContentUtils::IsForbiddenResponseHeader(const nsACString& aHeader)
+{
+ return (aHeader.LowerCaseEqualsASCII("set-cookie") ||
+ aHeader.LowerCaseEqualsASCII("set-cookie2"));
+}
+
+// static
+bool
+nsContentUtils::IsAllowedNonCorsContentType(const nsACString& aHeaderValue)
+{
+ nsAutoCString contentType;
+ nsAutoCString unused;
+
+ nsresult rv = NS_ParseRequestContentType(aHeaderValue, contentType, unused);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+
+ return contentType.LowerCaseEqualsLiteral("text/plain") ||
+ contentType.LowerCaseEqualsLiteral("application/x-www-form-urlencoded") ||
+ contentType.LowerCaseEqualsLiteral("multipart/form-data");
+}
+
+bool
+nsContentUtils::DOMWindowDumpEnabled()
+{
+#if !(defined(DEBUG) || defined(MOZ_ENABLE_JS_DUMP))
+ // In optimized builds we check a pref that controls if we should
+ // enable output from dump() or not, in debug builds it's always
+ // enabled.
+ return nsContentUtils::sDOMWindowDumpEnabled;
+#else
+ return true;
+#endif
+}
+
+bool
+nsContentUtils::DoNotTrackEnabled()
+{
+ return nsContentUtils::sDoNotTrackEnabled;
+}
+
+mozilla::LogModule*
+nsContentUtils::DOMDumpLog()
+{
+ return sDOMDumpLog;
+}
+
+bool
+nsContentUtils::GetNodeTextContent(nsINode* aNode, bool aDeep, nsAString& aResult,
+ const fallible_t& aFallible)
+{
+ aResult.Truncate();
+ return AppendNodeTextContent(aNode, aDeep, aResult, aFallible);
+}
+
+void
+nsContentUtils::GetNodeTextContent(nsINode* aNode, bool aDeep, nsAString& aResult)
+{
+ if (!GetNodeTextContent(aNode, aDeep, aResult, fallible)) {
+ NS_ABORT_OOM(0); // Unfortunately we don't know the allocation size
+ }
+}
+
+void
+nsContentUtils::DestroyMatchString(void* aData)
+{
+ if (aData) {
+ nsString* matchString = static_cast<nsString*>(aData);
+ delete matchString;
+ }
+}
+
+bool
+nsContentUtils::IsJavascriptMIMEType(const nsAString& aMIMEType)
+{
+ // Table ordered from most to least likely JS MIME types.
+ static const char* jsTypes[] = {
+ "text/javascript",
+ "text/ecmascript",
+ "application/javascript",
+ "application/ecmascript",
+ "application/x-javascript",
+ "application/x-ecmascript",
+ "text/javascript1.0",
+ "text/javascript1.1",
+ "text/javascript1.2",
+ "text/javascript1.3",
+ "text/javascript1.4",
+ "text/javascript1.5",
+ "text/jscript",
+ "text/livescript",
+ "text/x-ecmascript",
+ "text/x-javascript",
+ nullptr
+ };
+
+ for (uint32_t i = 0; jsTypes[i]; ++i) {
+ if (aMIMEType.LowerCaseEqualsASCII(jsTypes[i])) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+nsresult
+nsContentUtils::GenerateUUIDInPlace(nsID& aUUID)
+{
+ MOZ_ASSERT(sUUIDGenerator);
+
+ nsresult rv = sUUIDGenerator->GenerateUUIDInPlace(&aUUID);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+bool
+nsContentUtils::PrefetchEnabled(nsIDocShell* aDocShell)
+{
+ //
+ // SECURITY CHECK: disable prefetching from mailnews!
+ //
+ // walk up the docshell tree to see if any containing
+ // docshell are of type MAIL.
+ //
+
+ if (!aDocShell) {
+ return false;
+ }
+
+ nsCOMPtr<nsIDocShell> docshell = aDocShell;
+ nsCOMPtr<nsIDocShellTreeItem> parentItem;
+
+ do {
+ uint32_t appType = 0;
+ nsresult rv = docshell->GetAppType(&appType);
+ if (NS_FAILED(rv) || appType == nsIDocShell::APP_TYPE_MAIL) {
+ return false; // do not prefetch, preconnect from mailnews
+ }
+
+ docshell->GetParent(getter_AddRefs(parentItem));
+ if (parentItem) {
+ docshell = do_QueryInterface(parentItem);
+ if (!docshell) {
+ NS_ERROR("cannot get a docshell from a treeItem!");
+ return false;
+ }
+ }
+ } while (parentItem);
+
+ return true;
+}
+
+uint64_t
+nsContentUtils::GetInnerWindowID(nsIRequest* aRequest)
+{
+ // can't do anything if there's no nsIRequest!
+ if (!aRequest) {
+ return 0;
+ }
+
+ nsCOMPtr<nsILoadGroup> loadGroup;
+ nsresult rv = aRequest->GetLoadGroup(getter_AddRefs(loadGroup));
+
+ if (NS_FAILED(rv) || !loadGroup) {
+ return 0;
+ }
+
+ nsCOMPtr<nsIInterfaceRequestor> callbacks;
+ rv = loadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks));
+ if (NS_FAILED(rv) || !callbacks) {
+ return 0;
+ }
+
+ nsCOMPtr<nsILoadContext> loadContext = do_GetInterface(callbacks);
+ if (!loadContext) {
+ return 0;
+ }
+
+ nsCOMPtr<mozIDOMWindowProxy> window;
+ rv = loadContext->GetAssociatedWindow(getter_AddRefs(window));
+ if (NS_FAILED(rv) || !window) {
+ return 0;
+ }
+
+ auto* pwindow = nsPIDOMWindowOuter::From(window);
+ if (!pwindow) {
+ return 0;
+ }
+
+ nsPIDOMWindowInner* inner = pwindow->GetCurrentInnerWindow();
+ return inner ? inner->WindowID() : 0;
+}
+
+nsresult
+nsContentUtils::GetHostOrIPv6WithBrackets(nsIURI* aURI, nsCString& aHost)
+{
+ aHost.Truncate();
+ nsresult rv = aURI->GetHost(aHost);
+ if (NS_FAILED(rv)) { // Some URIs do not have a host
+ return rv;
+ }
+
+ if (aHost.FindChar(':') != -1) { // Escape IPv6 address
+ MOZ_ASSERT(!aHost.Length() ||
+ (aHost[0] !='[' && aHost[aHost.Length() - 1] != ']'));
+ aHost.Insert('[', 0);
+ aHost.Append(']');
+ }
+
+ return NS_OK;
+}
+
+nsresult
+nsContentUtils::GetHostOrIPv6WithBrackets(nsIURI* aURI, nsAString& aHost)
+{
+ nsAutoCString hostname;
+ nsresult rv = GetHostOrIPv6WithBrackets(aURI, hostname);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ CopyUTF8toUTF16(hostname, aHost);
+ return NS_OK;
+}
+
+bool
+nsContentUtils::CallOnAllRemoteChildren(nsIMessageBroadcaster* aManager,
+ CallOnRemoteChildFunction aCallback,
+ void* aArg)
+{
+ uint32_t tabChildCount = 0;
+ aManager->GetChildCount(&tabChildCount);
+ for (uint32_t j = 0; j < tabChildCount; ++j) {
+ nsCOMPtr<nsIMessageListenerManager> childMM;
+ aManager->GetChildAt(j, getter_AddRefs(childMM));
+ if (!childMM) {
+ continue;
+ }
+
+ nsCOMPtr<nsIMessageBroadcaster> nonLeafMM = do_QueryInterface(childMM);
+ if (nonLeafMM) {
+ if (CallOnAllRemoteChildren(nonLeafMM, aCallback, aArg)) {
+ return true;
+ }
+ continue;
+ }
+
+ nsCOMPtr<nsIMessageSender> tabMM = do_QueryInterface(childMM);
+
+ mozilla::dom::ipc::MessageManagerCallback* cb =
+ static_cast<nsFrameMessageManager*>(tabMM.get())->GetCallback();
+ if (cb) {
+ nsFrameLoader* fl = static_cast<nsFrameLoader*>(cb);
+ TabParent* remote = TabParent::GetFrom(fl);
+ if (remote && aCallback) {
+ if (aCallback(remote, aArg)) {
+ return true;
+ }
+ }
+ }
+ }
+
+ return false;
+}
+
+void
+nsContentUtils::CallOnAllRemoteChildren(nsPIDOMWindowOuter* aWindow,
+ CallOnRemoteChildFunction aCallback,
+ void* aArg)
+{
+ nsCOMPtr<nsIDOMChromeWindow> chromeWindow(do_QueryInterface(aWindow));
+ if (chromeWindow) {
+ nsCOMPtr<nsIMessageBroadcaster> windowMM;
+ chromeWindow->GetMessageManager(getter_AddRefs(windowMM));
+ if (windowMM) {
+ CallOnAllRemoteChildren(windowMM, aCallback, aArg);
+ }
+ }
+}
+
+struct UIStateChangeInfo {
+ UIStateChangeType mShowAccelerators;
+ UIStateChangeType mShowFocusRings;
+
+ UIStateChangeInfo(UIStateChangeType aShowAccelerators,
+ UIStateChangeType aShowFocusRings)
+ : mShowAccelerators(aShowAccelerators),
+ mShowFocusRings(aShowFocusRings)
+ {}
+};
+
+bool
+SetKeyboardIndicatorsChild(TabParent* aParent, void* aArg)
+{
+ UIStateChangeInfo* stateInfo = static_cast<UIStateChangeInfo*>(aArg);
+ Unused << aParent->SendSetKeyboardIndicators(stateInfo->mShowAccelerators,
+ stateInfo->mShowFocusRings);
+ return false;
+}
+
+void
+nsContentUtils::SetKeyboardIndicatorsOnRemoteChildren(nsPIDOMWindowOuter* aWindow,
+ UIStateChangeType aShowAccelerators,
+ UIStateChangeType aShowFocusRings)
+{
+ UIStateChangeInfo stateInfo(aShowAccelerators, aShowFocusRings);
+ CallOnAllRemoteChildren(aWindow, SetKeyboardIndicatorsChild,
+ (void *)&stateInfo);
+}
+
+nsresult
+nsContentUtils::IPCTransferableToTransferable(const IPCDataTransfer& aDataTransfer,
+ const bool& aIsPrivateData,
+ nsIPrincipal* aRequestingPrincipal,
+ nsITransferable* aTransferable,
+ mozilla::dom::nsIContentParent* aContentParent,
+ mozilla::dom::TabChild* aTabChild)
+{
+ nsresult rv;
+
+ const nsTArray<IPCDataTransferItem>& items = aDataTransfer.items();
+ for (const auto& item : items) {
+ aTransferable->AddDataFlavor(item.flavor().get());
+
+ if (item.data().type() == IPCDataTransferData::TnsString) {
+ nsCOMPtr<nsISupportsString> dataWrapper =
+ do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ const nsString& text = item.data().get_nsString();
+ rv = dataWrapper->SetData(text);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = aTransferable->SetTransferData(item.flavor().get(), dataWrapper,
+ text.Length() * sizeof(char16_t));
+
+ NS_ENSURE_SUCCESS(rv, rv);
+ } else if (item.data().type() == IPCDataTransferData::TShmem) {
+ if (nsContentUtils::IsFlavorImage(item.flavor())) {
+ nsCOMPtr<imgIContainer> imageContainer;
+ rv = nsContentUtils::DataTransferItemToImage(item,
+ getter_AddRefs(imageContainer));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsISupportsInterfacePointer> imgPtr =
+ do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID);
+ NS_ENSURE_TRUE(imgPtr, NS_ERROR_FAILURE);
+
+ rv = imgPtr->SetData(imageContainer);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aTransferable->SetTransferData(item.flavor().get(), imgPtr, sizeof(nsISupports*));
+ } else {
+ nsCOMPtr<nsISupportsCString> dataWrapper =
+ do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID, &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // The buffer contains the terminating null.
+ Shmem itemData = item.data().get_Shmem();
+ const nsDependentCString text(itemData.get<char>(),
+ itemData.Size<char>());
+ rv = dataWrapper->SetData(text);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = aTransferable->SetTransferData(item.flavor().get(), dataWrapper, text.Length());
+
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ if (aContentParent) {
+ Unused << aContentParent->DeallocShmem(item.data().get_Shmem());
+ } else if (aTabChild) {
+ Unused << aTabChild->DeallocShmem(item.data().get_Shmem());
+ }
+ }
+ }
+
+ aTransferable->SetIsPrivateData(aIsPrivateData);
+ aTransferable->SetRequestingPrincipal(aRequestingPrincipal);
+ return NS_OK;
+}
+
+void
+nsContentUtils::TransferablesToIPCTransferables(nsIArray* aTransferables,
+ nsTArray<IPCDataTransfer>& aIPC,
+ bool aInSyncMessage,
+ mozilla::dom::nsIContentChild* aChild,
+ mozilla::dom::nsIContentParent* aParent)
+{
+ aIPC.Clear();
+ if (aTransferables) {
+ uint32_t transferableCount = 0;
+ aTransferables->GetLength(&transferableCount);
+ for (uint32_t i = 0; i < transferableCount; ++i) {
+ IPCDataTransfer* dt = aIPC.AppendElement();
+ nsCOMPtr<nsITransferable> transferable = do_QueryElementAt(aTransferables, i);
+ TransferableToIPCTransferable(transferable, dt, aInSyncMessage, aChild, aParent);
+ }
+ }
+}
+
+nsresult
+nsContentUtils::SlurpFileToString(nsIFile* aFile, nsACString& aString)
+{
+ aString.Truncate();
+
+ nsCOMPtr<nsIURI> fileURI;
+ nsresult rv = NS_NewFileURI(getter_AddRefs(fileURI), aFile);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ nsCOMPtr<nsIChannel> channel;
+ rv = NS_NewChannel(getter_AddRefs(channel),
+ fileURI,
+ nsContentUtils::GetSystemPrincipal(),
+ nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
+ nsIContentPolicy::TYPE_OTHER);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ nsCOMPtr<nsIInputStream> stream;
+ rv = channel->Open2(getter_AddRefs(stream));
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ rv = NS_ConsumeStream(stream, UINT32_MAX, aString);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ rv = stream->Close();
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+bool
+nsContentUtils::IsFileImage(nsIFile* aFile, nsACString& aType)
+{
+ nsCOMPtr<nsIMIMEService> mime = do_GetService("@mozilla.org/mime;1");
+ if (!mime) {
+ return false;
+ }
+
+ nsresult rv = mime->GetTypeFromFile(aFile, aType);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+
+ return StringBeginsWith(aType, NS_LITERAL_CSTRING("image/"));
+}
+
+nsresult
+nsContentUtils::DataTransferItemToImage(const IPCDataTransferItem& aItem,
+ imgIContainer** aContainer)
+{
+ MOZ_ASSERT(aItem.data().type() == IPCDataTransferData::TShmem);
+ MOZ_ASSERT(IsFlavorImage(aItem.flavor()));
+
+ const IPCDataTransferImage& imageDetails = aItem.imageDetails();
+ const IntSize size(imageDetails.width(), imageDetails.height());
+ if (!size.width || !size.height) {
+ return NS_ERROR_FAILURE;
+ }
+
+ Shmem data = aItem.data().get_Shmem();
+
+ RefPtr<DataSourceSurface> image =
+ CreateDataSourceSurfaceFromData(size,
+ static_cast<SurfaceFormat>(imageDetails.format()),
+ data.get<uint8_t>(),
+ imageDetails.stride());
+
+ RefPtr<gfxDrawable> drawable = new gfxSurfaceDrawable(image, size);
+ nsCOMPtr<imgIContainer> imageContainer =
+ image::ImageOps::CreateFromDrawable(drawable);
+ imageContainer.forget(aContainer);
+
+ return NS_OK;
+}
+
+bool
+nsContentUtils::IsFlavorImage(const nsACString& aFlavor)
+{
+ return aFlavor.EqualsLiteral(kNativeImageMime) ||
+ aFlavor.EqualsLiteral(kJPEGImageMime) ||
+ aFlavor.EqualsLiteral(kJPGImageMime) ||
+ aFlavor.EqualsLiteral(kPNGImageMime) ||
+ aFlavor.EqualsLiteral(kGIFImageMime);
+}
+
+static Shmem
+ConvertToShmem(mozilla::dom::nsIContentChild* aChild,
+ mozilla::dom::nsIContentParent* aParent,
+ const nsACString& aInput)
+{
+ MOZ_ASSERT((aChild && !aParent) || (!aChild && aParent));
+
+ IShmemAllocator* allocator =
+ aChild ? static_cast<IShmemAllocator*>(aChild)
+ : static_cast<IShmemAllocator*>(aParent);
+
+ Shmem result;
+ if (!allocator->AllocShmem(aInput.Length() + 1,
+ SharedMemory::TYPE_BASIC,
+ &result)) {
+ return result;
+ }
+
+ memcpy(result.get<char>(),
+ aInput.BeginReading(),
+ aInput.Length() + 1);
+
+ return result;
+}
+
+void
+nsContentUtils::TransferableToIPCTransferable(nsITransferable* aTransferable,
+ IPCDataTransfer* aIPCDataTransfer,
+ bool aInSyncMessage,
+ mozilla::dom::nsIContentChild* aChild,
+ mozilla::dom::nsIContentParent* aParent)
+{
+ MOZ_ASSERT((aChild && !aParent) || (!aChild && aParent));
+
+ if (aTransferable) {
+ nsCOMPtr<nsIArray> flavorList;
+ aTransferable->FlavorsTransferableCanExport(getter_AddRefs(flavorList));
+ if (flavorList) {
+ uint32_t flavorCount = 0;
+ flavorList->GetLength(&flavorCount);
+ for (uint32_t j = 0; j < flavorCount; ++j) {
+ nsCOMPtr<nsISupportsCString> flavor = do_QueryElementAt(flavorList, j);
+ if (!flavor) {
+ continue;
+ }
+
+ nsAutoCString flavorStr;
+ flavor->GetData(flavorStr);
+ if (!flavorStr.Length()) {
+ continue;
+ }
+
+ nsCOMPtr<nsISupports> data;
+ uint32_t dataLen = 0;
+ aTransferable->GetTransferData(flavorStr.get(), getter_AddRefs(data), &dataLen);
+
+ nsCOMPtr<nsISupportsString> text = do_QueryInterface(data);
+ nsCOMPtr<nsISupportsCString> ctext = do_QueryInterface(data);
+ if (text) {
+ nsAutoString dataAsString;
+ text->GetData(dataAsString);
+ IPCDataTransferItem* item = aIPCDataTransfer->items().AppendElement();
+ item->flavor() = flavorStr;
+ item->data() = dataAsString;
+ } else if (ctext) {
+ nsAutoCString dataAsString;
+ ctext->GetData(dataAsString);
+ IPCDataTransferItem* item = aIPCDataTransfer->items().AppendElement();
+ item->flavor() = flavorStr;
+
+ Shmem dataAsShmem = ConvertToShmem(aChild, aParent, dataAsString);
+ if (!dataAsShmem.IsReadable() || !dataAsShmem.Size<char>()) {
+ continue;
+ }
+
+ item->data() = dataAsShmem;
+ } else {
+ nsCOMPtr<nsISupportsInterfacePointer> sip =
+ do_QueryInterface(data);
+ if (sip) {
+ sip->GetData(getter_AddRefs(data));
+ }
+
+ // Images to be pasted on the clipboard are nsIInputStreams
+ nsCOMPtr<nsIInputStream> stream(do_QueryInterface(data));
+ if (stream) {
+ IPCDataTransferItem* item = aIPCDataTransfer->items().AppendElement();
+ item->flavor() = flavorStr;
+
+ nsCString imageData;
+ NS_ConsumeStream(stream, UINT32_MAX, imageData);
+
+ Shmem imageDataShmem = ConvertToShmem(aChild, aParent, imageData);
+ if (!imageDataShmem.IsReadable() || !imageDataShmem.Size<char>()) {
+ continue;
+ }
+
+ item->data() = imageDataShmem;
+ continue;
+ }
+
+ // Images to be placed on the clipboard are imgIContainers.
+ nsCOMPtr<imgIContainer> image(do_QueryInterface(data));
+ if (image) {
+ RefPtr<mozilla::gfx::SourceSurface> surface =
+ image->GetFrame(imgIContainer::FRAME_CURRENT,
+ imgIContainer::FLAG_SYNC_DECODE);
+ if (!surface) {
+ continue;
+ }
+ RefPtr<mozilla::gfx::DataSourceSurface> dataSurface =
+ surface->GetDataSurface();
+ if (!dataSurface) {
+ continue;
+ }
+ size_t length;
+ int32_t stride;
+ Shmem surfaceData;
+ IShmemAllocator* allocator = aChild ? static_cast<IShmemAllocator*>(aChild)
+ : static_cast<IShmemAllocator*>(aParent);
+ GetSurfaceData(dataSurface, &length, &stride,
+ allocator,
+ &surfaceData);
+
+ IPCDataTransferItem* item = aIPCDataTransfer->items().AppendElement();
+ item->flavor() = flavorStr;
+ // Turn item->data() into an nsCString prior to accessing it.
+ item->data() = surfaceData;
+
+ IPCDataTransferImage& imageDetails = item->imageDetails();
+ mozilla::gfx::IntSize size = dataSurface->GetSize();
+ imageDetails.width() = size.width;
+ imageDetails.height() = size.height;
+ imageDetails.stride() = stride;
+ imageDetails.format() = static_cast<uint8_t>(dataSurface->GetFormat());
+
+ continue;
+ }
+
+ // Otherwise, handle this as a file.
+ nsCOMPtr<BlobImpl> blobImpl;
+ nsCOMPtr<nsIFile> file = do_QueryInterface(data);
+ if (file) {
+ // If we can send this over as a blob, do so. Otherwise, we're
+ // responding to a sync message and the child can't process the blob
+ // constructor before processing our response, which would crash. In
+ // that case, hope that the caller is nsClipboardProxy::GetData,
+ // called from editor and send over images as raw data.
+ if (aInSyncMessage) {
+ nsAutoCString type;
+ if (IsFileImage(file, type)) {
+ IPCDataTransferItem* item = aIPCDataTransfer->items().AppendElement();
+ item->flavor() = type;
+ nsAutoCString data;
+ SlurpFileToString(file, data);
+
+ Shmem dataAsShmem = ConvertToShmem(aChild, aParent, data);
+ item->data() = dataAsShmem;
+ }
+
+ continue;
+ }
+
+ if (aParent) {
+ bool isDir = false;
+ if (NS_SUCCEEDED(file->IsDirectory(&isDir)) && isDir) {
+ nsAutoString path;
+ if (NS_WARN_IF(NS_FAILED(file->GetPath(path)))) {
+ continue;
+ }
+
+ RefPtr<FileSystemSecurity> fss = FileSystemSecurity::GetOrCreate();
+ fss->GrantAccessToContentProcess(aParent->ChildID(), path);
+ }
+ }
+
+ blobImpl = new BlobImplFile(file, false);
+ ErrorResult rv;
+ // Ensure that file data is cached no that the content process
+ // has this data available to it when passed over:
+ blobImpl->GetSize(rv);
+ blobImpl->GetLastModified(rv);
+ } else {
+ if (aInSyncMessage) {
+ // Can't do anything.
+ continue;
+ }
+ blobImpl = do_QueryInterface(data);
+ }
+ if (blobImpl) {
+ IPCDataTransferData data;
+
+ // If we failed to create the blob actor, then this blob probably
+ // can't get the file size for the underlying file, ignore it for
+ // now. TODO pass this through anyway.
+ if (aChild) {
+ auto* child = mozilla::dom::BlobChild::GetOrCreate(aChild,
+ static_cast<BlobImpl*>(blobImpl.get()));
+ if (!child) {
+ continue;
+ }
+
+ data = child;
+ } else if (aParent) {
+ auto* parent = mozilla::dom::BlobParent::GetOrCreate(aParent,
+ static_cast<BlobImpl*>(blobImpl.get()));
+ if (!parent) {
+ continue;
+ }
+
+ data = parent;
+ }
+
+ IPCDataTransferItem* item = aIPCDataTransfer->items().AppendElement();
+ item->flavor() = flavorStr;
+ item->data() = data;
+ } else {
+ // This is a hack to support kFilePromiseMime.
+ // On Windows there just needs to be an entry for it,
+ // and for OSX we need to create
+ // nsContentAreaDragDropDataProvider as nsIFlavorDataProvider.
+ if (flavorStr.EqualsLiteral(kFilePromiseMime)) {
+ IPCDataTransferItem* item = aIPCDataTransfer->items().AppendElement();
+ item->flavor() = flavorStr;
+ item->data() = NS_ConvertUTF8toUTF16(flavorStr);
+ } else if (!data) {
+ // Empty element, transfer only the flavor
+ IPCDataTransferItem* item = aIPCDataTransfer->items().AppendElement();
+ item->flavor() = flavorStr;
+ item->data() = nsString();
+ continue;
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+namespace {
+// The default type used for calling GetSurfaceData(). Gets surface data as
+// raw buffer.
+struct GetSurfaceDataRawBuffer
+{
+ using ReturnType = mozilla::UniquePtr<char[]>;
+ using BufferType = char*;
+
+ ReturnType Allocate(size_t aSize)
+ {
+ return ReturnType(new char[aSize]);
+ }
+
+ static BufferType
+ GetBuffer(const ReturnType& aReturnValue)
+ {
+ return aReturnValue.get();
+ }
+
+ static ReturnType
+ NullValue()
+ {
+ return ReturnType();
+ }
+};
+
+// The type used for calling GetSurfaceData() that allocates and writes to
+// a shared memory buffer.
+struct GetSurfaceDataShmem
+{
+ using ReturnType = Shmem;
+ using BufferType = char*;
+
+ explicit GetSurfaceDataShmem(IShmemAllocator* aAllocator)
+ : mAllocator(aAllocator)
+ { }
+
+ ReturnType Allocate(size_t aSize)
+ {
+ Shmem returnValue;
+ mAllocator->AllocShmem(aSize,
+ SharedMemory::TYPE_BASIC,
+ &returnValue);
+ return returnValue;
+ }
+
+ static BufferType
+ GetBuffer(ReturnType aReturnValue)
+ {
+ return aReturnValue.get<char>();
+ }
+
+ static ReturnType
+ NullValue()
+ {
+ return ReturnType();
+ }
+private:
+ IShmemAllocator* mAllocator;
+};
+
+/*
+ * Get the pixel data from the given source surface and return it as a buffer.
+ * The length and stride will be assigned from the surface.
+ */
+template <typename GetSurfaceDataContext = GetSurfaceDataRawBuffer>
+typename GetSurfaceDataContext::ReturnType
+GetSurfaceDataImpl(mozilla::gfx::DataSourceSurface* aSurface,
+ size_t* aLength, int32_t* aStride,
+ GetSurfaceDataContext aContext = GetSurfaceDataContext())
+{
+ mozilla::gfx::DataSourceSurface::MappedSurface map;
+ if (!aSurface->Map(mozilla::gfx::DataSourceSurface::MapType::READ, &map)) {
+ return GetSurfaceDataContext::NullValue();
+ }
+
+ mozilla::gfx::IntSize size = aSurface->GetSize();
+ mozilla::CheckedInt32 requiredBytes =
+ mozilla::CheckedInt32(map.mStride) * mozilla::CheckedInt32(size.height);
+ if (!requiredBytes.isValid()) {
+ return GetSurfaceDataContext::NullValue();
+ }
+
+ size_t maxBufLen = requiredBytes.value();
+ mozilla::gfx::SurfaceFormat format = aSurface->GetFormat();
+
+ // Surface data handling is totally nuts. This is the magic one needs to
+ // know to access the data.
+ size_t bufLen = maxBufLen - map.mStride + (size.width * BytesPerPixel(format));
+
+ // nsDependentCString wants null-terminated string.
+ typename GetSurfaceDataContext::ReturnType surfaceData = aContext.Allocate(maxBufLen + 1);
+ if (GetSurfaceDataContext::GetBuffer(surfaceData)) {
+ memcpy(GetSurfaceDataContext::GetBuffer(surfaceData),
+ reinterpret_cast<char*>(map.mData),
+ bufLen);
+ memset(GetSurfaceDataContext::GetBuffer(surfaceData) + bufLen,
+ 0,
+ maxBufLen - bufLen + 1);
+ }
+
+ *aLength = maxBufLen;
+ *aStride = map.mStride;
+
+ aSurface->Unmap();
+ return surfaceData;
+}
+} // Anonymous namespace.
+
+mozilla::UniquePtr<char[]>
+nsContentUtils::GetSurfaceData(
+ NotNull<mozilla::gfx::DataSourceSurface*> aSurface,
+ size_t* aLength, int32_t* aStride)
+{
+ return GetSurfaceDataImpl(aSurface, aLength, aStride);
+}
+
+void
+nsContentUtils::GetSurfaceData(mozilla::gfx::DataSourceSurface* aSurface,
+ size_t* aLength, int32_t* aStride,
+ IShmemAllocator* aAllocator,
+ Shmem *aOutShmem)
+{
+ *aOutShmem = GetSurfaceDataImpl(aSurface, aLength, aStride,
+ GetSurfaceDataShmem(aAllocator));
+}
+
+mozilla::Modifiers
+nsContentUtils::GetWidgetModifiers(int32_t aModifiers)
+{
+ Modifiers result = 0;
+ if (aModifiers & nsIDOMWindowUtils::MODIFIER_SHIFT) {
+ result |= mozilla::MODIFIER_SHIFT;
+ }
+ if (aModifiers & nsIDOMWindowUtils::MODIFIER_CONTROL) {
+ result |= mozilla::MODIFIER_CONTROL;
+ }
+ if (aModifiers & nsIDOMWindowUtils::MODIFIER_ALT) {
+ result |= mozilla::MODIFIER_ALT;
+ }
+ if (aModifiers & nsIDOMWindowUtils::MODIFIER_META) {
+ result |= mozilla::MODIFIER_META;
+ }
+ if (aModifiers & nsIDOMWindowUtils::MODIFIER_ALTGRAPH) {
+ result |= mozilla::MODIFIER_ALTGRAPH;
+ }
+ if (aModifiers & nsIDOMWindowUtils::MODIFIER_CAPSLOCK) {
+ result |= mozilla::MODIFIER_CAPSLOCK;
+ }
+ if (aModifiers & nsIDOMWindowUtils::MODIFIER_FN) {
+ result |= mozilla::MODIFIER_FN;
+ }
+ if (aModifiers & nsIDOMWindowUtils::MODIFIER_FNLOCK) {
+ result |= mozilla::MODIFIER_FNLOCK;
+ }
+ if (aModifiers & nsIDOMWindowUtils::MODIFIER_NUMLOCK) {
+ result |= mozilla::MODIFIER_NUMLOCK;
+ }
+ if (aModifiers & nsIDOMWindowUtils::MODIFIER_SCROLLLOCK) {
+ result |= mozilla::MODIFIER_SCROLLLOCK;
+ }
+ if (aModifiers & nsIDOMWindowUtils::MODIFIER_SYMBOL) {
+ result |= mozilla::MODIFIER_SYMBOL;
+ }
+ if (aModifiers & nsIDOMWindowUtils::MODIFIER_SYMBOLLOCK) {
+ result |= mozilla::MODIFIER_SYMBOLLOCK;
+ }
+ if (aModifiers & nsIDOMWindowUtils::MODIFIER_OS) {
+ result |= mozilla::MODIFIER_OS;
+ }
+ return result;
+}
+
+nsIWidget*
+nsContentUtils::GetWidget(nsIPresShell* aPresShell, nsPoint* aOffset) {
+ if (aPresShell) {
+ nsIFrame* frame = aPresShell->GetRootFrame();
+ if (frame)
+ return frame->GetView()->GetNearestWidget(aOffset);
+ }
+ return nullptr;
+}
+
+int16_t
+nsContentUtils::GetButtonsFlagForButton(int32_t aButton)
+{
+ switch (aButton) {
+ case -1:
+ return WidgetMouseEvent::eNoButtonFlag;
+ case WidgetMouseEvent::eLeftButton:
+ return WidgetMouseEvent::eLeftButtonFlag;
+ case WidgetMouseEvent::eMiddleButton:
+ return WidgetMouseEvent::eMiddleButtonFlag;
+ case WidgetMouseEvent::eRightButton:
+ return WidgetMouseEvent::eRightButtonFlag;
+ case 4:
+ return WidgetMouseEvent::e4thButtonFlag;
+ case 5:
+ return WidgetMouseEvent::e5thButtonFlag;
+ default:
+ NS_ERROR("Button not known.");
+ return 0;
+ }
+}
+
+LayoutDeviceIntPoint
+nsContentUtils::ToWidgetPoint(const CSSPoint& aPoint,
+ const nsPoint& aOffset,
+ nsPresContext* aPresContext)
+{
+ return LayoutDeviceIntPoint::FromAppUnitsRounded(
+ (CSSPoint::ToAppUnits(aPoint) +
+ aOffset).ApplyResolution(nsLayoutUtils::GetCurrentAPZResolutionScale(aPresContext->PresShell())),
+ aPresContext->AppUnitsPerDevPixel());
+}
+
+nsView*
+nsContentUtils::GetViewToDispatchEvent(nsPresContext* presContext,
+ nsIPresShell** presShell)
+{
+ if (presContext && presShell) {
+ *presShell = presContext->PresShell();
+ if (*presShell) {
+ NS_ADDREF(*presShell);
+ if (nsViewManager* viewManager = (*presShell)->GetViewManager()) {
+ if (nsView* view = viewManager->GetRootView()) {
+ return view;
+ }
+ }
+ }
+ }
+ return nullptr;
+}
+
+nsresult
+nsContentUtils::SendKeyEvent(nsIWidget* aWidget,
+ const nsAString& aType,
+ int32_t aKeyCode,
+ int32_t aCharCode,
+ int32_t aModifiers,
+ uint32_t aAdditionalFlags,
+ bool* aDefaultActionTaken)
+{
+ // get the widget to send the event to
+ if (!aWidget)
+ return NS_ERROR_FAILURE;
+
+ EventMessage msg;
+ if (aType.EqualsLiteral("keydown"))
+ msg = eKeyDown;
+ else if (aType.EqualsLiteral("keyup"))
+ msg = eKeyUp;
+ else if (aType.EqualsLiteral("keypress"))
+ msg = eKeyPress;
+ else
+ return NS_ERROR_FAILURE;
+
+ WidgetKeyboardEvent event(true, msg, aWidget);
+ event.mModifiers = GetWidgetModifiers(aModifiers);
+
+ if (msg == eKeyPress) {
+ event.mKeyCode = aCharCode ? 0 : aKeyCode;
+ event.mCharCode = aCharCode;
+ } else {
+ event.mKeyCode = aKeyCode;
+ event.mCharCode = 0;
+ }
+
+ uint32_t locationFlag = (aAdditionalFlags &
+ (nsIDOMWindowUtils::KEY_FLAG_LOCATION_STANDARD | nsIDOMWindowUtils::KEY_FLAG_LOCATION_LEFT |
+ nsIDOMWindowUtils::KEY_FLAG_LOCATION_RIGHT | nsIDOMWindowUtils::KEY_FLAG_LOCATION_NUMPAD));
+ switch (locationFlag) {
+ case nsIDOMWindowUtils::KEY_FLAG_LOCATION_STANDARD:
+ event.mLocation = nsIDOMKeyEvent::DOM_KEY_LOCATION_STANDARD;
+ break;
+ case nsIDOMWindowUtils::KEY_FLAG_LOCATION_LEFT:
+ event.mLocation = nsIDOMKeyEvent::DOM_KEY_LOCATION_LEFT;
+ break;
+ case nsIDOMWindowUtils::KEY_FLAG_LOCATION_RIGHT:
+ event.mLocation = nsIDOMKeyEvent::DOM_KEY_LOCATION_RIGHT;
+ break;
+ case nsIDOMWindowUtils::KEY_FLAG_LOCATION_NUMPAD:
+ event.mLocation = nsIDOMKeyEvent::DOM_KEY_LOCATION_NUMPAD;
+ break;
+ default:
+ if (locationFlag != 0) {
+ return NS_ERROR_INVALID_ARG;
+ }
+ // If location flag isn't set, choose the location from keycode.
+ switch (aKeyCode) {
+ case nsIDOMKeyEvent::DOM_VK_NUMPAD0:
+ case nsIDOMKeyEvent::DOM_VK_NUMPAD1:
+ case nsIDOMKeyEvent::DOM_VK_NUMPAD2:
+ case nsIDOMKeyEvent::DOM_VK_NUMPAD3:
+ case nsIDOMKeyEvent::DOM_VK_NUMPAD4:
+ case nsIDOMKeyEvent::DOM_VK_NUMPAD5:
+ case nsIDOMKeyEvent::DOM_VK_NUMPAD6:
+ case nsIDOMKeyEvent::DOM_VK_NUMPAD7:
+ case nsIDOMKeyEvent::DOM_VK_NUMPAD8:
+ case nsIDOMKeyEvent::DOM_VK_NUMPAD9:
+ case nsIDOMKeyEvent::DOM_VK_MULTIPLY:
+ case nsIDOMKeyEvent::DOM_VK_ADD:
+ case nsIDOMKeyEvent::DOM_VK_SEPARATOR:
+ case nsIDOMKeyEvent::DOM_VK_SUBTRACT:
+ case nsIDOMKeyEvent::DOM_VK_DECIMAL:
+ case nsIDOMKeyEvent::DOM_VK_DIVIDE:
+ event.mLocation = nsIDOMKeyEvent::DOM_KEY_LOCATION_NUMPAD;
+ break;
+ case nsIDOMKeyEvent::DOM_VK_SHIFT:
+ case nsIDOMKeyEvent::DOM_VK_CONTROL:
+ case nsIDOMKeyEvent::DOM_VK_ALT:
+ case nsIDOMKeyEvent::DOM_VK_META:
+ event.mLocation = nsIDOMKeyEvent::DOM_KEY_LOCATION_LEFT;
+ break;
+ default:
+ event.mLocation = nsIDOMKeyEvent::DOM_KEY_LOCATION_STANDARD;
+ break;
+ }
+ break;
+ }
+
+ event.mRefPoint = LayoutDeviceIntPoint(0, 0);
+ event.mTime = PR_IntervalNow();
+ if (!(aAdditionalFlags & nsIDOMWindowUtils::KEY_FLAG_NOT_SYNTHESIZED_FOR_TESTS)) {
+ event.mFlags.mIsSynthesizedForTests = true;
+ }
+
+ if (aAdditionalFlags & nsIDOMWindowUtils::KEY_FLAG_PREVENT_DEFAULT) {
+ event.PreventDefaultBeforeDispatch();
+ }
+
+ nsEventStatus status;
+ nsresult rv = aWidget->DispatchEvent(&event, status);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *aDefaultActionTaken = (status != nsEventStatus_eConsumeNoDefault);
+
+ return NS_OK;
+}
+
+nsresult
+nsContentUtils::SendMouseEvent(nsCOMPtr<nsIPresShell> aPresShell,
+ const nsAString& aType,
+ float aX,
+ float aY,
+ int32_t aButton,
+ int32_t aButtons,
+ int32_t aClickCount,
+ int32_t aModifiers,
+ bool aIgnoreRootScrollFrame,
+ float aPressure,
+ unsigned short aInputSourceArg,
+ bool aToWindow,
+ bool *aPreventDefault,
+ bool aIsDOMEventSynthesized,
+ bool aIsWidgetEventSynthesized)
+{
+ nsPoint offset;
+ nsCOMPtr<nsIWidget> widget = GetWidget(aPresShell, &offset);
+ if (!widget)
+ return NS_ERROR_FAILURE;
+
+ EventMessage msg;
+ WidgetMouseEvent::ExitFrom exitFrom = WidgetMouseEvent::eChild;
+ bool contextMenuKey = false;
+ if (aType.EqualsLiteral("mousedown")) {
+ msg = eMouseDown;
+ } else if (aType.EqualsLiteral("mouseup")) {
+ msg = eMouseUp;
+ } else if (aType.EqualsLiteral("mousemove")) {
+ msg = eMouseMove;
+ } else if (aType.EqualsLiteral("mouseover")) {
+ msg = eMouseEnterIntoWidget;
+ } else if (aType.EqualsLiteral("mouseout")) {
+ msg = eMouseExitFromWidget;
+ } else if (aType.EqualsLiteral("mousecancel")) {
+ msg = eMouseExitFromWidget;
+ exitFrom = WidgetMouseEvent::eTopLevel;
+ } else if (aType.EqualsLiteral("mouselongtap")) {
+ msg = eMouseLongTap;
+ } else if (aType.EqualsLiteral("contextmenu")) {
+ msg = eContextMenu;
+ contextMenuKey = (aButton == 0);
+ } else if (aType.EqualsLiteral("MozMouseHittest")) {
+ msg = eMouseHitTest;
+ } else {
+ return NS_ERROR_FAILURE;
+ }
+
+ if (aInputSourceArg == nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN) {
+ aInputSourceArg = nsIDOMMouseEvent::MOZ_SOURCE_MOUSE;
+ }
+
+ WidgetMouseEvent event(true, msg, widget,
+ aIsWidgetEventSynthesized ?
+ WidgetMouseEvent::eSynthesized :
+ WidgetMouseEvent::eReal,
+ contextMenuKey ? WidgetMouseEvent::eContextMenuKey :
+ WidgetMouseEvent::eNormal);
+ event.mModifiers = GetWidgetModifiers(aModifiers);
+ event.button = aButton;
+ event.buttons = aButtons != nsIDOMWindowUtils::MOUSE_BUTTONS_NOT_SPECIFIED ?
+ aButtons :
+ msg == eMouseUp ? 0 : GetButtonsFlagForButton(aButton);
+ event.pressure = aPressure;
+ event.inputSource = aInputSourceArg;
+ event.mClickCount = aClickCount;
+ event.mTime = PR_IntervalNow();
+ event.mFlags.mIsSynthesizedForTests = aIsDOMEventSynthesized;
+ event.mExitFrom = exitFrom;
+
+ nsPresContext* presContext = aPresShell->GetPresContext();
+ if (!presContext)
+ return NS_ERROR_FAILURE;
+
+ event.mRefPoint = ToWidgetPoint(CSSPoint(aX, aY), offset, presContext);
+ event.mIgnoreRootScrollFrame = aIgnoreRootScrollFrame;
+
+ nsEventStatus status = nsEventStatus_eIgnore;
+ if (aToWindow) {
+ nsCOMPtr<nsIPresShell> presShell;
+ nsView* view = GetViewToDispatchEvent(presContext, getter_AddRefs(presShell));
+ if (!presShell || !view) {
+ return NS_ERROR_FAILURE;
+ }
+ return presShell->HandleEvent(view->GetFrame(), &event, false, &status);
+ }
+ if (gfxPrefs::TestEventsAsyncEnabled()) {
+ status = widget->DispatchInputEvent(&event);
+ } else {
+ nsresult rv = widget->DispatchEvent(&event, status);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ if (aPreventDefault) {
+ *aPreventDefault = (status == nsEventStatus_eConsumeNoDefault);
+ }
+
+ return NS_OK;
+}
+
+/* static */
+void
+nsContentUtils::FirePageHideEvent(nsIDocShellTreeItem* aItem,
+ EventTarget* aChromeEventHandler)
+{
+ nsCOMPtr<nsIDocument> doc = aItem->GetDocument();
+ NS_ASSERTION(doc, "What happened here?");
+ doc->OnPageHide(true, aChromeEventHandler);
+
+ int32_t childCount = 0;
+ aItem->GetChildCount(&childCount);
+ AutoTArray<nsCOMPtr<nsIDocShellTreeItem>, 8> kids;
+ kids.AppendElements(childCount);
+ for (int32_t i = 0; i < childCount; ++i) {
+ aItem->GetChildAt(i, getter_AddRefs(kids[i]));
+ }
+
+ for (uint32_t i = 0; i < kids.Length(); ++i) {
+ if (kids[i]) {
+ FirePageHideEvent(kids[i], aChromeEventHandler);
+ }
+ }
+}
+
+// The pageshow event is fired for a given document only if IsShowing() returns
+// the same thing as aFireIfShowing. This gives us a way to fire pageshow only
+// on documents that are still loading or only on documents that are already
+// loaded.
+/* static */
+void
+nsContentUtils::FirePageShowEvent(nsIDocShellTreeItem* aItem,
+ EventTarget* aChromeEventHandler,
+ bool aFireIfShowing)
+{
+ int32_t childCount = 0;
+ aItem->GetChildCount(&childCount);
+ AutoTArray<nsCOMPtr<nsIDocShellTreeItem>, 8> kids;
+ kids.AppendElements(childCount);
+ for (int32_t i = 0; i < childCount; ++i) {
+ aItem->GetChildAt(i, getter_AddRefs(kids[i]));
+ }
+
+ for (uint32_t i = 0; i < kids.Length(); ++i) {
+ if (kids[i]) {
+ FirePageShowEvent(kids[i], aChromeEventHandler, aFireIfShowing);
+ }
+ }
+
+ nsCOMPtr<nsIDocument> doc = aItem->GetDocument();
+ NS_ASSERTION(doc, "What happened here?");
+ if (doc->IsShowing() == aFireIfShowing) {
+ doc->OnPageShow(true, aChromeEventHandler);
+ }
+}
+
+/* static */
+already_AddRefed<nsPIWindowRoot>
+nsContentUtils::GetWindowRoot(nsIDocument* aDoc)
+{
+ if (aDoc) {
+ if (nsPIDOMWindowOuter* win = aDoc->GetWindow()) {
+ return win->GetTopWindowRoot();
+ }
+ }
+ return nullptr;
+}
+
+/* static */
+nsContentPolicyType
+nsContentUtils::InternalContentPolicyTypeToExternal(nsContentPolicyType aType)
+{
+ switch (aType) {
+ case nsIContentPolicy::TYPE_INTERNAL_SCRIPT:
+ case nsIContentPolicy::TYPE_INTERNAL_SCRIPT_PRELOAD:
+ case nsIContentPolicy::TYPE_INTERNAL_WORKER:
+ case nsIContentPolicy::TYPE_INTERNAL_SHARED_WORKER:
+ case nsIContentPolicy::TYPE_INTERNAL_SERVICE_WORKER:
+ return nsIContentPolicy::TYPE_SCRIPT;
+
+ case nsIContentPolicy::TYPE_INTERNAL_EMBED:
+ case nsIContentPolicy::TYPE_INTERNAL_OBJECT:
+ return nsIContentPolicy::TYPE_OBJECT;
+
+ case nsIContentPolicy::TYPE_INTERNAL_FRAME:
+ case nsIContentPolicy::TYPE_INTERNAL_IFRAME:
+ return nsIContentPolicy::TYPE_SUBDOCUMENT;
+
+ case nsIContentPolicy::TYPE_INTERNAL_AUDIO:
+ case nsIContentPolicy::TYPE_INTERNAL_VIDEO:
+ case nsIContentPolicy::TYPE_INTERNAL_TRACK:
+ return nsIContentPolicy::TYPE_MEDIA;
+
+ case nsIContentPolicy::TYPE_INTERNAL_XMLHTTPREQUEST:
+ case nsIContentPolicy::TYPE_INTERNAL_EVENTSOURCE:
+ return nsIContentPolicy::TYPE_XMLHTTPREQUEST;
+
+ case nsIContentPolicy::TYPE_INTERNAL_IMAGE:
+ case nsIContentPolicy::TYPE_INTERNAL_IMAGE_PRELOAD:
+ case nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON:
+ return nsIContentPolicy::TYPE_IMAGE;
+
+ case nsIContentPolicy::TYPE_INTERNAL_STYLESHEET:
+ case nsIContentPolicy::TYPE_INTERNAL_STYLESHEET_PRELOAD:
+ return nsIContentPolicy::TYPE_STYLESHEET;
+
+ default:
+ return aType;
+ }
+}
+
+/* static */
+nsContentPolicyType
+nsContentUtils::InternalContentPolicyTypeToExternalOrWorker(nsContentPolicyType aType)
+{
+ switch (aType) {
+ case nsIContentPolicy::TYPE_INTERNAL_WORKER:
+ case nsIContentPolicy::TYPE_INTERNAL_SHARED_WORKER:
+ case nsIContentPolicy::TYPE_INTERNAL_SERVICE_WORKER:
+ return aType;
+
+ default:
+ return InternalContentPolicyTypeToExternal(aType);
+ }
+}
+
+/* static */
+bool
+nsContentUtils::IsPreloadType(nsContentPolicyType aType)
+{
+ if (aType == nsIContentPolicy::TYPE_INTERNAL_SCRIPT_PRELOAD ||
+ aType == nsIContentPolicy::TYPE_INTERNAL_IMAGE_PRELOAD ||
+ aType == nsIContentPolicy::TYPE_INTERNAL_STYLESHEET_PRELOAD) {
+ return true;
+ }
+ return false;
+}
+
+nsresult
+nsContentUtils::SetFetchReferrerURIWithPolicy(nsIPrincipal* aPrincipal,
+ nsIDocument* aDoc,
+ nsIHttpChannel* aChannel,
+ mozilla::net::ReferrerPolicy aReferrerPolicy)
+{
+ NS_ENSURE_ARG_POINTER(aPrincipal);
+ NS_ENSURE_ARG_POINTER(aChannel);
+
+ nsCOMPtr<nsIURI> principalURI;
+
+ if (IsSystemPrincipal(aPrincipal)) {
+ return NS_OK;
+ }
+
+ aPrincipal->GetURI(getter_AddRefs(principalURI));
+
+ if (!aDoc) {
+ return aChannel->SetReferrerWithPolicy(principalURI, aReferrerPolicy);
+ }
+
+ // If it weren't for history.push/replaceState, we could just use the
+ // principal's URI here. But since we want changes to the URI effected
+ // by push/replaceState to be reflected in the XHR referrer, we have to
+ // be more clever.
+ //
+ // If the document's original URI (before any push/replaceStates) matches
+ // our principal, then we use the document's current URI (after
+ // push/replaceStates). Otherwise (if the document is, say, a data:
+ // URI), we just use the principal's URI.
+ nsCOMPtr<nsIURI> docCurURI = aDoc->GetDocumentURI();
+ nsCOMPtr<nsIURI> docOrigURI = aDoc->GetOriginalURI();
+
+ nsCOMPtr<nsIURI> referrerURI;
+
+ if (principalURI && docCurURI && docOrigURI) {
+ bool equal = false;
+ principalURI->Equals(docOrigURI, &equal);
+ if (equal) {
+ referrerURI = docCurURI;
+ }
+ }
+
+ if (!referrerURI) {
+ referrerURI = principalURI;
+ }
+
+ net::ReferrerPolicy referrerPolicy = aReferrerPolicy;
+ if (referrerPolicy == net::RP_Default) {
+ referrerPolicy = aDoc->GetReferrerPolicy();
+ }
+ return aChannel->SetReferrerWithPolicy(referrerURI, referrerPolicy);
+}
+
+// static
+net::ReferrerPolicy
+nsContentUtils::GetReferrerPolicyFromHeader(const nsAString& aHeader)
+{
+ // Multiple headers could be concatenated into one comma-separated
+ // list of policies. Need to tokenize the multiple headers.
+ nsCharSeparatedTokenizer tokenizer(aHeader, ',');
+ nsAutoString token;
+ net::ReferrerPolicy referrerPolicy = mozilla::net::RP_Unset;
+ while (tokenizer.hasMoreTokens()) {
+ token = tokenizer.nextToken();
+ net::ReferrerPolicy policy = net::ReferrerPolicyFromString(token);
+ if (policy != net::RP_Unset) {
+ referrerPolicy = policy;
+ }
+ }
+ return referrerPolicy;
+}
+
+// static
+bool
+nsContentUtils::PushEnabled(JSContext* aCx, JSObject* aObj)
+{
+ if (NS_IsMainThread()) {
+ return Preferences::GetBool("dom.push.enabled", false);
+ }
+
+ using namespace workers;
+
+ // Otherwise, check the pref via the WorkerPrivate
+ WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(aCx);
+ if (!workerPrivate) {
+ return false;
+ }
+
+ return workerPrivate->PushEnabled();
+}
+
+// static
+bool
+nsContentUtils::IsNonSubresourceRequest(nsIChannel* aChannel)
+{
+ nsLoadFlags loadFlags = 0;
+ aChannel->GetLoadFlags(&loadFlags);
+ if (loadFlags & nsIChannel::LOAD_DOCUMENT_URI) {
+ return true;
+ }
+
+ nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
+ if (!loadInfo) {
+ return false;
+ }
+ nsContentPolicyType type = loadInfo->InternalContentPolicyType();
+ return type == nsIContentPolicy::TYPE_INTERNAL_WORKER ||
+ type == nsIContentPolicy::TYPE_INTERNAL_SHARED_WORKER;
+}
+
+// static, public
+nsContentUtils::StorageAccess
+nsContentUtils::StorageAllowedForWindow(nsPIDOMWindowInner* aWindow)
+{
+ MOZ_ASSERT(aWindow->IsInnerWindow());
+
+ if (nsIDocument* document = aWindow->GetExtantDoc()) {
+ nsCOMPtr<nsIPrincipal> principal = document->NodePrincipal();
+ return InternalStorageAllowedForPrincipal(principal, aWindow);
+ }
+
+ return StorageAccess::eDeny;
+}
+
+// static, public
+nsContentUtils::StorageAccess
+nsContentUtils::StorageAllowedForPrincipal(nsIPrincipal* aPrincipal)
+{
+ return InternalStorageAllowedForPrincipal(aPrincipal, nullptr);
+}
+
+// static, private
+nsContentUtils::StorageAccess
+nsContentUtils::InternalStorageAllowedForPrincipal(nsIPrincipal* aPrincipal,
+ nsPIDOMWindowInner* aWindow)
+{
+ MOZ_ASSERT(aPrincipal);
+ MOZ_ASSERT(!aWindow || aWindow->IsInnerWindow());
+
+ StorageAccess access = StorageAccess::eAllow;
+
+ // We don't allow storage on the null principal, in general. Even if the
+ // calling context is chrome.
+ if (aPrincipal->GetIsNullPrincipal()) {
+ return StorageAccess::eDeny;
+ }
+
+ if (aWindow) {
+ // If the document is sandboxed, then it is not permitted to use storage
+ nsIDocument* document = aWindow->GetExtantDoc();
+ if (document->GetSandboxFlags() & SANDBOXED_ORIGIN) {
+ return StorageAccess::eDeny;
+ }
+
+ // Check if we are in private browsing, and record that fact
+ if (IsInPrivateBrowsing(document)) {
+ access = StorageAccess::ePrivateBrowsing;
+ }
+ }
+
+ nsCOMPtr<nsIPermissionManager> permissionManager =
+ services::GetPermissionManager();
+ if (!permissionManager) {
+ return StorageAccess::eDeny;
+ }
+
+ // check the permission manager for any allow or deny permissions
+ // for cookies for the window.
+ uint32_t perm;
+ permissionManager->TestPermissionFromPrincipal(aPrincipal, "cookie", &perm);
+ if (perm == nsIPermissionManager::DENY_ACTION) {
+ return StorageAccess::eDeny;
+ } else if (perm == nsICookiePermission::ACCESS_SESSION) {
+ return std::min(access, StorageAccess::eSessionScoped);
+ } else if (perm == nsIPermissionManager::ALLOW_ACTION) {
+ return access;
+ }
+
+ // Check if we should only allow storage for the session, and record that fact
+ if (sCookiesLifetimePolicy == nsICookieService::ACCEPT_SESSION) {
+ // Storage could be StorageAccess::ePrivateBrowsing or StorageAccess::eAllow
+ // so perform a std::min comparison to make sure we preserve ePrivateBrowsing
+ // if it has been set.
+ access = std::min(StorageAccess::eSessionScoped, access);
+ }
+
+ // About URIs are allowed to access storage, even if they don't have chrome
+ // privileges. If this is not desired, than the consumer will have to
+ // implement their own restriction functionality.
+ //
+ // This is due to backwards-compatibility and the state of storage access before
+ // the introducton of nsContentUtils::InternalStorageAllowedForPrincipal:
+ //
+ // BEFORE:
+ // localStorage, caches: allowed in 3rd-party iframes always
+ // IndexedDB: allowed in 3rd-party iframes only if 3rd party URI is an about:
+ // URI within a specific whitelist
+ //
+ // AFTER:
+ // localStorage, caches: allowed in 3rd-party iframes by default. Preference
+ // can be set to disable in 3rd-party, which will not disallow in about: URIs.
+ // IndexedDB: allowed in 3rd-party iframes by default. Preference can be set to
+ // disable in 3rd-party, which will disallow in about: URIs, unless they are
+ // within a specific whitelist.
+ //
+ // This means that behavior for storage with internal about: URIs should not be
+ // affected, which is desireable due to the lack of automated testing for about:
+ // URIs with these preferences set, and the importance of the correct functioning
+ // of these URIs even with custom preferences.
+ nsCOMPtr<nsIURI> uri;
+ nsresult rv = aPrincipal->GetURI(getter_AddRefs(uri));
+ if (NS_SUCCEEDED(rv) && uri) {
+ bool isAbout = false;
+ MOZ_ALWAYS_SUCCEEDS(uri->SchemeIs("about", &isAbout));
+ if (isAbout) {
+ return access;
+ }
+ }
+
+ // We don't want to prompt for every attempt to access permissions.
+ if (sCookiesBehavior == nsICookieService::BEHAVIOR_REJECT) {
+ return StorageAccess::eDeny;
+ }
+
+ // In the absense of a window, we assume that we are first-party.
+ if (aWindow && (sCookiesBehavior == nsICookieService::BEHAVIOR_REJECT_FOREIGN ||
+ sCookiesBehavior == nsICookieService::BEHAVIOR_LIMIT_FOREIGN)) {
+ nsCOMPtr<mozIThirdPartyUtil> thirdPartyUtil =
+ do_GetService(THIRDPARTYUTIL_CONTRACTID);
+ MOZ_ASSERT(thirdPartyUtil);
+
+ bool thirdPartyWindow = false;
+ if (NS_SUCCEEDED(thirdPartyUtil->IsThirdPartyWindow(
+ aWindow->GetOuterWindow(), nullptr, &thirdPartyWindow)) && thirdPartyWindow) {
+ // XXX For non-cookie forms of storage, we handle BEHAVIOR_LIMIT_FOREIGN by
+ // simply rejecting the request to use the storage. In the future, if we
+ // change the meaning of BEHAVIOR_LIMIT_FOREIGN to be one which makes sense
+ // for non-cookie storage types, this may change.
+
+ return StorageAccess::eDeny;
+ }
+ }
+
+ return access;
+}
+
+namespace {
+
+// We put StringBuilder in the anonymous namespace to prevent anything outside
+// this file from accidentally being linked against it.
+
+class StringBuilder
+{
+private:
+ // Try to keep the size of StringBuilder close to a jemalloc bucket size.
+ static const uint32_t STRING_BUFFER_UNITS = 1020;
+ class Unit
+ {
+ public:
+ Unit() : mAtom(nullptr), mType(eUnknown), mLength(0)
+ {
+ MOZ_COUNT_CTOR(StringBuilder::Unit);
+ }
+ ~Unit()
+ {
+ if (mType == eString || mType == eStringWithEncode) {
+ delete mString;
+ }
+ MOZ_COUNT_DTOR(StringBuilder::Unit);
+ }
+
+ enum Type
+ {
+ eUnknown,
+ eAtom,
+ eString,
+ eStringWithEncode,
+ eLiteral,
+ eTextFragment,
+ eTextFragmentWithEncode,
+ };
+
+ union
+ {
+ nsIAtom* mAtom;
+ const char* mLiteral;
+ nsAutoString* mString;
+ const nsTextFragment* mTextFragment;
+ };
+ Type mType;
+ uint32_t mLength;
+ };
+public:
+ StringBuilder() : mLast(this), mLength(0)
+ {
+ MOZ_COUNT_CTOR(StringBuilder);
+ }
+
+ ~StringBuilder()
+ {
+ MOZ_COUNT_DTOR(StringBuilder);
+ }
+
+ void Append(nsIAtom* aAtom)
+ {
+ Unit* u = AddUnit();
+ u->mAtom = aAtom;
+ u->mType = Unit::eAtom;
+ uint32_t len = aAtom->GetLength();
+ u->mLength = len;
+ mLength += len;
+ }
+
+ template<int N>
+ void Append(const char (&aLiteral)[N])
+ {
+ Unit* u = AddUnit();
+ u->mLiteral = aLiteral;
+ u->mType = Unit::eLiteral;
+ uint32_t len = N - 1;
+ u->mLength = len;
+ mLength += len;
+ }
+
+ template<int N>
+ void Append(char (&aLiteral)[N])
+ {
+ Unit* u = AddUnit();
+ u->mLiteral = aLiteral;
+ u->mType = Unit::eLiteral;
+ uint32_t len = N - 1;
+ u->mLength = len;
+ mLength += len;
+ }
+
+ void Append(const nsAString& aString)
+ {
+ Unit* u = AddUnit();
+ u->mString = new nsAutoString(aString);
+ u->mType = Unit::eString;
+ uint32_t len = aString.Length();
+ u->mLength = len;
+ mLength += len;
+ }
+
+ void Append(nsAutoString* aString)
+ {
+ Unit* u = AddUnit();
+ u->mString = aString;
+ u->mType = Unit::eString;
+ uint32_t len = aString->Length();
+ u->mLength = len;
+ mLength += len;
+ }
+
+ void AppendWithAttrEncode(nsAutoString* aString, uint32_t aLen)
+ {
+ Unit* u = AddUnit();
+ u->mString = aString;
+ u->mType = Unit::eStringWithEncode;
+ u->mLength = aLen;
+ mLength += aLen;
+ }
+
+ void Append(const nsTextFragment* aTextFragment)
+ {
+ Unit* u = AddUnit();
+ u->mTextFragment = aTextFragment;
+ u->mType = Unit::eTextFragment;
+ uint32_t len = aTextFragment->GetLength();
+ u->mLength = len;
+ mLength += len;
+ }
+
+ void AppendWithEncode(const nsTextFragment* aTextFragment, uint32_t aLen)
+ {
+ Unit* u = AddUnit();
+ u->mTextFragment = aTextFragment;
+ u->mType = Unit::eTextFragmentWithEncode;
+ u->mLength = aLen;
+ mLength += aLen;
+ }
+
+ bool ToString(nsAString& aOut)
+ {
+ if (!aOut.SetCapacity(mLength, fallible)) {
+ return false;
+ }
+
+ for (StringBuilder* current = this; current; current = current->mNext) {
+ uint32_t len = current->mUnits.Length();
+ for (uint32_t i = 0; i < len; ++i) {
+ Unit& u = current->mUnits[i];
+ switch (u.mType) {
+ case Unit::eAtom:
+ aOut.Append(nsDependentAtomString(u.mAtom));
+ break;
+ case Unit::eString:
+ aOut.Append(*(u.mString));
+ break;
+ case Unit::eStringWithEncode:
+ EncodeAttrString(*(u.mString), aOut);
+ break;
+ case Unit::eLiteral:
+ aOut.AppendASCII(u.mLiteral, u.mLength);
+ break;
+ case Unit::eTextFragment:
+ u.mTextFragment->AppendTo(aOut);
+ break;
+ case Unit::eTextFragmentWithEncode:
+ EncodeTextFragment(u.mTextFragment, aOut);
+ break;
+ default:
+ MOZ_CRASH("Unknown unit type?");
+ }
+ }
+ }
+ return true;
+ }
+private:
+ Unit* AddUnit()
+ {
+ if (mLast->mUnits.Length() == STRING_BUFFER_UNITS) {
+ new StringBuilder(this);
+ }
+ return mLast->mUnits.AppendElement();
+ }
+
+ explicit StringBuilder(StringBuilder* aFirst)
+ : mLast(nullptr), mLength(0)
+ {
+ MOZ_COUNT_CTOR(StringBuilder);
+ aFirst->mLast->mNext = this;
+ aFirst->mLast = this;
+ }
+
+ void EncodeAttrString(const nsAutoString& aValue, nsAString& aOut)
+ {
+ const char16_t* c = aValue.BeginReading();
+ const char16_t* end = aValue.EndReading();
+ while (c < end) {
+ switch (*c) {
+ case '"':
+ aOut.AppendLiteral("&quot;");
+ break;
+ case '&':
+ aOut.AppendLiteral("&amp;");
+ break;
+ case 0x00A0:
+ aOut.AppendLiteral("&nbsp;");
+ break;
+ default:
+ aOut.Append(*c);
+ break;
+ }
+ ++c;
+ }
+ }
+
+ void EncodeTextFragment(const nsTextFragment* aValue, nsAString& aOut)
+ {
+ uint32_t len = aValue->GetLength();
+ if (aValue->Is2b()) {
+ const char16_t* data = aValue->Get2b();
+ for (uint32_t i = 0; i < len; ++i) {
+ const char16_t c = data[i];
+ switch (c) {
+ case '<':
+ aOut.AppendLiteral("&lt;");
+ break;
+ case '>':
+ aOut.AppendLiteral("&gt;");
+ break;
+ case '&':
+ aOut.AppendLiteral("&amp;");
+ break;
+ case 0x00A0:
+ aOut.AppendLiteral("&nbsp;");
+ break;
+ default:
+ aOut.Append(c);
+ break;
+ }
+ }
+ } else {
+ const char* data = aValue->Get1b();
+ for (uint32_t i = 0; i < len; ++i) {
+ const unsigned char c = data[i];
+ switch (c) {
+ case '<':
+ aOut.AppendLiteral("&lt;");
+ break;
+ case '>':
+ aOut.AppendLiteral("&gt;");
+ break;
+ case '&':
+ aOut.AppendLiteral("&amp;");
+ break;
+ case 0x00A0:
+ aOut.AppendLiteral("&nbsp;");
+ break;
+ default:
+ aOut.Append(c);
+ break;
+ }
+ }
+ }
+ }
+
+ AutoTArray<Unit, STRING_BUFFER_UNITS> mUnits;
+ nsAutoPtr<StringBuilder> mNext;
+ StringBuilder* mLast;
+ // mLength is used only in the first StringBuilder object in the linked list.
+ uint32_t mLength;
+};
+
+} // namespace
+
+static void
+AppendEncodedCharacters(const nsTextFragment* aText, StringBuilder& aBuilder)
+{
+ uint32_t extraSpaceNeeded = 0;
+ uint32_t len = aText->GetLength();
+ if (aText->Is2b()) {
+ const char16_t* data = aText->Get2b();
+ for (uint32_t i = 0; i < len; ++i) {
+ const char16_t c = data[i];
+ switch (c) {
+ case '<':
+ extraSpaceNeeded += ArrayLength("&lt;") - 2;
+ break;
+ case '>':
+ extraSpaceNeeded += ArrayLength("&gt;") - 2;
+ break;
+ case '&':
+ extraSpaceNeeded += ArrayLength("&amp;") - 2;
+ break;
+ case 0x00A0:
+ extraSpaceNeeded += ArrayLength("&nbsp;") - 2;
+ break;
+ default:
+ break;
+ }
+ }
+ } else {
+ const char* data = aText->Get1b();
+ for (uint32_t i = 0; i < len; ++i) {
+ const unsigned char c = data[i];
+ switch (c) {
+ case '<':
+ extraSpaceNeeded += ArrayLength("&lt;") - 2;
+ break;
+ case '>':
+ extraSpaceNeeded += ArrayLength("&gt;") - 2;
+ break;
+ case '&':
+ extraSpaceNeeded += ArrayLength("&amp;") - 2;
+ break;
+ case 0x00A0:
+ extraSpaceNeeded += ArrayLength("&nbsp;") - 2;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ if (extraSpaceNeeded) {
+ aBuilder.AppendWithEncode(aText, len + extraSpaceNeeded);
+ } else {
+ aBuilder.Append(aText);
+ }
+}
+
+static void
+AppendEncodedAttributeValue(nsAutoString* aValue, StringBuilder& aBuilder)
+{
+ const char16_t* c = aValue->BeginReading();
+ const char16_t* end = aValue->EndReading();
+
+ uint32_t extraSpaceNeeded = 0;
+ while (c < end) {
+ switch (*c) {
+ case '"':
+ extraSpaceNeeded += ArrayLength("&quot;") - 2;
+ break;
+ case '&':
+ extraSpaceNeeded += ArrayLength("&amp;") - 2;
+ break;
+ case 0x00A0:
+ extraSpaceNeeded += ArrayLength("&nbsp;") - 2;
+ break;
+ default:
+ break;
+ }
+ ++c;
+ }
+
+ if (extraSpaceNeeded) {
+ aBuilder.AppendWithAttrEncode(aValue, aValue->Length() + extraSpaceNeeded);
+ } else {
+ aBuilder.Append(aValue);
+ }
+}
+
+static void
+StartElement(Element* aContent, StringBuilder& aBuilder)
+{
+ nsIAtom* localName = aContent->NodeInfo()->NameAtom();
+ int32_t tagNS = aContent->GetNameSpaceID();
+
+ aBuilder.Append("<");
+ if (aContent->IsHTMLElement() || aContent->IsSVGElement() ||
+ aContent->IsMathMLElement()) {
+ aBuilder.Append(localName);
+ } else {
+ aBuilder.Append(aContent->NodeName());
+ }
+
+ int32_t count = aContent->GetAttrCount();
+ for (int32_t i = 0; i < count; i++) {
+ const nsAttrName* name = aContent->GetAttrNameAt(i);
+ int32_t attNs = name->NamespaceID();
+ nsIAtom* attName = name->LocalName();
+
+ // Filter out any attribute starting with [-|_]moz
+ nsDependentAtomString attrNameStr(attName);
+ if (StringBeginsWith(attrNameStr, NS_LITERAL_STRING("_moz")) ||
+ StringBeginsWith(attrNameStr, NS_LITERAL_STRING("-moz"))) {
+ continue;
+ }
+
+ nsAutoString* attValue = new nsAutoString();
+ aContent->GetAttr(attNs, attName, *attValue);
+
+ // Filter out special case of <br type="_moz*"> used by the editor.
+ // Bug 16988. Yuck.
+ if (localName == nsGkAtoms::br && tagNS == kNameSpaceID_XHTML &&
+ attName == nsGkAtoms::type && attNs == kNameSpaceID_None &&
+ StringBeginsWith(*attValue, NS_LITERAL_STRING("_moz"))) {
+ delete attValue;
+ continue;
+ }
+
+ aBuilder.Append(" ");
+
+ if (MOZ_LIKELY(attNs == kNameSpaceID_None) ||
+ (attNs == kNameSpaceID_XMLNS &&
+ attName == nsGkAtoms::xmlns)) {
+ // Nothing else required
+ } else if (attNs == kNameSpaceID_XML) {
+ aBuilder.Append("xml:");
+ } else if (attNs == kNameSpaceID_XMLNS) {
+ aBuilder.Append("xmlns:");
+ } else if (attNs == kNameSpaceID_XLink) {
+ aBuilder.Append("xlink:");
+ } else {
+ nsIAtom* prefix = name->GetPrefix();
+ if (prefix) {
+ aBuilder.Append(prefix);
+ aBuilder.Append(":");
+ }
+ }
+
+ aBuilder.Append(attName);
+ aBuilder.Append("=\"");
+ AppendEncodedAttributeValue(attValue, aBuilder);
+ aBuilder.Append("\"");
+ }
+
+ aBuilder.Append(">");
+
+ /*
+ // Per HTML spec we should append one \n if the first child of
+ // pre/textarea/listing is a textnode and starts with a \n.
+ // But because browsers haven't traditionally had that behavior,
+ // we're not changing our behavior either - yet.
+ if (aContent->IsHTMLElement()) {
+ if (localName == nsGkAtoms::pre || localName == nsGkAtoms::textarea ||
+ localName == nsGkAtoms::listing) {
+ nsIContent* fc = aContent->GetFirstChild();
+ if (fc &&
+ (fc->NodeType() == nsIDOMNode::TEXT_NODE ||
+ fc->NodeType() == nsIDOMNode::CDATA_SECTION_NODE)) {
+ const nsTextFragment* text = fc->GetText();
+ if (text && text->GetLength() && text->CharAt(0) == char16_t('\n')) {
+ aBuilder.Append("\n");
+ }
+ }
+ }
+ }*/
+}
+
+static inline bool
+ShouldEscape(nsIContent* aParent)
+{
+ if (!aParent || !aParent->IsHTMLElement()) {
+ return true;
+ }
+
+ static const nsIAtom* nonEscapingElements[] = {
+ nsGkAtoms::style, nsGkAtoms::script, nsGkAtoms::xmp,
+ nsGkAtoms::iframe, nsGkAtoms::noembed, nsGkAtoms::noframes,
+ nsGkAtoms::plaintext,
+ // Per the current spec noscript should be escaped in case
+ // scripts are disabled or if document doesn't have
+ // browsing context. However the latter seems to be a spec bug
+ // and Gecko hasn't traditionally done the former.
+ nsGkAtoms::noscript
+ };
+ static mozilla::BloomFilter<12, nsIAtom> sFilter;
+ static bool sInitialized = false;
+ if (!sInitialized) {
+ sInitialized = true;
+ for (uint32_t i = 0; i < ArrayLength(nonEscapingElements); ++i) {
+ sFilter.add(nonEscapingElements[i]);
+ }
+ }
+
+ nsIAtom* tag = aParent->NodeInfo()->NameAtom();
+ if (sFilter.mightContain(tag)) {
+ for (uint32_t i = 0; i < ArrayLength(nonEscapingElements); ++i) {
+ if (tag == nonEscapingElements[i]) {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+static inline bool
+IsVoidTag(Element* aElement)
+{
+ if (!aElement->IsHTMLElement()) {
+ return false;
+ }
+ return FragmentOrElement::IsHTMLVoid(aElement->NodeInfo()->NameAtom());
+}
+
+bool
+nsContentUtils::SerializeNodeToMarkup(nsINode* aRoot,
+ bool aDescendentsOnly,
+ nsAString& aOut)
+{
+ // If you pass in a DOCUMENT_NODE, you must pass aDescendentsOnly as true
+ MOZ_ASSERT(aDescendentsOnly ||
+ aRoot->NodeType() != nsIDOMNode::DOCUMENT_NODE);
+
+ nsINode* current = aDescendentsOnly ?
+ nsNodeUtils::GetFirstChildOfTemplateOrNode(aRoot) : aRoot;
+
+ if (!current) {
+ return true;
+ }
+
+ StringBuilder builder;
+ nsIContent* next;
+ while (true) {
+ bool isVoid = false;
+ switch (current->NodeType()) {
+ case nsIDOMNode::ELEMENT_NODE: {
+ Element* elem = current->AsElement();
+ StartElement(elem, builder);
+ isVoid = IsVoidTag(elem);
+ if (!isVoid &&
+ (next = nsNodeUtils::GetFirstChildOfTemplateOrNode(current))) {
+ current = next;
+ continue;
+ }
+ break;
+ }
+
+ case nsIDOMNode::TEXT_NODE:
+ case nsIDOMNode::CDATA_SECTION_NODE: {
+ const nsTextFragment* text = static_cast<nsIContent*>(current)->GetText();
+ nsIContent* parent = current->GetParent();
+ if (ShouldEscape(parent)) {
+ AppendEncodedCharacters(text, builder);
+ } else {
+ builder.Append(text);
+ }
+ break;
+ }
+
+ case nsIDOMNode::COMMENT_NODE: {
+ builder.Append("<!--");
+ builder.Append(static_cast<nsIContent*>(current)->GetText());
+ builder.Append("-->");
+ break;
+ }
+
+ case nsIDOMNode::DOCUMENT_TYPE_NODE: {
+ builder.Append("<!DOCTYPE ");
+ builder.Append(current->NodeName());
+ builder.Append(">");
+ break;
+ }
+
+ case nsIDOMNode::PROCESSING_INSTRUCTION_NODE: {
+ builder.Append("<?");
+ builder.Append(current->NodeName());
+ builder.Append(" ");
+ builder.Append(static_cast<nsIContent*>(current)->GetText());
+ builder.Append(">");
+ break;
+ }
+ }
+
+ while (true) {
+ if (!isVoid && current->NodeType() == nsIDOMNode::ELEMENT_NODE) {
+ builder.Append("</");
+ nsIContent* elem = static_cast<nsIContent*>(current);
+ if (elem->IsHTMLElement() || elem->IsSVGElement() ||
+ elem->IsMathMLElement()) {
+ builder.Append(elem->NodeInfo()->NameAtom());
+ } else {
+ builder.Append(current->NodeName());
+ }
+ builder.Append(">");
+ }
+ isVoid = false;
+
+ if (current == aRoot) {
+ return builder.ToString(aOut);
+ }
+
+ if ((next = current->GetNextSibling())) {
+ current = next;
+ break;
+ }
+
+ current = current->GetParentNode();
+
+ // Handle template element. If the parent is a template's content,
+ // then adjust the parent to be the template element.
+ if (current != aRoot &&
+ current->NodeType() == nsIDOMNode::DOCUMENT_FRAGMENT_NODE) {
+ DocumentFragment* frag = static_cast<DocumentFragment*>(current);
+ nsIContent* fragHost = frag->GetHost();
+ if (fragHost && nsNodeUtils::IsTemplateElement(fragHost)) {
+ current = fragHost;
+ }
+ }
+
+ if (aDescendentsOnly && current == aRoot) {
+ return builder.ToString(aOut);
+ }
+ }
+ }
+}
+
+bool
+nsContentUtils::IsSpecificAboutPage(JSObject* aGlobal, const char* aUri)
+{
+ // aUri must start with about: or this isn't the right function to be using.
+ MOZ_ASSERT(strncmp(aUri, "about:", 6) == 0);
+
+ // Make sure the global is a window
+ nsGlobalWindow* win = xpc::WindowGlobalOrNull(aGlobal);
+ if (!win) {
+ return false;
+ }
+
+ nsCOMPtr<nsIPrincipal> principal = win->GetPrincipal();
+ NS_ENSURE_TRUE(principal, false);
+ nsCOMPtr<nsIURI> uri;
+ principal->GetURI(getter_AddRefs(uri));
+ if (!uri) {
+ return false;
+ }
+
+ // First check the scheme to avoid getting long specs in the common case.
+ bool isAbout = false;
+ uri->SchemeIs("about", &isAbout);
+ if (!isAbout) {
+ return false;
+ }
+
+ // Now check the spec itself
+ nsAutoCString spec;
+ uri->GetSpecIgnoringRef(spec);
+ return spec.EqualsASCII(aUri);
+}
+
+/* static */ void
+nsContentUtils::SetScrollbarsVisibility(nsIDocShell* aDocShell, bool aVisible)
+{
+ nsCOMPtr<nsIScrollable> scroller = do_QueryInterface(aDocShell);
+
+ if (scroller) {
+ int32_t prefValue;
+
+ if (aVisible) {
+ prefValue = nsIScrollable::Scrollbar_Auto;
+ } else {
+ prefValue = nsIScrollable::Scrollbar_Never;
+ }
+
+ scroller->SetDefaultScrollbarPreferences(
+ nsIScrollable::ScrollOrientation_Y, prefValue);
+ scroller->SetDefaultScrollbarPreferences(
+ nsIScrollable::ScrollOrientation_X, prefValue);
+ }
+}
+
+/* static */ void
+nsContentUtils::GetPresentationURL(nsIDocShell* aDocShell, nsAString& aPresentationUrl)
+{
+ MOZ_ASSERT(aDocShell);
+
+ // Simulate receiver context for web platform test
+ if (Preferences::GetBool("dom.presentation.testing.simulate-receiver")) {
+ nsCOMPtr<nsIDocument> doc;
+
+ nsCOMPtr<nsPIDOMWindowOuter> docShellWin =
+ do_QueryInterface(aDocShell->GetScriptGlobalObject());
+ if (docShellWin) {
+ doc = docShellWin->GetExtantDoc();
+ }
+
+ if (NS_WARN_IF(!doc)) {
+ return;
+ }
+
+ nsCOMPtr<nsIURI> uri = doc->GetDocumentURI();
+ if (NS_WARN_IF(!uri)) {
+ return;
+ }
+
+ nsAutoCString uriStr;
+ uri->GetSpec(uriStr);
+ aPresentationUrl = NS_ConvertUTF8toUTF16(uriStr);
+ return;
+ }
+
+ if (XRE_IsContentProcess()) {
+ nsCOMPtr<nsIDocShellTreeItem> sameTypeRoot;
+ aDocShell->GetSameTypeRootTreeItem(getter_AddRefs(sameTypeRoot));
+ nsCOMPtr<nsIDocShellTreeItem> root;
+ aDocShell->GetRootTreeItem(getter_AddRefs(root));
+ if (sameTypeRoot.get() == root.get()) {
+ // presentation URL is stored in TabChild for the top most
+ // <iframe mozbrowser> in content process.
+ TabChild* tabChild = TabChild::GetFrom(aDocShell);
+ if (tabChild) {
+ aPresentationUrl = tabChild->PresentationURL();
+ }
+ return;
+ }
+ }
+
+ nsCOMPtr<nsILoadContext> loadContext(do_QueryInterface(aDocShell));
+ nsCOMPtr<nsIDOMElement> topFrameElement;
+ loadContext->GetTopFrameElement(getter_AddRefs(topFrameElement));
+ if (!topFrameElement) {
+ return;
+ }
+
+ topFrameElement->GetAttribute(NS_LITERAL_STRING("mozpresentation"), aPresentationUrl);
+}
+
+/* static */ nsIDocShell*
+nsContentUtils::GetDocShellForEventTarget(EventTarget* aTarget)
+{
+ nsCOMPtr<nsPIDOMWindowInner> innerWindow;
+
+ if (nsCOMPtr<nsINode> node = do_QueryInterface(aTarget)) {
+ bool ignore;
+ innerWindow =
+ do_QueryInterface(node->OwnerDoc()->GetScriptHandlingObject(ignore));
+ } else if ((innerWindow = do_QueryInterface(aTarget))) {
+ // Nothing else to do
+ } else {
+ nsCOMPtr<DOMEventTargetHelper> helper = do_QueryInterface(aTarget);
+ if (helper) {
+ innerWindow = helper->GetOwner();
+ }
+ }
+
+ if (innerWindow) {
+ return innerWindow->GetDocShell();
+ }
+
+ return nullptr;
+}
+
+/*
+ * Note: this function only relates to figuring out HTTPS state, which is an
+ * input to the Secure Context algorithm. We are not actually implementing any
+ * part of the Secure Context algorithm itself here.
+ *
+ * This is a bit of a hack. Ideally we'd propagate HTTPS state through
+ * nsIChannel as described in the Fetch and HTML specs, but making channels
+ * know about whether they should inherit HTTPS state, propagating information
+ * about who the channel's "client" is, exposing GetHttpsState API on channels
+ * and modifying the various cache implementations to store and retrieve HTTPS
+ * state involves a huge amount of code (see bug 1220687). We avoid that for
+ * now using this function.
+ *
+ * This function takes advantage of the observation that we can return true if
+ * nsIContentSecurityManager::IsOriginPotentiallyTrustworthy returns true for
+ * the document's origin (e.g. the origin has a scheme of 'https' or host
+ * 'localhost' etc.). Since we generally propagate a creator document's origin
+ * onto data:, blob:, etc. documents, this works for them too.
+ *
+ * The scenario where this observation breaks down is sandboxing without the
+ * 'allow-same-origin' flag, since in this case a document is given a unique
+ * origin (IsOriginPotentiallyTrustworthy would return false). We handle that
+ * by using the origin that the document would have had had it not been
+ * sandboxed.
+ *
+ * DEFICIENCIES: Note that this function uses nsIScriptSecurityManager's
+ * getChannelResultPrincipalIfNotSandboxed, and that method's ignoring of
+ * sandboxing is limited to the immediate sandbox. In the case that aDocument
+ * should inherit its origin (e.g. data: URI) but its parent has ended up
+ * with a unique origin due to sandboxing further up the parent chain we may
+ * end up returning false when we would ideally return true (since we will
+ * examine the parent's origin for 'https' and not finding it.) This means
+ * that we may restrict the privileges of some pages unnecessarily in this
+ * edge case.
+ */
+/* static */ bool
+nsContentUtils::HttpsStateIsModern(nsIDocument* aDocument)
+{
+ if (!aDocument) {
+ return false;
+ }
+
+ nsCOMPtr<nsIPrincipal> principal = aDocument->NodePrincipal();
+
+ if (principal->GetIsSystemPrincipal()) {
+ return true;
+ }
+
+ // If aDocument is sandboxed, try and get the principal that it would have
+ // been given had it not been sandboxed:
+ if (principal->GetIsNullPrincipal() &&
+ (aDocument->GetSandboxFlags() & SANDBOXED_ORIGIN)) {
+ nsIChannel* channel = aDocument->GetChannel();
+ if (channel) {
+ nsCOMPtr<nsIScriptSecurityManager> ssm =
+ nsContentUtils::GetSecurityManager();
+ nsresult rv =
+ ssm->GetChannelResultPrincipalIfNotSandboxed(channel,
+ getter_AddRefs(principal));
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+ if (principal->GetIsSystemPrincipal()) {
+ // If a document with the system principal is sandboxing a subdocument
+ // that would normally inherit the embedding element's principal (e.g.
+ // a srcdoc document) then the embedding document does not trust the
+ // content that is written to the embedded document. Unlike when the
+ // embedding document is https, in this case we have no indication as
+ // to whether the embedded document's contents are delivered securely
+ // or not, and the sandboxing would possibly indicate that they were
+ // not. To play it safe we return false here. (See bug 1162772
+ // comment 73-80.)
+ return false;
+ }
+ }
+ }
+
+ if (principal->GetIsNullPrincipal()) {
+ return false;
+ }
+
+ MOZ_ASSERT(principal->GetIsCodebasePrincipal());
+
+ nsCOMPtr<nsIContentSecurityManager> csm =
+ do_GetService(NS_CONTENTSECURITYMANAGER_CONTRACTID);
+ NS_WARNING_ASSERTION(csm, "csm is null");
+ if (csm) {
+ bool isTrustworthyOrigin = false;
+ csm->IsOriginPotentiallyTrustworthy(principal, &isTrustworthyOrigin);
+ if (isTrustworthyOrigin) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+/* static */ CustomElementDefinition*
+nsContentUtils::LookupCustomElementDefinition(nsIDocument* aDoc,
+ const nsAString& aLocalName,
+ uint32_t aNameSpaceID,
+ const nsAString* aIs)
+{
+ MOZ_ASSERT(aDoc);
+
+ // To support imported document.
+ nsCOMPtr<nsIDocument> doc = aDoc->MasterDocument();
+
+ if (aNameSpaceID != kNameSpaceID_XHTML ||
+ !doc->GetDocShell()) {
+ return nullptr;
+ }
+
+ nsCOMPtr<nsPIDOMWindowInner> window(doc->GetInnerWindow());
+ if (!window) {
+ return nullptr;
+ }
+
+ RefPtr<CustomElementRegistry> registry(window->CustomElements());
+ if (!registry) {
+ return nullptr;
+ }
+
+ return registry->LookupCustomElementDefinition(aLocalName, aIs);
+}
+
+/* static */ void
+nsContentUtils::SetupCustomElement(Element* aElement,
+ const nsAString* aTypeExtension)
+{
+ MOZ_ASSERT(aElement);
+
+ nsCOMPtr<nsIDocument> doc = aElement->OwnerDoc();
+
+ if (!doc) {
+ return;
+ }
+
+ // To support imported document.
+ doc = doc->MasterDocument();
+
+ if (aElement->GetNameSpaceID() != kNameSpaceID_XHTML ||
+ !doc->GetDocShell()) {
+ return;
+ }
+
+ nsCOMPtr<nsPIDOMWindowInner> window(doc->GetInnerWindow());
+ if (!window) {
+ return;
+ }
+
+ RefPtr<CustomElementRegistry> registry(window->CustomElements());
+ if (!registry) {
+ return;
+ }
+
+ return registry->SetupCustomElement(aElement, aTypeExtension);
+}
+
+/* static */ void
+nsContentUtils::EnqueueLifecycleCallback(nsIDocument* aDoc,
+ nsIDocument::ElementCallbackType aType,
+ Element* aCustomElement,
+ LifecycleCallbackArgs* aArgs,
+ CustomElementDefinition* aDefinition)
+{
+ MOZ_ASSERT(aDoc);
+
+ // To support imported document.
+ nsCOMPtr<nsIDocument> doc = aDoc->MasterDocument();
+
+ if (!doc->GetDocShell()) {
+ return;
+ }
+
+ nsCOMPtr<nsPIDOMWindowInner> window(doc->GetInnerWindow());
+ if (!window) {
+ return;
+ }
+
+ RefPtr<CustomElementRegistry> registry(window->CustomElements());
+ if (!registry) {
+ return;
+ }
+
+ registry->EnqueueLifecycleCallback(aType, aCustomElement, aArgs, aDefinition);
+}
+
+/* static */ void
+nsContentUtils::GetCustomPrototype(nsIDocument* aDoc,
+ int32_t aNamespaceID,
+ nsIAtom* aAtom,
+ JS::MutableHandle<JSObject*> aPrototype)
+{
+ MOZ_ASSERT(aDoc);
+
+ // To support imported document.
+ nsCOMPtr<nsIDocument> doc = aDoc->MasterDocument();
+
+ if (aNamespaceID != kNameSpaceID_XHTML ||
+ !doc->GetDocShell()) {
+ return;
+ }
+
+ nsCOMPtr<nsPIDOMWindowInner> window(doc->GetInnerWindow());
+ if (!window) {
+ return;
+ }
+
+ RefPtr<CustomElementRegistry> registry(window->CustomElements());
+ if (!registry) {
+ return;
+ }
+
+ return registry->GetCustomPrototype(aAtom, aPrototype);
+}
+
+/* static */ bool
+nsContentUtils::AttemptLargeAllocationLoad(nsIHttpChannel* aChannel)
+{
+ MOZ_ASSERT(aChannel);
+
+ nsCOMPtr<nsILoadGroup> loadGroup;
+ nsresult rv = aChannel->GetLoadGroup(getter_AddRefs(loadGroup));
+ if (NS_WARN_IF(NS_FAILED(rv) || !loadGroup)) {
+ return false;
+ }
+
+ nsCOMPtr<nsIInterfaceRequestor> callbacks;
+ rv = loadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks));
+ if (NS_WARN_IF(NS_FAILED(rv) || !callbacks)) {
+ return false;
+ }
+
+ nsCOMPtr<nsILoadContext> loadContext = do_GetInterface(callbacks);
+ if (NS_WARN_IF(!loadContext)) {
+ return false;
+ }
+
+ nsCOMPtr<mozIDOMWindowProxy> window;
+ rv = loadContext->GetAssociatedWindow(getter_AddRefs(window));
+ if (NS_WARN_IF(NS_FAILED(rv) || !window)) {
+ return false;
+ }
+
+ nsPIDOMWindowOuter* outer = nsPIDOMWindowOuter::From(window);
+ if (NS_WARN_IF(!outer)) {
+ return false;
+ }
+
+ nsIDocShell* docShell = outer->GetDocShell();
+ nsIDocument* doc = outer->GetExtantDoc();
+
+ // If the docshell is not allowed to change process, report an error based on
+ // the reason
+ const char* errorName = nullptr;
+ switch (docShell->GetProcessLockReason()) {
+ case nsIDocShell::PROCESS_LOCK_NON_CONTENT:
+ errorName = "LargeAllocationNonE10S";
+ break;
+ case nsIDocShell::PROCESS_LOCK_IFRAME:
+ errorName = "LargeAllocationIFrame";
+ break;
+ case nsIDocShell::PROCESS_LOCK_RELATED_CONTEXTS:
+ errorName = "LargeAllocationRelatedBrowsingContexts";
+ break;
+ case nsIDocShell::PROCESS_LOCK_NONE:
+ // Don't print a warning, we're allowed to change processes!
+ break;
+ default:
+ MOZ_ASSERT(false, "Should be unreachable!");
+ return false;
+ }
+
+ if (errorName) {
+ if (doc) {
+ nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
+ NS_LITERAL_CSTRING("DOM"),
+ doc,
+ nsContentUtils::eDOM_PROPERTIES,
+ errorName);
+ }
+
+ return false;
+ }
+
+ // Get the request method, and check if it is a GET request. If it is not GET,
+ // then we cannot perform a large allocation load.
+ nsAutoCString requestMethod;
+ rv = aChannel->GetRequestMethod(requestMethod);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ if (NS_WARN_IF(!requestMethod.LowerCaseEqualsLiteral("get"))) {
+ if (doc) {
+ nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
+ NS_LITERAL_CSTRING("DOM"),
+ doc,
+ nsContentUtils::eDOM_PROPERTIES,
+ "LargeAllocationNonGetRequest");
+ }
+ return false;
+ }
+
+ TabChild* tabChild = TabChild::GetFrom(outer);
+ NS_ENSURE_TRUE(tabChild, false);
+
+ if (tabChild->TakeIsFreshProcess()) {
+ NS_WARNING("Already in a fresh process, ignoring Large-Allocation header!");
+ if (doc) {
+ nsContentUtils::ReportToConsole(nsIScriptError::infoFlag,
+ NS_LITERAL_CSTRING("DOM"),
+ doc,
+ nsContentUtils::eDOM_PROPERTIES,
+ "LargeAllocationSuccess");
+ }
+ return false;
+ }
+
+ // At this point the fress process load should succeed! We just need to get
+ // ourselves a nsIWebBrowserChrome3 to ask to perform the reload. We should
+ // have one, as we have already confirmed that we are running in a content
+ // process.
+ nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
+ docShell->GetTreeOwner(getter_AddRefs(treeOwner));
+ NS_ENSURE_TRUE(treeOwner, false);
+
+ nsCOMPtr<nsIWebBrowserChrome3> wbc3 = do_GetInterface(treeOwner);
+ NS_ENSURE_TRUE(wbc3, false);
+
+ nsCOMPtr<nsIURI> uri;
+ rv = aChannel->GetURI(getter_AddRefs(uri));
+ NS_ENSURE_SUCCESS(rv, false);
+ NS_ENSURE_TRUE(uri, false);
+
+ nsCOMPtr<nsIURI> referrer;
+ rv = aChannel->GetReferrer(getter_AddRefs(referrer));
+ NS_ENSURE_SUCCESS(rv, false);
+
+ // Actually perform the cross process load
+ bool reloadSucceeded = false;
+ rv = wbc3->ReloadInFreshProcess(docShell, uri, referrer, &reloadSucceeded);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ return reloadSucceeded;
+}