nsACString&
ThebesLayer::PrintInfo(nsACString& aTo, const char* aPrefix)
{
Layer::PrintInfo(aTo, aPrefix);
return mValidRegion.IsEmpty() ?
aTo : AppendToString(aTo, mValidRegion, " [valid=", "]");
}
NS_IMETHODIMP
nsXMLContentSerializer::AppendCDATASection(nsIDOMCDATASection* aCDATASection,
PRInt32 aStartOffset,
PRInt32 aEndOffset,
nsAString& aStr)
{
NS_ENSURE_ARG(aCDATASection);
nsresult rv;
AppendToString(NS_LITERAL_STRING("<![CDATA["), aStr);
rv = AppendTextData(aCDATASection, aStartOffset, aEndOffset, aStr, PR_FALSE, PR_TRUE);
if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
AppendToString(NS_LITERAL_STRING("]]>"), aStr);
return NS_OK;
}
nsACString&
ColorLayer::PrintInfo(nsACString& aTo, const char* aPrefix)
{
Layer::PrintInfo(aTo, aPrefix);
AppendToString(aTo, mColor, " [color=", "]");
return aTo;
}
void
nsHTMLContentSerializer::EndIndentation(nsIAtom* aName,
PRBool aHasDirtyAttr,
nsAString& aStr)
{
if ((aName == nsGkAtoms::head) ||
(aName == nsGkAtoms::table) ||
(aName == nsGkAtoms::tr) ||
(aName == nsGkAtoms::ul) ||
(aName == nsGkAtoms::ol) ||
(aName == nsGkAtoms::dl) ||
(aName == nsGkAtoms::li) ||
(aName == nsGkAtoms::tbody) ||
(aName == nsGkAtoms::form) ||
(aName == nsGkAtoms::blockquote) ||
(aName == nsGkAtoms::dt) ||
(aName == nsGkAtoms::dd) ||
(aName == nsGkAtoms::frameset)) {
mIndent--;
}
if ((mDoFormat || aHasDirtyAttr) && !mPreLevel && !mColPos) {
for (PRInt32 i = mIndent; --i >= 0; ) {
AppendToString(kIndentStr, aStr);
}
}
}
bool
nsXHTMLContentSerializer::AfterElementStart(nsIContent* aContent,
nsIContent* aOriginalElement,
nsAString& aStr)
{
nsIAtom *name = aContent->Tag();
if (aContent->GetNameSpaceID() == kNameSpaceID_XHTML &&
mRewriteEncodingDeclaration &&
name == nsGkAtoms::head) {
// Check if there already are any content-type meta children.
// If there are, they will be modified to use the correct charset.
// If there aren't, we'll insert one here.
bool hasMeta = false;
for (nsIContent* child = aContent->GetFirstChild();
child;
child = child->GetNextSibling()) {
if (child->IsHTML(nsGkAtoms::meta) &&
child->HasAttr(kNameSpaceID_None, nsGkAtoms::content)) {
nsAutoString header;
child->GetAttr(kNameSpaceID_None, nsGkAtoms::httpEquiv, header);
if (header.LowerCaseEqualsLiteral("content-type")) {
hasMeta = true;
break;
}
}
}
if (!hasMeta) {
NS_ENSURE_TRUE(AppendNewLineToString(aStr), false);
if (mDoFormat) {
NS_ENSURE_TRUE(AppendIndentation(aStr), false);
}
NS_ENSURE_TRUE(AppendToString(NS_LITERAL_STRING("<meta http-equiv=\"content-type\""), aStr), false);
NS_ENSURE_TRUE(AppendToString(NS_LITERAL_STRING(" content=\"text/html; charset="), aStr), false);
NS_ENSURE_TRUE(AppendToString(NS_ConvertASCIItoUTF16(mCharset), aStr), false);
if (mIsHTMLSerializer) {
NS_ENSURE_TRUE(AppendToString(NS_LITERAL_STRING("\">"), aStr), false);
} else {
NS_ENSURE_TRUE(AppendToString(NS_LITERAL_STRING("\" />"), aStr), false);
}
}
}
return true;
}
globle char *AppendStrings(
void *theEnv,
char *str1,
char *str2)
{
int pos = 0;
unsigned max = 0;
char *theString = NULL;
void *thePtr;
theString = AppendToString(theEnv,str1,theString,&pos,&max);
theString = AppendToString(theEnv,str2,theString,&pos,&max);
thePtr = EnvAddSymbol(theEnv,theString);
rm(theEnv,theString,max);
return(ValueToString(thePtr));
}
static nsACString&
PrintInfo(nsACString& aTo, LayerComposite* aLayerComposite)
{
if (!aLayerComposite) {
return aTo;
}
if (const nsIntRect* clipRect = aLayerComposite->GetShadowClipRect()) {
AppendToString(aTo, *clipRect, " [shadow-clip=", "]");
}
if (!aLayerComposite->GetShadowTransform().IsIdentity()) {
AppendToString(aTo, aLayerComposite->GetShadowTransform(), " [shadow-transform=", "]");
}
if (!aLayerComposite->GetShadowVisibleRegion().IsEmpty()) {
AppendToString(aTo, aLayerComposite->GetShadowVisibleRegion(), " [shadow-visible=", "]");
}
return aTo;
}
void
nsXHTMLContentSerializer::AfterElementStart(nsIContent * aContent,
nsIDOMElement *aOriginalElement,
nsAString& aStr)
{
nsIAtom *name = aContent->Tag();
if (aContent->GetNameSpaceID() == kNameSpaceID_XHTML &&
mRewriteEncodingDeclaration &&
name == nsGkAtoms::head) {
// Check if there already are any content-type meta children.
// If there are, they will be modified to use the correct charset.
// If there aren't, we'll insert one here.
PRBool hasMeta = PR_FALSE;
PRUint32 i, childCount = aContent->GetChildCount();
for (i = 0; i < childCount; ++i) {
nsIContent* child = aContent->GetChildAt(i);
if (child->IsHTML() &&
child->Tag() == nsGkAtoms::meta &&
child->HasAttr(kNameSpaceID_None, nsGkAtoms::content)) {
nsAutoString header;
child->GetAttr(kNameSpaceID_None, nsGkAtoms::httpEquiv, header);
if (header.LowerCaseEqualsLiteral("content-type")) {
hasMeta = PR_TRUE;
break;
}
}
}
if (!hasMeta) {
AppendNewLineToString(aStr);
if (mDoFormat) {
AppendIndentation(aStr);
}
AppendToString(NS_LITERAL_STRING("<meta http-equiv=\"content-type\""),
aStr);
AppendToString(NS_LITERAL_STRING(" content=\"text/html; charset="), aStr);
AppendToString(NS_ConvertASCIItoUTF16(mCharset), aStr);
if (mIsHTMLSerializer)
AppendToString(NS_LITERAL_STRING("\">"), aStr);
else
AppendToString(NS_LITERAL_STRING("\" />"), aStr);
}
}
}
nsACString&
RefLayer::PrintInfo(nsACString& aTo, const char* aPrefix)
{
ContainerLayer::PrintInfo(aTo, aPrefix);
if (0 != mId) {
AppendToString(aTo, mId, " [id=", "]");
}
return aTo;
}
nsACString&
ImageLayer::PrintInfo(nsACString& aTo, const char* aPrefix)
{
Layer::PrintInfo(aTo, aPrefix);
if (mFilter != gfxPattern::FILTER_GOOD) {
AppendToString(aTo, mFilter, " [filter=", "]");
}
return aTo;
}
nsACString&
CanvasLayer::PrintInfo(nsACString& aTo, const char* aPrefix)
{
Layer::PrintInfo(aTo, aPrefix);
if (mFilter != GraphicsFilter::FILTER_GOOD) {
AppendToString(aTo, mFilter, " [filter=", "]");
}
return aTo;
}
NS_IMETHODIMP
nsXMLContentSerializer::AppendElementEnd(nsIDOMElement *aElement,
nsAString& aStr)
{
NS_ENSURE_ARG(aElement);
// We don't output a separate end tag for empty element
nsCOMPtr<nsIDOMNode> node(do_QueryInterface(aElement));
PRBool hasChildren;
if (NS_SUCCEEDED(node->HasChildNodes(&hasChildren)) && !hasChildren) {
PopNameSpaceDeclsFor(aElement);
return NS_OK;
}
nsCOMPtr<nsIContent> content(do_QueryInterface(aElement));
if (!content) return NS_ERROR_FAILURE;
nsAutoString tagPrefix, tagLocalName, tagNamespaceURI;
aElement->GetPrefix(tagPrefix);
aElement->GetLocalName(tagLocalName);
aElement->GetNamespaceURI(tagNamespaceURI);
#ifdef DEBUG
PRBool debugNeedToPushNamespace =
#endif
ConfirmPrefix(tagPrefix, tagNamespaceURI, aElement, PR_FALSE);
NS_ASSERTION(!debugNeedToPushNamespace, "Can't push namespaces in closing tag!");
AppendToString(NS_LITERAL_STRING("</"), aStr);
if (!tagPrefix.IsEmpty()) {
AppendToString(tagPrefix, aStr);
AppendToString(NS_LITERAL_STRING(":"), aStr);
}
AppendToString(tagLocalName, aStr);
AppendToString(NS_LITERAL_STRING(">"), aStr);
MaybeFlagNewline(aElement);
PopNameSpaceDeclsFor(aElement);
return NS_OK;
}
static int PrintErrorCapture(
char *logicalName,
char *str)
{
if (strcmp(logicalName,WERROR) == 0)
{
ErrorString = AppendToString(str,ErrorString,
&ErrorCurrentPosition,
&ErrorMaximumPosition);
}
else if (strcmp(logicalName,WWARNING) == 0)
{
WarningString = AppendToString(str,WarningString,
&WarningCurrentPosition,
&WarningMaximumPosition);
}
return(1);
}
nsACString&
Layer::PrintInfo(nsACString& aTo, const char* aPrefix)
{
aTo += aPrefix;
aTo += nsPrintfCString(64, "%s%s (0x%p)", mManager->Name(), Name(), this);
if (mUseClipRect) {
AppendToString(aTo, mClipRect, " [clip=", "]");
}
if (!mTransform.IsIdentity())
AppendToString(aTo, mTransform, " [transform=", "]");
if (!mVisibleRegion.IsEmpty())
AppendToString(aTo, mVisibleRegion, " [visible=", "]");
if (1.0 != mOpacity)
aTo.AppendPrintf(" [opacity=%g]", mOpacity);
if (IsOpaqueContent())
aTo += " [opaqueContent]";
return aTo;
}
static int PrintErrorCapture(
void *theEnv,
char *logicalName,
char *str)
{
if (strcmp(logicalName,WERROR) == 0)
{
ParseFunctionData(theEnv)->ErrorString = AppendToString(theEnv,str,ParseFunctionData(theEnv)->ErrorString,
&ParseFunctionData(theEnv)->ErrorCurrentPosition,
&ParseFunctionData(theEnv)->ErrorMaximumPosition);
}
else if (strcmp(logicalName,WWARNING) == 0)
{
ParseFunctionData(theEnv)->WarningString = AppendToString(theEnv,str,ParseFunctionData(theEnv)->WarningString,
&ParseFunctionData(theEnv)->WarningCurrentPosition,
&ParseFunctionData(theEnv)->WarningMaximumPosition);
}
return(1);
}
void
ContentHostTexture::PrintInfo(std::stringstream& aStream, const char* aPrefix)
{
aStream << aPrefix;
aStream << nsPrintfCString("ContentHost (0x%p)", this).get();
AppendToString(aStream, mBufferRect, " [buffer-rect=", "]");
AppendToString(aStream, mBufferRotation, " [buffer-rotation=", "]");
if (PaintWillResample()) {
aStream << " [paint-will-resample]";
}
if (mTextureHost) {
nsAutoCString pfx(aPrefix);
pfx += " ";
aStream << "\n";
mTextureHost->PrintInfo(aStream, pfx.get());
}
}
void
DeprecatedContentHostSingleBuffered::PrintInfo(nsACString& aTo, const char* aPrefix)
{
aTo += aPrefix;
aTo += nsPrintfCString("DeprecatedContentHostSingleBuffered (0x%p)", this);
AppendToString(aTo, mBufferRect, " [buffer-rect=", "]");
AppendToString(aTo, mBufferRotation, " [buffer-rotation=", "]");
if (PaintWillResample()) {
aTo += " [paint-will-resample]";
}
nsAutoCString pfx(aPrefix);
pfx += " ";
if (mDeprecatedTextureHost) {
aTo += "\n";
mDeprecatedTextureHost->PrintInfo(aTo, pfx.get());
}
}
void
nsXHTMLContentSerializer::AppendEndOfElementStart(nsIContent *aOriginalElement,
nsIAtom * aName,
PRInt32 aNamespaceID,
nsAString& aStr)
{
// this method is not called by nsHTMLContentSerializer
// so we don't have to check HTML element, just XHTML
NS_ASSERTION(!mIsHTMLSerializer, "nsHTMLContentSerializer shouldn't call this method !");
if (kNameSpaceID_XHTML != aNamespaceID) {
nsXMLContentSerializer::AppendEndOfElementStart(aOriginalElement, aName,
aNamespaceID, aStr);
return;
}
nsIContent* content = aOriginalElement;
// for non empty elements, even if they are not a container, we always
// serialize their content, because the XHTML element could contain non XHTML
// nodes useful in some context, like in an XSLT stylesheet
if (HasNoChildren(content)) {
nsIParserService* parserService = nsContentUtils::GetParserService();
if (parserService) {
bool isContainer;
parserService->
IsContainer(parserService->HTMLCaseSensitiveAtomTagToId(aName),
isContainer);
if (!isContainer) {
// for backward compatibility with HTML 4 user agents
// only non-container HTML elements can be closed immediatly,
// and a space is added before />
AppendToString(NS_LITERAL_STRING(" />"), aStr);
return;
}
}
}
AppendToString(kGreaterThan, aStr);
}
nsACString&
ThebesLayer::PrintInfo(nsACString& aTo, const char* aPrefix)
{
Layer::PrintInfo(aTo, aPrefix);
if (!mValidRegion.IsEmpty()) {
AppendToString(aTo, mValidRegion, " [valid=", "]");
}
if (mXResolution != 1.0 || mYResolution != 1.0) {
aTo.AppendPrintf(" [xres=%g yres=%g]", mXResolution, mYResolution);
}
return aTo;
}
nsACString&
ContainerLayer::PrintInfo(nsACString& aTo, const char* aPrefix)
{
Layer::PrintInfo(aTo, aPrefix);
if (!mFrameMetrics.IsDefault()) {
AppendToString(aTo, mFrameMetrics, " [metrics=", "]");
}
if (UseIntermediateSurface()) {
aTo += " [usesTmpSurf]";
}
return aTo;
}
NS_IMETHODIMP
nsHTMLContentSerializer::AppendText(nsIDOMText* aText,
PRInt32 aStartOffset,
PRInt32 aEndOffset,
nsAString& aStr)
{
NS_ENSURE_ARG(aText);
if (mNeedLineBreaker) {
mNeedLineBreaker = PR_FALSE;
nsCOMPtr<nsIDOMDocument> domDoc;
aText->GetOwnerDocument(getter_AddRefs(domDoc));
nsCOMPtr<nsIDocument> document = do_QueryInterface(domDoc);
}
nsAutoString data;
nsresult rv;
rv = AppendTextData((nsIDOMNode*)aText, aStartOffset,
aEndOffset, data, PR_TRUE, PR_FALSE);
if (NS_FAILED(rv))
return NS_ERROR_FAILURE;
if (mPreLevel > 0) {
AppendToStringConvertLF(data, aStr);
}
else if (mFlags & nsIDocumentEncoder::OutputRaw) {
PRInt32 lastNewlineOffset = data.RFindChar('\n');
AppendToString(data, aStr);
if (lastNewlineOffset != kNotFound)
mColPos = data.Length() - lastNewlineOffset;
}
else if (!mDoFormat) {
PRInt32 lastNewlineOffset = kNotFound;
PRBool hasLongLines = HasLongLines(data, lastNewlineOffset);
if (hasLongLines) {
// We have long lines, rewrap
AppendToStringWrapped(data, aStr, PR_FALSE);
if (lastNewlineOffset != kNotFound)
mColPos = data.Length() - lastNewlineOffset;
}
else {
AppendToStringConvertLF(data, aStr);
}
}
else {
AppendToStringWrapped(data, aStr, PR_FALSE);
}
return NS_OK;
}
nsresult
nsXMLContentSerializer::AppendTextData(nsIDOMNode* aNode,
PRInt32 aStartOffset,
PRInt32 aEndOffset,
nsAString& aStr,
PRBool aTranslateEntities,
PRBool aIncrColumn)
{
nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
const nsTextFragment* frag;
if (!content || !(frag = content->GetText())) {
return NS_ERROR_FAILURE;
}
PRInt32 endoffset = (aEndOffset == -1) ? frag->GetLength() : aEndOffset;
PRInt32 length = endoffset - aStartOffset;
NS_ASSERTION(aStartOffset >= 0, "Negative start offset for text fragment!");
NS_ASSERTION(aStartOffset <= endoffset, "A start offset is beyond the end of the text fragment!");
if (length <= 0) {
// XXX Zero is a legal value, maybe non-zero values should be an
// error.
return NS_OK;
}
if (frag->Is2b()) {
const PRUnichar *strStart = frag->Get2b() + aStartOffset;
AppendToString(Substring(strStart, strStart + length), aStr,
aTranslateEntities, aIncrColumn);
}
else {
AppendToString(NS_ConvertASCIItoUTF16(frag->Get1b()+aStartOffset, length),
aStr, aTranslateEntities, aIncrColumn);
}
return NS_OK;
}
void
AppendToString(std::stringstream& aStream, const EventRegions& e,
const char* pfx, const char* sfx)
{
aStream << pfx << "{";
if (!e.mHitRegion.IsEmpty()) {
AppendToString(aStream, e.mHitRegion, " hitregion=", "");
}
if (!e.mDispatchToContentHitRegion.IsEmpty()) {
AppendToString(aStream, e.mDispatchToContentHitRegion, " dispatchtocontentregion=", "");
}
if (!e.mNoActionRegion.IsEmpty()) {
AppendToString(aStream, e.mNoActionRegion, " NoActionRegion=","");
}
if (!e.mHorizontalPanRegion.IsEmpty()) {
AppendToString(aStream, e.mHorizontalPanRegion, " HorizontalPanRegion=", "");
}
if (!e.mVerticalPanRegion.IsEmpty()) {
AppendToString(aStream, e.mVerticalPanRegion, " VerticalPanRegion=", "");
}
aStream << "}" << sfx;
}
globle void SavePPBuffer(
void *theEnv,
EXEC_STATUS,
char *str)
{
size_t increment;
/*==========================================*/
/* If the pretty print buffer isn't needed, */
/* then don't bother writing to it. */
/*==========================================*/
if ((PrettyPrintData(theEnv,execStatus)->PPBufferStatus == OFF) || (! PrettyPrintData(theEnv,execStatus)->PPBufferEnabled))
{ return; }
/*===============================*/
/* Determine the increment size. */
/*===============================*/
increment = 512;
if (PrettyPrintData(theEnv,execStatus)->PPBufferPos > increment)
{ increment = PrettyPrintData(theEnv,execStatus)->PPBufferPos * 3; }
/*================================================*/
/* If the pretty print buffer isn't big enough to */
/* contain the string, then increase its size. */
/*================================================*/
if (strlen(str) + PrettyPrintData(theEnv,execStatus)->PPBufferPos + 1 >= PrettyPrintData(theEnv,execStatus)->PPBufferMax)
{
PrettyPrintData(theEnv,execStatus)->PrettyPrintBuffer =
(char *) genrealloc(theEnv,execStatus,PrettyPrintData(theEnv,execStatus)->PrettyPrintBuffer,
PrettyPrintData(theEnv,execStatus)->PPBufferMax,
PrettyPrintData(theEnv,execStatus)->PPBufferMax + increment);
PrettyPrintData(theEnv,execStatus)->PPBufferMax += increment;
}
/*==================================================*/
/* Remember the previous tokens saved to the pretty */
/* print buffer in case it is necessary to back up. */
/*==================================================*/
PrettyPrintData(theEnv,execStatus)->PPBackupTwice = PrettyPrintData(theEnv,execStatus)->PPBackupOnce;
PrettyPrintData(theEnv,execStatus)->PPBackupOnce = PrettyPrintData(theEnv,execStatus)->PPBufferPos;
/*=============================================*/
/* Save the string to the pretty print buffer. */
/*=============================================*/
PrettyPrintData(theEnv,execStatus)->PrettyPrintBuffer = AppendToString(theEnv,execStatus,str,PrettyPrintData(theEnv,execStatus)->PrettyPrintBuffer,&PrettyPrintData(theEnv,execStatus)->PPBufferPos,&PrettyPrintData(theEnv,execStatus)->PPBufferMax);
}
void
ImageHostOverlay::PrintInfo(std::stringstream& aStream, const char* aPrefix)
{
aStream << aPrefix;
aStream << nsPrintfCString("ImageHost (0x%p)", this).get();
AppendToString(aStream, mPictureRect, " [picture-rect=", "]");
if (mOverlay.handle().type() == OverlayHandle::Tint32_t) {
nsAutoCString pfx(aPrefix);
pfx += " ";
aStream << nsPrintfCString("Overlay: %d", mOverlay.handle().get_int32_t()).get();
}
}
nsACString&
AppendToString(nsACString& s, const nsIntRegion& r,
const char* pfx, const char* sfx)
{
s += pfx;
nsIntRegionRectIterator it(r);
s += "< ";
while (const nsIntRect* sr = it.Next())
AppendToString(s, *sr) += "; ";
s += ">";
return s += sfx;
}
void
ImageHost::PrintInfo(std::stringstream& aStream, const char* aPrefix)
{
aStream << aPrefix;
aStream << nsPrintfCString("ImageHost (0x%p)", this).get();
nsAutoCString pfx(aPrefix);
pfx += " ";
for (auto& img : mImages) {
aStream << "\n";
img.mTextureHost->PrintInfo(aStream, pfx.get());
AppendToString(aStream, img.mPictureRect, " [picture-rect=", "]");
}
}
void
ImageHost::PrintInfo(std::stringstream& aStream, const char* aPrefix)
{
aStream << aPrefix;
aStream << nsPrintfCString("ImageHost (0x%p)", this).get();
AppendToString(aStream, mPictureRect, " [picture-rect=", "]");
if (mFrontBuffer) {
nsAutoCString pfx(aPrefix);
pfx += " ";
aStream << "\n";
mFrontBuffer->PrintInfo(aStream, pfx.get());
}
}
void
DeprecatedImageHostSingle::PrintInfo(nsACString& aTo, const char* aPrefix)
{
aTo += aPrefix;
aTo += nsPrintfCString("DeprecatedImageHostSingle (0x%p)", this);
AppendToString(aTo, mPictureRect, " [picture-rect=", "]");
if (mDeprecatedTextureHost) {
nsAutoCString pfx(aPrefix);
pfx += " ";
aTo += "\n";
mDeprecatedTextureHost->PrintInfo(aTo, pfx.get());
}
}
void
ImageHost::PrintInfo(nsACString& aTo, const char* aPrefix)
{
aTo += aPrefix;
aTo += nsPrintfCString("ImageHost (0x%p)", this);
AppendToString(aTo, mPictureRect, " [picture-rect=", "]");
if (mFrontBuffer) {
nsAutoCString pfx(aPrefix);
pfx += " ";
aTo += "\n";
mFrontBuffer->PrintInfo(aTo, pfx.get());
}
}
