mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-08 20:47:44 +00:00
840 lines
21 KiB
C++
840 lines
21 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "Logging.h"
|
|
|
|
#include "Accessible-inl.h"
|
|
#include "AccEvent.h"
|
|
#include "DocAccessible.h"
|
|
#include "nsAccessibilityService.h"
|
|
#include "nsCoreUtils.h"
|
|
#include "OuterDocAccessible.h"
|
|
|
|
#include "nsDocShellLoadTypes.h"
|
|
#include "nsIChannel.h"
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
#include "nsISelectionPrivate.h"
|
|
#include "nsTraceRefcnt.h"
|
|
#include "nsIWebProgress.h"
|
|
#include "prenv.h"
|
|
#include "nsIDocShellTreeItem.h"
|
|
#include "nsIURI.h"
|
|
#include "mozilla/dom/Element.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::a11y;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Logging helpers
|
|
|
|
static uint32_t sModules = 0;
|
|
|
|
struct ModuleRep {
|
|
const char* mStr;
|
|
logging::EModules mModule;
|
|
};
|
|
|
|
static ModuleRep sModuleMap[] = {
|
|
{ "docload", logging::eDocLoad },
|
|
{ "doccreate", logging::eDocCreate },
|
|
{ "docdestroy", logging::eDocDestroy },
|
|
{ "doclifecycle", logging::eDocLifeCycle },
|
|
|
|
{ "events", logging::eEvents },
|
|
{ "platforms", logging::ePlatforms },
|
|
{ "stack", logging::eStack },
|
|
{ "text", logging::eText },
|
|
{ "tree", logging::eTree },
|
|
|
|
{ "DOMEvents", logging::eDOMEvents },
|
|
{ "focus", logging::eFocus },
|
|
{ "selection", logging::eSelection },
|
|
{ "notifications", logging::eNotifications }
|
|
};
|
|
|
|
static void
|
|
EnableLogging(const char* aModulesStr)
|
|
{
|
|
sModules = 0;
|
|
if (!aModulesStr)
|
|
return;
|
|
|
|
const char* token = aModulesStr;
|
|
while (*token != '\0') {
|
|
size_t tokenLen = strcspn(token, ",");
|
|
for (unsigned int idx = 0; idx < ArrayLength(sModuleMap); idx++) {
|
|
if (strncmp(token, sModuleMap[idx].mStr, tokenLen) == 0) {
|
|
#if !defined(MOZ_PROFILING) && (!defined(DEBUG) || defined(MOZ_OPTIMIZE))
|
|
// Stack tracing on profiling enabled or debug not optimized builds.
|
|
if (strncmp(token, "stack", tokenLen) == 0)
|
|
break;
|
|
#endif
|
|
sModules |= sModuleMap[idx].mModule;
|
|
printf("\n\nmodule enabled: %s\n", sModuleMap[idx].mStr);
|
|
break;
|
|
}
|
|
}
|
|
token += tokenLen;
|
|
|
|
if (*token == ',')
|
|
token++; // skip ',' char
|
|
}
|
|
}
|
|
|
|
static void
|
|
LogDocURI(nsIDocument* aDocumentNode)
|
|
{
|
|
nsIURI* uri = aDocumentNode->GetDocumentURI();
|
|
nsAutoCString spec;
|
|
uri->GetSpec(spec);
|
|
printf("uri: %s", spec.get());
|
|
}
|
|
|
|
static void
|
|
LogDocShellState(nsIDocument* aDocumentNode)
|
|
{
|
|
printf("docshell busy: ");
|
|
|
|
nsAutoCString docShellBusy;
|
|
nsCOMPtr<nsIDocShell> docShell = aDocumentNode->GetDocShell();
|
|
uint32_t busyFlags = nsIDocShell::BUSY_FLAGS_NONE;
|
|
docShell->GetBusyFlags(&busyFlags);
|
|
if (busyFlags == nsIDocShell::BUSY_FLAGS_NONE)
|
|
printf("'none'");
|
|
if (busyFlags & nsIDocShell::BUSY_FLAGS_BUSY)
|
|
printf("'busy'");
|
|
if (busyFlags & nsIDocShell::BUSY_FLAGS_BEFORE_PAGE_LOAD)
|
|
printf(", 'before page load'");
|
|
if (busyFlags & nsIDocShell::BUSY_FLAGS_PAGE_LOADING)
|
|
printf(", 'page loading'");
|
|
|
|
printf("[failed]");
|
|
}
|
|
|
|
static void
|
|
LogDocType(nsIDocument* aDocumentNode)
|
|
{
|
|
if (aDocumentNode->IsActive()) {
|
|
bool isContent = nsCoreUtils::IsContentDocument(aDocumentNode);
|
|
printf("%s document", (isContent ? "content" : "chrome"));
|
|
} else {
|
|
printf("document type: [failed]");\
|
|
}
|
|
}
|
|
|
|
static void
|
|
LogDocShellTree(nsIDocument* aDocumentNode)
|
|
{
|
|
if (aDocumentNode->IsActive()) {
|
|
nsCOMPtr<nsIDocShellTreeItem> treeItem(aDocumentNode->GetDocShell());
|
|
nsCOMPtr<nsIDocShellTreeItem> parentTreeItem;
|
|
treeItem->GetParent(getter_AddRefs(parentTreeItem));
|
|
nsCOMPtr<nsIDocShellTreeItem> rootTreeItem;
|
|
treeItem->GetRootTreeItem(getter_AddRefs(rootTreeItem));
|
|
printf("docshell hierarchy, parent: %p, root: %p, is tab document: %s;",
|
|
static_cast<void*>(parentTreeItem), static_cast<void*>(rootTreeItem),
|
|
(nsCoreUtils::IsTabDocument(aDocumentNode) ? "yes" : "no"));
|
|
}
|
|
}
|
|
|
|
static void
|
|
LogDocState(nsIDocument* aDocumentNode)
|
|
{
|
|
const char* docState = nullptr;
|
|
nsIDocument::ReadyState docStateFlag = aDocumentNode->GetReadyStateEnum();
|
|
switch (docStateFlag) {
|
|
case nsIDocument::READYSTATE_UNINITIALIZED:
|
|
docState = "uninitialized";
|
|
break;
|
|
case nsIDocument::READYSTATE_LOADING:
|
|
docState = "loading";
|
|
break;
|
|
case nsIDocument::READYSTATE_INTERACTIVE:
|
|
docState = "interactive";
|
|
break;
|
|
case nsIDocument::READYSTATE_COMPLETE:
|
|
docState = "complete";
|
|
break;
|
|
}
|
|
|
|
printf("doc state: %s", docState);
|
|
printf(", %sinitial", aDocumentNode->IsInitialDocument() ? "" : "not ");
|
|
printf(", %sshowing", aDocumentNode->IsShowing() ? "" : "not ");
|
|
printf(", %svisible", aDocumentNode->IsVisible() ? "" : "not ");
|
|
printf(", %svisible considering ancestors", aDocumentNode->IsVisibleConsideringAncestors() ? "" : "not ");
|
|
printf(", %sactive", aDocumentNode->IsActive() ? "" : "not ");
|
|
printf(", %sresource", aDocumentNode->IsResourceDoc() ? "" : "not ");
|
|
printf(", has %srole content",
|
|
nsCoreUtils::GetRoleContent(aDocumentNode) ? "" : "no ");
|
|
}
|
|
|
|
static void
|
|
LogPresShell(nsIDocument* aDocumentNode)
|
|
{
|
|
nsIPresShell* ps = aDocumentNode->GetShell();
|
|
printf("presshell: %p", static_cast<void*>(ps));
|
|
|
|
nsIScrollableFrame* sf = nullptr;
|
|
if (ps) {
|
|
printf(", is %s destroying", (ps->IsDestroying() ? "" : "not"));
|
|
sf = ps->GetRootScrollFrameAsScrollable();
|
|
}
|
|
printf(", root scroll frame: %p", static_cast<void*>(sf));
|
|
}
|
|
|
|
static void
|
|
LogDocLoadGroup(nsIDocument* aDocumentNode)
|
|
{
|
|
nsCOMPtr<nsILoadGroup> loadGroup = aDocumentNode->GetDocumentLoadGroup();
|
|
printf("load group: %p", static_cast<void*>(loadGroup));
|
|
}
|
|
|
|
static void
|
|
LogDocParent(nsIDocument* aDocumentNode)
|
|
{
|
|
nsIDocument* parentDoc = aDocumentNode->GetParentDocument();
|
|
printf("parent DOM document: %p", static_cast<void*>(parentDoc));
|
|
if (parentDoc) {
|
|
printf(", parent acc document: %p",
|
|
static_cast<void*>(GetExistingDocAccessible(parentDoc)));
|
|
printf("\n parent ");
|
|
LogDocURI(parentDoc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
static void
|
|
LogDocInfo(nsIDocument* aDocumentNode, DocAccessible* aDocument)
|
|
{
|
|
printf(" DOM document: %p, acc document: %p\n ",
|
|
static_cast<void*>(aDocumentNode), static_cast<void*>(aDocument));
|
|
|
|
// log document info
|
|
if (aDocumentNode) {
|
|
LogDocURI(aDocumentNode);
|
|
printf("\n ");
|
|
LogDocShellState(aDocumentNode);
|
|
printf("; ");
|
|
LogDocType(aDocumentNode);
|
|
printf("\n ");
|
|
LogDocShellTree(aDocumentNode);
|
|
printf("\n ");
|
|
LogDocState(aDocumentNode);
|
|
printf("\n ");
|
|
LogPresShell(aDocumentNode);
|
|
printf("\n ");
|
|
LogDocLoadGroup(aDocumentNode);
|
|
printf(", ");
|
|
LogDocParent(aDocumentNode);
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
static void
|
|
LogShellLoadType(nsIDocShell* aDocShell)
|
|
{
|
|
printf("load type: ");
|
|
|
|
uint32_t loadType = 0;
|
|
aDocShell->GetLoadType(&loadType);
|
|
switch (loadType) {
|
|
case LOAD_NORMAL:
|
|
printf("normal; ");
|
|
break;
|
|
case LOAD_NORMAL_REPLACE:
|
|
printf("normal replace; ");
|
|
break;
|
|
case LOAD_NORMAL_EXTERNAL:
|
|
printf("normal external; ");
|
|
break;
|
|
case LOAD_HISTORY:
|
|
printf("history; ");
|
|
break;
|
|
case LOAD_NORMAL_BYPASS_CACHE:
|
|
printf("normal bypass cache; ");
|
|
break;
|
|
case LOAD_NORMAL_BYPASS_PROXY:
|
|
printf("normal bypass proxy; ");
|
|
break;
|
|
case LOAD_NORMAL_BYPASS_PROXY_AND_CACHE:
|
|
printf("normal bypass proxy and cache; ");
|
|
break;
|
|
case LOAD_NORMAL_ALLOW_MIXED_CONTENT:
|
|
printf("normal allow mixed content; ");
|
|
break;
|
|
case LOAD_RELOAD_NORMAL:
|
|
printf("reload normal; ");
|
|
break;
|
|
case LOAD_RELOAD_BYPASS_CACHE:
|
|
printf("reload bypass cache; ");
|
|
break;
|
|
case LOAD_RELOAD_BYPASS_PROXY:
|
|
printf("reload bypass proxy; ");
|
|
break;
|
|
case LOAD_RELOAD_BYPASS_PROXY_AND_CACHE:
|
|
printf("reload bypass proxy and cache; ");
|
|
break;
|
|
case LOAD_RELOAD_ALLOW_MIXED_CONTENT:
|
|
printf("reload allow mixed content; ");
|
|
break;
|
|
case LOAD_LINK:
|
|
printf("link; ");
|
|
break;
|
|
case LOAD_REFRESH:
|
|
printf("refresh; ");
|
|
break;
|
|
case LOAD_RELOAD_CHARSET_CHANGE:
|
|
printf("reload charset change; ");
|
|
break;
|
|
case LOAD_BYPASS_HISTORY:
|
|
printf("bypass history; ");
|
|
break;
|
|
case LOAD_STOP_CONTENT:
|
|
printf("stop content; ");
|
|
break;
|
|
case LOAD_STOP_CONTENT_AND_REPLACE:
|
|
printf("stop content and replace; ");
|
|
break;
|
|
case LOAD_PUSHSTATE:
|
|
printf("load pushstate; ");
|
|
break;
|
|
case LOAD_REPLACE_BYPASS_CACHE:
|
|
printf("replace bypass cache; ");
|
|
break;
|
|
case LOAD_ERROR_PAGE:
|
|
printf("error page;");
|
|
break;
|
|
default:
|
|
printf("unknown");
|
|
}
|
|
}
|
|
|
|
static void
|
|
LogRequest(nsIRequest* aRequest)
|
|
{
|
|
if (aRequest) {
|
|
nsAutoCString name;
|
|
aRequest->GetName(name);
|
|
printf(" request spec: %s\n", name.get());
|
|
uint32_t loadFlags = 0;
|
|
aRequest->GetLoadFlags(&loadFlags);
|
|
printf(" request load flags: %x; ", loadFlags);
|
|
if (loadFlags & nsIChannel::LOAD_DOCUMENT_URI)
|
|
printf("document uri; ");
|
|
if (loadFlags & nsIChannel::LOAD_RETARGETED_DOCUMENT_URI)
|
|
printf("retargeted document uri; ");
|
|
if (loadFlags & nsIChannel::LOAD_REPLACE)
|
|
printf("replace; ");
|
|
if (loadFlags & nsIChannel::LOAD_INITIAL_DOCUMENT_URI)
|
|
printf("initial document uri; ");
|
|
if (loadFlags & nsIChannel::LOAD_TARGETED)
|
|
printf("targeted; ");
|
|
if (loadFlags & nsIChannel::LOAD_CALL_CONTENT_SNIFFERS)
|
|
printf("call content sniffers; ");
|
|
if (loadFlags & nsIChannel::LOAD_CLASSIFY_URI)
|
|
printf("classify uri; ");
|
|
} else {
|
|
printf(" no request");
|
|
}
|
|
}
|
|
|
|
static void
|
|
LogDocAccState(DocAccessible* aDocument)
|
|
{
|
|
printf("document acc state: ");
|
|
if (aDocument->HasLoadState(DocAccessible::eCompletelyLoaded))
|
|
printf("completely loaded;");
|
|
else if (aDocument->HasLoadState(DocAccessible::eReady))
|
|
printf("ready;");
|
|
else if (aDocument->HasLoadState(DocAccessible::eDOMLoaded))
|
|
printf("DOM loaded;");
|
|
else if (aDocument->HasLoadState(DocAccessible::eTreeConstructed))
|
|
printf("tree constructed;");
|
|
}
|
|
|
|
static void
|
|
GetDocLoadEventType(AccEvent* aEvent, nsACString& aEventType)
|
|
{
|
|
uint32_t type = aEvent->GetEventType();
|
|
if (type == nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_STOPPED) {
|
|
aEventType.AssignLiteral("load stopped");
|
|
} else if (type == nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE) {
|
|
aEventType.AssignLiteral("load complete");
|
|
} else if (type == nsIAccessibleEvent::EVENT_DOCUMENT_RELOAD) {
|
|
aEventType.AssignLiteral("reload");
|
|
} else if (type == nsIAccessibleEvent::EVENT_STATE_CHANGE) {
|
|
AccStateChangeEvent* event = downcast_accEvent(aEvent);
|
|
if (event->GetState() == states::BUSY) {
|
|
aEventType.AssignLiteral("busy ");
|
|
if (event->IsStateEnabled())
|
|
aEventType.AppendLiteral("true");
|
|
else
|
|
aEventType.AppendLiteral("false");
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// namespace logging:: document life cycle logging methods
|
|
|
|
static const char* sDocLoadTitle = "DOCLOAD";
|
|
static const char* sDocCreateTitle = "DOCCREATE";
|
|
static const char* sDocDestroyTitle = "DOCDESTROY";
|
|
static const char* sDocEventTitle = "DOCEVENT";
|
|
static const char* sFocusTitle = "FOCUS";
|
|
|
|
void
|
|
logging::DocLoad(const char* aMsg, nsIWebProgress* aWebProgress,
|
|
nsIRequest* aRequest, uint32_t aStateFlags)
|
|
{
|
|
MsgBegin(sDocLoadTitle, aMsg);
|
|
|
|
nsCOMPtr<nsIDOMWindow> DOMWindow;
|
|
aWebProgress->GetDOMWindow(getter_AddRefs(DOMWindow));
|
|
nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(DOMWindow);
|
|
if (!window) {
|
|
MsgEnd();
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocument> documentNode = window->GetDoc();
|
|
if (!documentNode) {
|
|
MsgEnd();
|
|
return;
|
|
}
|
|
|
|
DocAccessible* document = GetExistingDocAccessible(documentNode);
|
|
|
|
LogDocInfo(documentNode, document);
|
|
|
|
nsCOMPtr<nsIDocShell> docShell = window->GetDocShell();
|
|
printf("\n ");
|
|
LogShellLoadType(docShell);
|
|
printf("\n");
|
|
LogRequest(aRequest);
|
|
printf("\n");
|
|
printf(" state flags: %x", aStateFlags);
|
|
bool isDocLoading;
|
|
aWebProgress->GetIsLoadingDocument(&isDocLoading);
|
|
printf(", document is %sloading\n", (isDocLoading ? "" : "not "));
|
|
|
|
MsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::DocLoad(const char* aMsg, nsIDocument* aDocumentNode)
|
|
{
|
|
MsgBegin(sDocLoadTitle, aMsg);
|
|
|
|
DocAccessible* document = GetExistingDocAccessible(aDocumentNode);
|
|
LogDocInfo(aDocumentNode, document);
|
|
|
|
MsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::DocCompleteLoad(DocAccessible* aDocument, bool aIsLoadEventTarget)
|
|
{
|
|
MsgBegin(sDocLoadTitle, "document loaded *completely*");
|
|
|
|
printf(" DOM document: %p, acc document: %p\n",
|
|
static_cast<void*>(aDocument->DocumentNode()),
|
|
static_cast<void*>(aDocument));
|
|
|
|
printf(" ");
|
|
LogDocURI(aDocument->DocumentNode());
|
|
printf("\n");
|
|
|
|
printf(" ");
|
|
LogDocAccState(aDocument);
|
|
printf("\n");
|
|
|
|
printf(" document is load event target: %s\n",
|
|
(aIsLoadEventTarget ? "true" : "false"));
|
|
|
|
MsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::DocLoadEventFired(AccEvent* aEvent)
|
|
{
|
|
nsAutoCString strEventType;
|
|
GetDocLoadEventType(aEvent, strEventType);
|
|
if (!strEventType.IsEmpty())
|
|
printf(" fire: %s\n", strEventType.get());
|
|
}
|
|
|
|
void
|
|
logging::DocLoadEventHandled(AccEvent* aEvent)
|
|
{
|
|
nsAutoCString strEventType;
|
|
GetDocLoadEventType(aEvent, strEventType);
|
|
if (strEventType.IsEmpty())
|
|
return;
|
|
|
|
MsgBegin(sDocEventTitle, "handled '%s' event", strEventType.get());
|
|
|
|
DocAccessible* document = aEvent->GetAccessible()->AsDoc();
|
|
if (document)
|
|
LogDocInfo(document->DocumentNode(), document);
|
|
|
|
MsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::DocCreate(const char* aMsg, nsIDocument* aDocumentNode,
|
|
DocAccessible* aDocument)
|
|
{
|
|
DocAccessible* document = aDocument ?
|
|
aDocument : GetExistingDocAccessible(aDocumentNode);
|
|
|
|
MsgBegin(sDocCreateTitle, aMsg);
|
|
LogDocInfo(aDocumentNode, document);
|
|
MsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::DocDestroy(const char* aMsg, nsIDocument* aDocumentNode,
|
|
DocAccessible* aDocument)
|
|
{
|
|
DocAccessible* document = aDocument ?
|
|
aDocument : GetExistingDocAccessible(aDocumentNode);
|
|
|
|
MsgBegin(sDocDestroyTitle, aMsg);
|
|
LogDocInfo(aDocumentNode, document);
|
|
MsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::OuterDocDestroy(OuterDocAccessible* aOuterDoc)
|
|
{
|
|
MsgBegin(sDocDestroyTitle, "outerdoc shutdown");
|
|
logging::Address("outerdoc", aOuterDoc);
|
|
MsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::FocusNotificationTarget(const char* aMsg, const char* aTargetDescr,
|
|
Accessible* aTarget)
|
|
{
|
|
MsgBegin(sFocusTitle, aMsg);
|
|
AccessibleNNode(aTargetDescr, aTarget);
|
|
MsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::FocusNotificationTarget(const char* aMsg, const char* aTargetDescr,
|
|
nsINode* aTargetNode)
|
|
{
|
|
MsgBegin(sFocusTitle, aMsg);
|
|
Node(aTargetDescr, aTargetNode);
|
|
MsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::FocusNotificationTarget(const char* aMsg, const char* aTargetDescr,
|
|
nsISupports* aTargetThing)
|
|
{
|
|
MsgBegin(sFocusTitle, aMsg);
|
|
|
|
if (aTargetThing) {
|
|
nsCOMPtr<nsINode> targetNode(do_QueryInterface(aTargetThing));
|
|
if (targetNode)
|
|
AccessibleNNode(aTargetDescr, targetNode);
|
|
else
|
|
printf(" %s: %p, window\n", aTargetDescr,
|
|
static_cast<void*>(aTargetThing));
|
|
}
|
|
|
|
MsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::ActiveItemChangeCausedBy(const char* aCause, Accessible* aTarget)
|
|
{
|
|
SubMsgBegin();
|
|
printf(" Caused by: %s\n", aCause);
|
|
AccessibleNNode("Item", aTarget);
|
|
SubMsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::ActiveWidget(Accessible* aWidget)
|
|
{
|
|
SubMsgBegin();
|
|
|
|
AccessibleNNode("Widget", aWidget);
|
|
printf(" Widget is active: %s, has operable items: %s\n",
|
|
(aWidget && aWidget->IsActiveWidget() ? "true" : "false"),
|
|
(aWidget && aWidget->AreItemsOperable() ? "true" : "false"));
|
|
|
|
SubMsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::FocusDispatched(Accessible* aTarget)
|
|
{
|
|
SubMsgBegin();
|
|
AccessibleNNode("A11y target", aTarget);
|
|
SubMsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::SelChange(nsISelection* aSelection, DocAccessible* aDocument,
|
|
int16_t aReason)
|
|
{
|
|
nsCOMPtr<nsISelectionPrivate> privSel(do_QueryInterface(aSelection));
|
|
|
|
int16_t type = 0;
|
|
privSel->GetType(&type);
|
|
|
|
const char* strType = 0;
|
|
if (type == nsISelectionController::SELECTION_NORMAL)
|
|
strType = "normal";
|
|
else if (type == nsISelectionController::SELECTION_SPELLCHECK)
|
|
strType = "spellcheck";
|
|
else
|
|
strType = "unknown";
|
|
|
|
bool isIgnored = !aDocument || !aDocument->IsContentLoaded();
|
|
printf("\nSelection changed, selection type: %s, notification %s, reason: %d\n",
|
|
strType, (isIgnored ? "ignored" : "pending"), aReason);
|
|
|
|
Stack();
|
|
}
|
|
|
|
void
|
|
logging::MsgBegin(const char* aTitle, const char* aMsgText, ...)
|
|
{
|
|
printf("\nA11Y %s: ", aTitle);
|
|
|
|
va_list argptr;
|
|
va_start(argptr, aMsgText);
|
|
vprintf(aMsgText, argptr);
|
|
va_end(argptr);
|
|
|
|
PRIntervalTime time = PR_IntervalNow();
|
|
uint32_t mins = (PR_IntervalToSeconds(time) / 60) % 60;
|
|
uint32_t secs = PR_IntervalToSeconds(time) % 60;
|
|
uint32_t msecs = PR_IntervalToMilliseconds(time) % 1000;
|
|
printf("; %02d:%02d.%03d", mins, secs, msecs);
|
|
|
|
printf("\n {\n");
|
|
}
|
|
|
|
void
|
|
logging::MsgEnd()
|
|
{
|
|
printf(" }\n");
|
|
}
|
|
|
|
void
|
|
logging::SubMsgBegin()
|
|
{
|
|
printf(" {\n");
|
|
}
|
|
|
|
void
|
|
logging::SubMsgEnd()
|
|
{
|
|
printf(" }\n");
|
|
}
|
|
|
|
void
|
|
logging::MsgEntry(const char* aEntryText, ...)
|
|
{
|
|
printf(" ");
|
|
|
|
va_list argptr;
|
|
va_start(argptr, aEntryText);
|
|
vprintf(aEntryText, argptr);
|
|
va_end(argptr);
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
void
|
|
logging::Text(const char* aText)
|
|
{
|
|
printf(" %s\n", aText);
|
|
}
|
|
|
|
void
|
|
logging::Address(const char* aDescr, Accessible* aAcc)
|
|
{
|
|
if (!aAcc->IsDoc()) {
|
|
printf(" %s accessible: %p, node: %p\n", aDescr,
|
|
static_cast<void*>(aAcc), static_cast<void*>(aAcc->GetNode()));
|
|
}
|
|
|
|
DocAccessible* doc = aAcc->Document();
|
|
nsIDocument* docNode = doc->DocumentNode();
|
|
printf(" document: %p, node: %p\n",
|
|
static_cast<void*>(doc), static_cast<void*>(docNode));
|
|
|
|
printf(" ");
|
|
LogDocURI(docNode);
|
|
printf("\n");
|
|
}
|
|
|
|
void
|
|
logging::Node(const char* aDescr, nsINode* aNode)
|
|
{
|
|
printf(" ");
|
|
|
|
if (!aNode) {
|
|
printf("%s: null\n", aDescr);
|
|
return;
|
|
}
|
|
|
|
if (aNode->IsNodeOfType(nsINode::eDOCUMENT)) {
|
|
printf("%s: %p, document\n", aDescr, static_cast<void*>(aNode));
|
|
return;
|
|
}
|
|
|
|
nsINode* parentNode = aNode->GetParentNode();
|
|
int32_t idxInParent = parentNode ? parentNode->IndexOf(aNode) : - 1;
|
|
|
|
if (aNode->IsNodeOfType(nsINode::eTEXT)) {
|
|
printf("%s: %p, text node, idx in parent: %d\n",
|
|
aDescr, static_cast<void*>(aNode), idxInParent);
|
|
return;
|
|
}
|
|
|
|
if (!aNode->IsElement()) {
|
|
printf("%s: %p, not accessible node type, idx in parent: %d\n",
|
|
aDescr, static_cast<void*>(aNode), idxInParent);
|
|
return;
|
|
}
|
|
|
|
dom::Element* elm = aNode->AsElement();
|
|
|
|
nsAutoCString tag;
|
|
elm->Tag()->ToUTF8String(tag);
|
|
|
|
nsIAtom* idAtom = elm->GetID();
|
|
nsAutoCString id;
|
|
if (idAtom)
|
|
idAtom->ToUTF8String(id);
|
|
|
|
printf("%s: %p, %s@id='%s', idx in parent: %d\n",
|
|
aDescr, static_cast<void*>(elm), tag.get(), id.get(), idxInParent);
|
|
}
|
|
|
|
void
|
|
logging::Document(DocAccessible* aDocument)
|
|
{
|
|
printf(" Document: %p, document node: %p\n",
|
|
static_cast<void*>(aDocument),
|
|
static_cast<void*>(aDocument->DocumentNode()));
|
|
|
|
printf(" Document ");
|
|
LogDocURI(aDocument->DocumentNode());
|
|
printf("\n");
|
|
}
|
|
|
|
void
|
|
logging::AccessibleNNode(const char* aDescr, Accessible* aAccessible)
|
|
{
|
|
printf(" %s: %p; ", aDescr, static_cast<void*>(aAccessible));
|
|
if (!aAccessible)
|
|
return;
|
|
|
|
nsAutoString role;
|
|
GetAccService()->GetStringRole(aAccessible->Role(), role);
|
|
nsAutoString name;
|
|
aAccessible->Name(name);
|
|
|
|
printf("role: %s, name: '%s';\n", NS_ConvertUTF16toUTF8(role).get(),
|
|
NS_ConvertUTF16toUTF8(name).get());
|
|
|
|
nsAutoCString nodeDescr(aDescr);
|
|
nodeDescr.AppendLiteral(" node");
|
|
Node(nodeDescr.get(), aAccessible->GetNode());
|
|
|
|
Document(aAccessible->Document());
|
|
}
|
|
|
|
void
|
|
logging::AccessibleNNode(const char* aDescr, nsINode* aNode)
|
|
{
|
|
DocAccessible* document =
|
|
GetAccService()->GetDocAccessible(aNode->OwnerDoc());
|
|
|
|
if (document) {
|
|
Accessible* accessible = document->GetAccessible(aNode);
|
|
if (accessible) {
|
|
AccessibleNNode(aDescr, accessible);
|
|
return;
|
|
}
|
|
}
|
|
|
|
nsAutoCString nodeDescr("[not accessible] ");
|
|
nodeDescr.Append(aDescr);
|
|
Node(nodeDescr.get(), aNode);
|
|
|
|
if (document) {
|
|
Document(document);
|
|
return;
|
|
}
|
|
|
|
printf(" [contained by not accessible document]:\n");
|
|
LogDocInfo(aNode->OwnerDoc(), document);
|
|
printf("\n");
|
|
}
|
|
|
|
void
|
|
logging::DOMEvent(const char* aDescr, nsINode* aOrigTarget,
|
|
const nsAString& aEventType)
|
|
{
|
|
logging::MsgBegin("DOMEvents", "event '%s' %s",
|
|
NS_ConvertUTF16toUTF8(aEventType).get(), aDescr);
|
|
logging::AccessibleNNode("Target", aOrigTarget);
|
|
logging::MsgEnd();
|
|
}
|
|
|
|
void
|
|
logging::Stack()
|
|
{
|
|
if (IsEnabled(eStack)) {
|
|
printf(" stack: \n");
|
|
nsTraceRefcnt::WalkTheStack(stdout);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// namespace logging:: initialization
|
|
|
|
bool
|
|
logging::IsEnabled(uint32_t aModules)
|
|
{
|
|
return sModules & aModules;
|
|
}
|
|
|
|
bool
|
|
logging::IsEnabled(const nsAString& aModuleStr)
|
|
{
|
|
for (unsigned int idx = 0; idx < ArrayLength(sModuleMap); idx++) {
|
|
if (aModuleStr.EqualsASCII(sModuleMap[idx].mStr))
|
|
return sModules & sModuleMap[idx].mModule;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void
|
|
logging::Enable(const nsAFlatCString& aModules)
|
|
{
|
|
EnableLogging(aModules.get());
|
|
}
|
|
|
|
|
|
void
|
|
logging::CheckEnv()
|
|
{
|
|
EnableLogging(PR_GetEnv("A11YLOG"));
|
|
}
|