/* -*- 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/JSON.h"

#include "js/Value.h"

#include "Layers.h"

#include "nsAppRunner.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/AntiTrackingCommon.h"

#include "mozilla/ArrayUtils.h"

#include "mozilla/Attributes.h"

#include "mozilla/AutoRestore.h"

#include "mozilla/AutoTimelineMarker.h"

#include "mozilla/BackgroundHangMonitor.h"

#include "mozilla/Base64.h"

#include "mozilla/CheckedInt.h"

#include "mozilla/DebugOnly.h"

#include "mozilla/LoadInfo.h"

#include "mozilla/dom/BlobURLProtocolHandler.h"

#include "mozilla/dom/ContentChild.h"

#include "mozilla/dom/CustomElementRegistry.h"

#include "mozilla/dom/MessageBroadcaster.h"

#include "mozilla/dom/DocumentFragment.h"

#include "mozilla/dom/DOMException.h"

#include "mozilla/dom/DOMExceptionBinding.h"

#include "mozilla/dom/DOMTypes.h"

#include "mozilla/dom/Element.h"

#include "mozilla/dom/ElementInlines.h"

#include "mozilla/dom/Event.h"

#include "mozilla/dom/FileSystemSecurity.h"

#include "mozilla/dom/FileBlobImpl.h"

#include "mozilla/dom/FontTableURIProtocolHandler.h"

#include "mozilla/dom/HTMLInputElement.h"

#include "mozilla/dom/HTMLSlotElement.h"

#include "mozilla/dom/HTMLTemplateElement.h"

#include "mozilla/dom/IDTracker.h"

#include "mozilla/dom/MouseEventBinding.h"

#include "mozilla/dom/KeyboardEventBinding.h"

#include "mozilla/dom/IPCBlobUtils.h"

#include "mozilla/dom/NodeBinding.h"

#include "mozilla/dom/Promise.h"

#include "mozilla/dom/ScriptSettings.h"

#include "mozilla/dom/TabParent.h"

#include "mozilla/dom/Text.h"

#include "mozilla/dom/TouchEvent.h"

#include "mozilla/dom/ShadowRoot.h"

#include "mozilla/dom/XULCommandEvent.h"

#include "mozilla/dom/WorkerCommon.h"

#include "mozilla/EventDispatcher.h"

#include "mozilla/EventListenerManager.h"

#include "mozilla/EventStateManager.h"

#include "mozilla/gfx/DataSurfaceHelpers.h"

#include "mozilla/HTMLEditor.h"

#include "mozilla/IMEStateManager.h"

#include "mozilla/InternalMutationEvent.h"

#include "mozilla/Likely.h"

#include "mozilla/ManualNAC.h"

#include "mozilla/MouseEvents.h"

#include "mozilla/Preferences.h"

#include "mozilla/ResultExtensions.h"

#include "mozilla/dom/Selection.h"

#include "mozilla/Services.h"

#include "mozilla/StaticPrefs.h"

#include "mozilla/TextEvents.h"

#include "nsArrayUtils.h"

#include "nsAString.h"

#include "nsAttrName.h"

#include "nsAttrValue.h"

#include "nsAttrValueInlines.h"

#include "nsBindingManager.h"

#include "nsCanvasFrame.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 "nsHtml5Module.h"

#include "nsHtml5StringParser.h"

#include "nsHTMLDocument.h"

#include "nsHTMLTags.h"

#include "nsIAddonPolicyService.h"

#include "nsIAnonymousContentCreator.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 "nsIDOMWindowUtils.h"

#include "nsIDragService.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 "nsILoadContext.h"

#include "nsILoadGroup.h"

#include "nsIMemoryReporter.h"

#include "nsIMIMEHeaderParam.h"

#include "nsIMIMEService.h"

#include "nsINode.h"

#include "mozilla/dom/NodeInfo.h"

#include "mozilla/NullPrincipal.h"

#include "nsIObjectLoadingContent.h"

#include "nsIObserver.h"

#include "nsIObserverService.h"

#include "nsIOfflineCacheUpdate.h"

#include "nsIParser.h"

#include "nsIParserUtils.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 "nsIStreamConverter.h"

#include "nsIStreamConverterService.h"

#include "nsIStringBundle.h"

#include "nsIURI.h"

#include "nsIURIWithSpecialOrigin.h"

#include "nsIURL.h"

#include "nsIWebNavigation.h"

#include "nsIWidget.h"

#include "nsIWindowMediator.h"

#include "nsIXPConnect.h"

#include "nsJSUtils.h"

#include "nsMappedAttributes.h"

#include "nsNetCID.h"

#include "nsNetUtil.h"

#include "nsNodeInfoManager.h"

#include "nsParserCIID.h"

#include "nsParserConstants.h"

#include "nsPIDOMWindow.h"

#include "nsPresContext.h"

#include "nsPrintfCString.h"

#include "nsSandboxFlags.h"

#include "nsScriptSecurityManager.h"

#include "nsSerializationHelper.h"

#include "nsStreamUtils.h"

#include "nsTextEditorState.h"

#include "nsTextFragment.h"

#include "nsTextNode.h"

#include "nsThreadUtils.h"

#include "nsTreeSanitizer.h"

#include "nsUnicodeProperties.h"

#include "nsURLHelper.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 "InProcessTabChildMessageManager.h"

#include "nsContentTypeParser.h"

#include "nsICookiePermission.h"

#include "nsICookieService.h"

#include "mozIThirdPartyUtil.h"

#include "mozilla/EnumSet.h"

#include "mozilla/BloomFilter.h"

#include "TabChild.h"

#include "mozilla/dom/DocGroup.h"

#include "mozilla/dom/TabGroup.h"

#include "nsIWebNavigationInfo.h"

#include "nsPluginHost.h"

#include "nsIBrowser.h"

#include "mozilla/HangAnnotations.h"

#include "mozilla/Encoding.h"

#include "nsXULElement.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;

class nsAtom;

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;

nsNameSpaceManager *nsContentUtils::sNameSpaceManager;

nsIIOService *nsContentUtils::sIOService;

nsIUUIDGenerator *nsContentUtils::sUUIDGenerator;

nsIConsoleService *nsContentUtils::sConsoleService;

nsDataHashtable<nsRefPtrHashKey<nsAtom>, EventNameMapping>* nsContentUtils::sAtomEventTable = nullptr;

nsDataHashtable<nsStringHashKey, EventNameMapping>* nsContentUtils::sStringEventTable = nullptr;

nsTArray<RefPtr<nsAtom>>* nsContentUtils::sUserDefinedEvents = nullptr;

nsIStringBundleService *nsContentUtils::sStringBundleService;

nsIStringBundle *nsContentUtils::sStringBundles[PropertiesFile_COUNT];

nsIContentPolicy *nsContentUtils::sContentPolicyService;

bool nsContentUtils::sTriedToGetContentPolicy = false;

RefPtr<mozilla::intl::LineBreaker> nsContentUtils::sLineBreaker;

RefPtr<mozilla::intl::WordBreaker> nsContentUtils::sWordBreaker;

StaticRefPtr<nsIBidiKeyboard> nsContentUtils::sBidiKeyboard;

uint32_t nsContentUtils::sScriptBlockerCount = 0;

uint32_t nsContentUtils::sDOMNodeRemovedSuppressCount = 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;

bool nsContentUtils::sDisablePopups = 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::sIsUpgradableDisplayContentPrefEnabled = false;

bool nsContentUtils::sIsFrameTimingPrefEnabled = false;

bool nsContentUtils::sIsPerformanceTimingEnabled = false;

bool nsContentUtils::sIsResourceTimingEnabled = false;

bool nsContentUtils::sIsPerformanceNavigationTimingEnabled = false;

bool nsContentUtils::sIsFormAutofillAutocompleteEnabled = false;

bool nsContentUtils::sIsUAWidgetEnabled = false;

bool nsContentUtils::sIsShadowDOMEnabled = false;

bool nsContentUtils::sIsCustomElementsEnabled = false;

bool nsContentUtils::sSendPerformanceTimingNotifications = false;

bool nsContentUtils::sUseActivityCursor = false;

bool nsContentUtils::sAnimationsAPICoreEnabled = false;

bool nsContentUtils::sGetBoxQuadsEnabled = false;

bool nsContentUtils::sSkipCursorMoveForSameValueSet = false;

bool nsContentUtils::sRequestIdleCallbackEnabled = false;

bool nsContentUtils::sLowerNetworkPriority = false;

bool nsContentUtils::sTailingEnabled = false;

bool nsContentUtils::sShowInputPlaceholderOnFocus = true;

bool nsContentUtils::sAutoFocusEnabled = true;

#ifndef RELEASE_OR_BETA

bool nsContentUtils::sBypassCSSOMOriginCheck = false;

#endif

bool nsContentUtils::sIsBytecodeCacheEnabled = false;

int32_t nsContentUtils::sBytecodeCacheStrategy = 0;

nsCString* nsContentUtils::sJSBytecodeMimeType = nullptr;

int32_t nsContentUtils::sPrivacyMaxInnerWidth = 1000;

int32_t nsContentUtils::sPrivacyMaxInnerHeight = 1000;

nsContentUtils::UserInteractionObserver*

nsContentUtils::sUserInteractionObserver = nullptr;

uint32_t nsContentUtils::sHandlingInputTimeout = 1000;

uint32_t nsContentUtils::sCookiesLifetimePolicy = nsICookieService::ACCEPT_NORMALLY;

nsHtml5StringParser* nsContentUtils::sHTMLFragmentParser = nullptr;

nsIParser* nsContentUtils::sXMLFragmentParser = nullptr;

nsIFragmentContentSink* nsContentUtils::sXMLFragmentSink = nullptr;

bool nsContentUtils::sFragmentParsingActive = false;

bool nsContentUtils::sDoNotTrackEnabled = false;

bool nsContentUtils::sAntiTrackingControlCenterUIEnabled = false;

mozilla::LazyLogModule nsContentUtils::sDOMDumpLog("Dump");

PopupControlState nsContentUtils::sPopupControlState = openAbused;

int32_t nsContentUtils::sInnerOrOuterWindowCount = 0;

uint32_t nsContentUtils::sInnerOrOuterWindowSerialCounter = 0;

// Subset of http://www.whatwg.org/specs/web-apps/current-work/#autofill-field-name

enum AutocompleteUnsupportedFieldName : uint8_t

{

  #define AUTOCOMPLETE_UNSUPPORTED_FIELD_NAME(name_, value_) \

    eAutocompleteUnsupportedFieldName_##name_,

  #include "AutocompleteFieldList.h"

  #undef AUTOCOMPLETE_UNSUPPORTED_FIELD_NAME

};

enum AutocompleteUnsupportFieldContactHint : uint8_t

{

  #define AUTOCOMPLETE_UNSUPPORTED_FIELD_CONTACT_HINT(name_, value_) \

    eAutocompleteUnsupportedFieldContactHint_##name_,

  #include "AutocompleteFieldList.h"

  #undef AUTOCOMPLETE_UNSUPPORTED_FIELD_CONTACT_HINT

};

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 kAutocompleteUnsupportedFieldNameTable[] = {

  #define AUTOCOMPLETE_UNSUPPORTED_FIELD_NAME(name_, value_) \

    { value_, eAutocompleteUnsupportedFieldName_##name_ },

  #include "AutocompleteFieldList.h"

  #undef AUTOCOMPLETE_UNSUPPORTED_FIELD_NAME

  { nullptr, 0 }

};

static const nsAttrValue::EnumTable kAutocompleteUnsupportedContactFieldHintTable[] = {

  #define AUTOCOMPLETE_UNSUPPORTED_FIELD_CONTACT_HINT(name_, value_) \

    { value_, eAutocompleteUnsupportedFieldContactHint_##name_ },

  #include "AutocompleteFieldList.h"

  #undef AUTOCOMPLETE_UNSUPPORTED_FIELD_CONTACT_HINT

  { nullptr, 0 }

};

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(kCParserCID, NS_PARSER_CID);

static PLDHashTable* sEventListenerManagersHash;

class DOMEventListenerManagersHashReporter final : public nsIMemoryReporter

{

  MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf)

  ~DOMEventListenerManagersHashReporter() = default;

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() = default;

  NS_DECL_ISUPPORTS

  NS_DECL_NSICHANNELEVENTSINK

  NS_DECL_NSIINTERFACEREQUESTOR

};

} // namespace

/**

 * This class is used to determine whether or not the user is currently

 * interacting with the browser. It listens to observer events to toggle the

 * value of the sUserActive static.

 *

 * This class is an internal implementation detail.

 * nsContentUtils::GetUserIsInteracting() should be used to access current

 * user interaction status.

 */

