зеркало из https://github.com/mozilla/gecko-dev.git
Bug 1405875 - Remove old dump/compare regression data methods on frames, and nsIFrameUtil interface and implementation. r=mats
These became unused as a result of the removal of nsRegressionTester and the removal of the printing debug file mechanism, earlier in this patch sequence. MozReview-Commit-ID: 9Tftf2AjpPb
This commit is contained in:
L. David Baron
Родитель
df95fa026f
Коммит
41e56eef86
|
|
@ -14,10 +14,6 @@
|
|||
#define NS_LAYOUT_DEBUGGER_CID \
|
||||
{ 0xa6cf90f9, 0x15b3, 0x11d2,{0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32}}
|
||||
|
||||
/* a6cf90d7-15b3-11d2-932e-00805f8add32 */
|
||||
#define NS_FRAME_UTIL_CID \
|
||||
{ 0xa6cf90d5, 0x15b3, 0x11d2,{0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32}}
|
||||
|
||||
#define NS_DOMSELECTION_CID \
|
||||
{/* {C87A37FC-8109-4ce2-A322-8CDEC925379F}*/ \
|
||||
0xc87a37fc, 0x8109, 0x4ce2, { 0xa3, 0x22, 0x8c, 0xde, 0xc9, 0x25, 0x37, 0x9f } }
|
||||
|
|
|
|||
|
|
@ -27,7 +27,6 @@
|
|||
#include "nsIDocument.h"
|
||||
#include "nsIDocumentEncoder.h"
|
||||
#include "nsIFactory.h"
|
||||
#include "nsIFrameUtil.h"
|
||||
#include "nsIIdleService.h"
|
||||
#include "nsHTMLStyleSheet.h"
|
||||
#include "nsILayoutDebugger.h"
|
||||
|
|
@ -342,7 +341,6 @@ Shutdown()
|
|||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
nsresult NS_NewFrameUtil(nsIFrameUtil** aResult);
|
||||
nsresult NS_NewLayoutDebugger(nsILayoutDebugger** aResult);
|
||||
#endif
|
||||
|
||||
|
|
@ -411,7 +409,6 @@ ctor_(nsISupports* aOuter, REFNSIID aIID, void** aResult) \
|
|||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
MAKE_CTOR(CreateNewFrameUtil, nsIFrameUtil, NS_NewFrameUtil)
|
||||
MAKE_CTOR(CreateNewLayoutDebugger, nsILayoutDebugger, NS_NewLayoutDebugger)
|
||||
#endif
|
||||
|
||||
|
|
@ -568,7 +565,6 @@ Construct_nsIScriptSecurityManager(nsISupports *aOuter, REFNSIID aIID,
|
|||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
NS_DEFINE_NAMED_CID(NS_FRAME_UTIL_CID);
|
||||
NS_DEFINE_NAMED_CID(NS_LAYOUT_DEBUGGER_CID);
|
||||
#endif
|
||||
NS_DEFINE_NAMED_CID(NS_FRAMETRAVERSAL_CID);
|
||||
|
|
@ -827,7 +823,6 @@ nsEditingCommandTableConstructor(nsISupports *aOuter, REFNSIID aIID,
|
|||
static const mozilla::Module::CIDEntry kLayoutCIDs[] = {
|
||||
XPCONNECT_CIDENTRIES
|
||||
#ifdef DEBUG
|
||||
{ &kNS_FRAME_UTIL_CID, false, nullptr, CreateNewFrameUtil },
|
||||
{ &kNS_LAYOUT_DEBUGGER_CID, false, nullptr, CreateNewLayoutDebugger },
|
||||
#endif
|
||||
{ &kNS_FRAMETRAVERSAL_CID, false, nullptr, CreateNewFrameTraversal },
|
||||
|
|
|
|||
|
|
@ -81,7 +81,6 @@ EXPORTS += [
|
|||
'nsIAnonymousContentCreator.h',
|
||||
'nsIFrame.h',
|
||||
'nsIFrameInlines.h',
|
||||
'nsIFrameUtil.h',
|
||||
'nsILineIterator.h',
|
||||
'nsIObjectFrame.h',
|
||||
'nsIPageSequenceFrame.h',
|
||||
|
|
@ -148,7 +147,6 @@ UNIFIED_SOURCES += [
|
|||
'nsFrameSelection.cpp',
|
||||
'nsFrameSetFrame.cpp',
|
||||
'nsFrameState.cpp',
|
||||
'nsFrameUtil.cpp',
|
||||
'nsGfxScrollFrame.cpp',
|
||||
'nsGridContainerFrame.cpp',
|
||||
'nsHTMLCanvasFrame.cpp',
|
||||
|
|
|
|||
|
|
@ -7458,74 +7458,6 @@ nsIFrame::GetConstFrameSelection() const
|
|||
return PresContext()->PresShell()->ConstFrameSelection();
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
nsresult
|
||||
nsFrame::DumpRegressionData(nsPresContext* aPresContext, FILE* out, int32_t aIndent)
|
||||
{
|
||||
IndentBy(out, aIndent);
|
||||
fprintf(out, "<frame va=\"%p\" type=\"", (void*)this);
|
||||
nsAutoString name;
|
||||
GetFrameName(name);
|
||||
XMLQuote(name);
|
||||
fputs(NS_LossyConvertUTF16toASCII(name).get(), out);
|
||||
fprintf(out, "\" state=\"%016llx\" parent=\"%p\">\n",
|
||||
(unsigned long long)GetDebugStateBits(), (void*)GetParent());
|
||||
|
||||
aIndent++;
|
||||
DumpBaseRegressionData(aPresContext, out, aIndent);
|
||||
aIndent--;
|
||||
|
||||
IndentBy(out, aIndent);
|
||||
fprintf(out, "</frame>\n");
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
void
|
||||
nsFrame::DumpBaseRegressionData(nsPresContext* aPresContext, FILE* out, int32_t aIndent)
|
||||
{
|
||||
if (GetNextSibling()) {
|
||||
IndentBy(out, aIndent);
|
||||
fprintf(out, "<next-sibling va=\"%p\"/>\n", (void*)GetNextSibling());
|
||||
}
|
||||
|
||||
if (HasView()) {
|
||||
IndentBy(out, aIndent);
|
||||
fprintf(out, "<view va=\"%p\">\n", (void*)GetView());
|
||||
aIndent++;
|
||||
// XXX add in code to dump out view state too...
|
||||
aIndent--;
|
||||
IndentBy(out, aIndent);
|
||||
fprintf(out, "</view>\n");
|
||||
}
|
||||
|
||||
IndentBy(out, aIndent);
|
||||
fprintf(out, "<bbox x=\"%d\" y=\"%d\" w=\"%d\" h=\"%d\"/>\n",
|
||||
mRect.x, mRect.y, mRect.width, mRect.height);
|
||||
|
||||
// Now dump all of the children on all of the child lists
|
||||
ChildListIterator lists(this);
|
||||
for (; !lists.IsDone(); lists.Next()) {
|
||||
IndentBy(out, aIndent);
|
||||
if (lists.CurrentID() != kPrincipalList) {
|
||||
fprintf(out, "<child-list name=\"%s\">\n", mozilla::layout::ChildListName(lists.CurrentID()));
|
||||
}
|
||||
else {
|
||||
fprintf(out, "<child-list>\n");
|
||||
}
|
||||
aIndent++;
|
||||
nsFrameList::Enumerator childFrames(lists.CurrentList());
|
||||
for (; !childFrames.AtEnd(); childFrames.Next()) {
|
||||
nsIFrame* kid = childFrames.get();
|
||||
kid->DumpRegressionData(aPresContext, out, aIndent);
|
||||
}
|
||||
aIndent--;
|
||||
IndentBy(out, aIndent);
|
||||
fprintf(out, "</child-list>\n");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
bool
|
||||
nsIFrame::IsFrameSelected() const
|
||||
{
|
||||
|
|
|
|||
|
|
@ -496,17 +496,6 @@ public:
|
|||
|
||||
static void XMLQuote(nsString& aString);
|
||||
|
||||
/**
|
||||
* Dump out the "base classes" regression data. This should dump
|
||||
* out the interior data, not the "frame" XML container. And it
|
||||
* should call the base classes same named method before doing
|
||||
* anything specific in a derived class. This means that derived
|
||||
* classes need not override DumpRegressionData unless they need
|
||||
* some custom behavior that requires changing how the outer "frame"
|
||||
* XML container is dumped.
|
||||
*/
|
||||
virtual void DumpBaseRegressionData(nsPresContext* aPresContext, FILE* out, int32_t aIndent);
|
||||
|
||||
// Display Reflow Debugging
|
||||
static void* DisplayReflowEnter(nsPresContext* aPresContext,
|
||||
nsIFrame* aFrame,
|
||||
|
|
@ -743,17 +732,6 @@ public:
|
|||
* is, those bits which indicate a real difference when they differ
|
||||
*/
|
||||
nsFrameState GetDebugStateBits() const override;
|
||||
/**
|
||||
* Called to dump out regression data that describes the layout
|
||||
* of the frame and its children, and so on. The format of the
|
||||
* data is dictated to be XML (using a specific DTD); the
|
||||
* specific kind of data dumped is up to the frame itself, with
|
||||
* the caveat that some base types are defined.
|
||||
* For more information, see XXX.
|
||||
*/
|
||||
nsresult DumpRegressionData(nsPresContext* aPresContext,
|
||||
FILE* out, int32_t aIndent) override;
|
||||
|
||||
/**
|
||||
* See if style tree verification is enabled. To enable style tree
|
||||
* verification add "styleverifytree:1" to your MOZ_LOG
|
||||
|
|
|
|||
|
|
@ -1,670 +0,0 @@
|
|||
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
||||
/* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
||||
|
||||
/* utilities for regression tests based on frame tree comparison */
|
||||
|
||||
#include "nsIFrameUtil.h"
|
||||
#include "nsFrame.h"
|
||||
#include "nsString.h"
|
||||
#include "nsRect.h"
|
||||
#include <stdlib.h>
|
||||
#include "plstr.h"
|
||||
|
||||
|
||||
#ifdef DEBUG
|
||||
class nsFrameUtil : public nsIFrameUtil {
|
||||
protected:
|
||||
virtual ~nsFrameUtil();
|
||||
|
||||
public:
|
||||
nsFrameUtil();
|
||||
|
||||
NS_DECL_ISUPPORTS
|
||||
|
||||
NS_IMETHOD CompareRegressionData(FILE* aFile1, FILE* aFile2,int32_t aRegressionOutput=0) override;
|
||||
NS_IMETHOD DumpRegressionData(FILE* aInputFile, FILE* aOutputFile) override;
|
||||
|
||||
struct Node;
|
||||
struct Tag;
|
||||
|
||||
struct NodeList {
|
||||
NodeList();
|
||||
~NodeList();
|
||||
|
||||
static void Destroy(NodeList* aLists);
|
||||
|
||||
NodeList* next; // for lists of lists
|
||||
Node* node;
|
||||
char* name;
|
||||
};
|
||||
|
||||
struct Node {
|
||||
Node();
|
||||
~Node();
|
||||
|
||||
static void Destroy(Node* aNode);
|
||||
|
||||
static Node* Read(FILE* aFile, Tag* aTag);
|
||||
|
||||
static Node* ReadTree(FILE* aFile);
|
||||
|
||||
Node* next;
|
||||
char* type;
|
||||
uint32_t state;
|
||||
nsRect bbox;
|
||||
nsCString styleData;
|
||||
NodeList* lists;
|
||||
};
|
||||
|
||||
struct Tag {
|
||||
Tag();
|
||||
~Tag();
|
||||
|
||||
static Tag* Parse(FILE* aFile);
|
||||
|
||||
void AddAttr(char* aAttr, char* aValue);
|
||||
|
||||
const char* GetAttr(const char* aAttr);
|
||||
|
||||
void ReadAttrs(FILE* aFile);
|
||||
|
||||
void ToString(nsString& aResult);
|
||||
|
||||
enum Type {
|
||||
open,
|
||||
close,
|
||||
openClose
|
||||
};
|
||||
|
||||
char* name;
|
||||
Type type;
|
||||
char** attributes;
|
||||
int32_t num;
|
||||
int32_t size;
|
||||
char** values;
|
||||
};
|
||||
|
||||
static char* Copy(const char* aString);
|
||||
|
||||
static void DumpNode(Node* aNode, FILE* aOutputFile, int32_t aIndent);
|
||||
static void DumpTree(Node* aNode, FILE* aOutputFile, int32_t aIndent);
|
||||
static bool CompareTrees(Node* aNode1, Node* aNode2);
|
||||
};
|
||||
|
||||
char*
|
||||
nsFrameUtil::Copy(const char* aString)
|
||||
{
|
||||
if (aString) {
|
||||
int l = ::strlen(aString);
|
||||
char* c = new char[l+1];
|
||||
if (!c)
|
||||
return nullptr;
|
||||
memcpy(c, aString, l+1);
|
||||
return c;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
nsFrameUtil::NodeList::NodeList()
|
||||
: next(nullptr), node(nullptr), name(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
nsFrameUtil::NodeList::~NodeList()
|
||||
{
|
||||
if (nullptr != name) {
|
||||
delete name;
|
||||
}
|
||||
if (nullptr != node) {
|
||||
Node::Destroy(node);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
nsFrameUtil::NodeList::Destroy(NodeList* aLists)
|
||||
{
|
||||
while (nullptr != aLists) {
|
||||
NodeList* next = aLists->next;
|
||||
delete aLists;
|
||||
aLists = next;
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
nsFrameUtil::Node::Node()
|
||||
: next(nullptr), type(nullptr), state(0), lists(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
nsFrameUtil::Node::~Node()
|
||||
{
|
||||
if (nullptr != type) {
|
||||
delete type;
|
||||
}
|
||||
if (nullptr != lists) {
|
||||
NodeList::Destroy(lists);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
nsFrameUtil::Node::Destroy(Node* aList)
|
||||
{
|
||||
while (nullptr != aList) {
|
||||
Node* next = aList->next;
|
||||
delete aList;
|
||||
aList = next;
|
||||
}
|
||||
}
|
||||
|
||||
static int32_t GetInt(nsFrameUtil::Tag* aTag, const char* aAttr)
|
||||
{
|
||||
const char* value = aTag->GetAttr(aAttr);
|
||||
if (nullptr != value) {
|
||||
return int32_t( atoi(value) );
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
nsFrameUtil::Node*
|
||||
nsFrameUtil::Node::ReadTree(FILE* aFile)
|
||||
{
|
||||
Tag* tag = Tag::Parse(aFile);
|
||||
if (nullptr == tag) {
|
||||
return nullptr;
|
||||
}
|
||||
if (PL_strcmp(tag->name, "frame") != 0) {
|
||||
delete tag;
|
||||
return nullptr;
|
||||
}
|
||||
Node* result = Read(aFile, tag);
|
||||
fclose(aFile);
|
||||
return result;
|
||||
}
|
||||
|
||||
nsFrameUtil::Node*
|
||||
nsFrameUtil::Node::Read(FILE* aFile, Tag* tag)
|
||||
{
|
||||
Node* node = new Node;
|
||||
node->type = Copy(tag->GetAttr("type"));
|
||||
if (!node->type) {
|
||||
/* crash() */
|
||||
}
|
||||
node->state = GetInt(tag, "state");
|
||||
delete tag;
|
||||
|
||||
for (;;) {
|
||||
tag = Tag::Parse(aFile);
|
||||
if (nullptr == tag) break;
|
||||
if (PL_strcmp(tag->name, "frame") == 0) {
|
||||
delete tag;
|
||||
break;
|
||||
}
|
||||
if (PL_strcmp(tag->name, "bbox") == 0) {
|
||||
nscoord x = nscoord( GetInt(tag, "x") );
|
||||
nscoord y = nscoord( GetInt(tag, "y") );
|
||||
nscoord w = nscoord( GetInt(tag, "w") );
|
||||
nscoord h = nscoord( GetInt(tag, "h") );
|
||||
node->bbox.SetRect(x, y, w, h);
|
||||
}
|
||||
else if (PL_strcmp(tag->name, "child-list") == 0) {
|
||||
NodeList* list = new NodeList();
|
||||
list->name = Copy(tag->GetAttr("name"));
|
||||
if (!list->name) {
|
||||
/* crash() */
|
||||
}
|
||||
list->next = node->lists;
|
||||
node->lists = list;
|
||||
delete tag;
|
||||
|
||||
Node** tailp = &list->node;
|
||||
for (;;) {
|
||||
tag = Tag::Parse(aFile);
|
||||
if (nullptr == tag) {
|
||||
break;
|
||||
}
|
||||
if (PL_strcmp(tag->name, "child-list") == 0) {
|
||||
break;
|
||||
}
|
||||
if (PL_strcmp(tag->name, "frame") != 0) {
|
||||
break;
|
||||
}
|
||||
Node* child = Node::Read(aFile, tag);
|
||||
if (nullptr == child) {
|
||||
break;
|
||||
}
|
||||
*tailp = child;
|
||||
tailp = &child->next;
|
||||
}
|
||||
}
|
||||
else if((PL_strcmp(tag->name, "font") == 0) ||
|
||||
(PL_strcmp(tag->name, "color") == 0) ||
|
||||
(PL_strcmp(tag->name, "spacing") == 0) ||
|
||||
(PL_strcmp(tag->name, "list") == 0) ||
|
||||
(PL_strcmp(tag->name, "position") == 0) ||
|
||||
(PL_strcmp(tag->name, "text") == 0) ||
|
||||
(PL_strcmp(tag->name, "display") == 0) ||
|
||||
(PL_strcmp(tag->name, "table") == 0) ||
|
||||
(PL_strcmp(tag->name, "content") == 0) ||
|
||||
(PL_strcmp(tag->name, "UI") == 0) ||
|
||||
(PL_strcmp(tag->name, "print") == 0)) {
|
||||
const char* attr = tag->GetAttr("data");
|
||||
node->styleData.Append('|');
|
||||
node->styleData.Append(attr ? attr : "null attr");
|
||||
}
|
||||
|
||||
delete tag;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
nsFrameUtil::Tag::Tag()
|
||||
: name(nullptr), type(open), attributes(nullptr), num(0), size(0),
|
||||
values(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
nsFrameUtil::Tag::~Tag()
|
||||
{
|
||||
int32_t i, n = num;
|
||||
if (0 != n) {
|
||||
for (i = 0; i < n; i++) {
|
||||
delete attributes[i];
|
||||
delete values[i];
|
||||
}
|
||||
delete attributes;
|
||||
delete values;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
nsFrameUtil::Tag::AddAttr(char* aAttr, char* aValue)
|
||||
{
|
||||
if (num == size) {
|
||||
int32_t newSize = size * 2 + 4;
|
||||
char** a = new char*[newSize];
|
||||
char** v = new char*[newSize];
|
||||
if (0 != num) {
|
||||
memcpy(a, attributes, num * sizeof(char*));
|
||||
memcpy(v, values, num * sizeof(char*));
|
||||
delete attributes;
|
||||
delete values;
|
||||
}
|
||||
attributes = a;
|
||||
values = v;
|
||||
size = newSize;
|
||||
}
|
||||
attributes[num] = aAttr;
|
||||
values[num] = aValue;
|
||||
num = num + 1;
|
||||
}
|
||||
|
||||
const char*
|
||||
nsFrameUtil::Tag::GetAttr(const char* aAttr)
|
||||
{
|
||||
int32_t i, n = num;
|
||||
for (i = 0; i < n; i++) {
|
||||
if (PL_strcmp(attributes[i], aAttr) == 0) {
|
||||
return values[i];
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static inline int IsWhiteSpace(int c) {
|
||||
return (c == ' ') || (c == '\t') || (c == '\n') || (c == '\r');
|
||||
}
|
||||
|
||||
static bool EatWS(FILE* aFile)
|
||||
{
|
||||
for (;;) {
|
||||
int c = getc(aFile);
|
||||
if (c < 0) {
|
||||
return false;
|
||||
}
|
||||
if (!IsWhiteSpace(c)) {
|
||||
ungetc(c, aFile);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool Expect(FILE* aFile, char aChar)
|
||||
{
|
||||
int c = getc(aFile);
|
||||
if (c < 0) return false;
|
||||
if (c != aChar) {
|
||||
ungetc(c, aFile);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static char* ReadIdent(FILE* aFile)
|
||||
{
|
||||
char id[1000];
|
||||
char* ip = id;
|
||||
char* end = ip + sizeof(id) - 1;
|
||||
while (ip < end) {
|
||||
int c = fgetc(aFile);
|
||||
if (c < 0) return nullptr;
|
||||
if ((c == '=') || (c == '>') || (c == '/') || IsWhiteSpace(c)) {
|
||||
ungetc(c, aFile);
|
||||
break;
|
||||
}
|
||||
*ip++ = char(c);
|
||||
}
|
||||
*ip = '\0';
|
||||
return nsFrameUtil::Copy(id);
|
||||
/* may return a null pointer */
|
||||
}
|
||||
|
||||
static char* ReadString(FILE* aFile)
|
||||
{
|
||||
if (!Expect(aFile, '\"')) {
|
||||
return nullptr;
|
||||
}
|
||||
char id[1000];
|
||||
char* ip = id;
|
||||
char* end = ip + sizeof(id) - 1;
|
||||
while (ip < end) {
|
||||
int c = fgetc(aFile);
|
||||
if (c < 0) return nullptr;
|
||||
if (c == '\"') {
|
||||
break;
|
||||
}
|
||||
*ip++ = char(c);
|
||||
}
|
||||
*ip = '\0';
|
||||
return nsFrameUtil::Copy(id);
|
||||
/* may return a null pointer */
|
||||
}
|
||||
|
||||
void
|
||||
nsFrameUtil::Tag::ReadAttrs(FILE* aFile)
|
||||
{
|
||||
for (;;) {
|
||||
if (!EatWS(aFile)) {
|
||||
break;
|
||||
}
|
||||
int c = getc(aFile);
|
||||
if (c < 0) break;
|
||||
if (c == '/') {
|
||||
if (!EatWS(aFile)) {
|
||||
return;
|
||||
}
|
||||
if (Expect(aFile, '>')) {
|
||||
type = openClose;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (c == '>') {
|
||||
break;
|
||||
}
|
||||
ungetc(c, aFile);
|
||||
char* attr = ReadIdent(aFile);
|
||||
if ((nullptr == attr) || !EatWS(aFile)) {
|
||||
break;
|
||||
}
|
||||
char* value = nullptr;
|
||||
if (Expect(aFile, '=')) {
|
||||
value = ReadString(aFile);
|
||||
if (nullptr == value) {
|
||||
delete [] attr;
|
||||
break;
|
||||
}
|
||||
}
|
||||
AddAttr(attr, value);
|
||||
}
|
||||
}
|
||||
|
||||
nsFrameUtil::Tag*
|
||||
nsFrameUtil::Tag::Parse(FILE* aFile)
|
||||
{
|
||||
if (!EatWS(aFile)) {
|
||||
return nullptr;
|
||||
}
|
||||
if (Expect(aFile, '<')) {
|
||||
Tag* tag = new Tag;
|
||||
if (Expect(aFile, '/')) {
|
||||
tag->type = close;
|
||||
}
|
||||
else {
|
||||
tag->type = open;
|
||||
}
|
||||
tag->name = ReadIdent(aFile);
|
||||
tag->ReadAttrs(aFile);
|
||||
return tag;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void
|
||||
nsFrameUtil::Tag::ToString(nsString& aResult)
|
||||
{
|
||||
aResult.Truncate();
|
||||
aResult.Append(char16_t('<'));
|
||||
if (type == close) {
|
||||
aResult.Append(char16_t('/'));
|
||||
}
|
||||
aResult.AppendASCII(name);
|
||||
if (0 != num) {
|
||||
int32_t i, n = num;
|
||||
for (i = 0; i < n; i++) {
|
||||
aResult.Append(char16_t(' '));
|
||||
aResult.AppendASCII(attributes[i]);
|
||||
if (values[i]) {
|
||||
aResult.AppendLiteral("=\"");
|
||||
aResult.AppendASCII(values[i]);
|
||||
aResult.Append(char16_t('\"'));
|
||||
}
|
||||
}
|
||||
}
|
||||
if (type == openClose) {
|
||||
aResult.Append(char16_t('/'));
|
||||
}
|
||||
aResult.Append(char16_t('>'));
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
nsresult
|
||||
NS_NewFrameUtil(nsIFrameUtil** aResult)
|
||||
{
|
||||
NS_PRECONDITION(nullptr != aResult, "null pointer");
|
||||
if (nullptr == aResult) {
|
||||
return NS_ERROR_NULL_POINTER;
|
||||
}
|
||||
|
||||
nsFrameUtil* it = new nsFrameUtil();
|
||||
|
||||
NS_ADDREF(*aResult = it);
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
nsFrameUtil::nsFrameUtil()
|
||||
{
|
||||
}
|
||||
|
||||
nsFrameUtil::~nsFrameUtil()
|
||||
{
|
||||
}
|
||||
|
||||
NS_IMPL_ISUPPORTS(nsFrameUtil, nsIFrameUtil)
|
||||
|
||||
void
|
||||
nsFrameUtil::DumpNode(Node* aNode, FILE* aOutputFile, int32_t aIndent)
|
||||
{
|
||||
nsFrame::IndentBy(aOutputFile, aIndent);
|
||||
fprintf(aOutputFile, "%s 0x%x %d,%d,%d,%d, %s\n", aNode->type, aNode->state,
|
||||
aNode->bbox.x, aNode->bbox.y,
|
||||
aNode->bbox.width, aNode->bbox.height,
|
||||
aNode->styleData.get());
|
||||
}
|
||||
|
||||
void
|
||||
nsFrameUtil::DumpTree(Node* aNode, FILE* aOutputFile, int32_t aIndent)
|
||||
{
|
||||
while (nullptr != aNode) {
|
||||
DumpNode(aNode, aOutputFile, aIndent);
|
||||
nsFrameUtil::NodeList* lists = aNode->lists;
|
||||
if (nullptr != lists) {
|
||||
while (nullptr != lists) {
|
||||
nsFrame::IndentBy(aOutputFile, aIndent);
|
||||
fprintf(aOutputFile, " list: %s\n",
|
||||
lists->name ? lists->name : "primary");
|
||||
DumpTree(lists->node, aOutputFile, aIndent + 1);
|
||||
lists = lists->next;
|
||||
}
|
||||
}
|
||||
aNode = aNode->next;
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
nsFrameUtil::CompareTrees(Node* tree1, Node* tree2)
|
||||
{
|
||||
bool result = true;
|
||||
for (;; tree1 = tree1->next, tree2 = tree2->next) {
|
||||
// Make sure both nodes are non-null, or at least agree with each other
|
||||
if (nullptr == tree1) {
|
||||
if (nullptr == tree2) {
|
||||
break;
|
||||
}
|
||||
printf("first tree prematurely ends\n");
|
||||
return false;
|
||||
}
|
||||
else if (nullptr == tree2) {
|
||||
printf("second tree prematurely ends\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check the attributes that we care about
|
||||
if (0 != PL_strcmp(tree1->type, tree2->type)) {
|
||||
printf("frame type mismatch: %s vs. %s\n", tree1->type, tree2->type);
|
||||
printf("Node 1:\n");
|
||||
DumpNode(tree1, stdout, 1);
|
||||
printf("Node 2:\n");
|
||||
DumpNode(tree2, stdout, 1);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Ignore the XUL scrollbar frames
|
||||
static const char kScrollbarFrame[] = "ScrollbarFrame";
|
||||
if (0 == PL_strncmp(tree1->type, kScrollbarFrame, sizeof(kScrollbarFrame) - 1))
|
||||
continue;
|
||||
|
||||
if (tree1->state != tree2->state) {
|
||||
printf("frame state mismatch: 0x%x vs. 0x%x\n",
|
||||
tree1->state, tree2->state);
|
||||
printf("Node 1:\n");
|
||||
DumpNode(tree1, stdout, 1);
|
||||
printf("Node 2:\n");
|
||||
DumpNode(tree2, stdout, 1);
|
||||
result = false; // we have a non-critical failure, so remember that but continue
|
||||
}
|
||||
if (tree1->bbox.IsEqualInterior(tree2->bbox)) {
|
||||
printf("frame bbox mismatch: %d,%d,%d,%d vs. %d,%d,%d,%d\n",
|
||||
tree1->bbox.x, tree1->bbox.y,
|
||||
tree1->bbox.width, tree1->bbox.height,
|
||||
tree2->bbox.x, tree2->bbox.y,
|
||||
tree2->bbox.width, tree2->bbox.height);
|
||||
printf("Node 1:\n");
|
||||
DumpNode(tree1, stdout, 1);
|
||||
printf("Node 2:\n");
|
||||
DumpNode(tree2, stdout, 1);
|
||||
result = false; // we have a non-critical failure, so remember that but continue
|
||||
}
|
||||
if (tree1->styleData != tree2->styleData) {
|
||||
printf("frame style data mismatch: %s vs. %s\n",
|
||||
tree1->styleData.get(),
|
||||
tree2->styleData.get());
|
||||
}
|
||||
|
||||
// Check child lists too
|
||||
NodeList* list1 = tree1->lists;
|
||||
NodeList* list2 = tree2->lists;
|
||||
for (;;) {
|
||||
if (nullptr == list1) {
|
||||
if (nullptr != list2) {
|
||||
printf("first tree prematurely ends (no child lists)\n");
|
||||
printf("Node 1:\n");
|
||||
DumpNode(tree1, stdout, 1);
|
||||
printf("Node 2:\n");
|
||||
DumpNode(tree2, stdout, 1);
|
||||
return false;
|
||||
}
|
||||
else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (nullptr == list2) {
|
||||
printf("second tree prematurely ends (no child lists)\n");
|
||||
printf("Node 1:\n");
|
||||
DumpNode(tree1, stdout, 1);
|
||||
printf("Node 2:\n");
|
||||
DumpNode(tree2, stdout, 1);
|
||||
return false;
|
||||
}
|
||||
if (0 != PL_strcmp(list1->name, list2->name)) {
|
||||
printf("child-list name mismatch: %s vs. %s\n",
|
||||
list1->name ? list1->name : "(null)",
|
||||
list2->name ? list2->name : "(null)");
|
||||
result = false; // we have a non-critical failure, so remember that but continue
|
||||
}
|
||||
else {
|
||||
bool equiv = CompareTrees(list1->node, list2->node);
|
||||
if (!equiv) {
|
||||
return equiv;
|
||||
}
|
||||
}
|
||||
list1 = list1->next;
|
||||
list2 = list2->next;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
nsFrameUtil::CompareRegressionData(FILE* aFile1, FILE* aFile2,int32_t aRegressionOutput)
|
||||
{
|
||||
Node* tree1 = Node::ReadTree(aFile1);
|
||||
Node* tree2 = Node::ReadTree(aFile2);
|
||||
|
||||
nsresult rv = NS_OK;
|
||||
if (!CompareTrees(tree1, tree2)) {
|
||||
// only output this if aRegressionOutput is 0
|
||||
if( 0 == aRegressionOutput ){
|
||||
printf("Regression data 1:\n");
|
||||
DumpTree(tree1, stdout, 0);
|
||||
printf("Regression data 2:\n");
|
||||
DumpTree(tree2, stdout, 0);
|
||||
}
|
||||
rv = NS_ERROR_FAILURE;
|
||||
}
|
||||
|
||||
Node::Destroy(tree1);
|
||||
Node::Destroy(tree2);
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
nsFrameUtil::DumpRegressionData(FILE* aInputFile, FILE* aOutputFile)
|
||||
{
|
||||
Node* tree1 = Node::ReadTree(aInputFile);
|
||||
if (nullptr != tree1) {
|
||||
DumpTree(tree1, aOutputFile, 0);
|
||||
Node::Destroy(tree1);
|
||||
return NS_OK;
|
||||
}
|
||||
return NS_ERROR_FAILURE;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -4447,8 +4447,6 @@ public:
|
|||
#ifdef DEBUG
|
||||
public:
|
||||
virtual nsFrameState GetDebugStateBits() const = 0;
|
||||
virtual nsresult DumpRegressionData(nsPresContext* aPresContext,
|
||||
FILE* out, int32_t aIndent) = 0;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -1,45 +0,0 @@
|
|||
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
||||
/* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
||||
|
||||
/* utilities for regression tests based on frame tree comparison */
|
||||
|
||||
#ifndef nsIFrameUtil_h___
|
||||
#define nsIFrameUtil_h___
|
||||
|
||||
#include <stdio.h>
|
||||
#include "nsISupports.h"
|
||||
|
||||
/* a6cf90d4-15b3-11d2-932e-00805f8add32 */
|
||||
#define NS_IFRAME_UTIL_IID \
|
||||
{ 0xa6cf90d6, 0x15b3, 0x11d2,{0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32}}
|
||||
|
||||
/**
|
||||
* Frame utility interface
|
||||
*/
|
||||
class nsIFrameUtil : public nsISupports {
|
||||
public:
|
||||
NS_DECLARE_STATIC_IID_ACCESSOR(NS_IFRAME_UTIL_IID)
|
||||
/**
|
||||
* Compare two regression data dumps. The return status will be NS_OK
|
||||
* if the trees compare favoribly, otherwise the return will indicate
|
||||
* NS_ERROR_FAILURE. Other return status's will indicate some other
|
||||
* type of failure. The files, aFile1 and aFile2 are closed before
|
||||
* returning.
|
||||
* aRegressionOutput will vary output, 0 is full output, 1 is brief
|
||||
*/
|
||||
NS_IMETHOD CompareRegressionData(FILE* aFile1, FILE* aFile2,int32_t aRegressionOutput) = 0;
|
||||
|
||||
/**
|
||||
* Display the regression dump data stored in aInputFile1 to
|
||||
* aOutputFile . The file is closed before returning. If the
|
||||
* regression data is in error somehow then NS_ERROR_FAILURE will be
|
||||
* returned.
|
||||
*/
|
||||
NS_IMETHOD DumpRegressionData(FILE* aInputFile, FILE* aOutputFile) = 0;
|
||||
};
|
||||
|
||||
NS_DEFINE_STATIC_IID_ACCESSOR(nsIFrameUtil, NS_IFRAME_UTIL_IID)
|
||||
|
||||
#endif /* nsIFrameUtil_h___ */
|
||||
|
|
@ -297,20 +297,3 @@ nsSplittableFrame::PreReflowBlockLevelLogicalSkipSides() const
|
|||
}
|
||||
return LogicalSides();
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
void
|
||||
nsSplittableFrame::DumpBaseRegressionData(nsPresContext* aPresContext, FILE* out, int32_t aIndent)
|
||||
{
|
||||
nsFrame::DumpBaseRegressionData(aPresContext, out, aIndent);
|
||||
if (nullptr != mNextContinuation) {
|
||||
IndentBy(out, aIndent);
|
||||
fprintf(out, "<next-continuation va=\"%p\"/>\n", (void*)mNextContinuation);
|
||||
}
|
||||
if (nullptr != mPrevContinuation) {
|
||||
IndentBy(out, aIndent);
|
||||
fprintf(out, "<prev-continuation va=\"%p\"/>\n", (void*)mPrevContinuation);
|
||||
}
|
||||
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -114,10 +114,6 @@ protected:
|
|||
*/
|
||||
LogicalSides PreReflowBlockLevelLogicalSkipSides() const;
|
||||
|
||||
#ifdef DEBUG
|
||||
virtual void DumpBaseRegressionData(nsPresContext* aPresContext, FILE* out, int32_t aIndent) override;
|
||||
#endif
|
||||
|
||||
nsIFrame* mPrevContinuation;
|
||||
nsIFrame* mNextContinuation;
|
||||
};
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче