The Tor Browser: accessible/src/base/Logging.cpp@b8a032363ba2 (annotated)

accessible/src/base/Logging.cpp@b8a032363ba2 (annotated)

accessible/src/base/Logging.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- 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 id: %p", static_cast<void*>(parentDoc));
   if (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<nsIWebNavigation> webNav(do_GetInterface(DOMWindow));
   nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(webNav));
   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"));
 }

The Tor Browser / annotate

accessible/src/base/Logging.cpp@b8a032363ba2 (annotated)

accessible/src/base/Logging.cpp