class nsContentUtils::UserInteractionObserver final : public nsIObserver

                                                    , public BackgroundHangAnnotator

{

public:

  NS_DECL_ISUPPORTS

  NS_DECL_NSIOBSERVER

  void Init();

  void Shutdown();

  void AnnotateHang(BackgroundHangAnnotations& aAnnotations) override;

  static Atomic<bool> sUserActive;

private:

  ~UserInteractionObserver() {}

};

/* static */

TimeDuration

nsContentUtils::HandlingUserInputTimeout()

{

  return TimeDuration::FromMilliseconds(sHandlingInputTimeout);

}

// static

nsresult

nsContentUtils::Init()

{

  if (sInitialized) {

    NS_WARNING("Init() called twice");

    return NS_OK;

  }

  nsHTMLTags::AddRefTable();

  sNameSpaceManager = nsNameSpaceManager::GetInstance();

  NS_ENSURE_TRUE(sNameSpaceManager, NS_ERROR_OUT_OF_MEMORY);

  sXPConnect = nsXPConnect::XPConnect();

  // We hold a strong ref to sXPConnect to ensure that it does not go away until

  // nsLayoutStatics::Shutdown is happening.  Otherwise ~nsXPConnect can be

  // triggered by xpcModuleDtor late in shutdown and cause crashes due to

  // various stuff already being torn down by then.  Note that this means that

  // we are effectively making sure that if we leak nsLayoutStatics then we also

  // leak nsXPConnect.

  NS_ADDREF(sXPConnect);

  sSecurityManager = nsScriptSecurityManager::GetScriptSecurityManager();

  if(!sSecurityManager)

    return NS_ERROR_FAILURE;

  NS_ADDREF(sSecurityManager);

  sSecurityManager->GetSystemPrincipal(&sSystemPrincipal);

  MOZ_ASSERT(sSystemPrincipal);

  RefPtr<NullPrincipal> nullPrincipal = NullPrincipal::CreateWithoutOriginAttributes();

  if (!nullPrincipal) {

    return NS_ERROR_FAILURE;

  }

  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;

  }

  sLineBreaker = mozilla::intl::LineBreaker::Create();

  sWordBreaker = mozilla::intl::WordBreaker::Create();

  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(&sIsPerformanceNavigationTimingEnabled,

                               "dom.enable_performance_navigation_timing", true);

  Preferences::AddBoolVarCache(&sIsUpgradableDisplayContentPrefEnabled,

                               "security.mixed_content.upgrade_display_content", false);

  Preferences::AddBoolVarCache(&sIsFrameTimingPrefEnabled,

                               "dom.enable_frame_timing", false);

  Preferences::AddBoolVarCache(&sIsFormAutofillAutocompleteEnabled,

                               "dom.forms.autocomplete.formautofill", false);

  Preferences::AddBoolVarCache(&sIsUAWidgetEnabled,

                               "dom.ua_widget.enabled", false);

  Preferences::AddBoolVarCache(&sIsShadowDOMEnabled,

                               "dom.webcomponents.shadowdom.enabled", false);

  Preferences::AddBoolVarCache(&sIsCustomElementsEnabled,

                               "dom.webcomponents.customelements.enabled", false);

  Preferences::AddIntVarCache(&sPrivacyMaxInnerWidth,

                              "privacy.window.maxInnerWidth",

                              1000);

  Preferences::AddIntVarCache(&sPrivacyMaxInnerHeight,

                              "privacy.window.maxInnerHeight",

                              1000);

  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::AddBoolVarCache(&sDoNotTrackEnabled,

                               "privacy.donottrackheader.enabled", false);

  Preferences::AddBoolVarCache(&sUseActivityCursor,

                               "ui.use_activity_cursor", false);

  Preferences::AddBoolVarCache(&sAnimationsAPICoreEnabled,

                               "dom.animations-api.core.enabled", false);

  Preferences::AddBoolVarCache(&sGetBoxQuadsEnabled,

                               "layout.css.getBoxQuads.enabled", false);

  Preferences::AddBoolVarCache(&sSkipCursorMoveForSameValueSet,

                               "dom.input.skip_cursor_move_for_same_value_set",

                               true);

  Preferences::AddBoolVarCache(&sRequestIdleCallbackEnabled,

                               "dom.requestIdleCallback.enabled", false);

