nsresult
EventListenerManager::GetListenerInfo(nsCOMArray<nsIEventListenerInfo>* aList)
{
nsCOMPtr<EventTarget> target = do_QueryInterface(mTarget);
NS_ENSURE_STATE(target);
aList->Clear();
uint32_t count = mListeners.Length();
for (uint32_t i = 0; i < count; ++i) {
const Listener& listener = mListeners.ElementAt(i);
// If this is a script handler and we haven't yet
// compiled the event handler itself go ahead and compile it
if (listener.mListenerType == Listener::eJSEventListener &&
listener.mHandlerIsString) {
CompileEventHandlerInternal(const_cast<Listener*>(&listener), nullptr,
nullptr);
}
nsAutoString eventType;
if (listener.mAllEvents) {
eventType.SetIsVoid(true);
} else {
eventType.Assign(Substring(nsDependentAtomString(listener.mTypeAtom), 2));
}
// EventListenerInfo is defined in XPCOM, so we have to go ahead
// and convert to an XPCOM callback here...
nsRefPtr<EventListenerInfo> info =
new EventListenerInfo(eventType, listener.mListener.ToXPCOMCallback(),
listener.mFlags.mCapture,
listener.mFlags.mAllowUntrustedEvents,
listener.mFlags.mInSystemGroup);
aList->AppendObject(info);
}
return NS_OK;
}
void
HTMLOptionsCollection::GetSupportedNames(nsTArray<nsString>& aNames)
{
nsAutoTArray<nsIAtom*, 8> atoms;
for (uint32_t i = 0; i < mElements.Length(); ++i) {
HTMLOptionElement* content = mElements.ElementAt(i);
if (content) {
// Note: HasName means the names is exposed on the document,
// which is false for options, so we don't check it here.
const nsAttrValue* val = content->GetParsedAttr(nsGkAtoms::name);
if (val && val->Type() == nsAttrValue::eAtom) {
nsIAtom* name = val->GetAtomValue();
if (!atoms.Contains(name)) {
atoms.AppendElement(name);
}
}
if (content->HasID()) {
nsIAtom* id = content->GetID();
if (!atoms.Contains(id)) {
atoms.AppendElement(id);
}
}
}
}
aNames.SetCapacity(atoms.Length());
for (uint32_t i = 0; i < atoms.Length(); ++i) {
aNames.AppendElement(nsDependentAtomString(atoms[i]));
}
}
PRBool
test_basic()
{
for (unsigned int i = 0; i < NS_ARRAY_LENGTH(ValidStrings); ++i) {
nsDependentString str16(ValidStrings[i].m16);
nsDependentCString str8(ValidStrings[i].m8);
nsCOMPtr<nsIAtom> atom = do_GetAtom(str16);
if (!atom->Equals(str16) || !atom->EqualsUTF8(str8))
return PR_FALSE;
nsString tmp16;
nsCString tmp8;
atom->ToString(tmp16);
atom->ToUTF8String(tmp8);
if (!str16.Equals(tmp16) || !str8.Equals(tmp8))
return PR_FALSE;
if (!nsDependentString(atom->GetUTF16String()).Equals(str16))
return PR_FALSE;
if (!nsAtomString(atom).Equals(str16) ||
!nsDependentAtomString(atom).Equals(str16) ||
!nsAtomCString(atom).Equals(str8))
return PR_FALSE;
}
return PR_TRUE;
}
PRBool
nsAttrValue::Contains(nsIAtom* aValue, nsCaseTreatment aCaseSensitive) const
{
switch (BaseType()) {
case eAtomBase:
{
nsIAtom* atom = GetAtomValue();
if (aCaseSensitive == eCaseMatters) {
return aValue == atom;
}
// For performance reasons, don't do a full on unicode case insensitive
// string comparison. This is only used for quirks mode anyway.
return
nsContentUtils::EqualsIgnoreASCIICase(nsDependentAtomString(aValue),
nsDependentAtomString(atom));
}
default:
{
if (Type() == eAtomArray) {
AtomArray* array = GetAtomArrayValue();
if (aCaseSensitive == eCaseMatters) {
return array->IndexOf(aValue) != AtomArray::NoIndex;
}
nsDependentAtomString val1(aValue);
for (nsCOMPtr<nsIAtom> *cur = array->Elements(),
*end = cur + array->Length();
cur != end; ++cur) {
// For performance reasons, don't do a full on unicode case
// insensitive string comparison. This is only used for quirks mode
// anyway.
if (nsContentUtils::EqualsIgnoreASCIICase(val1,
nsDependentAtomString(*cur))) {
return PR_TRUE;
}
}
}
}
}
return PR_FALSE;
}
nsresult
nsStyleUpdatingCommand::ToggleState(nsIEditor *aEditor)
{
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NO_INTERFACE);
//create some params now...
nsresult rv;
nsCOMPtr<nsICommandParams> params =
do_CreateInstance(NS_COMMAND_PARAMS_CONTRACTID,&rv);
if (NS_FAILED(rv) || !params)
return rv;
// tags "href" and "name" are special cases in the core editor
// they are used to remove named anchor/link and shouldn't be used for insertion
bool doTagRemoval;
if (mTagName == nsGkAtoms::href || mTagName == nsGkAtoms::name) {
doTagRemoval = true;
} else {
// check current selection; set doTagRemoval if formatting should be removed
rv = GetCurrentState(aEditor, params);
NS_ENSURE_SUCCESS(rv, rv);
rv = params->GetBooleanValue(STATE_ALL, &doTagRemoval);
NS_ENSURE_SUCCESS(rv, rv);
}
if (doTagRemoval) {
// Also remove equivalent properties (bug 317093)
if (mTagName == nsGkAtoms::b) {
rv = RemoveTextProperty(htmlEditor, NS_LITERAL_STRING("strong"));
NS_ENSURE_SUCCESS(rv, rv);
} else if (mTagName == nsGkAtoms::i) {
rv = RemoveTextProperty(htmlEditor, NS_LITERAL_STRING("em"));
NS_ENSURE_SUCCESS(rv, rv);
} else if (mTagName == nsGkAtoms::strike) {
rv = RemoveTextProperty(htmlEditor, NS_LITERAL_STRING("s"));
NS_ENSURE_SUCCESS(rv, rv);
}
rv = RemoveTextProperty(htmlEditor, nsDependentAtomString(mTagName));
} else {
// Superscript and Subscript styles are mutually exclusive
aEditor->BeginTransaction();
nsDependentAtomString tagName(mTagName);
if (mTagName == nsGkAtoms::sub || mTagName == nsGkAtoms::sup) {
rv = RemoveTextProperty(htmlEditor, tagName);
}
if (NS_SUCCEEDED(rv))
rv = SetTextProperty(htmlEditor, tagName);
aEditor->EndTransaction();
}
return rv;
}
already_AddRefed<nsIContent>
TextTrackCue::ConvertInternalNodeToContent(const webvtt_node* aWebVTTNode)
{
nsIAtom* atom = nsGkAtoms::span;
nsCOMPtr<nsIContent> cueTextContent;
mDocument->CreateElem(nsDependentAtomString(atom), nullptr,
kNameSpaceID_XHTML,
getter_AddRefs(cueTextContent));
return cueTextContent.forget();
}
static bool
AttrHasSuffix(Implementor* aElement, nsIAtom* aNS, nsIAtom* aName,
nsIAtom* aStr_)
{
FakeRef<nsIAtom> aStr(aStr_);
auto match = [aStr](const nsAttrValue* aValue) {
nsAutoString str;
aValue->ToString(str);
return StringEndsWith(str, nsDependentAtomString(aStr));
};
return DoMatch(aElement, aNS, aName, match);
}
static bool
AttrIncludes(Implementor* aElement, nsIAtom* aNS, nsIAtom* aName,
nsIAtom* aStr_)
{
FakeRef<nsIAtom> aStr(aStr_);
auto match = [aStr](const nsAttrValue* aValue) {
nsAutoString str;
aValue->ToString(str);
const nsDefaultStringComparator c;
return nsStyleUtil::ValueIncludes(str, nsDependentAtomString(aStr), c);
};
return DoMatch(aElement, aNS, aName, match);
}
PLHashNumber
nsNodeInfoManager::GetNodeInfoInnerHashValue(const void *key)
{
NS_ASSERTION(key, "Null key passed to nsNodeInfo::GetHashValue!");
const nsINodeInfo::nsNodeInfoInner *node =
reinterpret_cast<const nsINodeInfo::nsNodeInfoInner *>(key);
if (node->mName) {
return HashString(nsDependentAtomString(node->mName));
}
return HashString(*(node->mNameString));
}
nsresult
HTMLImageElement::AfterSetAttr(int32_t aNameSpaceID, nsIAtom* aName,
const nsAttrValue* aValue, bool aNotify)
{
if (aNameSpaceID == kNameSpaceID_None && mForm &&
(aName == nsGkAtoms::name || aName == nsGkAtoms::id) &&
aValue && !aValue->IsEmptyString()) {
// add the image to the hashtable as needed
NS_ABORT_IF_FALSE(aValue->Type() == nsAttrValue::eAtom,
"Expected atom value for name/id");
mForm->AddImageElementToTable(this,
nsDependentAtomString(aValue->GetAtomValue()));
}
// Handle src/srcset/crossorigin updates. If aNotify is false, we are coming
// from the parser or some such place; we'll get bound after all the
// attributes have been set, so we'll do the image load from BindToTree.
if (aName == nsGkAtoms::src &&
aNameSpaceID == kNameSpaceID_None) {
// SetAttr handles setting src in the non-responsive case, so only handle it
// for responsive mode or unsetting
if (!aValue) {
CancelImageRequests(aNotify);
} else if (mResponsiveSelector) {
mResponsiveSelector->SetDefaultSource(aValue ? aValue->GetStringValue()
: EmptyString());
LoadSelectedImage(false, aNotify);
}
} else if (aName == nsGkAtoms::srcset &&
aNameSpaceID == kNameSpaceID_None &&
aNotify &&
AsContent()->IsInDoc() &&
IsSrcsetEnabled()) {
// We currently don't handle responsive mode until BindToTree
UpdateSourceSet(aValue->GetStringValue());
LoadSelectedImage(false, aNotify);
} else if (aName == nsGkAtoms::crossorigin &&
aNameSpaceID == kNameSpaceID_None &&
aNotify) {
// We want aForce == true in this LoadImage call, because we want to force
// a new load of the image with the new cross origin policy.
nsCOMPtr<nsIURI> currentURI;
if (NS_SUCCEEDED(GetCurrentURI(getter_AddRefs(currentURI))) && currentURI) {
LoadImage(currentURI, true, aNotify);
}
}
return nsGenericHTMLElement::AfterSetAttr(aNameSpaceID, aName,
aValue, aNotify);
}
// Protected Helper Functions
// --------------------------
nsISMILAttr*
nsSMILCompositor::CreateSMILAttr()
{
if (mKey.mIsCSS) {
nsCSSProperty propId =
nsCSSProps::LookupProperty(nsDependentAtomString(mKey.mAttributeName));
if (nsSMILCSSProperty::IsPropertyAnimatable(propId)) {
return new nsSMILCSSProperty(propId, mKey.mElement.get());
}
} else {
return mKey.mElement->GetAnimatedAttr(mKey.mAttributeNamespaceID,
mKey.mAttributeName);
}
return nsnull;
}
void
nsXMLProcessingInstruction::List(FILE* out, PRInt32 aIndent) const
{
PRInt32 index;
for (index = aIndent; --index >= 0; ) fputs(" ", out);
fprintf(out, "Processing instruction refcount=%d<", mRefCnt.get());
nsAutoString tmp;
ToCString(tmp, 0, mText.GetLength());
tmp.Insert(nsDependentAtomString(NodeInfo()->GetExtraName()).get(), 0);
fputs(NS_LossyConvertUTF16toASCII(tmp).get(), out);
fputs(">\n", out);
}
nsresult
HTMLImageElement::AfterSetAttr(int32_t aNameSpaceID, nsIAtom* aName,
const nsAttrValue* aValue, bool aNotify)
{
if (aNameSpaceID == kNameSpaceID_None && mForm &&
(aName == nsGkAtoms::name || aName == nsGkAtoms::id) &&
aValue && !aValue->IsEmptyString()) {
// add the image to the hashtable as needed
NS_ABORT_IF_FALSE(aValue->Type() == nsAttrValue::eAtom,
"Expected atom value for name/id");
mForm->AddImageElementToTable(this,
nsDependentAtomString(aValue->GetAtomValue()));
}
return nsGenericHTMLElement::AfterSetAttr(aNameSpaceID, aName,
aValue, aNotify);
}
/* static */
nsresult
txXPathNativeNode::getNode(const txXPathNode& aNode, nsIDOMNode** aResult)
{
if (!aNode.isAttribute()) {
return CallQueryInterface(aNode.mNode, aResult);
}
const nsAttrName* name = aNode.Content()->GetAttrNameAt(aNode.mIndex);
nsAutoString namespaceURI;
nsContentUtils::NameSpaceManager()->GetNameSpaceURI(name->NamespaceID(), namespaceURI);
nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aNode.mNode);
nsCOMPtr<nsIDOMAttr> attr;
element->GetAttributeNodeNS(namespaceURI,
nsDependentAtomString(name->LocalName()),
getter_AddRefs(attr));
return CallQueryInterface(attr, aResult);
}
void
FunctionCall::toString(nsAString& aDest)
{
nsCOMPtr<nsIAtom> functionNameAtom;
if (NS_FAILED(getNameAtom(getter_AddRefs(functionNameAtom)))) {
NS_ERROR("Can't get function name.");
return;
}
aDest.Append(nsDependentAtomString(functionNameAtom) +
NS_LITERAL_STRING("("));
for (uint32_t i = 0; i < mParams.Length(); ++i) {
if (i != 0) {
aDest.Append(PRUnichar(','));
}
mParams[i]->toString(aDest);
}
aDest.Append(PRUnichar(')'));
}
void
nsMutationReceiver::AttributeWillChange(nsIDocument* aDocument,
mozilla::dom::Element* aElement,
int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType)
{
if (nsAutoMutationBatch::IsBatching() ||
!ObservesAttr(aElement, aNameSpaceID, aAttribute) ||
aElement->ChromeOnlyAccess()) {
return;
}
nsDOMMutationRecord* m =
Observer()->CurrentRecord(NS_LITERAL_STRING("attributes"));
NS_ASSERTION(!m->mTarget || m->mTarget == aElement,
"Wrong target!");
NS_ASSERTION(m->mAttrName.IsVoid() ||
m->mAttrName.Equals(nsDependentAtomString(aAttribute)),
"Wrong attribute!");
if (!m->mTarget) {
m->mTarget = aElement;
m->mAttrName = nsAtomString(aAttribute);
if (aNameSpaceID == kNameSpaceID_None) {
m->mAttrNamespace.SetIsVoid(true);
} else {
nsContentUtils::NameSpaceManager()->GetNameSpaceURI(aNameSpaceID,
m->mAttrNamespace);
}
}
if (AttributeOldValue() && m->mPrevValue.IsVoid()) {
if (!aElement->GetAttr(aNameSpaceID, aAttribute, m->mPrevValue)) {
m->mPrevValue.SetIsVoid(true);
}
}
}
void XULPersist::AttributeChanged(dom::Element* aElement, int32_t aNameSpaceID,
nsAtom* aAttribute, int32_t aModType,
const nsAttrValue* aOldValue) {
NS_ASSERTION(aElement->OwnerDoc() == mDocument, "unexpected doc");
// Might not need this, but be safe for now.
nsCOMPtr<nsIDocumentObserver> kungFuDeathGrip(this);
// See if there is anything we need to persist in the localstore.
//
// XXX Namespace handling broken :-(
nsAutoString persist;
aElement->GetAttr(kNameSpaceID_None, nsGkAtoms::persist, persist);
// Persistence of attributes of xul:window is handled in nsXULWindow.
if (ShouldPersistAttribute(aElement, aAttribute) && !persist.IsEmpty() &&
// XXXldb This should check that it's a token, not just a substring.
persist.Find(nsDependentAtomString(aAttribute)) >= 0) {
nsContentUtils::AddScriptRunner(
NewRunnableMethod<Element*, int32_t, nsAtom*>(
"dom::XULPersist::Persist", this, &XULPersist::Persist, aElement,
kNameSpaceID_None, aAttribute));
}
}
void
HTMLPropertiesCollection::CrawlProperties()
{
nsIDocument* doc = mRoot->GetCurrentDoc();
const nsAttrValue* attr = mRoot->GetParsedAttr(nsGkAtoms::itemref);
if (attr) {
for (uint32_t i = 0; i < attr->GetAtomCount(); i++) {
nsIAtom* ref = attr->AtomAt(i);
Element* element;
if (doc) {
element = doc->GetElementById(nsDependentAtomString(ref));
} else {
element = GetElementByIdForConnectedSubtree(mRoot, ref);
}
if (element && element != mRoot) {
CrawlSubtree(element);
}
}
}
CrawlSubtree(mRoot);
}
nsresult
nsListItemCommand::ToggleState(nsIEditor *aEditor)
{
NS_ASSERTION(aEditor, "Need editor here");
nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_INITIALIZED);
bool inList;
// Need to use mTagName????
nsresult rv;
nsCOMPtr<nsICommandParams> params =
do_CreateInstance(NS_COMMAND_PARAMS_CONTRACTID,&rv);
if (NS_FAILED(rv) || !params)
return rv;
rv = GetCurrentState(aEditor, params);
rv = params->GetBooleanValue(STATE_ALL,&inList);
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_SUCCESS(rv, rv);
if (inList) {
// To remove a list, first get what kind of list we're in
bool bMixed;
nsAutoString localName;
rv = GetListState(htmlEditor, &bMixed, localName);
NS_ENSURE_SUCCESS(rv, rv);
if (localName.IsEmpty() || bMixed) {
return rv;
}
return htmlEditor->RemoveList(localName);
}
// Set to the requested paragraph type
//XXX Note: This actually doesn't work for "LI",
// but we currently don't use this for non DL lists anyway.
// Problem: won't this replace any current block paragraph style?
return htmlEditor->SetParagraphFormat(nsDependentAtomString(mTagName));
}
static nsresult
createAndAddToResult(nsIAtom* aName, const nsSubstring& aValue,
txNodeSet* aResultSet, nsIContent* aResultHolder)
{
NS_ASSERTION(aResultHolder->IsNodeOfType(nsINode::eDOCUMENT_FRAGMENT) &&
aResultHolder->GetOwnerDoc(),
"invalid result-holder");
nsIDocument* doc = aResultHolder->GetOwnerDoc();
nsCOMPtr<nsIContent> elem;
nsresult rv = doc->CreateElem(nsDependentAtomString(aName),
nsnull, kNameSpaceID_None, PR_FALSE,
getter_AddRefs(elem));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIContent> text;
rv = NS_NewTextNode(getter_AddRefs(text), doc->NodeInfoManager());
NS_ENSURE_SUCCESS(rv, rv);
rv = text->SetText(aValue, PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
rv = elem->AppendChildTo(text, PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
rv = aResultHolder->AppendChildTo(elem, PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<txXPathNode> xpathNode(
txXPathNativeNode::createXPathNode(elem, PR_TRUE));
NS_ENSURE_TRUE(xpathNode, NS_ERROR_OUT_OF_MEMORY);
aResultSet->append(*xpathNode);
return NS_OK;
}
// Protected Helper Functions
// --------------------------
nsISMILAttr*
nsSMILCompositor::CreateSMILAttr()
{
nsCSSPropertyID propID =
nsCSSProps::LookupProperty(nsDependentAtomString(mKey.mAttributeName),
CSSEnabledState::eForAllContent);
if (nsSMILCSSProperty::IsPropertyAnimatable(propID)) {
// If we are animating the 'width' or 'height' of an outer SVG
// element we should animate it as a CSS property, but for other elements
// (e.g. <rect>) we should animate it as a length attribute.
// The easiest way to test for an outer SVG element, is to see if it is an
// SVG-namespace element mapping its width/height attribute to style.
bool animateAsAttr = (mKey.mAttributeName == nsGkAtoms::width ||
mKey.mAttributeName == nsGkAtoms::height) &&
mKey.mElement->GetNameSpaceID() == kNameSpaceID_SVG &&
!mKey.mElement->IsAttributeMapped(mKey.mAttributeName);
if (!animateAsAttr) {
return new nsSMILCSSProperty(propID, mKey.mElement.get());
}
}
return mKey.mElement->GetAnimatedAttr(mKey.mAttributeNamespaceID,
mKey.mAttributeName);
}
nsresult
txUnknownHandler::startElement(nsIAtom* aPrefix, nsIAtom* aLocalName,
nsIAtom* aLowercaseLocalName, PRInt32 aNsID)
{
// Make sure that mEs->mResultHandler == this is true, otherwise we'll
// leak mEs->mResultHandler in createHandlerAndFlush and we may crash
// later on trying to delete this handler again.
NS_ASSERTION(mEs->mResultHandler == this,
"We're leaking mEs->mResultHandler.");
nsCOMPtr<nsIAtom> owner;
if (!aLowercaseLocalName) {
owner = TX_ToLowerCaseAtom(aLocalName);
NS_ENSURE_TRUE(owner, NS_ERROR_OUT_OF_MEMORY);
aLowercaseLocalName = owner;
}
PRBool htmlRoot = aNsID == kNameSpaceID_None && !aPrefix &&
aLowercaseLocalName == txHTMLAtoms::html;
// Use aLocalName and not aLowercaseLocalName in case the output
// handler cares about case. For eHTMLOutput the handler will hardcode
// to 'html' anyway.
nsresult rv = createHandlerAndFlush(htmlRoot,
nsDependentAtomString(aLocalName),
aNsID);
NS_ENSURE_SUCCESS(rv, rv);
rv = mEs->mResultHandler->startElement(aPrefix, aLocalName,
aLowercaseLocalName, aNsID);
delete this;
return rv;
}
nsresult
NS_NewXBLEventHandler(nsXBLPrototypeHandler* aHandler,
nsIAtom* aEventType,
nsXBLEventHandler** aResult)
{
switch (nsContentUtils::GetEventCategory(nsDependentAtomString(aEventType))) {
case NS_DRAG_EVENT:
case NS_MOUSE_EVENT:
case NS_MOUSE_SCROLL_EVENT:
case NS_SIMPLE_GESTURE_EVENT:
*aResult = new nsXBLMouseEventHandler(aHandler);
break;
default:
*aResult = new nsXBLEventHandler(aHandler);
break;
}
if (!*aResult)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(*aResult);
return NS_OK;
}
PRInt32
nsParserService::HTMLAtomTagToId(nsIAtom* aAtom) const
{
return nsHTMLTags::LookupTag(nsDependentAtomString(aAtom));
}
nsresult
nsXBLPrototypeHandler::ExecuteHandler(nsPIDOMEventTarget* aTarget,
nsIDOMEvent* aEvent)
{
nsresult rv = NS_ERROR_FAILURE;
// Prevent default action?
if (mType & NS_HANDLER_TYPE_PREVENTDEFAULT) {
aEvent->PreventDefault();
// If we prevent default, then it's okay for
// mHandlerElement and mHandlerText to be null
rv = NS_OK;
}
if (!mHandlerElement) // This works for both types of handlers. In both cases, the union's var should be defined.
return rv;
// See if our event receiver is a content node (and not us).
PRBool isXULKey = !!(mType & NS_HANDLER_TYPE_XUL);
PRBool isXBLCommand = !!(mType & NS_HANDLER_TYPE_XBL_COMMAND);
NS_ASSERTION(!(isXULKey && isXBLCommand),
"can't be both a key and xbl command handler");
// XUL handlers and commands shouldn't be triggered by non-trusted
// events.
if (isXULKey || isXBLCommand) {
nsCOMPtr<nsIDOMNSEvent> domNSEvent = do_QueryInterface(aEvent);
PRBool trustedEvent = PR_FALSE;
if (domNSEvent) {
domNSEvent->GetIsTrusted(&trustedEvent);
}
if (!trustedEvent)
return NS_OK;
}
if (isXBLCommand) {
return DispatchXBLCommand(aTarget, aEvent);
}
// If we're executing on a XUL key element, just dispatch a command
// event at the element. It will take care of retargeting it to its
// command element, if applicable, and executing the event handler.
if (isXULKey) {
return DispatchXULKeyCommand(aEvent);
}
// Look for a compiled handler on the element.
// Should be compiled and bound with "on" in front of the name.
nsCOMPtr<nsIAtom> onEventAtom = do_GetAtom(NS_LITERAL_STRING("onxbl") +
nsDependentAtomString(mEventName));
// Compile the event handler.
PRUint32 stID = nsIProgrammingLanguage::JAVASCRIPT;
// Compile the handler and bind it to the element.
nsCOMPtr<nsIScriptGlobalObject> boundGlobal;
nsCOMPtr<nsPIWindowRoot> winRoot(do_QueryInterface(aTarget));
nsCOMPtr<nsPIDOMWindow> window;
if (winRoot) {
window = winRoot->GetWindow();
}
if (window) {
window = window->GetCurrentInnerWindow();
NS_ENSURE_TRUE(window, NS_ERROR_UNEXPECTED);
boundGlobal = do_QueryInterface(window->GetPrivateRoot());
}
else boundGlobal = do_QueryInterface(aTarget);
if (!boundGlobal) {
nsCOMPtr<nsIDocument> boundDocument(do_QueryInterface(aTarget));
if (!boundDocument) {
// We must be an element.
nsCOMPtr<nsIContent> content(do_QueryInterface(aTarget));
if (!content)
return NS_OK;
boundDocument = content->GetOwnerDoc();
if (!boundDocument)
return NS_OK;
}
boundGlobal = boundDocument->GetScopeObject();
}
if (!boundGlobal)
return NS_OK;
nsIScriptContext *boundContext = boundGlobal->GetScriptContext(stID);
if (!boundContext)
return NS_OK;
nsScriptObjectHolder handler(boundContext);
nsISupports *scriptTarget;
if (winRoot) {
scriptTarget = boundGlobal;
} else {
scriptTarget = aTarget;
}
rv = EnsureEventHandler(boundGlobal, boundContext, onEventAtom, handler);
NS_ENSURE_SUCCESS(rv, rv);
// Temporarily bind it to the bound element
void *scope = boundGlobal->GetScriptGlobal(stID);
rv = boundContext->BindCompiledEventHandler(scriptTarget, scope,
onEventAtom, handler);
NS_ENSURE_SUCCESS(rv, rv);
// Execute it.
nsCOMPtr<nsIDOMEventListener> eventListener;
NS_NewJSEventListener(boundContext, scope,
scriptTarget, onEventAtom,
getter_AddRefs(eventListener));
// Handle the event.
eventListener->HandleEvent(aEvent);
return NS_OK;
}
void
DOMEventTargetHelper::EventListenerRemoved(nsIAtom* aType)
{
ErrorResult rv;
EventListenerWasRemoved(Substring(nsDependentAtomString(aType), 2), rv);
}
void
nsCSSSelector::AppendToStringWithoutCombinatorsOrNegations
(nsAString& aString, nsCSSStyleSheet* aSheet,
PRBool aIsNegated) const
{
nsAutoString temp;
PRBool isPseudoElement = IsPseudoElement();
// For non-pseudo-element selectors or for lone pseudo-elements, deal with
// namespace prefixes.
PRBool wroteNamespace = PR_FALSE;
if (!isPseudoElement || !mNext) {
// append the namespace prefix if needed
nsXMLNameSpaceMap *sheetNS = aSheet ? aSheet->GetNameSpaceMap() : nsnull;
// sheetNS is non-null if and only if we had an @namespace rule. If it's
// null, that means that the only namespaces we could have are the
// wildcard namespace (which can be implicit in this case) and the "none"
// namespace, which then needs to be explicitly specified.
if (!sheetNS) {
NS_ASSERTION(mNameSpace == kNameSpaceID_Unknown ||
mNameSpace == kNameSpaceID_None,
"How did we get this namespace?");
if (mNameSpace == kNameSpaceID_None) {
aString.Append(PRUnichar('|'));
wroteNamespace = PR_TRUE;
}
} else if (sheetNS->FindNameSpaceID(nsnull) == mNameSpace) {
// We have the default namespace (possibly including the wildcard
// namespace). Do nothing.
NS_ASSERTION(mNameSpace == kNameSpaceID_Unknown ||
CanBeNamespaced(aIsNegated),
"How did we end up with this namespace?");
} else if (mNameSpace == kNameSpaceID_None) {
NS_ASSERTION(CanBeNamespaced(aIsNegated),
"How did we end up with this namespace?");
aString.Append(PRUnichar('|'));
wroteNamespace = PR_TRUE;
} else if (mNameSpace != kNameSpaceID_Unknown) {
NS_ASSERTION(CanBeNamespaced(aIsNegated),
"How did we end up with this namespace?");
nsIAtom *prefixAtom = sheetNS->FindPrefix(mNameSpace);
NS_ASSERTION(prefixAtom, "how'd we get a non-default namespace "
"without a prefix?");
nsStyleUtil::AppendEscapedCSSIdent(nsDependentAtomString(prefixAtom),
aString);
aString.Append(PRUnichar('|'));
wroteNamespace = PR_TRUE;
} else {
// A selector for an element in any namespace, while the default
// namespace is something else. :not() is special in that the default
// namespace is not implied for non-type selectors, so if this is a
// negated non-type selector we don't need to output an explicit wildcard
// namespace here, since those default to a wildcard namespace.
if (CanBeNamespaced(aIsNegated)) {
aString.AppendLiteral("*|");
wroteNamespace = PR_TRUE;
}
}
}
if (!mLowercaseTag) {
// Universal selector: avoid writing the universal selector when we
// can avoid it, especially since we're required to avoid it for the
// inside of :not()
if (wroteNamespace ||
(!mIDList && !mClassList && !mPseudoClassList && !mAttrList &&
(aIsNegated || !mNegations))) {
aString.Append(PRUnichar('*'));
}
} else {
// Append the tag name
nsAutoString tag;
(isPseudoElement ? mLowercaseTag : mCasedTag)->ToString(tag);
if (isPseudoElement) {
if (!mNext) {
// Lone pseudo-element selector -- toss in a wildcard type selector
// XXXldb Why?
aString.Append(PRUnichar('*'));
}
if (!nsCSSPseudoElements::IsCSS2PseudoElement(mLowercaseTag)) {
aString.Append(PRUnichar(':'));
}
// This should not be escaped since (a) the pseudo-element string
// has a ":" that can't be escaped and (b) all pseudo-elements at
// this point are known, and therefore we know they don't need
// escaping.
aString.Append(tag);
} else {
nsStyleUtil::AppendEscapedCSSIdent(tag, aString);
}
}
// Append the id, if there is one
if (mIDList) {
nsAtomList* list = mIDList;
while (list != nsnull) {
list->mAtom->ToString(temp);
aString.Append(PRUnichar('#'));
nsStyleUtil::AppendEscapedCSSIdent(temp, aString);
list = list->mNext;
}
}
// Append each class in the linked list
if (mClassList) {
if (isPseudoElement) {
#ifdef MOZ_XUL
NS_ABORT_IF_FALSE(nsCSSAnonBoxes::IsTreePseudoElement(mLowercaseTag),
"must be tree pseudo-element");
aString.Append(PRUnichar('('));
for (nsAtomList* list = mClassList; list; list = list->mNext) {
nsStyleUtil::AppendEscapedCSSIdent(nsDependentAtomString(list->mAtom), aString);
aString.Append(PRUnichar(','));
}
// replace the final comma with a close-paren
aString.Replace(aString.Length() - 1, 1, PRUnichar(')'));
#else
NS_ERROR("Can't happen");
#endif
} else {
nsAtomList* list = mClassList;
while (list != nsnull) {
list->mAtom->ToString(temp);
aString.Append(PRUnichar('.'));
nsStyleUtil::AppendEscapedCSSIdent(temp, aString);
list = list->mNext;
}
}
}
// Append each attribute selector in the linked list
if (mAttrList) {
nsAttrSelector* list = mAttrList;
while (list != nsnull) {
aString.Append(PRUnichar('['));
// Append the namespace prefix
if (list->mNameSpace == kNameSpaceID_Unknown) {
aString.Append(PRUnichar('*'));
aString.Append(PRUnichar('|'));
} else if (list->mNameSpace != kNameSpaceID_None) {
if (aSheet) {
nsXMLNameSpaceMap *sheetNS = aSheet->GetNameSpaceMap();
nsIAtom *prefixAtom = sheetNS->FindPrefix(list->mNameSpace);
// Default namespaces don't apply to attribute selectors, so
// we must have a useful prefix.
NS_ASSERTION(prefixAtom,
"How did we end up with a namespace if the prefix "
"is unknown?");
nsAutoString prefix;
prefixAtom->ToString(prefix);
nsStyleUtil::AppendEscapedCSSIdent(prefix, aString);
aString.Append(PRUnichar('|'));
}
}
// Append the attribute name
list->mCasedAttr->ToString(temp);
nsStyleUtil::AppendEscapedCSSIdent(temp, aString);
if (list->mFunction != NS_ATTR_FUNC_SET) {
// Append the function
if (list->mFunction == NS_ATTR_FUNC_INCLUDES)
aString.Append(PRUnichar('~'));
else if (list->mFunction == NS_ATTR_FUNC_DASHMATCH)
aString.Append(PRUnichar('|'));
else if (list->mFunction == NS_ATTR_FUNC_BEGINSMATCH)
aString.Append(PRUnichar('^'));
else if (list->mFunction == NS_ATTR_FUNC_ENDSMATCH)
aString.Append(PRUnichar('$'));
else if (list->mFunction == NS_ATTR_FUNC_CONTAINSMATCH)
aString.Append(PRUnichar('*'));
aString.Append(PRUnichar('='));
// Append the value
nsStyleUtil::AppendEscapedCSSString(list->mValue, aString);
}
aString.Append(PRUnichar(']'));
list = list->mNext;
}
}
// Append each pseudo-class in the linked list
for (nsPseudoClassList* list = mPseudoClassList; list; list = list->mNext) {
nsCSSPseudoClasses::PseudoTypeToString(list->mType, temp);
// This should not be escaped since (a) the pseudo-class string
// has a ":" that can't be escaped and (b) all pseudo-classes at
// this point are known, and therefore we know they don't need
// escaping.
aString.Append(temp);
if (list->u.mMemory) {
aString.Append(PRUnichar('('));
if (nsCSSPseudoClasses::HasStringArg(list->mType)) {
nsStyleUtil::AppendEscapedCSSIdent(
nsDependentString(list->u.mString), aString);
} else if (nsCSSPseudoClasses::HasNthPairArg(list->mType)) {
PRInt32 a = list->u.mNumbers[0],
b = list->u.mNumbers[1];
temp.Truncate();
if (a != 0) {
if (a == -1) {
temp.Append(PRUnichar('-'));
} else if (a != 1) {
temp.AppendInt(a);
}
temp.Append(PRUnichar('n'));
}
if (b != 0 || a == 0) {
if (b >= 0 && a != 0) // check a != 0 for whether we printed above
temp.Append(PRUnichar('+'));
temp.AppendInt(b);
}
aString.Append(temp);
} else {
NS_ASSERTION(nsCSSPseudoClasses::HasSelectorListArg(list->mType),
"unexpected pseudo-class");
nsString tmp;
list->u.mSelectors->ToString(tmp, aSheet);
aString.Append(tmp);
}
aString.Append(PRUnichar(')'));
}
}
}
nsresult
HTMLImageElement::AfterSetAttr(int32_t aNameSpaceID, nsIAtom* aName,
const nsAttrValue* aValue, bool aNotify)
{
if (aNameSpaceID == kNameSpaceID_None && mForm &&
(aName == nsGkAtoms::name || aName == nsGkAtoms::id) &&
aValue && !aValue->IsEmptyString()) {
// add the image to the hashtable as needed
MOZ_ASSERT(aValue->Type() == nsAttrValue::eAtom,
"Expected atom value for name/id");
mForm->AddImageElementToTable(this,
nsDependentAtomString(aValue->GetAtomValue()));
}
// Handle src/srcset/crossorigin updates. If aNotify is false, we are coming
// from the parser or some such place; we'll get bound after all the
// attributes have been set, so we'll do the image load from BindToTree.
nsAttrValueOrString attrVal(aValue);
if (aName == nsGkAtoms::src &&
aNameSpaceID == kNameSpaceID_None &&
!aValue) {
// SetAttr handles setting src since it needs to catch img.src =
// img.src, so we only need to handle the unset case
if (InResponsiveMode()) {
if (mResponsiveSelector &&
mResponsiveSelector->Content() == this) {
mResponsiveSelector->SetDefaultSource(NullString());
}
QueueImageLoadTask(true);
} else {
// Bug 1076583 - We still behave synchronously in the non-responsive case
CancelImageRequests(aNotify);
}
} else if (aName == nsGkAtoms::srcset &&
aNameSpaceID == kNameSpaceID_None &&
IsSrcsetEnabled()) {
PictureSourceSrcsetChanged(this, attrVal.String(), aNotify);
} else if (aName == nsGkAtoms::sizes &&
aNameSpaceID == kNameSpaceID_None &&
HTMLPictureElement::IsPictureEnabled()) {
PictureSourceSizesChanged(this, attrVal.String(), aNotify);
} else if (aName == nsGkAtoms::crossorigin &&
aNameSpaceID == kNameSpaceID_None &&
aNotify) {
// Force a new load of the image with the new cross origin policy.
if (InResponsiveMode()) {
// per spec, full selection runs when this changes, even though
// it doesn't directly affect the source selection
QueueImageLoadTask(true);
} else {
// Bug 1076583 - We still use the older synchronous algorithm in
// non-responsive mode. Force a new load of the image with the
// new cross origin policy.
ForceReload(aNotify);
}
}
return nsGenericHTMLElement::AfterSetAttr(aNameSpaceID, aName,
aValue, aNotify);
}
