docEncoder->Init(doc, NS_LITERAL_STRING("text/html"),
docEncoder->Init(doc, contentType,
NS_INTERFACE_MAP_BEGIN(nsGenericHTMLElementTearoff)  NS_INTERFACE_MAP_ENTRY(nsIDOMNSHTMLElement)  NS_INTERFACE_MAP_ENTRY(nsIDOMElementCSSInlineStyle)NS_INTERFACE_MAP_END_AGGREGATED(mElement)static nsICSSOMFactory* gCSSOMFactory = nsnull;static NS_DEFINE_CID(kCSSOMFactoryCID, NS_CSSOMFACTORY_CID);NS_IMPL_INT_ATTR(nsGenericHTMLElement, TabIndex, tabindex)nsresultnsGenericHTMLElement::DOMQueryInterface(nsIDOMHTMLElement *aElement,                                        REFNSIID aIID, void **aInstancePtr){  nsISupports *inst = nsnull;  if (aIID.Equals(NS_GET_IID(nsIDOMNode))) {    inst = NS_STATIC_CAST(nsIDOMNode *, aElement);  } else if (aIID.Equals(NS_GET_IID(nsIDOMElement))) {    inst = NS_STATIC_CAST(nsIDOMElement *, aElement);  } else if (aIID.Equals(NS_GET_IID(nsIDOMHTMLElement))) {    inst = NS_STATIC_CAST(nsIDOMHTMLElement *, aElement);  } else if (aIID.Equals(NS_GET_IID(nsIDOMNSHTMLElement))) {    inst = NS_STATIC_CAST(nsIDOMNSHTMLElement *,                          new nsGenericHTMLElementTearoff(this));    NS_ENSURE_TRUE(inst, NS_ERROR_OUT_OF_MEMORY);  } else if (aIID.Equals(NS_GET_IID(nsIDOMElementCSSInlineStyle))) {    inst = NS_STATIC_CAST(nsIDOMElementCSSInlineStyle *,                          new nsGenericHTMLElementTearoff(this));    NS_ENSURE_TRUE(inst, NS_ERROR_OUT_OF_MEMORY);  } else {    return NS_NOINTERFACE;  }  NS_ADDREF(inst);  *aInstancePtr = inst;  return NS_OK;}/* static */ voidnsGenericHTMLElement::Shutdown(){  NS_IF_RELEASE(gCSSOMFactory);}nsresultnsGenericHTMLElement::CopyInnerTo(nsGenericElement* aDst, PRBool aDeep){  nsresult rv = NS_OK;  PRInt32 i, count = GetAttrCount();  nsCOMPtr<nsIAtom> name, prefix;  PRInt32 namespace_id;  nsAutoString value;  for (i = 0; i < count; ++i) {    rv = GetAttrNameAt(i, &namespace_id, getter_AddRefs(name),                       getter_AddRefs(prefix));    NS_ENSURE_SUCCESS(rv, rv);    if (name == nsHTMLAtoms::style && namespace_id == kNameSpaceID_None) {      // We can't just set this as a string, because that will fail      // to reparse the string into style data until the node is      // inserted into the document.  Clone the HTMLValue instead.      const nsAttrValue* styleVal =        mAttrsAndChildren.GetAttr(nsHTMLAtoms::style);      if (styleVal && styleVal->Type() == nsAttrValue::eCSSStyleRule) {        nsCOMPtr<nsICSSRule> ruleClone;        rv = styleVal->GetCSSStyleRuleValue()->          Clone(*getter_AddRefs(ruleClone));        NS_ENSURE_SUCCESS(rv, rv);        nsCOMPtr<nsICSSStyleRule> styleRule = do_QueryInterface(ruleClone);        NS_ENSURE_TRUE(styleRule, NS_ERROR_UNEXPECTED);        rv = aDst->SetInlineStyleRule(styleRule, PR_FALSE);        NS_ENSURE_SUCCESS(rv, rv);        continue;      }    }    rv = GetAttr(namespace_id, name, value);    NS_ENSURE_SUCCESS(rv, rv);    rv = aDst->SetAttr(namespace_id, name, prefix, value, PR_FALSE);    NS_ENSURE_SUCCESS(rv, rv);  }  nsIDocument *doc = nsContentUtils::GetDocument(mNodeInfo);  PRInt32 id;  if (doc) {    id = doc->GetAndIncrementContentID();  } else {    id = PR_INT32_MAX;  }  aDst->SetContentID(id);  if (aDeep) {    PRInt32 i;    PRInt32 count = mAttrsAndChildren.ChildCount();    for (i = 0; i < count; ++i) {      nsCOMPtr<nsIDOMNode> node =           do_QueryInterface(mAttrsAndChildren.ChildAt(i));      NS_ASSERTION(node, "child doesn't implement nsIDOMNode");      nsCOMPtr<nsIDOMNode> newNode;      rv = node->CloneNode(aDeep, getter_AddRefs(newNode));      NS_ENSURE_SUCCESS(rv, rv);      nsCOMPtr<nsIContent> newContent(do_QueryInterface(newNode));      NS_ASSERTION(newContent, "clone doesn't implement nsIContent");      rv = aDst->AppendChildTo(newContent, PR_FALSE);      NS_ENSURE_SUCCESS(rv, rv);    }  }  return NS_OK;}nsresultnsGenericHTMLElement::GetTagName(nsAString& aTagName){  return GetNodeName(aTagName);}NS_IMETHODIMPnsGenericHTMLElement::SetAttribute(const nsAString& aName,                                   const nsAString& aValue){  const nsAttrName* name = InternalGetExistingAttrNameFromQName(aName);  if (!name) {    nsresult rv = nsContentUtils::CheckQName(aName, PR_FALSE);    NS_ENSURE_SUCCESS(rv, rv);    nsCOMPtr<nsIAtom> nameAtom;    if (mNodeInfo->NamespaceEquals(kNameSpaceID_None)) {      nsAutoString lower;      ToLowerCase(aName, lower);      nameAtom = do_GetAtom(lower);    }    else {      nameAtom = do_GetAtom(aName);    }    NS_ENSURE_TRUE(nameAtom, NS_ERROR_OUT_OF_MEMORY);    return SetAttr(kNameSpaceID_None, nameAtom, aValue, PR_TRUE);  }  return SetAttr(name->NamespaceID(), name->LocalName(), name->GetPrefix(),                 aValue, PR_TRUE);}nsresultnsGenericHTMLElement::GetNodeName(nsAString& aNodeName){  mNodeInfo->GetQualifiedName(aNodeName);  if (mNodeInfo->NamespaceEquals(kNameSpaceID_None))    ToUpperCase(aNodeName);  return NS_OK;}nsresultnsGenericHTMLElement::GetLocalName(nsAString& aLocalName){  mNodeInfo->GetLocalName(aLocalName);  if (mNodeInfo->NamespaceEquals(kNameSpaceID_None)) {    // No namespace, this means we're dealing with a good ol' HTML    // element, so uppercase the local name.    ToUpperCase(aLocalName);  }  return NS_OK;}nsresultnsGenericHTMLElement::GetElementsByTagName(const nsAString& aTagname,                                           nsIDOMNodeList** aReturn){  nsAutoString tagName(aTagname);  // Only lowercase the name if this element has no namespace (i.e.  // it's a HTML element, not an XHTML element).  if (mNodeInfo && mNodeInfo->NamespaceEquals(kNameSpaceID_None))    ToLowerCase(tagName);  return nsGenericElement::GetElementsByTagName(tagName, aReturn);}nsresultnsGenericHTMLElement::GetElementsByTagNameNS(const nsAString& aNamespaceURI,                                             const nsAString& aLocalName,                                             nsIDOMNodeList** aReturn){  nsAutoString localName(aLocalName);  // Only lowercase the name if this element has no namespace (i.e.  // it's a HTML element, not an XHTML element).  if (mNodeInfo && mNodeInfo->NamespaceEquals(kNameSpaceID_None))    ToLowerCase(localName);  return nsGenericElement::GetElementsByTagNameNS(aNamespaceURI, localName,                                                  aReturn);}// Implementation for nsIDOMHTMLElementnsresultnsGenericHTMLElement::GetId(nsAString& aId){  GetAttr(kNameSpaceID_None, nsHTMLAtoms::id, aId);  return NS_OK;}nsresultnsGenericHTMLElement::SetId(const nsAString& aId){  SetAttr(kNameSpaceID_None, nsHTMLAtoms::id, aId, PR_TRUE);  return NS_OK;}nsresultnsGenericHTMLElement::GetTitle(nsAString& aTitle){  GetAttr(kNameSpaceID_None, nsHTMLAtoms::title, aTitle);  return NS_OK;}nsresultnsGenericHTMLElement::SetTitle(const nsAString& aTitle){  SetAttr(kNameSpaceID_None, nsHTMLAtoms::title, aTitle, PR_TRUE);  return NS_OK;}nsresultnsGenericHTMLElement::GetLang(nsAString& aLang){  GetAttr(kNameSpaceID_None, nsHTMLAtoms::lang, aLang);  return NS_OK;}nsresultnsGenericHTMLElement::SetLang(const nsAString& aLang){  SetAttr(kNameSpaceID_None, nsHTMLAtoms::lang, aLang, PR_TRUE);  return NS_OK;}static const nsAttrValue::EnumTable kDirTable[] = {  { "ltr", NS_STYLE_DIRECTION_LTR },  { "rtl", NS_STYLE_DIRECTION_RTL },  { 0 }};nsresultnsGenericHTMLElement::GetDir(nsAString& aDir){  const nsAttrValue* attr = mAttrsAndChildren.GetAttr(nsHTMLAtoms::dir);  if (attr && attr->Type() == nsAttrValue::eInteger) {    attr->ToString(aDir);  }  else {    aDir.Truncate();  }  return NS_OK;}nsresultnsGenericHTMLElement::SetDir(const nsAString& aDir){  SetAttr(kNameSpaceID_None, nsHTMLAtoms::dir, aDir, PR_TRUE);  return NS_OK;}nsresultnsGenericHTMLElement::GetClassName(nsAString& aClassName){  GetAttr(kNameSpaceID_None, nsHTMLAtoms::kClass, aClassName);  return NS_OK;}nsresultnsGenericHTMLElement::SetClassName(const nsAString& aClassName){  SetAttr(kNameSpaceID_None, nsHTMLAtoms::kClass, aClassName, PR_TRUE);  return NS_OK;}nsresultnsGenericHTMLElement::GetStyle(nsIDOMCSSStyleDeclaration** aStyle){  nsDOMSlots *slots = GetDOMSlots();  if (!slots->mStyle) {    // Just in case...    ReparseStyleAttribute();    nsresult rv;    if (!gCSSOMFactory) {      rv = CallGetService(kCSSOMFactoryCID, &gCSSOMFactory);      if (NS_FAILED(rv)) {        return rv;      }    }    rv = gCSSOMFactory->CreateDOMCSSAttributeDeclaration(this,                                                         getter_AddRefs(slots->mStyle));    if (NS_FAILED(rv)) {      return rv;    }  }  // Why bother with QI?  NS_IF_ADDREF(*aStyle = slots->mStyle);  return NS_OK;}voidnsGenericHTMLElement::RecreateFrames(){  nsIDocument* document = GetCurrentDoc();    if (!document) {    return;  }  PRInt32 numShells = document->GetNumberOfShells();  for (PRInt32 i = 0; i < numShells; ++i) {    nsIPresShell *shell = document->GetShellAt(i);    if (shell) {      nsIFrame* frame = nsnull;      shell->GetPrimaryFrameFor(this, &frame);      if (frame) {        shell->RecreateFramesFor(this);      }    }  }}static PRBoolIsBody(nsIContent *aContent){  nsINodeInfo *ni = aContent->GetNodeInfo();  return (ni && ni->Equals(nsHTMLAtoms::body) &&          aContent->IsContentOfType(nsIContent::eHTML));}static PRBoolIsOffsetParent(nsIContent *aContent){  nsINodeInfo *ni = aContent->GetNodeInfo();  return (ni && (ni->Equals(nsHTMLAtoms::td) ||                 ni->Equals(nsHTMLAtoms::table) ||                 ni->Equals(nsHTMLAtoms::th)) &&          aContent->IsContentOfType(nsIContent::eHTML));}voidnsGenericHTMLElement::GetOffsetRect(nsRect& aRect, nsIContent** aOffsetParent){  *aOffsetParent = nsnull;  aRect.x = aRect.y = 0;  aRect.Empty();  nsIDocument *document = GetCurrentDoc();  if (!document) {    return;  }  // Flush all pending notifications so that our frames are up to date.  Make  // sure to do this first thing, since it may end up destroying our document's  // presshell.  document->FlushPendingNotifications(Flush_Layout);  // Get Presentation shell 0  nsIPresShell *presShell = document->GetShellAt(0);  if (!presShell) {    return;  }  // Get the Presentation Context from the Shell  nsPresContext *context = presShell->GetPresContext();  if (!context) {    return;  }  // Get the Frame for our content  nsIFrame* frame = nsnull;  presShell->GetPrimaryFrameFor(this, &frame);  if (!frame) {    return;  }  // Get the union of all rectangles in this and continuation frames  nsRect rcFrame;  nsIFrame* next = frame;  do {    rcFrame.UnionRect(rcFrame, next->GetRect());    next = next->GetNextInFlow();  } while (next);  if (rcFrame.IsEmpty()) {    // It could happen that all the rects are empty (eg zero-width or    // zero-height).  In that case, use the first rect for the frame.    rcFrame = frame->GetRect();  }  nsIContent *docElement = document->GetRootContent();  // Find the frame parent whose content's tagName either matches  // the tagName passed in or is the document element.  nsIFrame* parent = nsnull;  PRBool done = PR_FALSE;  nsIContent* content = frame->GetContent();  if (content) {    if (IsBody(content) || content == docElement) {      done = PR_TRUE;      parent = frame;    }  }  nsPoint origin(0, 0);  if (!done) {    PRBool is_absolutely_positioned = PR_FALSE;    PRBool is_positioned = PR_FALSE;    origin = frame->GetPosition();    const nsStyleDisplay* display = frame->GetStyleDisplay();    if (display->IsPositioned()) {      if (display->IsAbsolutelyPositioned()) {        // If the primary frame or a parent is absolutely positioned        // (fixed or absolute) we stop walking up the frame parent        // chain        is_absolutely_positioned = PR_TRUE;      }      // We need to know if the primary frame is positioned later on.      is_positioned = PR_TRUE;    }    parent = frame->GetParent();    while (parent) {      display = parent->GetStyleDisplay();      if (display->IsPositioned()) {        // Stop at the first *parent* that is positioned (fixed,        // absolute, or relatiive)        *aOffsetParent = parent->GetContent();        NS_IF_ADDREF(*aOffsetParent);        break;      }      // Add the parent's origin to our own to get to the      // right coordinate system      if (!is_absolutely_positioned) {        origin += parent->GetPosition();      }      content = parent->GetContent();      if (content) {        // If we've hit the document element, break here        if (content == docElement) {          break;        }        // If the tag of this frame is a offset parent tag and this        // element is *not* positioned, break here. Also break if we        // hit the body element.        if ((!is_positioned && IsOffsetParent(content)) || IsBody(content)) {          *aOffsetParent = content;          NS_ADDREF(*aOffsetParent);          break;        }      }      parent = parent->GetParent();    }    if (is_absolutely_positioned && !*aOffsetParent) {      // If this element is absolutely positioned, but we don't have      // an offset parent it means this element is an absolutely      // positioned child that's not nested inside another positioned      // element, in this case the element's frame's parent is the      // frame for the HTML element so we fail to find the body in the      // parent chain. We want the offset parent in this case to be      // the body, so we just get the body element from the document.      nsCOMPtr<nsIDOMHTMLDocument> html_doc(do_QueryInterface(document));      if (html_doc) {        nsCOMPtr<nsIDOMHTMLElement> html_element;        html_doc->GetBody(getter_AddRefs(html_element));        if (html_element) {          CallQueryInterface(html_element, aOffsetParent);        }      }    }  }  // For the origin, add in the border for the frame#if 0  // We used to do this to include the border of the frame in the  // calculations, but I think that's wrong. My tests show that we  // work more like IE if we don't do this, so lets try this and see  // if people agree.  const nsStyleBorder* border = frame->GetStyleBorder();  origin.x += border->GetBorderWidth(NS_SIDE_LEFT);  origin.y += border->GetBorderWidth(NS_SIDE_TOP);#endif  // And subtract out the border for the parent  if (parent) {    PRBool includeBorder = PR_TRUE;  // set to false if border-box sizing is used    const nsStylePosition* position = parent->GetStylePosition();    if (position->mBoxSizing == NS_STYLE_BOX_SIZING_BORDER) {      includeBorder = PR_FALSE;    }        if (includeBorder) {      const nsStyleBorder* border = parent->GetStyleBorder();      origin.x -= border->GetBorderWidth(NS_SIDE_LEFT);      origin.y -= border->GetBorderWidth(NS_SIDE_TOP);    }  }  // XXX We should really consider subtracting out padding for  // content-box sizing, but we should see what IE does....    // Get the scale from that Presentation Context  float scale;  scale = context->TwipsToPixels();  // Convert to pixels using that scale  aRect.x = NSTwipsToIntPixels(origin.x, scale);  aRect.y = NSTwipsToIntPixels(origin.y, scale);  aRect.width = NSTwipsToIntPixels(rcFrame.width, scale);  aRect.height = NSTwipsToIntPixels(rcFrame.height, scale);}nsresultnsGenericHTMLElement::GetOffsetTop(PRInt32* aOffsetTop){  nsRect rcFrame;  nsCOMPtr<nsIContent> parent;  GetOffsetRect(rcFrame, getter_AddRefs(parent));  *aOffsetTop = rcFrame.y;  return NS_OK;}nsresultnsGenericHTMLElement::GetOffsetLeft(PRInt32* aOffsetLeft){  nsRect rcFrame;  nsCOMPtr<nsIContent> parent;  GetOffsetRect(rcFrame, getter_AddRefs(parent));  *aOffsetLeft = rcFrame.x;  return NS_OK;}nsresultnsGenericHTMLElement::GetOffsetWidth(PRInt32* aOffsetWidth){  nsRect rcFrame;  nsCOMPtr<nsIContent> parent;  GetOffsetRect(rcFrame, getter_AddRefs(parent));  *aOffsetWidth = rcFrame.width;  return NS_OK;}nsresultnsGenericHTMLElement::GetOffsetHeight(PRInt32* aOffsetHeight){  nsRect rcFrame;  nsCOMPtr<nsIContent> parent;  GetOffsetRect(rcFrame, getter_AddRefs(parent));  *aOffsetHeight = rcFrame.height;  return NS_OK;}nsresultnsGenericHTMLElement::GetOffsetParent(nsIDOMElement** aOffsetParent){  nsRect rcFrame;  nsCOMPtr<nsIContent> parent;  GetOffsetRect(rcFrame, getter_AddRefs(parent));  if (parent) {    CallQueryInterface(parent, aOffsetParent);  } else {    *aOffsetParent = nsnull;  }  return NS_OK;}nsresultnsGenericHTMLElement::GetInnerHTML(nsAString& aInnerHTML){  aInnerHTML.Truncate();  nsCOMPtr<nsIDocument> doc = GetOwnerDoc();  if (!doc) {    return NS_OK; // We rely on the document for doing HTML conversion  }  nsCOMPtr<nsIDOMNode> thisNode(do_QueryInterface(NS_STATIC_CAST(nsIContent *,                                                                 this)));  nsresult rv = NS_OK;  nsCOMPtr<nsIDocumentEncoder> docEncoder;  docEncoder = do_CreateInstance(NS_DOC_ENCODER_CONTRACTID_BASE "text/html");  NS_ENSURE_TRUE(docEncoder, NS_ERROR_FAILURE);  docEncoder->Init(doc, NS_LITERAL_STRING("text/html"),                   nsIDocumentEncoder::OutputEncodeBasicEntities |                   // Output DOM-standard newlines                   nsIDocumentEncoder::OutputLFLineBreak |                   // Don't do linebreaking that's not present in the source                   nsIDocumentEncoder::OutputRaw);  nsCOMPtr<nsIDOMRange> range(new nsRange);  NS_ENSURE_TRUE(range, NS_ERROR_OUT_OF_MEMORY);  rv = range->SelectNodeContents(thisNode);  NS_ENSURE_SUCCESS(rv, rv);  docEncoder->SetRange(range);  docEncoder->EncodeToString(aInnerHTML);  return rv;}nsresultnsGenericHTMLElement::SetInnerHTML(const nsAString& aInnerHTML){  nsresult rv = NS_OK;  nsCOMPtr<nsIDOMRange> range = new nsRange;  NS_ENSURE_TRUE(range, NS_ERROR_OUT_OF_MEMORY);  nsCOMPtr<nsIDOMNSRange> nsrange(do_QueryInterface(range, &rv));  NS_ENSURE_SUCCESS(rv, rv);  nsCOMPtr<nsIDOMNode> thisNode(do_QueryInterface(NS_STATIC_CAST(nsIContent *,                                                                 this)));  rv = range->SelectNodeContents(thisNode);  NS_ENSURE_SUCCESS(rv, rv);  rv = range->DeleteContents();  NS_ENSURE_SUCCESS(rv, rv);  nsCOMPtr<nsIDOMDocumentFragment> df;  nsCOMPtr<nsIDocument> doc = GetOwnerDoc();  nsIScriptContext *scx = nsnull;  PRBool scripts_enabled = PR_FALSE;  if (doc) {    nsIScriptGlobalObject *sgo = doc->GetScriptGlobalObject();    if (sgo) {      scx = sgo->GetContext();      if (scx) {        scripts_enabled = scx->GetScriptsEnabled();      }    }  }  if (scripts_enabled) {    // Don't let scripts execute while setting .innerHTML.    scx->SetScriptsEnabled(PR_FALSE, PR_FALSE);  }  rv = nsrange->CreateContextualFragment(aInnerHTML, getter_AddRefs(df));  if (NS_SUCCEEDED(rv)) {    nsCOMPtr<nsIDOMNode> tmpNode;    rv = thisNode->AppendChild(df, getter_AddRefs(tmpNode));  }  if (scripts_enabled) {    // If we disabled scripts, re-enable them now that we're    // done. Don't fire JS timeouts when enabling the context here.    scx->SetScriptsEnabled(PR_TRUE, PR_FALSE);  }  return rv;}voidnsGenericHTMLElement::GetScrollInfo(nsIScrollableView **aScrollableView,                                    float *aP2T, float *aT2P,                                    nsIFrame **aFrame){  *aScrollableView = nsnull;  *aP2T = 0.0f;  *aT2P = 0.0f;  nsIDocument *document = GetCurrentDoc();  if (!document) {    return;  }  // Flush all pending notifications so that our frames are up to date.  Make  // sure to do this first thing, since it may end up destroying our document's  // presshell.  document->FlushPendingNotifications(Flush_Layout);  // Get the presentation shell  nsIPresShell *presShell = document->GetShellAt(0);  if (!presShell) {    return;  }  // Get the presentation context  nsPresContext *presContext = presShell->GetPresContext();  if (!presContext) {    return;  }  // Get the primary frame for this element  nsIFrame *frame = nsnull;  presShell->GetPrimaryFrameFor(this, &frame);  if (!frame) {    return;  }  if (aFrame) {    *aFrame = frame;  }  *aP2T = presContext->PixelsToTwips();  *aT2P = presContext->TwipsToPixels();  // Get the scrollable frame  nsIScrollableFrame *scrollFrame = nsnull;  CallQueryInterface(frame, &scrollFrame);  if (!scrollFrame) {    nsIScrollableViewProvider *scrollProvider = nsnull;    CallQueryInterface(frame, &scrollProvider);    if (scrollProvider) {      *aScrollableView = scrollProvider->GetScrollableView();      if (*aScrollableView) {        return;      }    }    PRBool quirksMode = InNavQuirksMode(document);    if ((quirksMode && mNodeInfo->Equals(nsHTMLAtoms::body)) ||        (!quirksMode && mNodeInfo->Equals(nsHTMLAtoms::html))) {      // In quirks mode, the scroll info for the body element should map to the      // scroll info for the nearest scrollable frame above the body element      // (i.e. the root scrollable frame).  This is what IE6 does in quirks      // mode.  In strict mode the root scrollable frame corresponds to the      // html element in IE6, so we map the scroll info for the html element to      // the root scrollable frame.      do {        frame = frame->GetParent();        if (!frame) {          break;        }        CallQueryInterface(frame, &scrollFrame);      } while (!scrollFrame);    }    if (!scrollFrame) {      return;    }  }  // Get the scrollable view  *aScrollableView = scrollFrame->GetScrollableView();  return;}nsresultnsGenericHTMLElement::GetScrollTop(PRInt32* aScrollTop){  NS_ENSURE_ARG_POINTER(aScrollTop);  *aScrollTop = 0;  nsIScrollableView *view = nsnull;  nsresult rv = NS_OK;  float p2t, t2p;  GetScrollInfo(&view, &p2t, &t2p);  if (view) {    nscoord xPos, yPos;    rv = view->GetScrollPosition(xPos, yPos);    *aScrollTop = NSTwipsToIntPixels(yPos, t2p);  }  return rv;}nsresultnsGenericHTMLElement::SetScrollTop(PRInt32 aScrollTop){  nsIScrollableView *view = nsnull;  nsresult rv = NS_OK;  float p2t, t2p;  GetScrollInfo(&view, &p2t, &t2p);  if (view) {    nscoord xPos, yPos;    rv = view->GetScrollPosition(xPos, yPos);    if (NS_SUCCEEDED(rv)) {      rv = view->ScrollTo(xPos, NSIntPixelsToTwips(aScrollTop, p2t),                          NS_VMREFRESH_IMMEDIATE);    }  }  return rv;}nsresultnsGenericHTMLElement::GetScrollLeft(PRInt32* aScrollLeft){  NS_ENSURE_ARG_POINTER(aScrollLeft);  *aScrollLeft = 0;  nsIScrollableView *view = nsnull;  nsresult rv = NS_OK;  float p2t, t2p;  GetScrollInfo(&view, &p2t, &t2p);  if (view) {    nscoord xPos, yPos;    rv = view->GetScrollPosition(xPos, yPos);    *aScrollLeft = NSTwipsToIntPixels(xPos, t2p);  }  return rv;}nsresultnsGenericHTMLElement::SetScrollLeft(PRInt32 aScrollLeft){  nsIScrollableView *view = nsnull;  nsresult rv = NS_OK;  float p2t, t2p;  GetScrollInfo(&view, &p2t, &t2p);  if (view) {    nscoord xPos, yPos;    rv = view->GetScrollPosition(xPos, yPos);    if (NS_SUCCEEDED(rv)) {      rv = view->ScrollTo(NSIntPixelsToTwips(aScrollLeft, p2t),                          yPos, NS_VMREFRESH_IMMEDIATE);    }  }  return rv;}nsresultnsGenericHTMLElement::GetScrollHeight(PRInt32* aScrollHeight){  NS_ENSURE_ARG_POINTER(aScrollHeight);  *aScrollHeight = 0;  nsIScrollableView *scrollView = nsnull;  nsresult rv = NS_OK;  float p2t, t2p;  GetScrollInfo(&scrollView, &p2t, &t2p);  if (!scrollView) {    return GetOffsetHeight(aScrollHeight);  }  // xMax and yMax is the total length of our container  nscoord xMax, yMax;  rv = scrollView->GetContainerSize(&xMax, &yMax);  *aScrollHeight = NSTwipsToIntPixels(yMax, t2p);  return rv;}nsresultnsGenericHTMLElement::GetScrollWidth(PRInt32* aScrollWidth){  NS_ENSURE_ARG_POINTER(aScrollWidth);  *aScrollWidth = 0;  nsIScrollableView *scrollView = nsnull;  nsresult rv = NS_OK;  float p2t, t2p;  GetScrollInfo(&scrollView, &p2t, &t2p);  if (!scrollView) {    return GetOffsetWidth(aScrollWidth);  }  nscoord xMax, yMax;  rv = scrollView->GetContainerSize(&xMax, &yMax);  *aScrollWidth = NSTwipsToIntPixels(xMax, t2p);  return rv;}// staticconst nsSizensGenericHTMLElement::GetClientAreaSize(nsIFrame *aFrame){  nsRect rect = aFrame->GetRect();  const nsStyleBorder* border = aFrame->GetStyleBorder();  nsMargin border_size;  border->CalcBorderFor(aFrame, border_size);  rect.Deflate(border_size);  return nsSize(rect.width, rect.height);}nsresultnsGenericHTMLElement::GetClientHeight(PRInt32* aClientHeight){  NS_ENSURE_ARG_POINTER(aClientHeight);  *aClientHeight = 0;  nsIScrollableView *scrollView = nsnull;  float p2t, t2p;  nsIFrame *frame = nsnull;  GetScrollInfo(&scrollView, &p2t, &t2p, &frame);  if (scrollView) {    nsRect r = scrollView->View()->GetBounds();    *aClientHeight = NSTwipsToIntPixels(r.height, t2p);  } else if (frame &&             (frame->GetStyleDisplay()->mDisplay != NS_STYLE_DISPLAY_INLINE ||              (frame->GetStateBits() & NS_FRAME_REPLACED_ELEMENT))) {    // Special case code to make clientHeight work even when there isn't    // a scroll view, see bug 180552 and bug 227567.    *aClientHeight = NSTwipsToIntPixels(GetClientAreaSize(frame).height, t2p);  }  return NS_OK;}nsresultnsGenericHTMLElement::GetClientWidth(PRInt32* aClientWidth){  NS_ENSURE_ARG_POINTER(aClientWidth);  *aClientWidth = 0;  nsIScrollableView *scrollView = nsnull;  float p2t, t2p;  nsIFrame *frame = nsnull;  GetScrollInfo(&scrollView, &p2t, &t2p, &frame);  if (scrollView) {    nsRect r = scrollView->View()->GetBounds();    *aClientWidth = NSTwipsToIntPixels(r.width, t2p);  } else if (frame &&             (frame->GetStyleDisplay()->mDisplay != NS_STYLE_DISPLAY_INLINE ||              (frame->GetStateBits() & NS_FRAME_REPLACED_ELEMENT))) {    // Special case code to make clientWidth work even when there isn't    // a scroll view, see bug 180552 and bug 227567.    *aClientWidth = NSTwipsToIntPixels(GetClientAreaSize(frame).width, t2p);  }  return NS_OK;}nsresultnsGenericHTMLElement::ScrollIntoView(PRBool aTop){  nsIDocument *document = GetCurrentDoc();  if (!document) {    return NS_OK;  }  // Flush all pending notifications so that our frames are up to date.  Make  // sure to do this first thing, since it may end up destroying our document's  // presshell.  document->FlushPendingNotifications(Flush_Layout);    // Get the presentation shell  nsIPresShell *presShell = document->GetShellAt(0);  if (!presShell) {    return NS_OK;  }  // Get the primary frame for this element  nsIFrame *frame = nsnull;  presShell->GetPrimaryFrameFor(this, &frame);  if (!frame) {    return NS_OK;  }  PRIntn vpercent = aTop ? NS_PRESSHELL_SCROLL_TOP :    NS_PRESSHELL_SCROLL_ANYWHERE;  presShell->ScrollFrameIntoView(frame, vpercent,                                 NS_PRESSHELL_SCROLL_ANYWHERE);  return NS_OK;}PRBoolnsGenericHTMLElement::InNavQuirksMode(nsIDocument* aDoc){  nsCOMPtr<nsIHTMLDocument> doc(do_QueryInterface(aDoc));  if (!doc) {    return PR_FALSE;  }  return doc->GetCompatibilityMode() == eCompatibility_NavQuirks;}nsresultnsGenericHTMLElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent,                                 nsIContent* aBindingParent,                                 PRBool aCompileEventHandlers){  nsresult rv = nsGenericElement::BindToTree(aDocument, aParent,                                             aBindingParent,                                             aCompileEventHandlers);  NS_ENSURE_SUCCESS(rv, rv);  // XXXbz if we already have a style attr parsed, this won't do  // anything... need to fix that.  ReparseStyleAttribute();  if (aDocument) {    // If we're in a document now, let our mapped attrs know what their new    // sheet is.    nsHTMLStyleSheet* sheet = aDocument->GetAttributeStyleSheet();    if (sheet) {      mAttrsAndChildren.SetMappedAttrStyleSheet(sheet);    }  }  return rv;}already_AddRefed<nsIDOMHTMLFormElement>nsGenericHTMLElement::FindForm(nsIForm* aCurrentForm){  nsIContent* content = this;  while (content) {    // If the current ancestor is a form, return it as our form    if (content->IsContentOfType(nsIContent::eHTML) &&        content->GetNodeInfo()->Equals(nsHTMLAtoms::form)) {      nsIDOMHTMLFormElement* form;      CallQueryInterface(content, &form);      return form;    }    nsIContent *prevContent = content;    content = prevContent->GetParent();    if (!content && aCurrentForm) {      // We got to the root of the subtree we're in, and we're being removed      // from the DOM (the only time we get into this method with a non-null      // aCurrentForm).  Check whether aCurrentForm is in the same subtree.  If      // it is, we want to return aCurrentForm, since this case means that      // we're one of those inputs-in-a-table that have a hacked mForm pointer      // and a subtree containing both us and the form got removed from the      // DOM.      nsCOMPtr<nsIContent> formCOMPtr = do_QueryInterface(aCurrentForm);      NS_ASSERTION(formCOMPtr, "aCurrentForm isn't an nsIContent?");      // Use an nsIContent temporary to reduce addref/releasing as we go up the      // tree      nsIContent* iter = formCOMPtr;      do {        iter = iter->GetParent();        if (iter == prevContent) {          nsIDOMHTMLFormElement* form;          CallQueryInterface(aCurrentForm, &form);          return form;        }      } while (iter);    }        if (content) {      PRInt32 i = content->IndexOf(prevContent);      if (i < 0) {        // This means 'prevContent' is anonymous content, form controls in        // anonymous content can't refer to the real form, if they do        // they end up in form.elements n' such, and that's wrong...        return nsnull;      }    }  }  return nsnull;}static PRBoolIsArea(nsIContent *aContent){  nsINodeInfo *ni = aContent->GetNodeInfo();  return (ni && ni->Equals(nsHTMLAtoms::area) &&          aContent->IsContentOfType(nsIContent::eHTML));}/* static */nsresultnsGenericHTMLElement::DispatchEvent(nsPresContext* aPresContext,                                    nsEvent* aEvent,                                    nsIContent* aTarget,                                    PRBool aFullDispatch,                                    nsEventStatus* aStatus){  NS_PRECONDITION(aTarget, "Must have target");  NS_PRECONDITION(aEvent, "Must have source event");  NS_PRECONDITION(aStatus, "Null out param?");  if (!aPresContext) {    return NS_OK;  }  nsIPresShell *shell = aPresContext->GetPresShell();  if (!shell) {    return NS_OK;  }  if (aFullDispatch) {    return shell->HandleEventWithTarget(aEvent, nsnull, aTarget,                                        NS_EVENT_FLAG_INIT, aStatus);  }  return shell->HandleDOMEventWithTarget(aTarget, aEvent, aStatus);}              /* static */nsresultnsGenericHTMLElement::DispatchClickEvent(nsPresContext* aPresContext,                                         nsInputEvent* aSourceEvent,                                         nsIContent* aTarget,                                         PRBool aFullDispatch,                                         nsEventStatus* aStatus){  NS_PRECONDITION(aTarget, "Must have target");  NS_PRECONDITION(aSourceEvent, "Must have source event");  NS_PRECONDITION(aStatus, "Null out param?");  nsMouseEvent event(NS_IS_TRUSTED_EVENT(aSourceEvent), NS_MOUSE_LEFT_CLICK,                     aSourceEvent->widget, nsMouseEvent::eReal);  event.point = aSourceEvent->point;  event.refPoint = aSourceEvent->refPoint;  PRUint32 clickCount = 1;  if (aSourceEvent->eventStructType == NS_MOUSE_EVENT) {    clickCount = NS_STATIC_CAST(nsMouseEvent*, aSourceEvent)->clickCount;  }  event.clickCount = clickCount;  event.isShift = aSourceEvent->isShift;  event.isControl = aSourceEvent->isControl;  event.isAlt = aSourceEvent->isAlt;  event.isMeta = aSourceEvent->isMeta;  return DispatchEvent(aPresContext, &event, aTarget, aFullDispatch, aStatus);}nsresultnsGenericHTMLElement::HandleDOMEventForAnchors(nsPresContext* aPresContext,                                               nsEvent* aEvent,                                               nsIDOMEvent** aDOMEvent,                                               PRUint32 aFlags,                                               nsEventStatus* aEventStatus){  NS_ENSURE_ARG_POINTER(aEventStatus);  NS_PRECONDITION(nsCOMPtr<nsILink>(do_QueryInterface(this)),                  "should be called only when |this| implements |nsILink|");  // Try script event handlers first  nsresult ret = nsGenericHTMLElement::HandleDOMEvent(aPresContext, aEvent,                                                      aDOMEvent, aFlags,                                                      aEventStatus);  if (!aPresContext) {    // No pres context when event generated by other parts of DOM code,    // as in mutation events    return NS_OK;   }  //Need to check if we hit an imagemap area and if so see if we're handling  //the event on that map or on a link farther up the tree.  If we're on a  //link farther up, do nothing.  if (NS_SUCCEEDED(ret)) {    nsCOMPtr<nsIContent> target;    aPresContext->EventStateManager()->      GetEventTargetContent(aEvent, getter_AddRefs(target));    if (target && IsArea(target) && !IsArea(this)) {      // We are over an area and our element is not one.  Return without      // running anchor code.      return ret;    }  }  if (NS_FAILED(ret))    return ret;  // Ensure that this is a trusted DOM event before going further.  // XXXldb Why can aDOMEvent by null?  if (aDOMEvent && *aDOMEvent) {    nsCOMPtr<nsIDOMNSEvent> nsEvent = do_QueryInterface(*aDOMEvent);    NS_ENSURE_TRUE(nsEvent, NS_OK);    PRBool isTrusted;    ret = nsEvent->GetIsTrusted(&isTrusted);    NS_ENSURE_SUCCESS(ret, NS_OK);    if (!isTrusted)      return NS_OK;  }  if ((*aEventStatus == nsEventStatus_eIgnore ||       (*aEventStatus != nsEventStatus_eConsumeNoDefault &&        (aEvent->message == NS_MOUSE_ENTER_SYNTH ||         aEvent->message == NS_MOUSE_EXIT_SYNTH))) &&      !(aFlags & NS_EVENT_FLAG_CAPTURE) && !(aFlags & NS_EVENT_FLAG_SYSTEM_EVENT)) {    // We'll use the equivalent of |GetHrefUTF8| on the    // nsILink interface to get a canonified URL that has been    // correctly escaped and URL-encoded for the document's charset.    nsCOMPtr<nsIURI> hrefURI;    GetHrefURIForAnchors(getter_AddRefs(hrefURI));    // Only bother to handle the mouse event if there was an href    // specified.    if (hrefURI) {      switch (aEvent->message) {      case NS_MOUSE_LEFT_BUTTON_DOWN:        {          // don't make the link grab the focus if there is no link handler          nsILinkHandler *handler = aPresContext->GetLinkHandler();          nsIDocument *document = GetCurrentDoc();          if (handler && document && ShouldFocus(this)) {            // If the window is not active, do not allow the focus to bring the            // window to the front.  We update the focus controller, but do            // nothing else.            nsCOMPtr<nsPIDOMWindow> win =              do_QueryInterface(document->GetScriptGlobalObject());            if (win) {              nsIFocusController *focusController =                win->GetRootFocusController();              PRBool isActive = PR_FALSE;              focusController->GetActive(&isActive);              if (!isActive) {                nsCOMPtr<nsIDOMElement> domElement = do_QueryInterface(this);                if(domElement)                  focusController->SetFocusedElement(domElement);                break;              }            }              aPresContext->EventStateManager()->              SetContentState(this,                              NS_EVENT_STATE_ACTIVE | NS_EVENT_STATE_FOCUS);          }        }        break;      case NS_MOUSE_LEFT_CLICK:        if (nsEventStatus_eConsumeNoDefault != *aEventStatus) {          nsInputEvent* inputEvent = NS_STATIC_CAST(nsInputEvent*, aEvent);          if (inputEvent->isControl || inputEvent->isMeta ||              inputEvent->isAlt ||inputEvent->isShift) {            break;  // let the click go through so we can handle it in JS/XUL          }          // The default action is simply to dispatch DOMActivate          nsIPresShell *shell = aPresContext->GetPresShell();          if (shell) {            // single-click            nsUIEvent actEvent(NS_IS_TRUSTED_EVENT(aEvent), NS_UI_ACTIVATE, 1);            nsEventStatus status = nsEventStatus_eIgnore;            ret = shell->HandleDOMEventWithTarget(this, &actEvent, &status);            *aEventStatus = status;          }          if (*aEventStatus != nsEventStatus_eConsumeNoDefault)            *aEventStatus = nsEventStatus_eConsumeDoDefault;        }        break;      case NS_UI_ACTIVATE:        if (nsEventStatus_eConsumeNoDefault != *aEventStatus) {          nsAutoString target;          nsCOMPtr<nsIURI> baseURI = GetBaseURI();          GetAttr(kNameSpaceID_None, nsHTMLAtoms::target, target);          if (target.IsEmpty()) {            GetBaseTarget(target);          }          ret = TriggerLink(aPresContext, eLinkVerb_Replace, baseURI, hrefURI,                            target, PR_TRUE, PR_TRUE);        }        break;      case NS_KEY_PRESS:        if (aEvent->eventStructType == NS_KEY_EVENT) {          nsKeyEvent* keyEvent = NS_STATIC_CAST(nsKeyEvent*, aEvent);          if (keyEvent->keyCode == NS_VK_RETURN) {            nsEventStatus status = nsEventStatus_eIgnore;            ret = DispatchClickEvent(aPresContext, keyEvent, this, PR_FALSE, &status);            if (NS_SUCCEEDED(ret)) {              *aEventStatus = nsEventStatus_eConsumeNoDefault;            }          }        }        break;      // Set the status bar the same for focus and mouseover      case NS_MOUSE_ENTER_SYNTH:        *aEventStatus = nsEventStatus_eConsumeNoDefault;      case NS_FOCUS_CONTENT:      {        nsAutoString target;        nsCOMPtr<nsIURI> baseURI = GetBaseURI();        GetAttr(kNameSpaceID_None, nsHTMLAtoms::target, target);        if (target.IsEmpty()) {          GetBaseTarget(target);        }        ret = TriggerLink(aPresContext, eLinkVerb_Replace, baseURI,                          hrefURI, target, PR_FALSE, PR_TRUE);      }      break;      case NS_MOUSE_EXIT_SYNTH:      {        *aEventStatus = nsEventStatus_eConsumeNoDefault;        ret = LeaveLink(aPresContext);      }      break;      default:        break;      }    }  }  return ret;}nsresultnsGenericHTMLElement::GetHrefURIForAnchors(nsIURI** aURI){  // This is used by the three nsILink implementations and  // nsHTMLStyleElement.  // Get href= attribute (relative URI).  // We use the nsAttrValue's copy of the URI string to avoid copying.  const nsAttrValue* attr = mAttrsAndChildren.GetAttr(nsHTMLAtoms::href);  if (attr) {    // Get base URI.    nsCOMPtr<nsIURI> baseURI = GetBaseURI();    // Get absolute URI.    nsresult rv = nsContentUtils::NewURIWithDocumentCharset(aURI,                                                            attr->GetStringValue(),                                                            GetOwnerDoc(),                                                            baseURI);    if (NS_FAILED(rv)) {      *aURI = nsnull;    }  }  else {    // Absolute URI is null to say we have no HREF.    *aURI = nsnull;  }  return NS_OK;}nsresultnsGenericHTMLElement::SetAttr(PRInt32 aNamespaceID, nsIAtom* aAttribute,                              nsIAtom* aPrefix, const nsAString& aValue,                              PRBool aNotify){  NS_ASSERTION(aNamespaceID != kNameSpaceID_XHTML,               "Error, attribute on [X]HTML element set with XHTML namespace, "               "this is wrong, trust me! Lose the prefix on the attribute!");  nsresult rv;  nsAutoString oldValue;  PRBool hasListeners = PR_FALSE;  PRBool modification = PR_FALSE;  if (IsInDoc()) {    hasListeners = nsGenericElement::HasMutationListeners(this,      NS_EVENT_BITS_MUTATION_ATTRMODIFIED);    // If we have no listeners and aNotify is false, we are almost certainly    // coming from the content sink and will almost certainly have no previous    // value.  Even if we do, setting the value is cheap when we have no    // listeners and don't plan to notify.  The check for aNotify here is an    // optimization, the check for haveListeners is a correctness issue.    if (hasListeners || aNotify) {      // don't do any update if old == new.      // It would be nice to not have to call GetAttr here but to rather just      // grab the nsAttrValue from mAttrsAndChildren and compare that to      // aValue. However not all nsAttrValues can currently be converted to      // strings (specifically enums and nsISupports can't) so we have to take      // the detour through GetAttr for now.      rv = GetAttr(aNamespaceID, aAttribute, oldValue);      modification = rv != NS_CONTENT_ATTR_NOT_THERE;      if (modification && aValue.Equals(oldValue)) {        return NS_OK;      }    }  }  // Parse into a nsAttrValue  nsAttrValue attrValue;  if (aNamespaceID == kNameSpaceID_None) {    if (!ParseAttribute(aAttribute, aValue, attrValue)) {      attrValue.SetTo(aValue);    }    if (IsEventName(aAttribute)) {      AddScriptEventListener(aAttribute, aValue);    }  }  else {    attrValue.SetTo(aValue);  }  return SetAttrAndNotify(aNamespaceID, aAttribute, aPrefix, oldValue,                          attrValue, modification, hasListeners, aNotify);}nsresultnsGenericHTMLElement::SetAttrAndNotify(PRInt32 aNamespaceID,                                       nsIAtom* aAttribute,                                       nsIAtom* aPrefix,                                       const nsAString& aOldValue,                                       nsAttrValue& aParsedValue,                                       PRBool aModification,                                       PRBool aFireMutation,                                       PRBool aNotify){  nsresult rv;  PRUint8 modType = aModification ?    NS_STATIC_CAST(PRUint8, nsIDOMMutationEvent::MODIFICATION) :    NS_STATIC_CAST(PRUint8, nsIDOMMutationEvent::ADDITION);  nsIDocument* document = GetCurrentDoc();  mozAutoDocUpdate updateBatch(document, UPDATE_CONTENT_MODEL, aNotify);  if (aNotify && document) {    document->AttributeWillChange(this, aNamespaceID, aAttribute);  }  if (aNamespaceID == kNameSpaceID_None) {    if (IsAttributeMapped(aAttribute)) {      nsHTMLStyleSheet* sheet = document ?        document->GetAttributeStyleSheet() : nsnull;      rv = mAttrsAndChildren.SetAndTakeMappedAttr(aAttribute, aParsedValue,                                                  this, sheet);    }    else {      rv = mAttrsAndChildren.SetAndTakeAttr(aAttribute, aParsedValue);    }    NS_ENSURE_SUCCESS(rv, rv);  }  else {    nsCOMPtr<nsINodeInfo> ni;    rv = mNodeInfo->NodeInfoManager()->GetNodeInfo(aAttribute, aPrefix,                                                   aNamespaceID,                                                   getter_AddRefs(ni));    NS_ENSURE_SUCCESS(rv, rv);    rv = mAttrsAndChildren.SetAndTakeAttr(ni, aParsedValue);    NS_ENSURE_SUCCESS(rv, rv);  }  if (document) {    nsXBLBinding *binding = document->BindingManager()->GetBinding(this);    if (binding) {      binding->AttributeChanged(aAttribute, aNamespaceID, PR_FALSE, aNotify);    }    if (aFireMutation) {      nsCOMPtr<nsIDOMEventTarget> node =        do_QueryInterface(NS_STATIC_CAST(nsIContent *, this));      nsMutationEvent mutation(PR_TRUE, NS_MUTATION_ATTRMODIFIED, node);      nsAutoString attrName;      aAttribute->ToString(attrName);      nsCOMPtr<nsIDOMAttr> attrNode;      GetAttributeNode(attrName, getter_AddRefs(attrNode));      mutation.mRelatedNode = attrNode;      mutation.mAttrName = aAttribute;      nsAutoString newValue;      aParsedValue.ToString(newValue);      if (!newValue.IsEmpty()) {        mutation.mNewAttrValue = do_GetAtom(newValue);      }      if (!aOldValue.IsEmpty()) {        mutation.mPrevAttrValue = do_GetAtom(aOldValue);      }      mutation.mAttrChange = modType;      nsEventStatus status = nsEventStatus_eIgnore;      HandleDOMEvent(nsnull, &mutation, nsnull,                     NS_EVENT_FLAG_INIT, &status);    }    if (aNotify) {      document->AttributeChanged(this, aNamespaceID, aAttribute, modType);    }  }    if (aNamespaceID == kNameSpaceID_XMLEvents &&       aAttribute == nsHTMLAtoms::_event && mNodeInfo->GetDocument()) {    mNodeInfo->GetDocument()->AddXMLEventsContent(this);  }  return NS_OK;}PRBool nsGenericHTMLElement::IsEventName(nsIAtom* aName){  const char* name;  aName->GetUTF8String(&name);  if (name[0] != 'o' || name[1] != 'n') {    return PR_FALSE;  }  return (aName == nsLayoutAtoms::onclick                       ||          aName == nsLayoutAtoms::ondblclick                    ||          aName == nsLayoutAtoms::onmousedown                   ||          aName == nsLayoutAtoms::onmouseup                     ||          aName == nsLayoutAtoms::onmouseover                   ||          aName == nsLayoutAtoms::onmouseout                    ||          aName == nsLayoutAtoms::onkeydown                     ||          aName == nsLayoutAtoms::onkeyup                       ||          aName == nsLayoutAtoms::onkeypress                    ||          aName == nsLayoutAtoms::onmousemove                   ||          aName == nsLayoutAtoms::onload                        ||          aName == nsLayoutAtoms::onunload                      ||          aName == nsLayoutAtoms::onbeforeunload                ||          aName == nsLayoutAtoms::onabort                       ||          aName == nsLayoutAtoms::onerror                       ||          aName == nsLayoutAtoms::onfocus                       ||          aName == nsLayoutAtoms::onblur                        ||          aName == nsLayoutAtoms::onsubmit                      ||          aName == nsLayoutAtoms::onreset                       ||          aName == nsLayoutAtoms::onchange                      ||          aName == nsLayoutAtoms::onselect                      ||           aName == nsLayoutAtoms::onpaint                       ||          aName == nsLayoutAtoms::onresize                      ||          aName == nsLayoutAtoms::onscroll                      ||          aName == nsLayoutAtoms::oninput                       ||          aName == nsLayoutAtoms::oncontextmenu                 ||          aName == nsLayoutAtoms::onDOMAttrModified             ||          aName == nsLayoutAtoms::onDOMCharacterDataModified    ||           aName == nsLayoutAtoms::onDOMSubtreeModified          ||          aName == nsLayoutAtoms::onDOMNodeInsertedIntoDocument ||           aName == nsLayoutAtoms::onDOMNodeRemovedFromDocument  ||          aName == nsLayoutAtoms::onDOMNodeInserted             ||           aName == nsLayoutAtoms::onDOMNodeRemoved              ||          aName == nsLayoutAtoms::onDOMActivate                 ||          aName == nsLayoutAtoms::onDOMFocusIn                  ||          aName == nsLayoutAtoms::onDOMFocusOut);}nsresultnsGenericHTMLElement::UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aAttribute,                                PRBool aNotify){  // Check for event handlers  if (aNameSpaceID == kNameSpaceID_None &&      IsEventName(aAttribute)) {    nsCOMPtr<nsIEventListenerManager> manager;    GetListenerManager(getter_AddRefs(manager));    if (manager) {      manager->RemoveScriptEventListener(aAttribute);    }  }  return nsGenericElement::UnsetAttr(aNameSpaceID, aAttribute, aNotify);}nsresultnsGenericHTMLElement::GetAttr(PRInt32 aNameSpaceID, nsIAtom *aAttribute,                              nsAString& aResult) const{  NS_ASSERTION(aNameSpaceID != kNameSpaceID_Unknown,               "must have a real namespace ID!");  aResult.Truncate();  const nsAttrValue* attrValue =    mAttrsAndChildren.GetAttr(aAttribute, aNameSpaceID);  if (!attrValue) {    return NS_CONTENT_ATTR_NOT_THERE;  }  attrValue->ToString(aResult);  return NS_CONTENT_ATTR_HAS_VALUE;}const nsAttrValue*nsGenericHTMLElement::GetClasses() const{  return mAttrsAndChildren.GetAttr(nsHTMLAtoms::kClass);}nsIAtom *nsGenericHTMLElement::GetIDAttributeName() const{  return nsHTMLAtoms::id;}nsIAtom *nsGenericHTMLElement::GetClassAttributeName() const{  return nsHTMLAtoms::kClass;}NS_IMETHODIMP_(PRBool)nsGenericHTMLElement::HasClass(nsIAtom* aClass, PRBool aCaseSensitive) const{  const nsAttrValue* val = mAttrsAndChildren.GetAttr(nsHTMLAtoms::kClass);  if (val) {    if (val->Type() == nsAttrValue::eAtom) {      if (aCaseSensitive) {        return aClass == val->GetAtomValue();      }      const char *class1, *class2;      aClass->GetUTF8String(&class1);      val->GetAtomValue()->GetUTF8String(&class2);      return nsCRT::strcasecmp(class1, class2) == 0;    }    if (val->Type() == nsAttrValue::eAtomArray) {      nsCOMArray<nsIAtom>* array = val->GetAtomArrayValue();      if (aCaseSensitive) {        return array->IndexOf(aClass) >= 0;      }      const char *class1, *class2;      aClass->GetUTF8String(&class1);      PRInt32 i, count = array->Count();      for (i = 0; i < count; ++i) {        array->ObjectAt(i)->GetUTF8String(&class2);        if (nsCRT::strcasecmp(class1, class2) == 0) {          return PR_TRUE;        }      }    }  }  return PR_FALSE;}nsresultnsGenericHTMLElement::WalkContentStyleRules(nsRuleWalker* aRuleWalker){  mAttrsAndChildren.WalkMappedAttributeStyleRules(aRuleWalker);  return NS_OK;}nsICSSStyleRule*nsGenericHTMLElement::GetInlineStyleRule(){   const nsAttrValue* attrVal = mAttrsAndChildren.GetAttr(nsHTMLAtoms::style);    if (attrVal) {    if (attrVal->Type() != nsAttrValue::eCSSStyleRule) {      ReparseStyleAttribute();      attrVal = mAttrsAndChildren.GetAttr(nsHTMLAtoms::style);      // hopefully attrVal->Type() is now nsAttrValue::eCSSStyleRule    }    if (attrVal->Type() == nsAttrValue::eCSSStyleRule) {      return attrVal->GetCSSStyleRuleValue();    }  }  return nsnull;}nsresultnsGenericHTMLElement::SetInlineStyleRule(nsICSSStyleRule* aStyleRule,                                         PRBool aNotify){  PRBool hasListeners = PR_FALSE;  PRBool modification = PR_FALSE;  nsAutoString oldValueStr;  if (IsInDoc()) {    hasListeners = nsGenericElement::HasMutationListeners(this,      NS_EVENT_BITS_MUTATION_ATTRMODIFIED);    // There's no point in comparing the stylerule pointers since we're always    // getting a new stylerule here. And we can't compare the stringvalues of    // the old and the new rules since both will point to the same declaration    // and thus will be the same.    if (hasListeners) {      // save the old attribute so we can set up the mutation event properly      modification = GetAttr(kNameSpaceID_None, nsHTMLAtoms::style,                             oldValueStr) != NS_CONTENT_ATTR_NOT_THERE;    }    else if (aNotify) {      modification = !!mAttrsAndChildren.GetAttr(nsHTMLAtoms::style);    }  }  nsAttrValue attrValue(aStyleRule);  return SetAttrAndNotify(kNameSpaceID_None, nsHTMLAtoms::style, nsnull, oldValueStr,                          attrValue, modification, hasListeners, aNotify);}already_AddRefed<nsIURI>nsGenericHTMLElement::GetBaseURI() const{  nsIDocument* doc = GetOwnerDoc();  const nsAttrValue* val = mAttrsAndChildren.GetAttr(nsHTMLAtoms::_baseHref);  if (val) {    // We have a _baseHref attribute; that will determine our base URI    nsAutoString str;    val->ToString(str);    nsIURI* docBaseURL = nsnull;    if (doc) {      docBaseURL = doc->GetBaseURI();    }    nsIURI* uri = nsnull;    NS_NewURI(&uri, str, nsnull, docBaseURL);    return uri;  }  // If we are a plain old HTML element (not XHTML), don't bother asking the  // base class -- our base URI is determined solely by the document base.  if (mNodeInfo->NamespaceEquals(kNameSpaceID_None)) {    if (doc) {      nsIURI *uri = doc->GetBaseURI();      NS_IF_ADDREF(uri);      return uri;    }    return nsnull;  }  return nsGenericElement::GetBaseURI();}voidnsGenericHTMLElement::GetBaseTarget(nsAString& aBaseTarget) const{  const nsAttrValue* val = mAttrsAndChildren.GetAttr(nsHTMLAtoms::_baseTarget);  if (val) {    val->ToString(aBaseTarget);    return;  }  nsIDocument* ownerDoc = GetOwnerDoc();  if (ownerDoc) {    ownerDoc->GetBaseTarget(aBaseTarget);  } else {    aBaseTarget.Truncate();  }}#ifdef DEBUGvoidnsGenericHTMLElement::ListAttributes(FILE* out) const{  PRUint32 index, count = GetAttrCount();  for (index = 0; index < count; index++) {    // name    nsCOMPtr<nsIAtom> attr;    nsCOMPtr<nsIAtom> prefix;    PRInt32 nameSpaceID;    GetAttrNameAt(index, &nameSpaceID, getter_AddRefs(attr),                  getter_AddRefs(prefix));    nsAutoString buffer;    attr->ToString(buffer);    // value    nsAutoString value;    GetAttr(nameSpaceID, attr, value);    buffer.AppendLiteral("=\"");    for (int i = value.Length(); i >= 0; --i) {      if (value[i] == PRUnichar('"'))        value.Insert(PRUnichar('\\'), PRUint32(i));    }    buffer.Append(value);    buffer.AppendLiteral("\"");    fputs(" ", out);    fputs(NS_LossyConvertUCS2toASCII(buffer).get(), out);  }}voidnsGenericHTMLElement::List(FILE* out, PRInt32 aIndent) const{  NS_PRECONDITION(IsInDoc(), "bad content");  PRInt32 index;  for (index = aIndent; --index >= 0; ) fputs("  ", out);  nsAutoString buf;  mNodeInfo->GetQualifiedName(buf);  fputs(NS_LossyConvertUCS2toASCII(buf).get(), out);  fprintf(out, "@%p", (void*)this);  ListAttributes(out);  fprintf(out, " refcount=%d<", mRefCnt.get());  fputs("\n", out);  PRInt32 kids = GetChildCount();  for (index = 0; index < kids; index++) {    nsIContent *kid = GetChildAt(index);    kid->List(out, aIndent + 1);  }  for (index = aIndent; --index >= 0; ) fputs("  ", out);  fputs(">\n", out);}voidnsGenericHTMLElement::DumpContent(FILE* out, PRInt32 aIndent,                                  PRBool aDumpAll) const{   NS_PRECONDITION(IsInDoc(), "bad content");  PRInt32 index;  for (index = aIndent; --index >= 0; ) fputs("  ", out);  nsAutoString buf;  mNodeInfo->GetQualifiedName(buf);  fputs("<",out);  fputs(NS_LossyConvertUCS2toASCII(buf).get(), out);  if(aDumpAll) ListAttributes(out);  fputs(">",out);  if(aIndent) fputs("\n", out);  PRInt32 kids = GetChildCount();  for (index = 0; index < kids; index++) {    nsIContent *kid = GetChildAt(index);    PRInt32 indent = aIndent ? aIndent + 1 : 0;    kid->DumpContent(out, indent, aDumpAll);  }  for (index = aIndent; --index >= 0; ) fputs("  ", out);  fputs("</",out);  fputs(NS_LossyConvertUCS2toASCII(buf).get(), out);  fputs(">",out);  if(aIndent) fputs("\n", out);}#endifPRBoolnsGenericHTMLElement::IsContentOfType(PRUint32 aFlags) const{  return !(aFlags & ~(eELEMENT | eHTML));}//----------------------------------------------------------------------PRBoolnsGenericHTMLElement::ParseAttribute(nsIAtom* aAttribute,                                     const nsAString& aValue,                                     nsAttrValue& aResult){  if (aAttribute == nsHTMLAtoms::dir) {    return aResult.ParseEnumValue(aValue, kDirTable);  }  if (aAttribute == nsHTMLAtoms::style) {    ParseStyleAttribute(this, mNodeInfo->NamespaceEquals(kNameSpaceID_XHTML),                        aValue, aResult);    return PR_TRUE;  }  if (aAttribute == nsHTMLAtoms::id && !aValue.IsEmpty()) {    aResult.ParseAtom(aValue);    return PR_TRUE;  }  if (aAttribute == nsHTMLAtoms::kClass) {    aResult.ParseAtomArray(aValue);    return PR_TRUE;  }  if (aAttribute == nsHTMLAtoms::tabindex) {    return aResult.ParseIntWithBounds(aValue, -32768, 32767);  }  return PR_FALSE;}PRBoolnsGenericHTMLElement::IsAttributeMapped(const nsIAtom* aAttribute) const{  static const MappedAttributeEntry* const map[] = {    sCommonAttributeMap  };    return FindAttributeDependence(aAttribute, map, NS_ARRAY_LENGTH(map));}nsMapRuleToAttributesFuncnsGenericHTMLElement::GetAttributeMappingFunction() const{  return &MapCommonAttributesInto;}// staticnsIFrame *nsGenericHTMLElement::GetPrimaryFrameFor(nsIContent* aContent,                                         nsIDocument* aDocument,                                         PRBool aFlushContent){  if (aFlushContent) {    // Cause a flush of content, so we get up-to-date frame    // information    aDocument->FlushPendingNotifications(Flush_Frames);  }  // Get presentation shell 0  nsIPresShell *presShell = aDocument->GetShellAt(0);  nsIFrame *frame = nsnull;  if (presShell) {    presShell->GetPrimaryFrameFor(aContent, &frame);  }  return frame;}// staticnsIFormControlFrame*nsGenericHTMLElement::GetFormControlFrameFor(nsIContent* aContent,                                             nsIDocument* aDocument,                                             PRBool aFlushContent){  nsIFrame* frame = GetPrimaryFrameFor(aContent, aDocument, aFlushContent);  if (frame) {    nsIFormControlFrame* form_frame = nsnull;    CallQueryInterface(frame, &form_frame);    if (form_frame) {      return form_frame;    }    // If we have generated content, the primary frame will be a    // wrapper frame..  out real frame will be in its child list.    for (frame = frame->GetFirstChild(nsnull);         frame;         frame = frame->GetNextSibling()) {      CallQueryInterface(frame, &form_frame);      if (form_frame) {        return form_frame;      }    }            NS_ERROR("Form control has a frame, but it's not a form frame");  }  return nsnull;}/* static */ nsresultnsGenericHTMLElement::GetPrimaryPresState(nsGenericHTMLElement* aContent,                                          nsPresState** aPresState){  NS_ENSURE_ARG_POINTER(aPresState);  *aPresState = nsnull;  nsresult result = NS_OK;  nsCOMPtr<nsILayoutHistoryState> history;  nsCAutoString key;  GetLayoutHistoryAndKey(aContent, getter_AddRefs(history), key);  if (history) {    // Get the pres state for this key, if it doesn't exist, create one    result = history->GetState(key, aPresState);    if (!*aPresState) {      result = NS_NewPresState(aPresState);      if (NS_SUCCEEDED(result)) {        result = history->AddState(key, *aPresState);      }    }  }  return result;}nsresultnsGenericHTMLElement::GetLayoutHistoryAndKey(nsGenericHTMLElement* aContent,                                             nsILayoutHistoryState** aHistory,                                             nsACString& aKey){  //  // Get the pres shell  //  nsCOMPtr<nsIDocument> doc = aContent->GetDocument();  if (!doc) {    return NS_OK;  }  //  // Get the history (don't bother with the key if the history is not there)  //  *aHistory = doc->GetLayoutHistoryState().get();  if (!*aHistory) {    return NS_OK;  }  //  // Get the state key  //  nsresult rv = nsContentUtils::GenerateStateKey(aContent, doc,                                                 nsIStatefulFrame::eNoID,                                                 aKey);  if (NS_FAILED(rv)) {    NS_RELEASE(*aHistory);    return rv;  }  // If the state key is blank, this is anonymous content or for  // whatever reason we are not supposed to save/restore state.  if (aKey.IsEmpty()) {    NS_RELEASE(*aHistory);    return NS_OK;  }  // Add something unique to content so layout doesn't muck us up  aKey += "-C";  return rv;}PRBoolnsGenericHTMLElement::RestoreFormControlState(nsGenericHTMLElement* aContent,                                              nsIFormControl* aControl){  nsCOMPtr<nsILayoutHistoryState> history;  nsCAutoString key;  nsresult rv = GetLayoutHistoryAndKey(aContent, getter_AddRefs(history), key);  if (!history) {    return PR_FALSE;  }  nsPresState *state;  // Get the pres state for this key  rv = history->GetState(key, &state);  if (state) {    PRBool result = aControl->RestoreState(state);    history->RemoveState(key);    return result;  }  return PR_FALSE;}// XXX This creates a dependency between content and framesnsPresContext*nsGenericHTMLElement::GetPresContext(){  // Get the document  nsIDocument* doc = GetDocument();  if (doc) {    // Get presentation shell 0    nsIPresShell *presShell = doc->GetShellAt(0);    if (presShell) {      return presShell->GetPresContext();    }  }  return nsnull;}// XXX check all mappings against ebina's usagestatic const nsAttrValue::EnumTable kAlignTable[] = {  { "left", NS_STYLE_TEXT_ALIGN_LEFT },  { "right", NS_STYLE_TEXT_ALIGN_RIGHT },  { "texttop", NS_STYLE_VERTICAL_ALIGN_TEXT_TOP },// verified  { "baseline", NS_STYLE_VERTICAL_ALIGN_BASELINE },// verified  { "center", NS_STYLE_VERTICAL_ALIGN_MIDDLE },  { "bottom", NS_STYLE_VERTICAL_ALIGN_BASELINE },//verified  { "top", NS_STYLE_VERTICAL_ALIGN_TOP },//verified  { "middle", NS_STYLE_VERTICAL_ALIGN_MIDDLE },//verified  { "absbottom", NS_STYLE_VERTICAL_ALIGN_BOTTOM },//verified  { "abscenter", NS_STYLE_VERTICAL_ALIGN_MIDDLE },/* XXX not the same as ebina */  { "absmiddle", NS_STYLE_VERTICAL_ALIGN_MIDDLE },/* XXX ditto */  { 0 }};// Elements that should return vertical align values "middle", "bottom", and "top" //  instead of "center", "baseline", and "texttop" from GetAttribute() should use thisstatic const nsAttrValue::EnumTable kVAlignTable[] = {  { "left", NS_STYLE_TEXT_ALIGN_LEFT },  { "right", NS_STYLE_TEXT_ALIGN_RIGHT },  { "top", NS_STYLE_VERTICAL_ALIGN_TOP },//verified  { "texttop", NS_STYLE_VERTICAL_ALIGN_TEXT_TOP },// verified  { "bottom", NS_STYLE_VERTICAL_ALIGN_BASELINE },//verified  { "baseline", NS_STYLE_VERTICAL_ALIGN_BASELINE },// verified  { "middle", NS_STYLE_VERTICAL_ALIGN_MIDDLE },//verified  { "center", NS_STYLE_VERTICAL_ALIGN_MIDDLE },  { "absbottom", NS_STYLE_VERTICAL_ALIGN_BOTTOM },//verified  { "abscenter", NS_STYLE_VERTICAL_ALIGN_MIDDLE },/* XXX not the same as ebina */  { "absmiddle", NS_STYLE_VERTICAL_ALIGN_MIDDLE },/* XXX ditto */  { 0 }};static const nsAttrValue::EnumTable kDivAlignTable[] = {  { "left", NS_STYLE_TEXT_ALIGN_MOZ_LEFT },  { "right", NS_STYLE_TEXT_ALIGN_MOZ_RIGHT },  { "center", NS_STYLE_TEXT_ALIGN_MOZ_CENTER },  { "middle", NS_STYLE_TEXT_ALIGN_MOZ_CENTER },  { "justify", NS_STYLE_TEXT_ALIGN_JUSTIFY },  { 0 }};static const nsAttrValue::EnumTable kFrameborderTable[] = {  { "yes", NS_STYLE_FRAME_YES },  { "no", NS_STYLE_FRAME_NO },  { "1", NS_STYLE_FRAME_1 },  { "0", NS_STYLE_FRAME_0 },  { 0 }};static const nsAttrValue::EnumTable kScrollingTable[] = {  { "yes", NS_STYLE_FRAME_YES },  { "no", NS_STYLE_FRAME_NO },  { "on", NS_STYLE_FRAME_ON },  { "off", NS_STYLE_FRAME_OFF },  { "scroll", NS_STYLE_FRAME_SCROLL },  { "noscroll", NS_STYLE_FRAME_NOSCROLL },  { "auto", NS_STYLE_FRAME_AUTO },  { 0 }};static const nsAttrValue::EnumTable kTableVAlignTable[] = {  { "top",     NS_STYLE_VERTICAL_ALIGN_TOP },  { "middle",  NS_STYLE_VERTICAL_ALIGN_MIDDLE },  { "bottom",  NS_STYLE_VERTICAL_ALIGN_BOTTOM },  { "baseline",NS_STYLE_VERTICAL_ALIGN_BASELINE },  { 0 }};PRBoolnsGenericHTMLElement::ParseAlignValue(const nsAString& aString,                                      nsAttrValue& aResult){  return aResult.ParseEnumValue(aString, kAlignTable);}//----------------------------------------// Vanilla table as defined by the html4 spec...static const nsAttrValue::EnumTable kTableHAlignTable[] = {  { "left",   NS_STYLE_TEXT_ALIGN_LEFT },  { "right",  NS_STYLE_TEXT_ALIGN_RIGHT },  { "center", NS_STYLE_TEXT_ALIGN_CENTER },  { "char",   NS_STYLE_TEXT_ALIGN_CHAR },  { "justify",NS_STYLE_TEXT_ALIGN_JUSTIFY },  { 0 }};// This table is used for TABLE when in compatability modestatic const nsAttrValue::EnumTable kCompatTableHAlignTable[] = {  { "left",   NS_STYLE_TEXT_ALIGN_LEFT },  { "right",  NS_STYLE_TEXT_ALIGN_RIGHT },  { "center", NS_STYLE_TEXT_ALIGN_CENTER },  { "char",   NS_STYLE_TEXT_ALIGN_CHAR },  { "justify",NS_STYLE_TEXT_ALIGN_JUSTIFY },  { "abscenter", NS_STYLE_TEXT_ALIGN_CENTER },  { "absmiddle", NS_STYLE_TEXT_ALIGN_CENTER },  { "middle", NS_STYLE_TEXT_ALIGN_CENTER },  { 0 }};PRBoolnsGenericHTMLElement::ParseTableHAlignValue(const nsAString& aString,                                            nsAttrValue& aResult) const{  if (InNavQuirksMode(GetOwnerDoc())) {    return aResult.ParseEnumValue(aString, kCompatTableHAlignTable);  }  return aResult.ParseEnumValue(aString, kTableHAlignTable);}//----------------------------------------// These tables are used for TD,TH,TR, etc (but not TABLE)static const nsAttrValue::EnumTable kTableCellHAlignTable[] = {  { "left",   NS_STYLE_TEXT_ALIGN_MOZ_LEFT },  { "right",  NS_STYLE_TEXT_ALIGN_MOZ_RIGHT },  { "center", NS_STYLE_TEXT_ALIGN_MOZ_CENTER },  { "char",   NS_STYLE_TEXT_ALIGN_CHAR },  { "justify",NS_STYLE_TEXT_ALIGN_JUSTIFY },  { 0 }};static const nsAttrValue::EnumTable kCompatTableCellHAlignTable[] = {  { "left",   NS_STYLE_TEXT_ALIGN_MOZ_LEFT },  { "right",  NS_STYLE_TEXT_ALIGN_MOZ_RIGHT },  { "center", NS_STYLE_TEXT_ALIGN_MOZ_CENTER },  { "char",   NS_STYLE_TEXT_ALIGN_CHAR },  { "justify",NS_STYLE_TEXT_ALIGN_JUSTIFY },  // The following are non-standard but necessary for Nav4 compatibility  { "middle", NS_STYLE_TEXT_ALIGN_MOZ_CENTER },  // allow center and absmiddle to map to NS_STYLE_TEXT_ALIGN_CENTER and  // NS_STYLE_TEXT_ALIGN_CENTER to map to center by using the following order  { "center", NS_STYLE_TEXT_ALIGN_CENTER },  { "absmiddle", NS_STYLE_TEXT_ALIGN_CENTER },  { 0 }};PRBoolnsGenericHTMLElement::ParseTableCellHAlignValue(const nsAString& aString,                                                nsAttrValue& aResult) const{  if (InNavQuirksMode(GetOwnerDoc())) {    return aResult.ParseEnumValue(aString, kCompatTableCellHAlignTable);  }  return aResult.ParseEnumValue(aString, kTableCellHAlignTable);}//----------------------------------------PRBoolnsGenericHTMLElement::ParseTableVAlignValue(const nsAString& aString,                                            nsAttrValue& aResult){  return aResult.ParseEnumValue(aString, kTableVAlignTable);}PRBoolnsGenericHTMLElement::ParseDivAlignValue(const nsAString& aString,                                         nsAttrValue& aResult) const{  return aResult.ParseEnumValue(aString, kDivAlignTable);}PRBoolnsGenericHTMLElement::ParseImageAttribute(nsIAtom* aAttribute,                                          const nsAString& aString,                                          nsAttrValue& aResult){  if ((aAttribute == nsHTMLAtoms::width) ||      (aAttribute == nsHTMLAtoms::height)) {    return aResult.ParseSpecialIntValue(aString, PR_TRUE, PR_FALSE);  }  else if ((aAttribute == nsHTMLAtoms::hspace) ||           (aAttribute == nsHTMLAtoms::vspace) ||           (aAttribute == nsHTMLAtoms::border)) {    return aResult.ParseIntWithBounds(aString, 0);  }  return PR_FALSE;}PRBoolnsGenericHTMLElement::ParseFrameborderValue(const nsAString& aString,                                            nsAttrValue& aResult){  return aResult.ParseEnumValue(aString, kFrameborderTable);}PRBoolnsGenericHTMLElement::ParseScrollingValue(const nsAString& aString,                                          nsAttrValue& aResult){  return aResult.ParseEnumValue(aString, kScrollingTable);}nsresultnsGenericHTMLElement::ReparseStyleAttribute(){  const nsAttrValue* oldVal = mAttrsAndChildren.GetAttr(nsHTMLAtoms::style);    if (oldVal && oldVal->Type() != nsAttrValue::eCSSStyleRule) {    nsAttrValue attrValue;    nsAutoString stringValue;    oldVal->ToString(stringValue);    ParseStyleAttribute(this, mNodeInfo->NamespaceEquals(kNameSpaceID_XHTML),                        stringValue, attrValue);    // Don't bother going through SetInlineStyleRule, we don't want to fire off    // mutation events or document notifications anyway    nsresult rv = mAttrsAndChildren.SetAndTakeAttr(nsHTMLAtoms::style, attrValue);    NS_ENSURE_SUCCESS(rv, rv);  }    return NS_OK;}voidnsGenericHTMLElement::ParseStyleAttribute(nsIContent* aContent,                                          PRBool aCaseSensitive,                                          const nsAString& aValue,                                          nsAttrValue& aResult){  nsresult result = NS_OK;  NS_ASSERTION(aContent->GetNodeInfo(), "If we don't have a nodeinfo, we are very screwed");  nsIDocument* doc = aContent->GetOwnerDoc();  if (doc) {    PRBool isCSS = PR_TRUE; // assume CSS until proven otherwise    if (!aContent->IsNativeAnonymous()) {  // native anonymous content                                           // always assumes CSS      nsAutoString styleType;      doc->GetHeaderData(nsHTMLAtoms::headerContentStyleType, styleType);      if (!styleType.IsEmpty()) {        static const char textCssStr[] = "text/css";        isCSS = (styleType.EqualsIgnoreCase(textCssStr, sizeof(textCssStr) - 1));      }    }    if (isCSS) {      nsICSSLoader* cssLoader = doc->CSSLoader();      nsCOMPtr<nsICSSParser> cssParser;      result = cssLoader->GetParserFor(nsnull, getter_AddRefs(cssParser));      if (cssParser) {        nsCOMPtr<nsIURI> baseURI = aContent->GetBaseURI();        nsCOMPtr<nsICSSStyleRule> rule;        result = cssParser->ParseStyleAttribute(aValue, doc->GetDocumentURI(),                                                baseURI,                                                getter_AddRefs(rule));        cssLoader->RecycleParser(cssParser);        if (rule) {          aResult.SetTo(rule);          return;        }      }    }  }  aResult.SetTo(aValue);}/** * Handle attributes common to all html elements */voidnsGenericHTMLElement::MapCommonAttributesInto(const nsMappedAttributes* aAttributes,                                              nsRuleData* aData){  if (aData->mSID == eStyleStruct_Visibility) {    const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::lang);    if (value && value->Type() == nsAttrValue::eString) {      aData->mDisplayData->mLang.SetStringValue(value->GetStringValue(),                                                eCSSUnit_String);    }  }}/* static */ const nsGenericHTMLElement::MappedAttributeEntrynsGenericHTMLElement::sCommonAttributeMap[] = {  { &nsHTMLAtoms::lang },  { nsnull }};/* static */ const nsGenericElement::MappedAttributeEntrynsGenericHTMLElement::sImageMarginSizeAttributeMap[] = {  { &nsHTMLAtoms::width },  { &nsHTMLAtoms::height },  { &nsHTMLAtoms::hspace },  { &nsHTMLAtoms::vspace },  { nsnull }};/* static */ const nsGenericElement::MappedAttributeEntrynsGenericHTMLElement::sImageAlignAttributeMap[] = {  { &nsHTMLAtoms::align },  { nsnull }};/* static */ const nsGenericElement::MappedAttributeEntrynsGenericHTMLElement::sDivAlignAttributeMap[] = {  { &nsHTMLAtoms::align },  { nsnull }};/* static */ const nsGenericElement::MappedAttributeEntrynsGenericHTMLElement::sImageBorderAttributeMap[] = {  { &nsHTMLAtoms::border },  { nsnull }};/* static */ const nsGenericElement::MappedAttributeEntrynsGenericHTMLElement::sBackgroundAttributeMap[] = {  { &nsHTMLAtoms::background },  { &nsHTMLAtoms::bgcolor },  { nsnull }};/* static */ const nsGenericElement::MappedAttributeEntrynsGenericHTMLElement::sScrollingAttributeMap[] = {  { &nsHTMLAtoms::scrolling },  { nsnull }};voidnsGenericHTMLElement::MapImageAlignAttributeInto(const nsMappedAttributes* aAttributes,                                                 nsRuleData* aRuleData){  if (aRuleData->mSID == eStyleStruct_Display || aRuleData->mSID == eStyleStruct_TextReset) {    const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::align);    if (value && value->Type() == nsAttrValue::eEnum) {      PRInt32 align = value->GetEnumValue();      if (aRuleData->mSID == eStyleStruct_Display && aRuleData->mDisplayData->mFloat.GetUnit() == eCSSUnit_Null) {        if (align == NS_STYLE_TEXT_ALIGN_LEFT)          aRuleData->mDisplayData->mFloat.SetIntValue(NS_STYLE_FLOAT_LEFT, eCSSUnit_Enumerated);        else if (align == NS_STYLE_TEXT_ALIGN_RIGHT)          aRuleData->mDisplayData->mFloat.SetIntValue(NS_STYLE_FLOAT_RIGHT, eCSSUnit_Enumerated);      }      else if (aRuleData->mSID == eStyleStruct_TextReset && aRuleData->mTextData->mVerticalAlign.GetUnit() == eCSSUnit_Null) {        switch (align) {        case NS_STYLE_TEXT_ALIGN_LEFT:        case NS_STYLE_TEXT_ALIGN_RIGHT:          break;        default:          aRuleData->mTextData->mVerticalAlign.SetIntValue(align, eCSSUnit_Enumerated);          break;        }      }    }  }}voidnsGenericHTMLElement::MapDivAlignAttributeInto(const nsMappedAttributes* aAttributes,                                               nsRuleData* aRuleData){  if (aRuleData->mSID == eStyleStruct_Text) {    if (aRuleData->mTextData->mTextAlign.GetUnit() == eCSSUnit_Null) {      // align: enum      const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::align);      if (value && value->Type() == nsAttrValue::eEnum)        aRuleData->mTextData->mTextAlign.SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);    }  }}voidnsGenericHTMLElement::MapImageMarginAttributeInto(const nsMappedAttributes* aAttributes,                                                  nsRuleData* aData){  if (aData->mSID != eStyleStruct_Margin)    return;  const nsAttrValue* value;  // hspace: value  value = aAttributes->GetAttr(nsHTMLAtoms::hspace);  if (value) {    nsCSSValue hval;    if (value->Type() == nsAttrValue::eInteger)      hval.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);    else if (value->Type() == nsAttrValue::ePercent)      hval.SetPercentValue(value->GetPercentValue());    if (hval.GetUnit() != eCSSUnit_Null) {      nsCSSRect& margin = aData->mMarginData->mMargin;      if (margin.mLeft.GetUnit() == eCSSUnit_Null)        margin.mLeft = hval;      if (margin.mRight.GetUnit() == eCSSUnit_Null)        margin.mRight = hval;    }  }  // vspace: value  value = aAttributes->GetAttr(nsHTMLAtoms::vspace);  if (value) {    nsCSSValue vval;    if (value->Type() == nsAttrValue::eInteger)      vval.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);    else if (value->Type() == nsAttrValue::ePercent)      vval.SetPercentValue(value->GetPercentValue());      if (vval.GetUnit() != eCSSUnit_Null) {      nsCSSRect& margin = aData->mMarginData->mMargin;      if (margin.mTop.GetUnit() == eCSSUnit_Null)        margin.mTop = vval;      if (margin.mBottom.GetUnit() == eCSSUnit_Null)        margin.mBottom = vval;    }  }}voidnsGenericHTMLElement::MapImageSizeAttributesInto(const nsMappedAttributes* aAttributes,                                                 nsRuleData* aData){  if (aData->mSID != eStyleStruct_Position)    return;  // width: value  if (aData->mPositionData->mWidth.GetUnit() == eCSSUnit_Null) {    const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::width);    if (value && value->Type() == nsAttrValue::eInteger)      aData->mPositionData->mWidth.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);    else if (value && value->Type() == nsAttrValue::ePercent)      aData->mPositionData->mWidth.SetPercentValue(value->GetPercentValue());  }  // height: value  if (aData->mPositionData->mHeight.GetUnit() == eCSSUnit_Null) {    const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::height);    if (value && value->Type() == nsAttrValue::eInteger)      aData->mPositionData->mHeight.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);     else if (value && value->Type() == nsAttrValue::ePercent)      aData->mPositionData->mHeight.SetPercentValue(value->GetPercentValue());      }}voidnsGenericHTMLElement::MapImageBorderAttributeInto(const nsMappedAttributes* aAttributes,                                                  nsRuleData* aData){  if (aData->mSID != eStyleStruct_Border)    return;  // border: pixels  const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::border);  if (!value)    return;    nscoord val = 0;  if (value->Type() == nsAttrValue::eInteger)    val = value->GetIntegerValue();  nsCSSRect& borderWidth = aData->mMarginData->mBorderWidth;  if (borderWidth.mLeft.GetUnit() == eCSSUnit_Null)    borderWidth.mLeft.SetFloatValue((float)val, eCSSUnit_Pixel);  if (borderWidth.mTop.GetUnit() == eCSSUnit_Null)    borderWidth.mTop.SetFloatValue((float)val, eCSSUnit_Pixel);  if (borderWidth.mRight.GetUnit() == eCSSUnit_Null)    borderWidth.mRight.SetFloatValue((float)val, eCSSUnit_Pixel);  if (borderWidth.mBottom.GetUnit() == eCSSUnit_Null)    borderWidth.mBottom.SetFloatValue((float)val, eCSSUnit_Pixel);  nsCSSRect& borderStyle = aData->mMarginData->mBorderStyle;  if (borderStyle.mLeft.GetUnit() == eCSSUnit_Null)    borderStyle.mLeft.SetIntValue(NS_STYLE_BORDER_STYLE_SOLID, eCSSUnit_Enumerated);  if (borderStyle.mTop.GetUnit() == eCSSUnit_Null)    borderStyle.mTop.SetIntValue(NS_STYLE_BORDER_STYLE_SOLID, eCSSUnit_Enumerated);  if (borderStyle.mRight.GetUnit() == eCSSUnit_Null)    borderStyle.mRight.SetIntValue(NS_STYLE_BORDER_STYLE_SOLID, eCSSUnit_Enumerated);  if (borderStyle.mBottom.GetUnit() == eCSSUnit_Null)    borderStyle.mBottom.SetIntValue(NS_STYLE_BORDER_STYLE_SOLID, eCSSUnit_Enumerated);  nsCSSRect& borderColor = aData->mMarginData->mBorderColor;  if (borderColor.mLeft.GetUnit() == eCSSUnit_Null)    borderColor.mLeft.SetIntValue(NS_STYLE_COLOR_MOZ_USE_TEXT_COLOR, eCSSUnit_Enumerated);  if (borderColor.mTop.GetUnit() == eCSSUnit_Null)    borderColor.mTop.SetIntValue(NS_STYLE_COLOR_MOZ_USE_TEXT_COLOR, eCSSUnit_Enumerated);  if (borderColor.mRight.GetUnit() == eCSSUnit_Null)    borderColor.mRight.SetIntValue(NS_STYLE_COLOR_MOZ_USE_TEXT_COLOR, eCSSUnit_Enumerated);  if (borderColor.mBottom.GetUnit() == eCSSUnit_Null)    borderColor.mBottom.SetIntValue(NS_STYLE_COLOR_MOZ_USE_TEXT_COLOR, eCSSUnit_Enumerated);}voidnsGenericHTMLElement::MapBackgroundAttributesInto(const nsMappedAttributes* aAttributes,                                                  nsRuleData* aData){  if (aData->mSID != eStyleStruct_Background)    return;  if (aData->mColorData->mBackImage.GetUnit() == eCSSUnit_Null) {    // background    const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::background);    if (value && value->Type() == nsAttrValue::eString) {      nsAutoString spec(value->GetStringValue());      if (!spec.IsEmpty()) {        // Resolve url to an absolute url        // XXX this breaks if the HTML element has an xml:base        // attribute (the xml:base will not be taken into account)        // as well as elements with _baseHref set. We need to be able        // to get to the element somehow, or store the base URI in the        // attributes.        nsIDocument* doc = aData->mPresContext->GetDocument();        nsCOMPtr<nsIURI> uri;        nsresult rv = nsContentUtils::NewURIWithDocumentCharset(            getter_AddRefs(uri), spec, doc, doc->GetBaseURI());        if (NS_SUCCEEDED(rv)) {          nsCSSValue::Image *img =            new nsCSSValue::Image(uri, spec.get(), doc->GetDocumentURI(),                                  doc, PR_TRUE);          if (img) {            if (img->mString) {              aData->mColorData->mBackImage.SetImageValue(img);            }            else              delete img;          }        }      }      else if (aData->mPresContext->CompatibilityMode() ==               eCompatibility_NavQuirks) {        // in NavQuirks mode, allow the empty string to set the        // background to empty        aData->mColorData->mBackImage.SetNoneValue();      }    }  }  // bgcolor  if (aData->mColorData->mBackColor.GetUnit() == eCSSUnit_Null) {    const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::bgcolor);    nscolor color;    if (value && value->GetColorValue(color)) {      aData->mColorData->mBackColor.SetColorValue(color);    }  }}voidnsGenericHTMLElement::MapScrollingAttributeInto(const nsMappedAttributes* aAttributes,                                                nsRuleData* aData){  if (aData->mSID != eStyleStruct_Display)    return;  // scrolling  nsCSSValue* overflowValues[2] = {    &aData->mDisplayData->mOverflowX,    &aData->mDisplayData->mOverflowY,  };  for (PRUint32 i = 0; i < NS_ARRAY_LENGTH(overflowValues); ++i) {    if (overflowValues[i]->GetUnit() == eCSSUnit_Null) {      const nsAttrValue* value = aAttributes->GetAttr(nsHTMLAtoms::scrolling);      if (value && value->Type() == nsAttrValue::eEnum) {        PRInt32 mappedValue;        switch (value->GetEnumValue()) {          case NS_STYLE_FRAME_ON:          case NS_STYLE_FRAME_SCROLL:          case NS_STYLE_FRAME_YES:            mappedValue = NS_STYLE_OVERFLOW_SCROLL;            break;          case NS_STYLE_FRAME_OFF:          case NS_STYLE_FRAME_NOSCROLL:          case NS_STYLE_FRAME_NO:            mappedValue = NS_STYLE_OVERFLOW_HIDDEN;            break;                  case NS_STYLE_FRAME_AUTO:            mappedValue = NS_STYLE_OVERFLOW_AUTO;            break;          default:            NS_NOTREACHED("unexpected value");            mappedValue = NS_STYLE_OVERFLOW_AUTO;            break;        }        overflowValues[i]->SetIntValue(mappedValue, eCSSUnit_Enumerated);      }    }  }}//----------------------------------------------------------------------nsresultnsGenericHTMLElement::ReplaceContentsWithText(const nsAString& aText,                                              PRBool aNotify){  PRUint32 count = GetChildCount();  nsresult rv = NS_OK;  nsCOMPtr<nsIDOMText> textChild;  if (count > 0) {    // if we already have a DOMText child, reuse it.    textChild = do_QueryInterface(GetChildAt(0));    PRUint32 lastChild = textChild ? 1 : 0;    PRUint32 i = count - 1;    while (i-- > lastChild) {      RemoveChildAt(i, aNotify);    }  }  if (textChild) {    rv = textChild->SetData(aText);  } else {    nsCOMPtr<nsITextContent> text;    rv = NS_NewTextNode(getter_AddRefs(text));    NS_ENSURE_SUCCESS(rv, rv);    text->SetText(aText, PR_TRUE);    rv = InsertChildAt(text, 0, aNotify);  }            return rv;}nsresultnsGenericHTMLElement::GetAttrHelper(nsIAtom* aAttr, nsAString& aValue){  GetAttr(kNameSpaceID_None, aAttr, aValue);  return NS_OK;}nsresultnsGenericHTMLElement::SetAttrHelper(nsIAtom* aAttr, const nsAString& aValue){  return SetAttr(kNameSpaceID_None, aAttr, aValue, PR_TRUE);}nsresultnsGenericHTMLElement::GetStringAttrWithDefault(nsIAtom* aAttr,                                               const char* aDefault,                                               nsAString& aResult){  nsresult rv = GetAttr(kNameSpaceID_None, aAttr, aResult);  if (rv == NS_CONTENT_ATTR_NOT_THERE) {    CopyASCIItoUTF16(aDefault, aResult);  }  return NS_OK;}nsresultnsGenericHTMLElement::SetBoolAttr(nsIAtom* aAttr, PRBool aValue){  if (aValue) {    return SetAttr(kNameSpaceID_None, aAttr, EmptyString(), PR_TRUE);  }  return UnsetAttr(kNameSpaceID_None, aAttr, PR_TRUE);}nsresultnsGenericHTMLElement::GetBoolAttr(nsIAtom* aAttr, PRBool* aValue){  *aValue = HasAttr(kNameSpaceID_None, aAttr);  return NS_OK;}nsresultnsGenericHTMLElement::GetIntAttr(nsIAtom* aAttr, PRInt32 aDefault, PRInt32* aResult){  const nsAttrValue* attrVal = mAttrsAndChildren.GetAttr(aAttr);  if (attrVal && attrVal->Type() == nsAttrValue::eInteger) {    *aResult = attrVal->GetIntegerValue();  }  else {    *aResult = aDefault;  }  return NS_OK;}nsresultnsGenericHTMLElement::SetIntAttr(nsIAtom* aAttr, PRInt32 aValue){  nsAutoString value;  value.AppendInt(aValue);  return SetAttr(kNameSpaceID_None, aAttr, value, PR_TRUE);}nsresultnsGenericHTMLElement::GetURIAttr(nsIAtom* aAttr, nsAString& aResult){  nsAutoString attrValue;  nsresult rv = GetAttr(kNameSpaceID_None, aAttr, attrValue);  if (rv != NS_CONTENT_ATTR_HAS_VALUE) {    aResult.Truncate();    return NS_OK;  }  nsCOMPtr<nsIURI> baseURI = GetBaseURI();  nsCOMPtr<nsIURI> attrURI;  rv = nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(attrURI),                                                 attrValue, GetOwnerDoc(),                                                 baseURI);  if (NS_FAILED(rv)) {    // Just use the attr value as the result...    aResult = attrValue;    return NS_OK;  }  NS_ASSERTION(attrURI,               "nsContentUtils::NewURIWithDocumentCharset return value lied");  nsCAutoString spec;  attrURI->GetSpec(spec);  CopyUTF8toUTF16(spec, aResult);  return NS_OK;}//----------------------------------------------------------------------NS_IMPL_INT_ATTR_DEFAULT_VALUE(nsGenericHTMLFrameElement, TabIndex, tabindex, 0)nsGenericHTMLFormElement::nsGenericHTMLFormElement(nsINodeInfo *aNodeInfo)  : nsGenericHTMLElement(aNodeInfo){  mForm = nsnull;}