#ifndef RELEASE_OR_BETA

  sBypassCSSOMOriginCheck = getenv("MOZ_BYPASS_CSSOM_ORIGIN_CHECK");

#endif

  Preferences::AddBoolVarCache(&sLowerNetworkPriority,

                               "privacy.trackingprotection.lower_network_priority", false);

  Preferences::AddBoolVarCache(&sTailingEnabled,

                               "network.http.tailing.enabled", true);

  Preferences::AddBoolVarCache(&sShowInputPlaceholderOnFocus,

                               "dom.placeholder.show_on_focus", true);

  Preferences::AddBoolVarCache(&sAutoFocusEnabled,

                               "browser.autofocus", true);

  Preferences::AddBoolVarCache(&sIsBytecodeCacheEnabled,

                               "dom.script_loader.bytecode_cache.enabled", false);

  Preferences::AddBoolVarCache(&sDisablePopups,

                               "dom.disable_open_during_load", false);

  Preferences::AddBoolVarCache(&sAntiTrackingControlCenterUIEnabled,

                               "browser.contentblocking.rejecttrackers.control-center.ui.enabled", false);

  Preferences::AddIntVarCache(&sBytecodeCacheStrategy,

                              "dom.script_loader.bytecode_cache.strategy", 0);

  nsDependentCString buildID(mozilla::PlatformBuildID());

  sJSBytecodeMimeType = new nsCString(NS_LITERAL_CSTRING("javascript/moz-bytecode-") + buildID);

  Element::InitCCCallbacks();

  Unused << nsRFPService::GetOrCreate();

  nsCOMPtr<nsIUUIDGenerator> uuidGenerator =

    do_GetService("@mozilla.org/uuid-generator;1", &rv);

  if (NS_WARN_IF(NS_FAILED(rv))) {

    return rv;

  }

  uuidGenerator.forget(&sUUIDGenerator);

  if (XRE_IsParentProcess()) {

    AsyncPrecreateStringBundles();

  }

  RefPtr<UserInteractionObserver> uio = new UserInteractionObserver();

  uio->Init();

  uio.forget(&sUserInteractionObserver);

  sInitialized = true;

  return NS_OK;

}

