mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-21 09:15:35 +00:00
ace6d1063f
The inclusions were removed with the following very crude script and the
resulting breakage was fixed up by hand. The manual fixups did either
revert the changes done by the script, replace a generic header with a more
specific one or replace a header with a forward declaration.
find . -name "*.idl" | grep -v web-platform | grep -v third_party | while read path; do
interfaces=$(grep "^\(class\|interface\).*:.*" "$path" | cut -d' ' -f2)
if [ -n "$interfaces" ]; then
if [[ "$interfaces" == *$'\n'* ]]; then
regexp="\("
for i in $interfaces; do regexp="$regexp$i\|"; done
regexp="${regexp%%\\\|}\)"
else
regexp="$interfaces"
fi
interface=$(basename "$path")
rg -l "#include.*${interface%%.idl}.h" . | while read path2; do
hits=$(grep -v "#include.*${interface%%.idl}.h" "$path2" | grep -c "$regexp" )
if [ $hits -eq 0 ]; then
echo "Removing ${interface} from ${path2}"
grep -v "#include.*${interface%%.idl}.h" "$path2" > "$path2".tmp
mv -f "$path2".tmp "$path2"
fi
done
fi
done
Differential Revision: https://phabricator.services.mozilla.com/D55442
--HG--
extra : moz-landing-system : lando
1938 lines
64 KiB
C++
1938 lines
64 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* 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/. */
|
|
|
|
#include "nsCOMPtr.h"
|
|
#include "nsDOMCID.h"
|
|
#include "nsError.h"
|
|
#include "nsDOMString.h"
|
|
#include "nsAtom.h"
|
|
#include "nsIBaseWindow.h"
|
|
#include "nsIDOMEventListener.h"
|
|
#include "nsIDOMXULControlElement.h"
|
|
#include "nsIDOMXULSelectCntrlItemEl.h"
|
|
#include "mozilla/dom/BindContext.h"
|
|
#include "mozilla/dom/Document.h"
|
|
#include "mozilla/ClearOnShutdown.h"
|
|
#include "mozilla/EventListenerManager.h"
|
|
#include "mozilla/EventStateManager.h"
|
|
#include "mozilla/EventStates.h"
|
|
#include "mozilla/DeclarationBlock.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "js/CompilationAndEvaluation.h"
|
|
#include "js/SourceText.h"
|
|
#include "nsFocusManager.h"
|
|
#include "nsHTMLStyleSheet.h"
|
|
#include "nsNameSpaceManager.h"
|
|
#include "nsIObjectInputStream.h"
|
|
#include "nsIObjectOutputStream.h"
|
|
#include "nsIPrincipal.h"
|
|
#include "nsIScriptContext.h"
|
|
#include "nsIXPConnect.h"
|
|
#include "nsViewManager.h"
|
|
#include "nsIWidget.h"
|
|
#include "nsLayoutCID.h"
|
|
#include "nsContentCID.h"
|
|
#include "mozilla/dom/Event.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsString.h"
|
|
#include "nsXULControllers.h"
|
|
#include "nsXULPopupListener.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsContentList.h"
|
|
#include "mozilla/InternalMutationEvent.h"
|
|
#include "mozilla/MouseEvents.h"
|
|
#include "nsPIDOMWindow.h"
|
|
#include "nsJSPrincipals.h"
|
|
#include "nsDOMAttributeMap.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsFrameLoader.h"
|
|
#include "mozilla/Logging.h"
|
|
#include "nsIControllers.h"
|
|
#include "nsAttrValueOrString.h"
|
|
#include "nsAttrValueInlines.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "nsIController.h"
|
|
#include "nsQueryObject.h"
|
|
#include <algorithm>
|
|
|
|
#include "nsReadableUtils.h"
|
|
#include "nsIFrame.h"
|
|
#include "nsNodeInfoManager.h"
|
|
#include "nsXULTooltipListener.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozAutoDocUpdate.h"
|
|
#include "nsCCUncollectableMarker.h"
|
|
#include "nsICSSDeclaration.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "XULFrameElement.h"
|
|
#include "XULMenuElement.h"
|
|
#include "XULPopupElement.h"
|
|
#include "XULTreeElement.h"
|
|
#include "nsXULPrototypeCache.h"
|
|
|
|
#include "mozilla/dom/nsCSPUtils.h"
|
|
#include "mozilla/dom/XULElementBinding.h"
|
|
#include "mozilla/dom/XULBroadcastManager.h"
|
|
#include "mozilla/dom/MouseEventBinding.h"
|
|
#include "mozilla/dom/MutationEventBinding.h"
|
|
#include "mozilla/dom/XULCommandEvent.h"
|
|
#include "mozilla/GlobalKeyListener.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
|
|
#ifdef XUL_PROTOTYPE_ATTRIBUTE_METERING
|
|
uint32_t nsXULPrototypeAttribute::gNumElements;
|
|
uint32_t nsXULPrototypeAttribute::gNumAttributes;
|
|
uint32_t nsXULPrototypeAttribute::gNumCacheTests;
|
|
uint32_t nsXULPrototypeAttribute::gNumCacheHits;
|
|
uint32_t nsXULPrototypeAttribute::gNumCacheSets;
|
|
uint32_t nsXULPrototypeAttribute::gNumCacheFills;
|
|
#endif
|
|
|
|
#define NS_DISPATCH_XUL_COMMAND (1 << 0)
|
|
|
|
//----------------------------------------------------------------------
|
|
// nsXULElement
|
|
//
|
|
|
|
nsXULElement::nsXULElement(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)
|
|
: nsStyledElement(std::move(aNodeInfo)) {
|
|
XUL_PROTOTYPE_ATTRIBUTE_METER(gNumElements);
|
|
}
|
|
|
|
nsXULElement::~nsXULElement() {}
|
|
|
|
void nsXULElement::MaybeUpdatePrivateLifetime() {
|
|
if (AttrValueIs(kNameSpaceID_None, nsGkAtoms::windowtype,
|
|
NS_LITERAL_STRING("navigator:browser"), eCaseMatters)) {
|
|
return;
|
|
}
|
|
|
|
nsPIDOMWindowOuter* win = OwnerDoc()->GetWindow();
|
|
nsCOMPtr<nsIDocShell> docShell = win ? win->GetDocShell() : nullptr;
|
|
if (docShell) {
|
|
docShell->SetAffectPrivateSessionLifetime(false);
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
nsXULElement* NS_NewBasicXULElement(
|
|
already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo) {
|
|
return new nsXULElement(std::move(aNodeInfo));
|
|
}
|
|
|
|
/* static */
|
|
nsXULElement* nsXULElement::Construct(
|
|
already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo) {
|
|
RefPtr<mozilla::dom::NodeInfo> nodeInfo = aNodeInfo;
|
|
if (nodeInfo->Equals(nsGkAtoms::label) ||
|
|
nodeInfo->Equals(nsGkAtoms::description)) {
|
|
return new XULTextElement(nodeInfo.forget());
|
|
}
|
|
|
|
if (nodeInfo->Equals(nsGkAtoms::menupopup) ||
|
|
nodeInfo->Equals(nsGkAtoms::popup) ||
|
|
nodeInfo->Equals(nsGkAtoms::panel)) {
|
|
return NS_NewXULPopupElement(nodeInfo.forget());
|
|
}
|
|
|
|
if (nodeInfo->Equals(nsGkAtoms::tooltip)) {
|
|
return NS_NewXULTooltipElement(nodeInfo.forget());
|
|
}
|
|
|
|
if (nodeInfo->Equals(nsGkAtoms::iframe) ||
|
|
nodeInfo->Equals(nsGkAtoms::browser) ||
|
|
nodeInfo->Equals(nsGkAtoms::editor)) {
|
|
return new XULFrameElement(nodeInfo.forget());
|
|
}
|
|
|
|
if (nodeInfo->Equals(nsGkAtoms::menu) ||
|
|
nodeInfo->Equals(nsGkAtoms::menulist)) {
|
|
return new XULMenuElement(nodeInfo.forget());
|
|
}
|
|
|
|
if (nodeInfo->Equals(nsGkAtoms::tree)) {
|
|
return new XULTreeElement(nodeInfo.forget());
|
|
}
|
|
|
|
return NS_NewBasicXULElement(nodeInfo.forget());
|
|
}
|
|
|
|
/* static */
|
|
already_AddRefed<nsXULElement> nsXULElement::CreateFromPrototype(
|
|
nsXULPrototypeElement* aPrototype, mozilla::dom::NodeInfo* aNodeInfo,
|
|
bool aIsScriptable, bool aIsRoot) {
|
|
RefPtr<mozilla::dom::NodeInfo> ni = aNodeInfo;
|
|
nsCOMPtr<Element> baseElement;
|
|
NS_NewXULElement(getter_AddRefs(baseElement), ni.forget(),
|
|
dom::FROM_PARSER_NETWORK, aPrototype->mIsAtom);
|
|
|
|
if (baseElement) {
|
|
nsXULElement* element = FromNode(baseElement);
|
|
|
|
if (aPrototype->mHasIdAttribute) {
|
|
element->SetHasID();
|
|
}
|
|
if (aPrototype->mHasClassAttribute) {
|
|
element->SetMayHaveClass();
|
|
}
|
|
if (aPrototype->mHasStyleAttribute) {
|
|
element->SetMayHaveStyle();
|
|
}
|
|
|
|
element->MakeHeavyweight(aPrototype);
|
|
if (aIsScriptable) {
|
|
// Check each attribute on the prototype to see if we need to do
|
|
// any additional processing and hookup that would otherwise be
|
|
// done 'automagically' by SetAttr().
|
|
for (const auto& attribute : aPrototype->mAttributes) {
|
|
element->AddListenerForAttributeIfNeeded(attribute.mName);
|
|
}
|
|
}
|
|
|
|
if (aIsRoot && aPrototype->mNodeInfo->Equals(nsGkAtoms::window)) {
|
|
for (size_t i = 0; i < aPrototype->mAttributes.Length(); ++i) {
|
|
if (aPrototype->mAttributes[i].mName.Equals(nsGkAtoms::windowtype)) {
|
|
element->MaybeUpdatePrivateLifetime();
|
|
}
|
|
}
|
|
}
|
|
|
|
return baseElement.forget().downcast<nsXULElement>();
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
nsresult nsXULElement::CreateFromPrototype(nsXULPrototypeElement* aPrototype,
|
|
Document* aDocument,
|
|
bool aIsScriptable, bool aIsRoot,
|
|
Element** aResult) {
|
|
// Create an nsXULElement from a prototype
|
|
MOZ_ASSERT(aPrototype != nullptr, "null ptr");
|
|
if (!aPrototype) return NS_ERROR_NULL_POINTER;
|
|
|
|
MOZ_ASSERT(aResult != nullptr, "null ptr");
|
|
if (!aResult) return NS_ERROR_NULL_POINTER;
|
|
|
|
RefPtr<mozilla::dom::NodeInfo> nodeInfo;
|
|
if (aDocument) {
|
|
mozilla::dom::NodeInfo* ni = aPrototype->mNodeInfo;
|
|
nodeInfo = aDocument->NodeInfoManager()->GetNodeInfo(
|
|
ni->NameAtom(), ni->GetPrefixAtom(), ni->NamespaceID(), ELEMENT_NODE);
|
|
} else {
|
|
nodeInfo = aPrototype->mNodeInfo;
|
|
}
|
|
|
|
RefPtr<nsXULElement> element =
|
|
CreateFromPrototype(aPrototype, nodeInfo, aIsScriptable, aIsRoot);
|
|
element.forget(aResult);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult NS_NewXULElement(Element** aResult,
|
|
already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,
|
|
FromParser aFromParser, nsAtom* aIsAtom,
|
|
mozilla::dom::CustomElementDefinition* aDefinition) {
|
|
RefPtr<mozilla::dom::NodeInfo> nodeInfo = aNodeInfo;
|
|
|
|
MOZ_ASSERT(nodeInfo, "need nodeinfo for non-proto Create");
|
|
|
|
NS_ASSERTION(
|
|
nodeInfo->NamespaceEquals(kNameSpaceID_XUL),
|
|
"Trying to create XUL elements that don't have the XUL namespace");
|
|
|
|
Document* doc = nodeInfo->GetDocument();
|
|
if (doc && !doc->AllowXULXBL()) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
return nsContentUtils::NewXULOrHTMLElement(aResult, nodeInfo, aFromParser,
|
|
aIsAtom, aDefinition);
|
|
}
|
|
|
|
void NS_TrustedNewXULElement(
|
|
Element** aResult, already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo) {
|
|
RefPtr<mozilla::dom::NodeInfo> ni = aNodeInfo;
|
|
MOZ_ASSERT(ni, "need nodeinfo for non-proto Create");
|
|
|
|
// Create an nsXULElement with the specified namespace and tag.
|
|
NS_ADDREF(*aResult = nsXULElement::Construct(ni.forget()));
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// nsISupports interface
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_INHERITED(nsXULElement, nsStyledElement)
|
|
|
|
NS_IMPL_ADDREF_INHERITED(nsXULElement, nsStyledElement)
|
|
NS_IMPL_RELEASE_INHERITED(nsXULElement, nsStyledElement)
|
|
|
|
NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(nsXULElement)
|
|
NS_ELEMENT_INTERFACE_TABLE_TO_MAP_SEGUE
|
|
NS_INTERFACE_MAP_END_INHERITING(nsStyledElement)
|
|
|
|
//----------------------------------------------------------------------
|
|
// nsINode interface
|
|
|
|
nsresult nsXULElement::Clone(mozilla::dom::NodeInfo* aNodeInfo,
|
|
nsINode** aResult) const {
|
|
*aResult = nullptr;
|
|
|
|
RefPtr<mozilla::dom::NodeInfo> ni = aNodeInfo;
|
|
RefPtr<nsXULElement> element = Construct(ni.forget());
|
|
|
|
nsresult rv = const_cast<nsXULElement*>(this)->CopyInnerTo(
|
|
element, ReparseAttributes::No);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Note that we're _not_ copying mControllers.
|
|
|
|
element.forget(aResult);
|
|
return rv;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
EventListenerManager* nsXULElement::GetEventListenerManagerForAttr(
|
|
nsAtom* aAttrName, bool* aDefer) {
|
|
// XXXbz sXBL/XBL2 issue: should we instead use GetComposedDoc()
|
|
// here, override BindToTree for those classes and munge event
|
|
// listeners there?
|
|
Document* doc = OwnerDoc();
|
|
|
|
nsPIDOMWindowInner* window;
|
|
Element* root = doc->GetRootElement();
|
|
if ((!root || root == this) && (window = doc->GetInnerWindow())) {
|
|
nsCOMPtr<EventTarget> piTarget = do_QueryInterface(window);
|
|
|
|
*aDefer = false;
|
|
return piTarget->GetOrCreateListenerManager();
|
|
}
|
|
|
|
return nsStyledElement::GetEventListenerManagerForAttr(aAttrName, aDefer);
|
|
}
|
|
|
|
// returns true if the element is not a list
|
|
static bool IsNonList(mozilla::dom::NodeInfo* aNodeInfo) {
|
|
return !aNodeInfo->Equals(nsGkAtoms::tree) &&
|
|
!aNodeInfo->Equals(nsGkAtoms::richlistbox);
|
|
}
|
|
|
|
bool nsXULElement::IsFocusableInternal(int32_t* aTabIndex, bool aWithMouse) {
|
|
/*
|
|
* Returns true if an element may be focused, and false otherwise. The inout
|
|
* argument aTabIndex will be set to the tab order index to be used; -1 for
|
|
* elements that should not be part of the tab order and a greater value to
|
|
* indicate its tab order.
|
|
*
|
|
* Confusingly, the supplied value for the aTabIndex argument may indicate
|
|
* whether the element may be focused as a result of the -moz-user-focus
|
|
* property, where -1 means no and 0 means yes.
|
|
*
|
|
* For controls, the element cannot be focused and is not part of the tab
|
|
* order if it is disabled.
|
|
*
|
|
* -moz-user-focus is overridden if a tabindex (even -1) is specified.
|
|
*
|
|
* Specifically, the behaviour for all XUL elements is as follows:
|
|
* *aTabIndex = -1 no tabindex Not focusable or tabbable
|
|
* *aTabIndex = -1 tabindex="-1" Focusable but not tabbable
|
|
* *aTabIndex = -1 tabindex=">=0" Focusable and tabbable
|
|
* *aTabIndex >= 0 no tabindex Focusable and tabbable
|
|
* *aTabIndex >= 0 tabindex="-1" Focusable but not tabbable
|
|
* *aTabIndex >= 0 tabindex=">=0" Focusable and tabbable
|
|
*
|
|
* If aTabIndex is null, then the tabindex is not computed, and
|
|
* true is returned for non-disabled controls and false otherwise.
|
|
*/
|
|
|
|
// elements are not focusable by default
|
|
bool shouldFocus = false;
|
|
|
|
#ifdef XP_MACOSX
|
|
// on Mac, mouse interactions only focus the element if it's a list,
|
|
// or if it's a remote target, since the remote target must handle
|
|
// the focus.
|
|
if (aWithMouse && IsNonList(mNodeInfo) &&
|
|
!EventStateManager::IsRemoteTarget(this)) {
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
nsCOMPtr<nsIDOMXULControlElement> xulControl = AsXULControl();
|
|
if (xulControl) {
|
|
// a disabled element cannot be focused and is not part of the tab order
|
|
bool disabled;
|
|
xulControl->GetDisabled(&disabled);
|
|
if (disabled) {
|
|
if (aTabIndex) *aTabIndex = -1;
|
|
return false;
|
|
}
|
|
shouldFocus = true;
|
|
}
|
|
|
|
if (aTabIndex) {
|
|
if (HasAttr(kNameSpaceID_None, nsGkAtoms::tabindex)) {
|
|
// The tabindex attribute was specified, so the element becomes
|
|
// focusable.
|
|
shouldFocus = true;
|
|
*aTabIndex = TabIndex();
|
|
} else {
|
|
// otherwise, if there is no tabindex attribute, just use the value of
|
|
// *aTabIndex to indicate focusability. Reset any supplied tabindex to 0.
|
|
shouldFocus = *aTabIndex >= 0;
|
|
if (shouldFocus) {
|
|
*aTabIndex = 0;
|
|
}
|
|
}
|
|
|
|
if (xulControl && shouldFocus && sTabFocusModelAppliesToXUL &&
|
|
!(sTabFocusModel & eTabFocus_formElementsMask)) {
|
|
// By default, the tab focus model doesn't apply to xul element on any
|
|
// system but OS X. on OS X we're following it for UI elements (XUL) as
|
|
// sTabFocusModel is based on "Full Keyboard Access" system setting (see
|
|
// mac/nsILookAndFeel). both textboxes and list elements (i.e. trees and
|
|
// list) should always be focusable (textboxes are handled as html:input)
|
|
// For compatibility, we only do this for controls, otherwise elements
|
|
// like <browser> cannot take this focus.
|
|
if (IsNonList(mNodeInfo)) {
|
|
*aTabIndex = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return shouldFocus;
|
|
}
|
|
|
|
int32_t nsXULElement::ScreenX() {
|
|
nsIFrame* frame = GetPrimaryFrame(FlushType::Layout);
|
|
return frame ? frame->GetScreenRect().x : 0;
|
|
}
|
|
|
|
int32_t nsXULElement::ScreenY() {
|
|
nsIFrame* frame = GetPrimaryFrame(FlushType::Layout);
|
|
return frame ? frame->GetScreenRect().y : 0;
|
|
}
|
|
|
|
bool nsXULElement::HasMenu() {
|
|
nsMenuFrame* menu = do_QueryFrame(GetPrimaryFrame());
|
|
return menu != nullptr;
|
|
}
|
|
|
|
void nsXULElement::OpenMenu(bool aOpenFlag) {
|
|
nsMenuFrame* menu = do_QueryFrame(GetPrimaryFrame(FlushType::Frames));
|
|
|
|
nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
|
|
if (pm) {
|
|
if (aOpenFlag) {
|
|
// Nothing will happen if this element isn't a menu.
|
|
pm->ShowMenu(this, false, false);
|
|
} else if (menu) {
|
|
nsMenuPopupFrame* popupFrame = menu->GetPopup();
|
|
if (popupFrame) {
|
|
pm->HidePopup(popupFrame->GetContent(), false, true, false, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool nsXULElement::PerformAccesskey(bool aKeyCausesActivation,
|
|
bool aIsTrustedEvent) {
|
|
RefPtr<Element> content(this);
|
|
|
|
if (IsXULElement(nsGkAtoms::label)) {
|
|
nsAutoString control;
|
|
GetAttr(kNameSpaceID_None, nsGkAtoms::control, control);
|
|
if (control.IsEmpty()) {
|
|
return false;
|
|
}
|
|
|
|
// XXXsmaug Should we use ShadowRoot::GetElementById in case
|
|
// content is in Shadow DOM?
|
|
nsCOMPtr<Document> document = content->GetUncomposedDoc();
|
|
if (!document) {
|
|
return false;
|
|
}
|
|
|
|
content = document->GetElementById(control);
|
|
if (!content) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
nsIFrame* frame = content->GetPrimaryFrame();
|
|
if (!frame || !frame->IsVisibleConsideringAncestors()) {
|
|
return false;
|
|
}
|
|
|
|
bool focused = false;
|
|
nsXULElement* elm = FromNode(content);
|
|
if (elm) {
|
|
// Define behavior for each type of XUL element.
|
|
if (!content->IsXULElement(nsGkAtoms::toolbarbutton)) {
|
|
nsIFocusManager* fm = nsFocusManager::GetFocusManager();
|
|
if (fm) {
|
|
nsCOMPtr<Element> elementToFocus;
|
|
// for radio buttons, focus the radiogroup instead
|
|
if (content->IsXULElement(nsGkAtoms::radio)) {
|
|
nsCOMPtr<nsIDOMXULSelectControlItemElement> controlItem =
|
|
content->AsXULSelectControlItem();
|
|
if (controlItem) {
|
|
bool disabled;
|
|
controlItem->GetDisabled(&disabled);
|
|
if (!disabled) {
|
|
controlItem->GetControl(getter_AddRefs(elementToFocus));
|
|
}
|
|
}
|
|
} else {
|
|
elementToFocus = content;
|
|
}
|
|
if (elementToFocus) {
|
|
fm->SetFocus(elementToFocus, nsIFocusManager::FLAG_BYKEY);
|
|
|
|
// Return true if the element became focused.
|
|
nsPIDOMWindowOuter* window = OwnerDoc()->GetWindow();
|
|
focused = (window && window->GetFocusedElement());
|
|
}
|
|
}
|
|
}
|
|
if (aKeyCausesActivation && !content->IsXULElement(nsGkAtoms::menulist)) {
|
|
elm->ClickWithInputSource(MouseEvent_Binding::MOZ_SOURCE_KEYBOARD,
|
|
aIsTrustedEvent);
|
|
}
|
|
} else {
|
|
return content->PerformAccesskey(aKeyCausesActivation, aIsTrustedEvent);
|
|
}
|
|
|
|
return focused;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
void nsXULElement::AddListenerForAttributeIfNeeded(nsAtom* aLocalName) {
|
|
// If appropriate, add a popup listener and/or compile the event
|
|
// handler. Called when we change the element's document, create a
|
|
// new element, change an attribute's value, etc.
|
|
// Eventlistenener-attributes are always in the null namespace.
|
|
if (aLocalName == nsGkAtoms::menu || aLocalName == nsGkAtoms::contextmenu ||
|
|
// XXXdwh popup and context are deprecated
|
|
aLocalName == nsGkAtoms::popup || aLocalName == nsGkAtoms::context) {
|
|
AddPopupListener(aLocalName);
|
|
}
|
|
if (nsContentUtils::IsEventAttributeName(aLocalName, EventNameType_XUL)) {
|
|
nsAutoString value;
|
|
GetAttr(kNameSpaceID_None, aLocalName, value);
|
|
SetEventHandler(aLocalName, value, true);
|
|
}
|
|
}
|
|
|
|
void nsXULElement::AddListenerForAttributeIfNeeded(const nsAttrName& aName) {
|
|
if (aName.IsAtom()) {
|
|
AddListenerForAttributeIfNeeded(aName.Atom());
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
//
|
|
// nsIContent interface
|
|
//
|
|
void nsXULElement::UpdateEditableState(bool aNotify) {
|
|
// Don't call through to Element here because the things
|
|
// it does don't work for cases when we're an editable control.
|
|
nsIContent* parent = GetParent();
|
|
|
|
SetEditableFlag(parent && parent->HasFlag(NODE_IS_EDITABLE));
|
|
UpdateState(aNotify);
|
|
}
|
|
|
|
class XULInContentErrorReporter : public Runnable {
|
|
public:
|
|
explicit XULInContentErrorReporter(Document& aDocument)
|
|
: mozilla::Runnable("XULInContentErrorReporter"), mDocument(aDocument) {}
|
|
|
|
NS_IMETHOD Run() override {
|
|
mDocument->WarnOnceAbout(Document::eImportXULIntoContent, false);
|
|
return NS_OK;
|
|
}
|
|
|
|
private:
|
|
OwningNonNull<Document> mDocument;
|
|
};
|
|
|
|
static bool NeedTooltipSupport(const nsXULElement& aXULElement) {
|
|
if (aXULElement.NodeInfo()->Equals(nsGkAtoms::treechildren)) {
|
|
// treechildren always get tooltip support, since cropped tree cells show
|
|
// their full text in a tooltip.
|
|
return true;
|
|
}
|
|
|
|
return aXULElement.GetBoolAttr(nsGkAtoms::tooltip) ||
|
|
aXULElement.GetBoolAttr(nsGkAtoms::tooltiptext);
|
|
}
|
|
|
|
nsresult nsXULElement::BindToTree(BindContext& aContext, nsINode& aParent) {
|
|
nsresult rv = nsStyledElement::BindToTree(aContext, aParent);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (!IsInComposedDoc()) {
|
|
return rv;
|
|
}
|
|
|
|
Document& doc = aContext.OwnerDoc();
|
|
if (!IsInNativeAnonymousSubtree() && !doc.IsLoadedAsInteractiveData() &&
|
|
!doc.AllowXULXBL() &&
|
|
!doc.HasWarnedAbout(Document::eImportXULIntoContent)) {
|
|
nsContentUtils::AddScriptRunner(new XULInContentErrorReporter(doc));
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (!doc.AllowXULXBL() && !doc.IsUnstyledDocument()) {
|
|
// To save CPU cycles and memory, non-XUL documents only load the user
|
|
// agent style sheet rules for a minimal set of XUL elements such as
|
|
// 'scrollbar' that may be created implicitly for their content (those
|
|
// rules being in minimal-xul.css).
|
|
//
|
|
// This assertion makes sure no other XUL element is used in a non-XUL
|
|
// document.
|
|
nsAtom* tag = NodeInfo()->NameAtom();
|
|
MOZ_ASSERT(
|
|
// scrollbar parts
|
|
tag == nsGkAtoms::scrollbar || tag == nsGkAtoms::scrollbarbutton ||
|
|
tag == nsGkAtoms::scrollcorner || tag == nsGkAtoms::slider ||
|
|
tag == nsGkAtoms::thumb ||
|
|
// other
|
|
tag == nsGkAtoms::resizer || tag == nsGkAtoms::label,
|
|
"Unexpected XUL element in non-XUL doc");
|
|
}
|
|
#endif
|
|
|
|
// Within Bug 1492063 and its dependencies we started to apply a
|
|
// CSP to system privileged about pages. Since some about: pages
|
|
// are implemented in *.xul files we added this workaround to
|
|
// apply a CSP to them. To do so, we check the introduced custom
|
|
// attribute 'csp' on the root element.
|
|
if (doc.GetRootElement() == this) {
|
|
nsAutoString cspPolicyStr;
|
|
GetAttr(kNameSpaceID_None, nsGkAtoms::csp, cspPolicyStr);
|
|
|
|
#ifdef DEBUG
|
|
{
|
|
nsCOMPtr<nsIContentSecurityPolicy> docCSP = doc.GetCsp();
|
|
uint32_t policyCount = 0;
|
|
if (docCSP) {
|
|
docCSP->GetPolicyCount(&policyCount);
|
|
}
|
|
MOZ_ASSERT(policyCount == 0, "how come we already have a policy?");
|
|
}
|
|
#endif
|
|
|
|
CSP_ApplyMetaCSPToDoc(doc, cspPolicyStr);
|
|
}
|
|
|
|
if (NodeInfo()->Equals(nsGkAtoms::keyset, kNameSpaceID_XUL)) {
|
|
// Create our XUL key listener and hook it up.
|
|
XULKeySetGlobalKeyListener::AttachKeyHandler(this);
|
|
}
|
|
|
|
if (NeedTooltipSupport(*this)) {
|
|
AddTooltipSupport();
|
|
}
|
|
|
|
if (XULBroadcastManager::MayNeedListener(*this)) {
|
|
if (!doc.HasXULBroadcastManager()) {
|
|
doc.InitializeXULBroadcastManager();
|
|
}
|
|
XULBroadcastManager* broadcastManager = doc.GetXULBroadcastManager();
|
|
broadcastManager->AddListener(this);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
void nsXULElement::UnbindFromTree(bool aNullParent) {
|
|
if (NodeInfo()->Equals(nsGkAtoms::keyset, kNameSpaceID_XUL)) {
|
|
XULKeySetGlobalKeyListener::DetachKeyHandler(this);
|
|
}
|
|
|
|
if (NeedTooltipSupport(*this)) {
|
|
RemoveTooltipSupport();
|
|
}
|
|
|
|
Document* doc = GetComposedDoc();
|
|
if (doc && doc->HasXULBroadcastManager() &&
|
|
XULBroadcastManager::MayNeedListener(*this)) {
|
|
RefPtr<XULBroadcastManager> broadcastManager =
|
|
doc->GetXULBroadcastManager();
|
|
broadcastManager->RemoveListener(this);
|
|
}
|
|
|
|
// mControllers can own objects that are implemented
|
|
// in JavaScript (such as some implementations of
|
|
// nsIControllers. These objects prevent their global
|
|
// object's script object from being garbage collected,
|
|
// which means JS continues to hold an owning reference
|
|
// to the nsGlobalWindow, which owns the document,
|
|
// which owns this content. That's a cycle, so we break
|
|
// it here. (It might be better to break this by releasing
|
|
// mDocument in nsGlobalWindow::SetDocShell, but I'm not
|
|
// sure whether that would fix all possible cycles through
|
|
// mControllers.)
|
|
nsExtendedDOMSlots* slots = GetExistingExtendedDOMSlots();
|
|
if (slots) {
|
|
slots->mControllers = nullptr;
|
|
}
|
|
|
|
nsStyledElement::UnbindFromTree(aNullParent);
|
|
}
|
|
|
|
void nsXULElement::DoneAddingChildren(bool aHaveNotified) {
|
|
if (IsXULElement(nsGkAtoms::linkset)) {
|
|
Document* doc = GetComposedDoc();
|
|
if (doc) {
|
|
doc->OnL10nResourceContainerParsed();
|
|
}
|
|
}
|
|
}
|
|
|
|
void nsXULElement::UnregisterAccessKey(const nsAString& aOldValue) {
|
|
// If someone changes the accesskey, unregister the old one
|
|
//
|
|
Document* doc = GetComposedDoc();
|
|
if (doc && !aOldValue.IsEmpty()) {
|
|
if (PresShell* presShell = doc->GetPresShell()) {
|
|
presShell->GetPresContext()->EventStateManager()->UnregisterAccessKey(
|
|
this, aOldValue.First());
|
|
}
|
|
}
|
|
}
|
|
|
|
nsresult nsXULElement::BeforeSetAttr(int32_t aNamespaceID, nsAtom* aName,
|
|
const nsAttrValueOrString* aValue,
|
|
bool aNotify) {
|
|
if (aNamespaceID == kNameSpaceID_None && aName == nsGkAtoms::accesskey &&
|
|
IsInUncomposedDoc()) {
|
|
nsAutoString oldValue;
|
|
if (GetAttr(aNamespaceID, aName, oldValue)) {
|
|
UnregisterAccessKey(oldValue);
|
|
}
|
|
} else if (aNamespaceID == kNameSpaceID_None &&
|
|
(aName == nsGkAtoms::command || aName == nsGkAtoms::observes) &&
|
|
IsInUncomposedDoc()) {
|
|
// XXX sXBL/XBL2 issue! Owner or current document?
|
|
// XXX Why does this not also remove broadcast listeners if the
|
|
// "element" attribute was changed on an <observer>?
|
|
nsAutoString oldValue;
|
|
GetAttr(kNameSpaceID_None, nsGkAtoms::observes, oldValue);
|
|
if (oldValue.IsEmpty()) {
|
|
GetAttr(kNameSpaceID_None, nsGkAtoms::command, oldValue);
|
|
}
|
|
|
|
Document* doc = GetUncomposedDoc();
|
|
if (!oldValue.IsEmpty() && doc->HasXULBroadcastManager()) {
|
|
RefPtr<XULBroadcastManager> broadcastManager =
|
|
doc->GetXULBroadcastManager();
|
|
broadcastManager->RemoveListener(this);
|
|
}
|
|
} else if (aNamespaceID == kNameSpaceID_None && aValue &&
|
|
mNodeInfo->Equals(nsGkAtoms::window) &&
|
|
aName == nsGkAtoms::chromemargin) {
|
|
nsAttrValue attrValue;
|
|
// Make sure the margin format is valid first
|
|
if (!attrValue.ParseIntMarginValue(aValue->String())) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
} else if (aNamespaceID == kNameSpaceID_None &&
|
|
aName == nsGkAtoms::usercontextid) {
|
|
nsAutoString oldValue;
|
|
bool hasAttribute =
|
|
GetAttr(kNameSpaceID_None, nsGkAtoms::usercontextid, oldValue);
|
|
if (hasAttribute && (!aValue || !aValue->String().Equals(oldValue))) {
|
|
MOZ_ASSERT(false, "Changing usercontextid is not allowed.");
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
}
|
|
|
|
return nsStyledElement::BeforeSetAttr(aNamespaceID, aName, aValue, aNotify);
|
|
}
|
|
|
|
nsresult nsXULElement::AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
|
|
const nsAttrValue* aValue,
|
|
const nsAttrValue* aOldValue,
|
|
nsIPrincipal* aSubjectPrincipal,
|
|
bool aNotify) {
|
|
if (aNamespaceID == kNameSpaceID_None) {
|
|
if (aValue) {
|
|
AddListenerForAttributeIfNeeded(aName);
|
|
}
|
|
|
|
if (aName == nsGkAtoms::tooltip || aName == nsGkAtoms::tooltiptext) {
|
|
if (!!aValue != !!aOldValue && IsInComposedDoc() &&
|
|
!NodeInfo()->Equals(nsGkAtoms::treechildren)) {
|
|
if (aValue) {
|
|
AddTooltipSupport();
|
|
} else {
|
|
RemoveTooltipSupport();
|
|
}
|
|
}
|
|
}
|
|
Document* doc = GetComposedDoc();
|
|
if (doc && doc->HasXULBroadcastManager()) {
|
|
RefPtr<XULBroadcastManager> broadcastManager =
|
|
doc->GetXULBroadcastManager();
|
|
broadcastManager->AttributeChanged(this, aNamespaceID, aName);
|
|
}
|
|
if (doc && XULBroadcastManager::MayNeedListener(*this)) {
|
|
if (!doc->HasXULBroadcastManager()) {
|
|
doc->InitializeXULBroadcastManager();
|
|
}
|
|
XULBroadcastManager* broadcastManager = doc->GetXULBroadcastManager();
|
|
broadcastManager->AddListener(this);
|
|
}
|
|
|
|
// XXX need to check if they're changing an event handler: if
|
|
// so, then we need to unhook the old one. Or something.
|
|
}
|
|
|
|
return nsStyledElement::AfterSetAttr(aNamespaceID, aName, aValue, aOldValue,
|
|
aSubjectPrincipal, aNotify);
|
|
}
|
|
|
|
void nsXULElement::AddTooltipSupport() {
|
|
nsXULTooltipListener* listener = nsXULTooltipListener::GetInstance();
|
|
if (!listener) {
|
|
return;
|
|
}
|
|
|
|
listener->AddTooltipSupport(this);
|
|
}
|
|
|
|
void nsXULElement::RemoveTooltipSupport() {
|
|
nsXULTooltipListener* listener = nsXULTooltipListener::GetInstance();
|
|
if (!listener) {
|
|
return;
|
|
}
|
|
|
|
listener->RemoveTooltipSupport(this);
|
|
}
|
|
|
|
bool nsXULElement::ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
|
|
const nsAString& aValue,
|
|
nsIPrincipal* aMaybeScriptedPrincipal,
|
|
nsAttrValue& aResult) {
|
|
if (aNamespaceID == kNameSpaceID_None && aAttribute == nsGkAtoms::tabindex) {
|
|
return aResult.ParseIntValue(aValue);
|
|
}
|
|
|
|
// Parse into a nsAttrValue
|
|
if (!nsStyledElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
|
|
aMaybeScriptedPrincipal, aResult)) {
|
|
// Fall back to parsing as atom for short values
|
|
aResult.ParseStringOrAtom(aValue);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void nsXULElement::DestroyContent() {
|
|
nsExtendedDOMSlots* slots = GetExistingExtendedDOMSlots();
|
|
if (slots) {
|
|
slots->mControllers = nullptr;
|
|
}
|
|
|
|
nsStyledElement::DestroyContent();
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void nsXULElement::List(FILE* out, int32_t aIndent) const {
|
|
nsCString prefix("XUL");
|
|
if (HasSlots()) {
|
|
prefix.Append('*');
|
|
}
|
|
prefix.Append(' ');
|
|
|
|
nsStyledElement::List(out, aIndent, prefix);
|
|
}
|
|
#endif
|
|
|
|
bool nsXULElement::IsEventStoppedFromAnonymousScrollbar(EventMessage aMessage) {
|
|
return (IsRootOfNativeAnonymousSubtree() &&
|
|
IsAnyOfXULElements(nsGkAtoms::scrollbar, nsGkAtoms::scrollcorner) &&
|
|
(aMessage == eMouseClick || aMessage == eMouseDoubleClick ||
|
|
aMessage == eXULCommand || aMessage == eContextMenu ||
|
|
aMessage == eDragStart || aMessage == eMouseAuxClick));
|
|
}
|
|
|
|
nsresult nsXULElement::DispatchXULCommand(const EventChainVisitor& aVisitor,
|
|
nsAutoString& aCommand) {
|
|
// XXX sXBL/XBL2 issue! Owner or current document?
|
|
nsCOMPtr<Document> doc = GetUncomposedDoc();
|
|
NS_ENSURE_STATE(doc);
|
|
RefPtr<Element> commandElt = doc->GetElementById(aCommand);
|
|
if (commandElt) {
|
|
// Create a new command event to dispatch to the element
|
|
// pointed to by the command attribute. The new event's
|
|
// sourceEvent will be the original command event that we're
|
|
// handling.
|
|
RefPtr<Event> event = aVisitor.mDOMEvent;
|
|
uint16_t inputSource = MouseEvent_Binding::MOZ_SOURCE_UNKNOWN;
|
|
while (event) {
|
|
NS_ENSURE_STATE(event->GetOriginalTarget() != commandElt);
|
|
RefPtr<XULCommandEvent> commandEvent = event->AsXULCommandEvent();
|
|
if (commandEvent) {
|
|
event = commandEvent->GetSourceEvent();
|
|
inputSource = commandEvent->InputSource();
|
|
} else {
|
|
event = nullptr;
|
|
}
|
|
}
|
|
WidgetInputEvent* orig = aVisitor.mEvent->AsInputEvent();
|
|
nsContentUtils::DispatchXULCommand(
|
|
commandElt, orig->IsTrusted(), MOZ_KnownLive(aVisitor.mDOMEvent),
|
|
nullptr, orig->IsControl(), orig->IsAlt(), orig->IsShift(),
|
|
orig->IsMeta(), inputSource);
|
|
} else {
|
|
NS_WARNING("A XUL element is attached to a command that doesn't exist!\n");
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
void nsXULElement::GetEventTargetParent(EventChainPreVisitor& aVisitor) {
|
|
aVisitor.mForceContentDispatch = true; // FIXME! Bug 329119
|
|
if (IsEventStoppedFromAnonymousScrollbar(aVisitor.mEvent->mMessage)) {
|
|
// Don't propagate these events from native anonymous scrollbar.
|
|
aVisitor.mCanHandle = true;
|
|
aVisitor.SetParentTarget(nullptr, false);
|
|
return;
|
|
}
|
|
if (aVisitor.mEvent->mMessage == eXULCommand &&
|
|
aVisitor.mEvent->mClass == eInputEventClass &&
|
|
aVisitor.mEvent->mOriginalTarget == static_cast<nsIContent*>(this) &&
|
|
!IsXULElement(nsGkAtoms::command)) {
|
|
// Check that we really have an xul command event. That will be handled
|
|
// in a special way.
|
|
// See if we have a command elt. If so, we execute on the command
|
|
// instead of on our content element.
|
|
if (aVisitor.mDOMEvent && aVisitor.mDOMEvent->AsXULCommandEvent() &&
|
|
HasNonEmptyAttr(nsGkAtoms::command)) {
|
|
// Stop building the event target chain for the original event.
|
|
// We don't want it to propagate to any DOM nodes.
|
|
aVisitor.mCanHandle = false;
|
|
aVisitor.mAutomaticChromeDispatch = false;
|
|
// Dispatch XUL command in PreHandleEvent to prevent it breaks event
|
|
// target chain creation
|
|
aVisitor.mWantsPreHandleEvent = true;
|
|
aVisitor.mItemFlags |= NS_DISPATCH_XUL_COMMAND;
|
|
return;
|
|
}
|
|
}
|
|
|
|
nsStyledElement::GetEventTargetParent(aVisitor);
|
|
}
|
|
|
|
nsresult nsXULElement::PreHandleEvent(EventChainVisitor& aVisitor) {
|
|
if (aVisitor.mItemFlags & NS_DISPATCH_XUL_COMMAND) {
|
|
nsAutoString command;
|
|
GetAttr(kNameSpaceID_None, nsGkAtoms::command, command);
|
|
MOZ_ASSERT(!command.IsEmpty());
|
|
return DispatchXULCommand(aVisitor, command);
|
|
}
|
|
return nsStyledElement::PreHandleEvent(aVisitor);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Implementation methods
|
|
|
|
nsChangeHint nsXULElement::GetAttributeChangeHint(const nsAtom* aAttribute,
|
|
int32_t aModType) const {
|
|
if (aAttribute == nsGkAtoms::value &&
|
|
(aModType == MutationEvent_Binding::REMOVAL ||
|
|
aModType == MutationEvent_Binding::ADDITION) &&
|
|
IsAnyOfXULElements(nsGkAtoms::label, nsGkAtoms::description)) {
|
|
// Label and description dynamically morph between a normal
|
|
// block and a cropping single-line XUL text frame. If the
|
|
// value attribute is being added or removed, then we need to
|
|
// return a hint of frame change. (See bugzilla bug 95475 for
|
|
// details.)
|
|
return nsChangeHint_ReconstructFrame;
|
|
}
|
|
|
|
if (aAttribute == nsGkAtoms::type &&
|
|
IsAnyOfXULElements(nsGkAtoms::toolbarbutton, nsGkAtoms::button)) {
|
|
// type=menu switches from a button frame to a menu frame.
|
|
return nsChangeHint_ReconstructFrame;
|
|
}
|
|
|
|
// if left or top changes we reflow. This will happen in xul
|
|
// containers that manage positioned children such as a stack.
|
|
if (nsGkAtoms::left == aAttribute || nsGkAtoms::top == aAttribute ||
|
|
nsGkAtoms::right == aAttribute || nsGkAtoms::bottom == aAttribute ||
|
|
nsGkAtoms::start == aAttribute || nsGkAtoms::end == aAttribute) {
|
|
return NS_STYLE_HINT_REFLOW;
|
|
}
|
|
|
|
return nsChangeHint(0);
|
|
}
|
|
|
|
NS_IMETHODIMP_(bool)
|
|
nsXULElement::IsAttributeMapped(const nsAtom* aAttribute) const {
|
|
return false;
|
|
}
|
|
|
|
nsIControllers* nsXULElement::GetControllers(ErrorResult& rv) {
|
|
if (!Controllers()) {
|
|
nsExtendedDOMSlots* slots = ExtendedDOMSlots();
|
|
|
|
slots->mControllers = new nsXULControllers();
|
|
}
|
|
|
|
return Controllers();
|
|
}
|
|
|
|
void nsXULElement::Click(CallerType aCallerType) {
|
|
ClickWithInputSource(MouseEvent_Binding::MOZ_SOURCE_UNKNOWN,
|
|
aCallerType == CallerType::System);
|
|
}
|
|
|
|
void nsXULElement::ClickWithInputSource(uint16_t aInputSource,
|
|
bool aIsTrustedEvent) {
|
|
if (BoolAttrIsTrue(nsGkAtoms::disabled)) return;
|
|
|
|
nsCOMPtr<Document> doc = GetComposedDoc(); // Strong just in case
|
|
if (doc) {
|
|
RefPtr<nsPresContext> context = doc->GetPresContext();
|
|
if (context) {
|
|
// strong ref to PresContext so events don't destroy it
|
|
|
|
WidgetMouseEvent eventDown(aIsTrustedEvent, eMouseDown, nullptr,
|
|
WidgetMouseEvent::eReal);
|
|
WidgetMouseEvent eventUp(aIsTrustedEvent, eMouseUp, nullptr,
|
|
WidgetMouseEvent::eReal);
|
|
WidgetMouseEvent eventClick(aIsTrustedEvent, eMouseClick, nullptr,
|
|
WidgetMouseEvent::eReal);
|
|
eventDown.mInputSource = eventUp.mInputSource = eventClick.mInputSource =
|
|
aInputSource;
|
|
|
|
// send mouse down
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
EventDispatcher::Dispatch(static_cast<nsIContent*>(this), context,
|
|
&eventDown, nullptr, &status);
|
|
|
|
// send mouse up
|
|
status = nsEventStatus_eIgnore; // reset status
|
|
EventDispatcher::Dispatch(static_cast<nsIContent*>(this), context,
|
|
&eventUp, nullptr, &status);
|
|
|
|
// send mouse click
|
|
status = nsEventStatus_eIgnore; // reset status
|
|
EventDispatcher::Dispatch(static_cast<nsIContent*>(this), context,
|
|
&eventClick, nullptr, &status);
|
|
|
|
// If the click has been prevented, lets skip the command call
|
|
// this is how a physical click works
|
|
if (status == nsEventStatus_eConsumeNoDefault) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// oncommand is fired when an element is clicked...
|
|
DoCommand();
|
|
}
|
|
|
|
void nsXULElement::DoCommand() {
|
|
nsCOMPtr<Document> doc = GetComposedDoc(); // strong just in case
|
|
if (doc) {
|
|
RefPtr<nsXULElement> self = this;
|
|
nsContentUtils::DispatchXULCommand(self, true);
|
|
}
|
|
}
|
|
|
|
bool nsXULElement::IsNodeOfType(uint32_t aFlags) const { return false; }
|
|
|
|
nsresult nsXULElement::AddPopupListener(nsAtom* aName) {
|
|
// Add a popup listener to the element
|
|
bool isContext =
|
|
(aName == nsGkAtoms::context || aName == nsGkAtoms::contextmenu);
|
|
uint32_t listenerFlag = isContext ? XUL_ELEMENT_HAS_CONTENTMENU_LISTENER
|
|
: XUL_ELEMENT_HAS_POPUP_LISTENER;
|
|
|
|
if (HasFlag(listenerFlag)) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMEventListener> listener =
|
|
new nsXULPopupListener(this, isContext);
|
|
|
|
// Add the popup as a listener on this element.
|
|
EventListenerManager* manager = GetOrCreateListenerManager();
|
|
SetFlags(listenerFlag);
|
|
|
|
if (isContext) {
|
|
manager->AddEventListenerByType(listener, NS_LITERAL_STRING("contextmenu"),
|
|
TrustedEventsAtSystemGroupBubble());
|
|
} else {
|
|
manager->AddEventListenerByType(listener, NS_LITERAL_STRING("mousedown"),
|
|
TrustedEventsAtSystemGroupBubble());
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
nsresult nsXULElement::MakeHeavyweight(nsXULPrototypeElement* aPrototype) {
|
|
if (!aPrototype) {
|
|
return NS_OK;
|
|
}
|
|
|
|
size_t i;
|
|
nsresult rv;
|
|
for (i = 0; i < aPrototype->mAttributes.Length(); ++i) {
|
|
nsXULPrototypeAttribute* protoattr = &aPrototype->mAttributes[i];
|
|
nsAttrValue attrValue;
|
|
|
|
// Style rules need to be cloned.
|
|
if (protoattr->mValue.Type() == nsAttrValue::eCSSDeclaration) {
|
|
DeclarationBlock* decl = protoattr->mValue.GetCSSDeclarationValue();
|
|
RefPtr<DeclarationBlock> declClone = decl->Clone();
|
|
|
|
nsString stringValue;
|
|
protoattr->mValue.ToString(stringValue);
|
|
|
|
attrValue.SetTo(declClone.forget(), &stringValue);
|
|
} else {
|
|
attrValue.SetTo(protoattr->mValue);
|
|
}
|
|
|
|
bool oldValueSet;
|
|
// XXX we might wanna have a SetAndTakeAttr that takes an nsAttrName
|
|
if (protoattr->mName.IsAtom()) {
|
|
rv = mAttrs.SetAndSwapAttr(protoattr->mName.Atom(), attrValue,
|
|
&oldValueSet);
|
|
} else {
|
|
rv = mAttrs.SetAndSwapAttr(protoattr->mName.NodeInfo(), attrValue,
|
|
&oldValueSet);
|
|
}
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
bool nsXULElement::BoolAttrIsTrue(nsAtom* aName) const {
|
|
const nsAttrValue* attr = GetAttrInfo(kNameSpaceID_None, aName).mValue;
|
|
|
|
return attr && attr->Type() == nsAttrValue::eAtom &&
|
|
attr->GetAtomValue() == nsGkAtoms::_true;
|
|
}
|
|
|
|
void nsXULElement::RecompileScriptEventListeners() {
|
|
int32_t i, count = mAttrs.AttrCount();
|
|
for (i = 0; i < count; ++i) {
|
|
const nsAttrName* name = mAttrs.AttrNameAt(i);
|
|
|
|
// Eventlistenener-attributes are always in the null namespace
|
|
if (!name->IsAtom()) {
|
|
continue;
|
|
}
|
|
|
|
nsAtom* attr = name->Atom();
|
|
if (!nsContentUtils::IsEventAttributeName(attr, EventNameType_XUL)) {
|
|
continue;
|
|
}
|
|
|
|
nsAutoString value;
|
|
GetAttr(kNameSpaceID_None, attr, value);
|
|
SetEventHandler(attr, value, true);
|
|
}
|
|
}
|
|
|
|
bool nsXULElement::IsEventAttributeNameInternal(nsAtom* aName) {
|
|
return nsContentUtils::IsEventAttributeName(aName, EventNameType_XUL);
|
|
}
|
|
|
|
JSObject* nsXULElement::WrapNode(JSContext* aCx,
|
|
JS::Handle<JSObject*> aGivenProto) {
|
|
return dom::XULElement_Binding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
bool nsXULElement::IsInteractiveHTMLContent(bool aIgnoreTabindex) const {
|
|
return IsXULElement(nsGkAtoms::menupopup) ||
|
|
Element::IsInteractiveHTMLContent(aIgnoreTabindex);
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(nsXULPrototypeNode)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsXULPrototypeNode)
|
|
if (tmp->mType == nsXULPrototypeNode::eType_Element) {
|
|
static_cast<nsXULPrototypeElement*>(tmp)->Unlink();
|
|
} else if (tmp->mType == nsXULPrototypeNode::eType_Script) {
|
|
static_cast<nsXULPrototypeScript*>(tmp)->UnlinkJSObjects();
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsXULPrototypeNode)
|
|
if (tmp->mType == nsXULPrototypeNode::eType_Element) {
|
|
nsXULPrototypeElement* elem = static_cast<nsXULPrototypeElement*>(tmp);
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mNodeInfo");
|
|
cb.NoteNativeChild(elem->mNodeInfo,
|
|
NS_CYCLE_COLLECTION_PARTICIPANT(NodeInfo));
|
|
size_t i;
|
|
for (i = 0; i < elem->mAttributes.Length(); ++i) {
|
|
const nsAttrName& name = elem->mAttributes[i].mName;
|
|
if (!name.IsAtom()) {
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb,
|
|
"mAttributes[i].mName.NodeInfo()");
|
|
cb.NoteNativeChild(name.NodeInfo(),
|
|
NS_CYCLE_COLLECTION_PARTICIPANT(NodeInfo));
|
|
}
|
|
}
|
|
ImplCycleCollectionTraverse(cb, elem->mChildren, "mChildren");
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsXULPrototypeNode)
|
|
if (tmp->mType == nsXULPrototypeNode::eType_Script) {
|
|
nsXULPrototypeScript* script = static_cast<nsXULPrototypeScript*>(tmp);
|
|
script->Trace(aCallbacks, aClosure);
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(nsXULPrototypeNode, AddRef)
|
|
NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(nsXULPrototypeNode, Release)
|
|
|
|
//----------------------------------------------------------------------
|
|
//
|
|
// nsXULPrototypeAttribute
|
|
//
|
|
|
|
nsXULPrototypeAttribute::~nsXULPrototypeAttribute() {
|
|
MOZ_COUNT_DTOR(nsXULPrototypeAttribute);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
//
|
|
// nsXULPrototypeElement
|
|
//
|
|
|
|
nsresult nsXULPrototypeElement::Serialize(
|
|
nsIObjectOutputStream* aStream, nsXULPrototypeDocument* aProtoDoc,
|
|
const nsTArray<RefPtr<mozilla::dom::NodeInfo>>* aNodeInfos) {
|
|
nsresult rv;
|
|
|
|
// Write basic prototype data
|
|
rv = aStream->Write32(mType);
|
|
|
|
// Write Node Info
|
|
int32_t index = aNodeInfos->IndexOf(mNodeInfo);
|
|
NS_ASSERTION(index >= 0, "unknown mozilla::dom::NodeInfo index");
|
|
nsresult tmp = aStream->Write32(index);
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
|
|
// Write Attributes
|
|
tmp = aStream->Write32(mAttributes.Length());
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
|
|
nsAutoString attributeValue;
|
|
size_t i;
|
|
for (i = 0; i < mAttributes.Length(); ++i) {
|
|
RefPtr<mozilla::dom::NodeInfo> ni;
|
|
if (mAttributes[i].mName.IsAtom()) {
|
|
ni = mNodeInfo->NodeInfoManager()->GetNodeInfo(
|
|
mAttributes[i].mName.Atom(), nullptr, kNameSpaceID_None,
|
|
nsINode::ATTRIBUTE_NODE);
|
|
NS_ASSERTION(ni, "the nodeinfo should already exist");
|
|
} else {
|
|
ni = mAttributes[i].mName.NodeInfo();
|
|
}
|
|
|
|
index = aNodeInfos->IndexOf(ni);
|
|
NS_ASSERTION(index >= 0, "unknown mozilla::dom::NodeInfo index");
|
|
tmp = aStream->Write32(index);
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
|
|
mAttributes[i].mValue.ToString(attributeValue);
|
|
tmp = aStream->WriteWStringZ(attributeValue.get());
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
}
|
|
|
|
// Now write children
|
|
tmp = aStream->Write32(uint32_t(mChildren.Length()));
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
for (i = 0; i < mChildren.Length(); i++) {
|
|
nsXULPrototypeNode* child = mChildren[i].get();
|
|
switch (child->mType) {
|
|
case eType_Element:
|
|
case eType_Text:
|
|
case eType_PI:
|
|
tmp = child->Serialize(aStream, aProtoDoc, aNodeInfos);
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
break;
|
|
case eType_Script:
|
|
tmp = aStream->Write32(child->mType);
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
nsXULPrototypeScript* script =
|
|
static_cast<nsXULPrototypeScript*>(child);
|
|
|
|
tmp = aStream->Write8(script->mOutOfLine);
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
if (!script->mOutOfLine) {
|
|
tmp = script->Serialize(aStream, aProtoDoc, aNodeInfos);
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
} else {
|
|
tmp = aStream->WriteCompoundObject(script->mSrcURI,
|
|
NS_GET_IID(nsIURI), true);
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
|
|
if (script->HasScriptObject()) {
|
|
// This may return NS_OK without muxing script->mSrcURI's
|
|
// data into the cache file, in the case where that
|
|
// muxed document is already there (written by a prior
|
|
// session, or by an earlier cache episode during this
|
|
// session).
|
|
tmp = script->SerializeOutOfLine(aStream, aProtoDoc);
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult nsXULPrototypeElement::Deserialize(
|
|
nsIObjectInputStream* aStream, nsXULPrototypeDocument* aProtoDoc,
|
|
nsIURI* aDocumentURI,
|
|
const nsTArray<RefPtr<mozilla::dom::NodeInfo>>* aNodeInfos) {
|
|
MOZ_ASSERT(aNodeInfos, "missing nodeinfo array");
|
|
|
|
// Read Node Info
|
|
uint32_t number = 0;
|
|
nsresult rv = aStream->Read32(&number);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
mNodeInfo = aNodeInfos->SafeElementAt(number, nullptr);
|
|
if (!mNodeInfo) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
// Read Attributes
|
|
rv = aStream->Read32(&number);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
int32_t attributes = int32_t(number);
|
|
|
|
if (attributes > 0) {
|
|
mAttributes.AppendElements(attributes);
|
|
|
|
nsAutoString attributeValue;
|
|
for (size_t i = 0; i < mAttributes.Length(); ++i) {
|
|
rv = aStream->Read32(&number);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
mozilla::dom::NodeInfo* ni = aNodeInfos->SafeElementAt(number, nullptr);
|
|
if (!ni) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
mAttributes[i].mName.SetTo(ni);
|
|
|
|
rv = aStream->ReadString(attributeValue);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
rv = SetAttrAt(i, attributeValue, aDocumentURI);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
}
|
|
}
|
|
|
|
rv = aStream->Read32(&number);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
uint32_t numChildren = int32_t(number);
|
|
|
|
if (numChildren > 0) {
|
|
if (!mChildren.SetCapacity(numChildren, fallible)) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < numChildren; i++) {
|
|
rv = aStream->Read32(&number);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
Type childType = (Type)number;
|
|
|
|
RefPtr<nsXULPrototypeNode> child;
|
|
|
|
switch (childType) {
|
|
case eType_Element:
|
|
child = new nsXULPrototypeElement();
|
|
rv = child->Deserialize(aStream, aProtoDoc, aDocumentURI, aNodeInfos);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
break;
|
|
case eType_Text:
|
|
child = new nsXULPrototypeText();
|
|
rv = child->Deserialize(aStream, aProtoDoc, aDocumentURI, aNodeInfos);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
break;
|
|
case eType_PI:
|
|
child = new nsXULPrototypePI();
|
|
rv = child->Deserialize(aStream, aProtoDoc, aDocumentURI, aNodeInfos);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
break;
|
|
case eType_Script: {
|
|
// language version/options obtained during deserialization.
|
|
RefPtr<nsXULPrototypeScript> script = new nsXULPrototypeScript(0);
|
|
|
|
rv = aStream->ReadBoolean(&script->mOutOfLine);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
if (!script->mOutOfLine) {
|
|
rv = script->Deserialize(aStream, aProtoDoc, aDocumentURI,
|
|
aNodeInfos);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
} else {
|
|
nsCOMPtr<nsISupports> supports;
|
|
rv = aStream->ReadObject(true, getter_AddRefs(supports));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
script->mSrcURI = do_QueryInterface(supports);
|
|
|
|
rv = script->DeserializeOutOfLine(aStream, aProtoDoc);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
}
|
|
|
|
child = script.forget();
|
|
break;
|
|
}
|
|
default:
|
|
MOZ_ASSERT(false, "Unexpected child type!");
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
MOZ_ASSERT(child, "Don't append null to mChildren");
|
|
MOZ_ASSERT(child->mType == childType);
|
|
mChildren.AppendElement(child);
|
|
|
|
// Oh dear. Something failed during the deserialization.
|
|
// We don't know what. But likely consequences of failed
|
|
// deserializations included calls to |AbortCaching| which
|
|
// shuts down the cache and closes our streams.
|
|
// If that happens, next time through this loop, we die a messy
|
|
// death. So, let's just fail now, and propagate that failure
|
|
// upward so that the ChromeProtocolHandler knows it can't use
|
|
// a cached chrome channel for this.
|
|
if (NS_WARN_IF(NS_FAILED(rv))) return rv;
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult nsXULPrototypeElement::SetAttrAt(uint32_t aPos,
|
|
const nsAString& aValue,
|
|
nsIURI* aDocumentURI) {
|
|
MOZ_ASSERT(aPos < mAttributes.Length(), "out-of-bounds");
|
|
|
|
// WARNING!!
|
|
// This code is largely duplicated in nsXULElement::SetAttr.
|
|
// Any changes should be made to both functions.
|
|
|
|
if (!mNodeInfo->NamespaceEquals(kNameSpaceID_XUL)) {
|
|
if (mNodeInfo->NamespaceEquals(kNameSpaceID_XHTML) &&
|
|
mAttributes[aPos].mName.Equals(nsGkAtoms::is)) {
|
|
// We still care about the is attribute set on HTML elements.
|
|
mAttributes[aPos].mValue.ParseAtom(aValue);
|
|
mIsAtom = mAttributes[aPos].mValue.GetAtomValue();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
mAttributes[aPos].mValue.ParseStringOrAtom(aValue);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
if (mAttributes[aPos].mName.Equals(nsGkAtoms::id) && !aValue.IsEmpty()) {
|
|
mHasIdAttribute = true;
|
|
// Store id as atom.
|
|
// id="" means that the element has no id. Not that it has
|
|
// emptystring as id.
|
|
mAttributes[aPos].mValue.ParseAtom(aValue);
|
|
|
|
return NS_OK;
|
|
} else if (mAttributes[aPos].mName.Equals(nsGkAtoms::is)) {
|
|
// Store is as atom.
|
|
mAttributes[aPos].mValue.ParseAtom(aValue);
|
|
mIsAtom = mAttributes[aPos].mValue.GetAtomValue();
|
|
|
|
return NS_OK;
|
|
} else if (mAttributes[aPos].mName.Equals(nsGkAtoms::_class)) {
|
|
mHasClassAttribute = true;
|
|
// Compute the element's class list
|
|
mAttributes[aPos].mValue.ParseAtomArray(aValue);
|
|
|
|
return NS_OK;
|
|
} else if (mAttributes[aPos].mName.Equals(nsGkAtoms::style)) {
|
|
mHasStyleAttribute = true;
|
|
// Parse the element's 'style' attribute
|
|
|
|
// This is basically duplicating what nsINode::NodePrincipal() does
|
|
nsIPrincipal* principal = mNodeInfo->NodeInfoManager()->DocumentPrincipal();
|
|
// XXX Get correct Base URI (need GetBaseURI on *prototype* element)
|
|
// TODO: If we implement Content Security Policy for chrome documents
|
|
// as has been discussed, the CSP should be checked here to see if
|
|
// inline styles are allowed to be applied.
|
|
// XXX No specific specs talk about xul and referrer policy, pass Unset
|
|
nsCOMPtr<nsIReferrerInfo> referrerInfo =
|
|
new ReferrerInfo(aDocumentURI, ReferrerPolicy::_empty);
|
|
|
|
RefPtr<URLExtraData> data =
|
|
new URLExtraData(aDocumentURI, referrerInfo, principal);
|
|
RefPtr<DeclarationBlock> declaration = DeclarationBlock::FromCssText(
|
|
aValue, data, eCompatibility_FullStandards, nullptr);
|
|
if (declaration) {
|
|
mAttributes[aPos].mValue.SetTo(declaration.forget(), &aValue);
|
|
|
|
return NS_OK;
|
|
}
|
|
// Don't abort if parsing failed, it could just be malformed css.
|
|
} else if (mAttributes[aPos].mName.Equals(nsGkAtoms::tabindex)) {
|
|
mAttributes[aPos].mValue.ParseIntValue(aValue);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
mAttributes[aPos].mValue.ParseStringOrAtom(aValue);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void nsXULPrototypeElement::Unlink() {
|
|
mAttributes.Clear();
|
|
mChildren.Clear();
|
|
}
|
|
|
|
void nsXULPrototypeElement::TraceAllScripts(JSTracer* aTrc) {
|
|
for (uint32_t i = 0; i < mChildren.Length(); ++i) {
|
|
nsXULPrototypeNode* child = mChildren[i];
|
|
if (child->mType == nsXULPrototypeNode::eType_Element) {
|
|
static_cast<nsXULPrototypeElement*>(child)->TraceAllScripts(aTrc);
|
|
} else if (child->mType == nsXULPrototypeNode::eType_Script) {
|
|
static_cast<nsXULPrototypeScript*>(child)->TraceScriptObject(aTrc);
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
//
|
|
// nsXULPrototypeScript
|
|
//
|
|
|
|
nsXULPrototypeScript::nsXULPrototypeScript(uint32_t aLineNo)
|
|
: nsXULPrototypeNode(eType_Script),
|
|
mLineNo(aLineNo),
|
|
mSrcLoading(false),
|
|
mOutOfLine(true),
|
|
mSrcLoadWaiters(nullptr),
|
|
mScriptObject(nullptr) {}
|
|
|
|
nsXULPrototypeScript::~nsXULPrototypeScript() { UnlinkJSObjects(); }
|
|
|
|
nsresult nsXULPrototypeScript::Serialize(
|
|
nsIObjectOutputStream* aStream, nsXULPrototypeDocument* aProtoDoc,
|
|
const nsTArray<RefPtr<mozilla::dom::NodeInfo>>* aNodeInfos) {
|
|
NS_ENSURE_TRUE(aProtoDoc, NS_ERROR_UNEXPECTED);
|
|
|
|
AutoJSAPI jsapi;
|
|
if (!jsapi.Init(xpc::CompilationScope())) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
NS_ASSERTION(!mSrcLoading || mSrcLoadWaiters != nullptr || !mScriptObject,
|
|
"script source still loading when serializing?!");
|
|
if (!mScriptObject) return NS_ERROR_FAILURE;
|
|
|
|
// Write basic prototype data
|
|
nsresult rv;
|
|
rv = aStream->Write32(mLineNo);
|
|
if (NS_FAILED(rv)) return rv;
|
|
rv = aStream->Write32(0); // See bug 1418294.
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
JSContext* cx = jsapi.cx();
|
|
JS::Rooted<JSScript*> script(cx, mScriptObject);
|
|
MOZ_ASSERT(xpc::CompilationScope() == JS::CurrentGlobalOrNull(cx));
|
|
return nsContentUtils::XPConnect()->WriteScript(aStream, cx, script);
|
|
}
|
|
|
|
nsresult nsXULPrototypeScript::SerializeOutOfLine(
|
|
nsIObjectOutputStream* aStream, nsXULPrototypeDocument* aProtoDoc) {
|
|
if (!mSrcURI->SchemeIs("chrome"))
|
|
// Don't cache scripts that don't come from chrome uris.
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
nsXULPrototypeCache* cache = nsXULPrototypeCache::GetInstance();
|
|
if (!cache) return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
NS_ASSERTION(cache->IsEnabled(),
|
|
"writing to the cache file, but the XUL cache is off?");
|
|
bool exists;
|
|
cache->HasData(mSrcURI, &exists);
|
|
|
|
/* return will be NS_OK from GetAsciiSpec.
|
|
* that makes no sense.
|
|
* nor does returning NS_OK from HasMuxedDocument.
|
|
* XXX return something meaningful.
|
|
*/
|
|
if (exists) return NS_OK;
|
|
|
|
nsCOMPtr<nsIObjectOutputStream> oos;
|
|
nsresult rv = cache->GetOutputStream(mSrcURI, getter_AddRefs(oos));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsresult tmp = Serialize(oos, aProtoDoc, nullptr);
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
tmp = cache->FinishOutputStream(mSrcURI);
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
|
|
if (NS_FAILED(rv)) cache->AbortCaching();
|
|
return rv;
|
|
}
|
|
|
|
nsresult nsXULPrototypeScript::Deserialize(
|
|
nsIObjectInputStream* aStream, nsXULPrototypeDocument* aProtoDoc,
|
|
nsIURI* aDocumentURI,
|
|
const nsTArray<RefPtr<mozilla::dom::NodeInfo>>* aNodeInfos) {
|
|
nsresult rv;
|
|
NS_ASSERTION(!mSrcLoading || mSrcLoadWaiters != nullptr || !mScriptObject,
|
|
"prototype script not well-initialized when deserializing?!");
|
|
|
|
// Read basic prototype data
|
|
rv = aStream->Read32(&mLineNo);
|
|
if (NS_FAILED(rv)) return rv;
|
|
uint32_t dummy;
|
|
rv = aStream->Read32(&dummy); // See bug 1418294.
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
AutoJSAPI jsapi;
|
|
if (!jsapi.Init(xpc::CompilationScope())) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
JSContext* cx = jsapi.cx();
|
|
|
|
JS::Rooted<JSScript*> newScriptObject(cx);
|
|
rv = nsContentUtils::XPConnect()->ReadScript(aStream, cx,
|
|
newScriptObject.address());
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
Set(newScriptObject);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult nsXULPrototypeScript::DeserializeOutOfLine(
|
|
nsIObjectInputStream* aInput, nsXULPrototypeDocument* aProtoDoc) {
|
|
// Keep track of failure via rv, so we can
|
|
// AbortCaching if things look bad.
|
|
nsresult rv = NS_OK;
|
|
nsXULPrototypeCache* cache = nsXULPrototypeCache::GetInstance();
|
|
|
|
nsCOMPtr<nsIObjectInputStream> objectInput = aInput;
|
|
if (cache) {
|
|
bool useXULCache = true;
|
|
if (mSrcURI) {
|
|
// NB: we must check the XUL script cache early, to avoid
|
|
// multiple deserialization attempts for a given script.
|
|
// Note that PrototypeDocumentContentSink::LoadScript
|
|
// checks the XUL script cache too, in order to handle the
|
|
// serialization case.
|
|
//
|
|
// We need do this only for <script src='strres.js'> and the
|
|
// like, i.e., out-of-line scripts that are included by several
|
|
// different XUL documents stored in the cache file.
|
|
useXULCache = cache->IsEnabled();
|
|
|
|
if (useXULCache) {
|
|
JSScript* newScriptObject = cache->GetScript(mSrcURI);
|
|
if (newScriptObject) Set(newScriptObject);
|
|
}
|
|
}
|
|
|
|
if (!mScriptObject) {
|
|
if (mSrcURI) {
|
|
rv = cache->GetInputStream(mSrcURI, getter_AddRefs(objectInput));
|
|
}
|
|
// If !mSrcURI, we have an inline script. We shouldn't have
|
|
// to do anything else in that case, I think.
|
|
|
|
// We do reflect errors into rv, but our caller may want to
|
|
// ignore our return value, because mScriptObject will be null
|
|
// after any error, and that suffices to cause the script to
|
|
// be reloaded (from the src= URI, if any) and recompiled.
|
|
// We're better off slow-loading than bailing out due to a
|
|
// error.
|
|
if (NS_SUCCEEDED(rv))
|
|
rv = Deserialize(objectInput, aProtoDoc, nullptr, nullptr);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
if (useXULCache && mSrcURI && mSrcURI->SchemeIs("chrome")) {
|
|
JS::Rooted<JSScript*> script(RootingCx(), GetScriptObject());
|
|
cache->PutScript(mSrcURI, script);
|
|
}
|
|
cache->FinishInputStream(mSrcURI);
|
|
} else {
|
|
// If mSrcURI is not in the cache,
|
|
// rv will be NS_ERROR_NOT_AVAILABLE and we'll try to
|
|
// update the cache file to hold a serialization of
|
|
// this script, once it has finished loading.
|
|
if (rv != NS_ERROR_NOT_AVAILABLE) cache->AbortCaching();
|
|
}
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
class NotifyOffThreadScriptCompletedRunnable : public Runnable {
|
|
// An array of all outstanding script receivers. All reference counting of
|
|
// these objects happens on the main thread. When we return to the main
|
|
// thread from script compilation we make sure our receiver is still in
|
|
// this array (still alive) before proceeding. This array is cleared during
|
|
// shutdown, potentially before all outstanding script compilations have
|
|
// finished. We do not need to worry about pointer replay here, because
|
|
// a) we should not be starting script compilation after clearing this
|
|
// array and b) in all other cases the receiver will still be alive.
|
|
static StaticAutoPtr<nsTArray<nsCOMPtr<nsIOffThreadScriptReceiver>>>
|
|
sReceivers;
|
|
static bool sSetupClearOnShutdown;
|
|
|
|
nsIOffThreadScriptReceiver* mReceiver;
|
|
JS::OffThreadToken* mToken;
|
|
|
|
public:
|
|
NotifyOffThreadScriptCompletedRunnable(nsIOffThreadScriptReceiver* aReceiver,
|
|
JS::OffThreadToken* aToken)
|
|
: mozilla::Runnable("NotifyOffThreadScriptCompletedRunnable"),
|
|
mReceiver(aReceiver),
|
|
mToken(aToken) {}
|
|
|
|
static void NoteReceiver(nsIOffThreadScriptReceiver* aReceiver) {
|
|
if (!sSetupClearOnShutdown) {
|
|
ClearOnShutdown(&sReceivers);
|
|
sSetupClearOnShutdown = true;
|
|
sReceivers = new nsTArray<nsCOMPtr<nsIOffThreadScriptReceiver>>();
|
|
}
|
|
|
|
// If we ever crash here, it's because we tried to lazy compile script
|
|
// too late in shutdown.
|
|
sReceivers->AppendElement(aReceiver);
|
|
}
|
|
|
|
NS_DECL_NSIRUNNABLE
|
|
};
|
|
|
|
StaticAutoPtr<nsTArray<nsCOMPtr<nsIOffThreadScriptReceiver>>>
|
|
NotifyOffThreadScriptCompletedRunnable::sReceivers;
|
|
bool NotifyOffThreadScriptCompletedRunnable::sSetupClearOnShutdown = false;
|
|
|
|
NS_IMETHODIMP
|
|
NotifyOffThreadScriptCompletedRunnable::Run() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
JS::Rooted<JSScript*> script(RootingCx());
|
|
{
|
|
AutoJSAPI jsapi;
|
|
if (!jsapi.Init(xpc::CompilationScope())) {
|
|
// Now what? I guess we just leak... this should probably never
|
|
// happen.
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
JSContext* cx = jsapi.cx();
|
|
script = JS::FinishOffThreadScript(cx, mToken);
|
|
}
|
|
|
|
if (!sReceivers) {
|
|
// We've already shut down.
|
|
return NS_OK;
|
|
}
|
|
|
|
auto index = sReceivers->IndexOf(mReceiver);
|
|
MOZ_RELEASE_ASSERT(index != sReceivers->NoIndex);
|
|
nsCOMPtr<nsIOffThreadScriptReceiver> receiver = (*sReceivers)[index].forget();
|
|
sReceivers->RemoveElementAt(index);
|
|
|
|
return receiver->OnScriptCompileComplete(script,
|
|
script ? NS_OK : NS_ERROR_FAILURE);
|
|
}
|
|
|
|
static void OffThreadScriptReceiverCallback(JS::OffThreadToken* aToken,
|
|
void* aCallbackData) {
|
|
// Be careful not to adjust the refcount on the receiver, as this callback
|
|
// may be invoked off the main thread.
|
|
nsIOffThreadScriptReceiver* aReceiver =
|
|
static_cast<nsIOffThreadScriptReceiver*>(aCallbackData);
|
|
RefPtr<NotifyOffThreadScriptCompletedRunnable> notify =
|
|
new NotifyOffThreadScriptCompletedRunnable(aReceiver, aToken);
|
|
NS_DispatchToMainThread(notify);
|
|
}
|
|
|
|
nsresult nsXULPrototypeScript::Compile(
|
|
const char16_t* aText, size_t aTextLength, JS::SourceOwnership aOwnership,
|
|
nsIURI* aURI, uint32_t aLineNo, Document* aDocument,
|
|
nsIOffThreadScriptReceiver* aOffThreadReceiver /* = nullptr */) {
|
|
// We'll compile the script in the compilation scope.
|
|
AutoJSAPI jsapi;
|
|
if (!jsapi.Init(xpc::CompilationScope())) {
|
|
if (aOwnership == JS::SourceOwnership::TakeOwnership) {
|
|
// In this early-exit case -- before the |srcBuf.init| call will
|
|
// own |aText| -- we must relinquish ownership manually.
|
|
js_free(const_cast<char16_t*>(aText));
|
|
}
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
JSContext* cx = jsapi.cx();
|
|
|
|
JS::SourceText<char16_t> srcBuf;
|
|
if (NS_WARN_IF(!srcBuf.init(cx, aText, aTextLength, aOwnership))) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsAutoCString urlspec;
|
|
nsresult rv = aURI->GetSpec(urlspec);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
// Ok, compile it to create a prototype script object!
|
|
JS::CompileOptions options(cx);
|
|
options.setIntroductionType("scriptElement")
|
|
.setFileAndLine(urlspec.get(), aLineNo);
|
|
// If the script was inline, tell the JS parser to save source for
|
|
// Function.prototype.toSource(). If it's out of line, we retrieve the
|
|
// source from the files on demand.
|
|
options.setSourceIsLazy(mOutOfLine);
|
|
JS::Rooted<JSObject*> scope(cx, JS::CurrentGlobalOrNull(cx));
|
|
|
|
if (aOffThreadReceiver && JS::CanCompileOffThread(cx, options, aTextLength)) {
|
|
if (!JS::CompileOffThread(cx, options, srcBuf,
|
|
OffThreadScriptReceiverCallback,
|
|
static_cast<void*>(aOffThreadReceiver))) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
NotifyOffThreadScriptCompletedRunnable::NoteReceiver(aOffThreadReceiver);
|
|
} else {
|
|
JS::Rooted<JSScript*> script(cx, JS::Compile(cx, options, srcBuf));
|
|
if (!script) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
Set(script);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
void nsXULPrototypeScript::UnlinkJSObjects() {
|
|
if (mScriptObject) {
|
|
mScriptObject = nullptr;
|
|
mozilla::DropJSObjects(this);
|
|
}
|
|
}
|
|
|
|
void nsXULPrototypeScript::Set(JSScript* aObject) {
|
|
MOZ_ASSERT(!mScriptObject, "Leaking script object.");
|
|
if (!aObject) {
|
|
mScriptObject = nullptr;
|
|
return;
|
|
}
|
|
|
|
mScriptObject = aObject;
|
|
mozilla::HoldJSObjects(this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
//
|
|
// nsXULPrototypeText
|
|
//
|
|
|
|
nsresult nsXULPrototypeText::Serialize(
|
|
nsIObjectOutputStream* aStream, nsXULPrototypeDocument* aProtoDoc,
|
|
const nsTArray<RefPtr<mozilla::dom::NodeInfo>>* aNodeInfos) {
|
|
nsresult rv;
|
|
|
|
// Write basic prototype data
|
|
rv = aStream->Write32(mType);
|
|
|
|
nsresult tmp = aStream->WriteWStringZ(mValue.get());
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult nsXULPrototypeText::Deserialize(
|
|
nsIObjectInputStream* aStream, nsXULPrototypeDocument* aProtoDoc,
|
|
nsIURI* aDocumentURI,
|
|
const nsTArray<RefPtr<mozilla::dom::NodeInfo>>* aNodeInfos) {
|
|
nsresult rv = aStream->ReadString(mValue);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
//
|
|
// nsXULPrototypePI
|
|
//
|
|
|
|
nsresult nsXULPrototypePI::Serialize(
|
|
nsIObjectOutputStream* aStream, nsXULPrototypeDocument* aProtoDoc,
|
|
const nsTArray<RefPtr<mozilla::dom::NodeInfo>>* aNodeInfos) {
|
|
nsresult rv;
|
|
|
|
// Write basic prototype data
|
|
rv = aStream->Write32(mType);
|
|
|
|
nsresult tmp = aStream->WriteWStringZ(mTarget.get());
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
tmp = aStream->WriteWStringZ(mData.get());
|
|
if (NS_FAILED(tmp)) {
|
|
rv = tmp;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult nsXULPrototypePI::Deserialize(
|
|
nsIObjectInputStream* aStream, nsXULPrototypeDocument* aProtoDoc,
|
|
nsIURI* aDocumentURI,
|
|
const nsTArray<RefPtr<mozilla::dom::NodeInfo>>* aNodeInfos) {
|
|
nsresult rv;
|
|
|
|
rv = aStream->ReadString(mTarget);
|
|
if (NS_FAILED(rv)) return rv;
|
|
rv = aStream->ReadString(mData);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
return rv;
|
|
}
|