nsresult nsContentUtils::RemoveWyciwygScheme(nsIURI* aURI, nsIURI** aReturn)

{

#ifdef DEBUG

  bool isWyciwyg = false;

  aURI->SchemeIs("wyciwyg", &isWyciwyg);

  MOZ_ASSERT(isWyciwyg, "Scheme should be wyciwyg");

#endif

  nsAutoCString path;

  nsresult rv = aURI->GetPathQueryRef(path);

  NS_ENSURE_SUCCESS(rv, rv);

  uint32_t pathLength = path.Length();

  if (pathLength <= 2) {

    return NS_ERROR_FAILURE;

  }

  // Path is of the form "//123/http://foo/bar", with a variable number of

  // digits. To figure out where the "real" URL starts, search path for a '/',

  // starting at the third character.

  int32_t slashIndex = path.FindChar('/', 2);

  if (slashIndex == kNotFound) {

    return NS_ERROR_FAILURE;

  }

  return NS_NewURI(aReturn,

    Substring(path, slashIndex + 1, pathLength - slashIndex - 1));

}

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");

  nsAutoString shiftModifier;

  nsAutoString metaModifier;

  nsAutoString osModifier;

  nsAutoString altModifier;

  nsAutoString controlModifier;

  nsAutoString modifierSeparator;

  if (bundle) {

    //macs use symbols for each modifier key, so fetch each from the bundle, which also covers i18n

    bundle->GetStringFromName("VK_SHIFT", shiftModifier);

    bundle->GetStringFromName("VK_META", metaModifier);

    bundle->GetStringFromName("VK_WIN", osModifier);

    bundle->GetStringFromName("VK_ALT", altModifier);

    bundle->GetStringFromName("VK_CONTROL", controlModifier);

    bundle->GetStringFromName("MODIFIER_SEPARATOR", 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);

}

mozilla::EventClassID

nsContentUtils::GetEventClassIDFromMessage(EventMessage aEventMessage)

{

  switch (aEventMessage) {

#define MESSAGE_TO_EVENT(name_, message_, type_, struct_) \

  case message_: return struct_;

#include "mozilla/EventNameList.h"

#undef MESSAGE_TO_EVENT

  default:

    MOZ_ASSERT_UNREACHABLE("Invalid event message?");

    return eBasicEventClass;

  }

}

static nsAtom*

GetEventTypeFromMessage(EventMessage aEventMessage)

{

  switch (aEventMessage) {

#define MESSAGE_TO_EVENT(name_, message_, type_, struct_) \

  case message_: return nsGkAtoms::on##name_;

#include "mozilla/EventNameList.h"

#undef MESSAGE_TO_EVENT

  default:

    return nullptr;

  }

}

// 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)

{

  MOZ_ASSERT(aMapping.mAtom);

  return GetEventTypeFromMessage(aMapping.mMessage) == aMapping.mAtom;

}

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 DOCUMENT_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<nsRefPtrHashKey<nsAtom>, EventNameMapping>(

      ArrayLength(eventArray));

  sStringEventTable = new nsDataHashtable<nsStringHashKey, EventNameMapping>(

      ArrayLength(eventArray));

  sUserDefinedEvents = new nsTArray<RefPtr<nsAtom>>(64);

  // Subtract one from the length because of the trailing null

  for (uint32_t i = 0; i < ArrayLength(eventArray) - 1; ++i) {

    MOZ_ASSERT(!sAtomEventTable->Lookup(eventArray[i].mAtom),

               "Double-defining event name; fix your EventNameList.h");

    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* cur = start;

  const char16_t* end = aAsciiBase64String.EndReading();

  bool hasWhitespace = false;

  while (cur < end) {

    if (nsContentUtils::IsHTMLWhitespace(*cur)) {