accessible/base/Logging.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "Logging.h"
   8
   9 #include "LocalAccessible-inl.h"
  10 #include "AccEvent.h"
  11 #include "DocAccessible.h"
  12 #include "DocAccessible-inl.h"
  13 #include "nsAccessibilityService.h"
  14 #include "nsCoreUtils.h"
  15 #include "OuterDocAccessible.h"
  16
  17 #include "nsDocShellLoadTypes.h"
  18 #include "nsIChannel.h"
  19 #include "nsIInterfaceRequestorUtils.h"
  20 #include "nsIWebProgress.h"
  21 #include "prenv.h"
  22 #include "nsIDocShellTreeItem.h"
  23 #include "mozilla/Maybe.h"
  24 #include "mozilla/PresShell.h"
  25 #include "mozilla/StackWalk.h"
  26 #include "mozilla/ToString.h"
  27 #include "mozilla/dom/BorrowedAttrInfo.h"
  28 #include "mozilla/dom/Document.h"
  29 #include "mozilla/dom/Element.h"
  30 #include "mozilla/dom/HTMLBodyElement.h"
  31 #include "mozilla/dom/Selection.h"
  32
  33 using namespace mozilla;
  34 using namespace mozilla::a11y;
  35
  36 using mozilla::dom::BorrowedAttrInfo;
  37
  38 MOZ_DEFINE_MALLOC_SIZE_OF(AccessibleLoggingMallocSizeOf)
  39
  40 ////////////////////////////////////////////////////////////////////////////////
  41 // Logging helpers
  42
  43 static uint32_t sModules = 0;
  44
  45 struct ModuleRep {
  46   const char* mStr;
  47   logging::EModules mModule;
  48 };
  49
  50 static ModuleRep sModuleMap[] = {{"docload", logging::eDocLoad},
  51                                  {"doccreate", logging::eDocCreate},
  52                                  {"docdestroy", logging::eDocDestroy},
  53                                  {"doclifecycle", logging::eDocLifeCycle},
  54
  55                                  {"events", logging::eEvents},
  56                                  {"platforms", logging::ePlatforms},
  57                                  {"text", logging::eText},
  58                                  {"tree", logging::eTree},
  59                                  {"treeSize", logging::eTreeSize},
  60
  61                                  {"DOMEvents", logging::eDOMEvents},
  62                                  {"focus", logging::eFocus},
  63                                  {"selection", logging::eSelection},
  64                                  {"notifications", logging::eNotifications},
  65
  66                                  {"stack", logging::eStack},
  67                                  {"verbose", logging::eVerbose},
  68                                  {"cache", logging::eCache}};
  69
  70 static void EnableLogging(const char* aModulesStr) {
  71   sModules = 0;
  72   if (!aModulesStr) return;
  73
  74   const char* token = aModulesStr;
  75   while (*token != '\0') {
  76     size_t tokenLen = strcspn(token, ",");
  77     for (unsigned int idx = 0; idx < ArrayLength(sModuleMap); idx++) {
  78       if (strncmp(token, sModuleMap[idx].mStr, tokenLen) == 0) {
  79 #if !defined(MOZ_PROFILING) && (!defined(DEBUG) || defined(MOZ_OPTIMIZE))
  80         // Stack tracing on profiling enabled or debug not optimized builds.
  81         if (strncmp(token, "stack", tokenLen) == 0) break;
  82 #endif
  83         sModules |= sModuleMap[idx].mModule;
  84         printf("\n\nmodule enabled: %s\n", sModuleMap[idx].mStr);
  85         break;
  86       }
  87     }
  88     token += tokenLen;
  89
  90     if (*token == ',') token++;  // skip ',' char
  91   }
  92 }
  93
  94 static void LogDocURI(dom::Document* aDocumentNode) {
  95   nsIURI* uri = aDocumentNode->GetDocumentURI();
  96   if (uri) {
  97     printf("uri: %s", uri->GetSpecOrDefault().get());
  98   } else {
  99     printf("uri: null");
 100   }
 101 }
 102
 103 static void LogDocShellState(dom::Document* aDocumentNode) {
 104   printf("docshell busy: ");
 105   nsCOMPtr<nsIDocShell> docShell = aDocumentNode->GetDocShell();
 106   if (!docShell) {
 107     printf("null docshell");
 108     return;
 109   }
 110
 111   nsAutoCString docShellBusy;
 112   nsIDocShell::BusyFlags busyFlags = nsIDocShell::BUSY_FLAGS_NONE;
 113   docShell->GetBusyFlags(&busyFlags);
 114   if (busyFlags == nsIDocShell::BUSY_FLAGS_NONE) {
 115     printf("'none'");
 116   }
 117   if (busyFlags & nsIDocShell::BUSY_FLAGS_BUSY) {
 118     printf("'busy'");
 119   }
 120   if (busyFlags & nsIDocShell::BUSY_FLAGS_BEFORE_PAGE_LOAD) {
 121     printf(", 'before page load'");
 122   }
 123   if (busyFlags & nsIDocShell::BUSY_FLAGS_PAGE_LOADING) {
 124     printf(", 'page loading'");
 125   }
 126 }
 127
 128 static void LogDocType(dom::Document* aDocumentNode) {
 129   if (aDocumentNode->IsActive()) {
 130     bool isContent = aDocumentNode->IsContentDocument();
 131     printf("%s document", (isContent ? "content" : "chrome"));
 132   } else {
 133     printf("document type: [failed]");
 134   }
 135 }
 136
 137 static void LogDocShellTree(dom::Document* aDocumentNode) {
 138   if (aDocumentNode->IsActive()) {
 139     nsCOMPtr<nsIDocShellTreeItem> treeItem(aDocumentNode->GetDocShell());
 140     if (!treeItem) {
 141       printf("in-process docshell hierarchy, null docshell;");
 142       return;
 143     }
 144     nsCOMPtr<nsIDocShellTreeItem> parentTreeItem;
 145     treeItem->GetInProcessParent(getter_AddRefs(parentTreeItem));
 146     nsCOMPtr<nsIDocShellTreeItem> rootTreeItem;
 147     treeItem->GetInProcessRootTreeItem(getter_AddRefs(rootTreeItem));
 148     printf(
 149         "in-process docshell hierarchy, parent: %p, root: %p, "
 150         "is top level: %s;",
 151         static_cast<void*>(parentTreeItem), static_cast<void*>(rootTreeItem),
 152         (nsCoreUtils::IsTopLevelContentDocInProcess(aDocumentNode) ? "yes"
 153                                                                    : "no"));
 154   }
 155 }
 156
 157 static void LogDocState(dom::Document* aDocumentNode) {
 158   const char* docState = nullptr;
 159   dom::Document::ReadyState docStateFlag = aDocumentNode->GetReadyStateEnum();
 160   switch (docStateFlag) {
 161     case dom::Document::READYSTATE_UNINITIALIZED:
 162       docState = "uninitialized";
 163       break;
 164     case dom::Document::READYSTATE_LOADING:
 165       docState = "loading";
 166       break;
 167     case dom::Document::READYSTATE_INTERACTIVE:
 168       docState = "interactive";
 169       break;
 170     case dom::Document::READYSTATE_COMPLETE:
 171       docState = "complete";
 172       break;
 173   }
 174
 175   printf("doc state: %s", docState);
 176   printf(", %sinitial", aDocumentNode->IsInitialDocument() ? "" : "not ");
 177   printf(", %sshowing", aDocumentNode->IsShowing() ? "" : "not ");
 178   printf(", %svisible", aDocumentNode->IsVisible() ? "" : "not ");
 179   printf(
 180       ", %svisible considering ancestors",
 181       nsCoreUtils::IsDocumentVisibleConsideringInProcessAncestors(aDocumentNode)
 182           ? ""
 183           : "not ");
 184   printf(", %sactive", aDocumentNode->IsActive() ? "" : "not ");
 185   printf(", %sresource", aDocumentNode->IsResourceDoc() ? "" : "not ");
 186
 187   dom::Element* rootEl = aDocumentNode->GetBodyElement();
 188   if (!rootEl) {
 189     rootEl = aDocumentNode->GetRootElement();
 190   }
 191   printf(", has %srole content", rootEl ? "" : "no ");
 192 }
 193
 194 static void LogPresShell(dom::Document* aDocumentNode) {
 195   PresShell* presShell = aDocumentNode->GetPresShell();
 196   printf("presshell: %p", static_cast<void*>(presShell));
 197
 198   nsIScrollableFrame* sf = nullptr;
 199   if (presShell) {
 200     printf(", is %s destroying", (presShell->IsDestroying() ? "" : "not"));
 201     sf = presShell->GetRootScrollFrameAsScrollable();
 202   }
 203   printf(", root scroll frame: %p", static_cast<void*>(sf));
 204 }
 205
 206 static void LogDocLoadGroup(dom::Document* aDocumentNode) {
 207   nsCOMPtr<nsILoadGroup> loadGroup = aDocumentNode->GetDocumentLoadGroup();
 208   printf("load group: %p", static_cast<void*>(loadGroup));
 209 }
 210
 211 static void LogDocParent(dom::Document* aDocumentNode) {
 212   dom::Document* parentDoc = aDocumentNode->GetInProcessParentDocument();
 213   printf("parent DOM document: %p", static_cast<void*>(parentDoc));
 214   if (parentDoc) {
 215     printf(", parent acc document: %p",
 216            static_cast<void*>(GetExistingDocAccessible(parentDoc)));
 217     printf("\n    parent ");
 218     LogDocURI(parentDoc);
 219     printf("\n");
 220   }
 221 }
 222
 223 static void LogDocInfo(dom::Document* aDocumentNode, DocAccessible* aDocument) {
 224   printf("    DOM document: %p, acc document: %p\n    ",
 225          static_cast<void*>(aDocumentNode), static_cast<void*>(aDocument));
 226
 227   // log document info
 228   if (aDocumentNode) {
 229     LogDocURI(aDocumentNode);
 230     printf("\n    ");
 231     LogDocShellState(aDocumentNode);
 232     printf("; ");
 233     LogDocType(aDocumentNode);
 234     printf("\n    ");
 235     LogDocShellTree(aDocumentNode);
 236     printf("\n    ");
 237     LogDocState(aDocumentNode);
 238     printf("\n    ");
 239     LogPresShell(aDocumentNode);
 240     printf("\n    ");
 241     LogDocLoadGroup(aDocumentNode);
 242     printf(", ");
 243     LogDocParent(aDocumentNode);
 244     printf("\n");
 245   }
 246 }
 247
 248 static void LogShellLoadType(nsIDocShell* aDocShell) {
 249   printf("load type: ");
 250
 251   uint32_t loadType = 0;
 252   aDocShell->GetLoadType(&loadType);
 253   switch (loadType) {
 254     case LOAD_NORMAL:
 255       printf("normal; ");
 256       break;
 257     case LOAD_NORMAL_REPLACE:
 258       printf("normal replace; ");
 259       break;
 260     case LOAD_HISTORY:
 261       printf("history; ");
 262       break;
 263     case LOAD_NORMAL_BYPASS_CACHE:
 264       printf("normal bypass cache; ");
 265       break;
 266     case LOAD_NORMAL_BYPASS_PROXY:
 267       printf("normal bypass proxy; ");
 268       break;
 269     case LOAD_NORMAL_BYPASS_PROXY_AND_CACHE:
 270       printf("normal bypass proxy and cache; ");
 271       break;
 272     case LOAD_RELOAD_NORMAL:
 273       printf("reload normal; ");
 274       break;
 275     case LOAD_RELOAD_BYPASS_CACHE:
 276       printf("reload bypass cache; ");
 277       break;
 278     case LOAD_RELOAD_BYPASS_PROXY:
 279       printf("reload bypass proxy; ");
 280       break;
 281     case LOAD_RELOAD_BYPASS_PROXY_AND_CACHE:
 282       printf("reload bypass proxy and cache; ");
 283       break;
 284     case LOAD_LINK:
 285       printf("link; ");
 286       break;
 287     case LOAD_REFRESH:
 288       printf("refresh; ");
 289       break;
 290     case LOAD_REFRESH_REPLACE:
 291       printf("refresh replace; ");
 292       break;
 293     case LOAD_RELOAD_CHARSET_CHANGE:
 294       printf("reload charset change; ");
 295       break;
 296     case LOAD_BYPASS_HISTORY:
 297       printf("bypass history; ");
 298       break;
 299     case LOAD_STOP_CONTENT:
 300       printf("stop content; ");
 301       break;
 302     case LOAD_STOP_CONTENT_AND_REPLACE:
 303       printf("stop content and replace; ");
 304       break;
 305     case LOAD_PUSHSTATE:
 306       printf("load pushstate; ");
 307       break;
 308     case LOAD_REPLACE_BYPASS_CACHE:
 309       printf("replace bypass cache; ");
 310       break;
 311     case LOAD_ERROR_PAGE:
 312       printf("error page;");
 313       break;
 314     default:
 315       printf("unknown");
 316   }
 317 }
 318
 319 static void LogRequest(nsIRequest* aRequest) {
 320   if (aRequest) {
 321     nsAutoCString name;
 322     aRequest->GetName(name);
 323     printf("    request spec: %s\n", name.get());
 324     uint32_t loadFlags = 0;
 325     aRequest->GetLoadFlags(&loadFlags);
 326     printf("    request load flags: %x; ", loadFlags);
 327     if (loadFlags & nsIChannel::LOAD_DOCUMENT_URI) printf("document uri; ");
 328     if (loadFlags & nsIChannel::LOAD_RETARGETED_DOCUMENT_URI) {
 329       printf("retargeted document uri; ");
 330     }
 331     if (loadFlags & nsIChannel::LOAD_REPLACE) printf("replace; ");
 332     if (loadFlags & nsIChannel::LOAD_INITIAL_DOCUMENT_URI) {
 333       printf("initial document uri; ");
 334     }
 335     if (loadFlags & nsIChannel::LOAD_TARGETED) printf("targeted; ");
 336     if (loadFlags & nsIChannel::LOAD_CALL_CONTENT_SNIFFERS) {
 337       printf("call content sniffers; ");
 338     }
 339     if (loadFlags & nsIChannel::LOAD_BYPASS_URL_CLASSIFIER) {
 340       printf("bypass classify uri; ");
 341     }
 342   } else {
 343     printf("    no request");
 344   }
 345 }
 346
 347 static void LogDocAccState(DocAccessible* aDocument) {
 348   printf("document acc state: ");
 349   if (aDocument->HasLoadState(DocAccessible::eCompletelyLoaded)) {
 350     printf("completely loaded;");
 351   } else if (aDocument->HasLoadState(DocAccessible::eReady)) {
 352     printf("ready;");
 353   } else if (aDocument->HasLoadState(DocAccessible::eDOMLoaded)) {
 354     printf("DOM loaded;");
 355   } else if (aDocument->HasLoadState(DocAccessible::eTreeConstructed)) {
 356     printf("tree constructed;");
 357   }
 358 }
 359
 360 static void GetDocLoadEventType(AccEvent* aEvent, nsACString& aEventType) {
 361   uint32_t type = aEvent->GetEventType();
 362   if (type == nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_STOPPED) {
 363     aEventType.AssignLiteral("load stopped");
 364   } else if (type == nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE) {
 365     aEventType.AssignLiteral("load complete");
 366   } else if (type == nsIAccessibleEvent::EVENT_DOCUMENT_RELOAD) {
 367     aEventType.AssignLiteral("reload");
 368   } else if (type == nsIAccessibleEvent::EVENT_STATE_CHANGE) {
 369     AccStateChangeEvent* event = downcast_accEvent(aEvent);
 370     if (event->GetState() == states::BUSY) {
 371       aEventType.AssignLiteral("busy ");
 372       if (event->IsStateEnabled()) {
 373         aEventType.AppendLiteral("true");
 374       } else {
 375         aEventType.AppendLiteral("false");
 376       }
 377     }
 378   }
 379 }
 380
 381 static void DescribeNode(nsINode* aNode, nsAString& aOutDescription) {
 382   if (!aNode) {
 383     aOutDescription.AppendLiteral("null");
 384     return;
 385   }
 386
 387   aOutDescription.AppendPrintf("0x%p, ", (void*)aNode);
 388   aOutDescription.Append(aNode->NodeInfo()->QualifiedName());
 389
 390   if (!aNode->IsElement()) {
 391     return;
 392   }
 393
 394   dom::Element* elm = aNode->AsElement();
 395
 396   nsAtom* idAtom = elm->GetID();
 397   if (idAtom) {
 398     nsAutoCString id;
 399     idAtom->ToUTF8String(id);
 400     aOutDescription.AppendPrintf("@id=\"%s\" ", id.get());
 401   } else {
 402     aOutDescription.Append(' ');
 403   }
 404
 405   uint32_t attrCount = elm->GetAttrCount();
 406   if (!attrCount || (idAtom && attrCount == 1)) {
 407     return;
 408   }
 409
 410   aOutDescription.AppendLiteral("[ ");
 411
 412   for (uint32_t index = 0; index < attrCount; index++) {
 413     BorrowedAttrInfo info = elm->GetAttrInfoAt(index);
 414
 415     // Skip redundant display of id attribute.
 416     if (info.mName->Equals(nsGkAtoms::id)) {
 417       continue;
 418     }
 419
 420     // name
 421     nsAutoString name;
 422     info.mName->GetQualifiedName(name);
 423     aOutDescription.Append(name);
 424
 425     aOutDescription.AppendLiteral("=\"");
 426
 427     // value
 428     nsAutoString value;
 429     info.mValue->ToString(value);
 430     for (uint32_t i = value.Length(); i > 0; --i) {
 431       if (value[i - 1] == char16_t('"')) value.Insert(char16_t('\\'), i - 1);
 432     }
 433     aOutDescription.Append(value);
 434     aOutDescription.AppendLiteral("\" ");
 435   }
 436
 437   aOutDescription.Append(']');
 438 }
 439
 440 ////////////////////////////////////////////////////////////////////////////////
 441 // namespace logging:: document life cycle logging methods
 442
 443 static const char* sDocLoadTitle = "DOCLOAD";
 444 static const char* sDocCreateTitle = "DOCCREATE";
 445 static const char* sDocDestroyTitle = "DOCDESTROY";
 446 static const char* sDocEventTitle = "DOCEVENT";
 447 static const char* sFocusTitle = "FOCUS";
 448
 449 void logging::DocLoad(const char* aMsg, nsIWebProgress* aWebProgress,
 450                       nsIRequest* aRequest, uint32_t aStateFlags) {
 451   MsgBegin(sDocLoadTitle, "%s", aMsg);
 452
 453   nsCOMPtr<mozIDOMWindowProxy> DOMWindow;
 454   aWebProgress->GetDOMWindow(getter_AddRefs(DOMWindow));
 455   nsPIDOMWindowOuter* window = nsPIDOMWindowOuter::From(DOMWindow);
 456   if (!window) {
 457     MsgEnd();
 458     return;
 459   }
 460
 461   nsCOMPtr<dom::Document> documentNode = window->GetDoc();
 462   if (!documentNode) {
 463     MsgEnd();
 464     return;
 465   }
 466
 467   DocAccessible* document = GetExistingDocAccessible(documentNode);
 468
 469   LogDocInfo(documentNode, document);
 470
 471   nsCOMPtr<nsIDocShell> docShell = window->GetDocShell();
 472   printf("\n    ");
 473   LogShellLoadType(docShell);
 474   printf("\n");
 475   LogRequest(aRequest);
 476   printf("\n");
 477   printf("    state flags: %x", aStateFlags);
 478   bool isDocLoading;
 479   aWebProgress->GetIsLoadingDocument(&isDocLoading);
 480   printf(", document is %sloading\n", (isDocLoading ? "" : "not "));
 481
 482   MsgEnd();
 483 }
 484
 485 void logging::DocLoad(const char* aMsg, dom::Document* aDocumentNode) {
 486   MsgBegin(sDocLoadTitle, "%s", aMsg);
 487
 488   DocAccessible* document = GetExistingDocAccessible(aDocumentNode);
 489   LogDocInfo(aDocumentNode, document);
 490
 491   MsgEnd();
 492 }
 493
 494 void logging::DocCompleteLoad(DocAccessible* aDocument,
 495                               bool aIsLoadEventTarget) {
 496   MsgBegin(sDocLoadTitle, "document loaded *completely*");
 497
 498   printf("    DOM document: %p, acc document: %p\n",
 499          static_cast<void*>(aDocument->DocumentNode()),
 500          static_cast<void*>(aDocument));
 501
 502   printf("    ");
 503   LogDocURI(aDocument->DocumentNode());
 504   printf("\n");
 505
 506   printf("    ");
 507   LogDocAccState(aDocument);
 508   printf("\n");
 509
 510   printf("    document is load event target: %s\n",
 511          (aIsLoadEventTarget ? "true" : "false"));
 512
 513   MsgEnd();
 514 }
 515
 516 void logging::DocLoadEventFired(AccEvent* aEvent) {
 517   nsAutoCString strEventType;
 518   GetDocLoadEventType(aEvent, strEventType);
 519   if (!strEventType.IsEmpty()) printf("  fire: %s\n", strEventType.get());
 520 }
 521
 522 void logging::DocLoadEventHandled(AccEvent* aEvent) {
 523   nsAutoCString strEventType;
 524   GetDocLoadEventType(aEvent, strEventType);
 525   if (strEventType.IsEmpty()) return;
 526
 527   MsgBegin(sDocEventTitle, "handled '%s' event", strEventType.get());
 528
 529   DocAccessible* document = aEvent->GetAccessible()->AsDoc();
 530   if (document) LogDocInfo(document->DocumentNode(), document);
 531
 532   MsgEnd();
 533 }
 534
 535 void logging::DocCreate(const char* aMsg, dom::Document* aDocumentNode,
 536                         DocAccessible* aDocument) {
 537   DocAccessible* document =
 538       aDocument ? aDocument : GetExistingDocAccessible(aDocumentNode);
 539
 540   MsgBegin(sDocCreateTitle, "%s", aMsg);
 541   LogDocInfo(aDocumentNode, document);
 542   MsgEnd();
 543 }
 544
 545 void logging::DocDestroy(const char* aMsg, dom::Document* aDocumentNode,
 546                          DocAccessible* aDocument) {
 547   DocAccessible* document =
 548       aDocument ? aDocument : GetExistingDocAccessible(aDocumentNode);
 549
 550   MsgBegin(sDocDestroyTitle, "%s", aMsg);
 551   LogDocInfo(aDocumentNode, document);
 552   MsgEnd();
 553 }
 554
 555 void logging::OuterDocDestroy(OuterDocAccessible* aOuterDoc) {
 556   MsgBegin(sDocDestroyTitle, "outerdoc shutdown");
 557   logging::Address("outerdoc", aOuterDoc);
 558   MsgEnd();
 559 }
 560
 561 void logging::FocusNotificationTarget(const char* aMsg,
 562                                       const char* aTargetDescr,
 563                                       LocalAccessible* aTarget) {
 564   MsgBegin(sFocusTitle, "%s", aMsg);
 565   AccessibleNNode(aTargetDescr, aTarget);
 566   MsgEnd();
 567 }
 568
 569 void logging::FocusNotificationTarget(const char* aMsg,
 570                                       const char* aTargetDescr,
 571                                       nsINode* aTargetNode) {
 572   MsgBegin(sFocusTitle, "%s", aMsg);
 573   Node(aTargetDescr, aTargetNode);
 574   MsgEnd();
 575 }
 576
 577 void logging::FocusNotificationTarget(const char* aMsg,
 578                                       const char* aTargetDescr,
 579                                       nsISupports* aTargetThing) {
 580   MsgBegin(sFocusTitle, "%s", aMsg);
 581
 582   if (aTargetThing) {
 583     nsCOMPtr<nsINode> targetNode(do_QueryInterface(aTargetThing));
 584     if (targetNode) {
 585       AccessibleNNode(aTargetDescr, targetNode);
 586     } else {
 587       printf("    %s: %p, window\n", aTargetDescr,
 588              static_cast<void*>(aTargetThing));
 589     }
 590   }
 591
 592   MsgEnd();
 593 }
 594
 595 void logging::ActiveItemChangeCausedBy(const char* aCause,
 596                                        LocalAccessible* aTarget) {
 597   SubMsgBegin();
 598   printf("    Caused by: %s\n", aCause);
 599   AccessibleNNode("Item", aTarget);
 600   SubMsgEnd();
 601 }
 602
 603 void logging::ActiveWidget(LocalAccessible* aWidget) {
 604   SubMsgBegin();
 605
 606   AccessibleNNode("Widget", aWidget);
 607   printf("    Widget is active: %s, has operable items: %s\n",
 608          (aWidget && aWidget->IsActiveWidget() ? "true" : "false"),
 609          (aWidget && aWidget->AreItemsOperable() ? "true" : "false"));
 610
 611   SubMsgEnd();
 612 }
 613
 614 void logging::FocusDispatched(LocalAccessible* aTarget) {
 615   SubMsgBegin();
 616   AccessibleNNode("A11y target", aTarget);
 617   SubMsgEnd();
 618 }
 619
 620 void logging::SelChange(dom::Selection* aSelection, DocAccessible* aDocument,
 621                         int16_t aReason) {
 622   SelectionType type = aSelection->GetType();
 623
 624   const char* strType = 0;
 625   if (type == SelectionType::eNormal) {
 626     strType = "normal";
 627   } else if (type == SelectionType::eSpellCheck) {
 628     strType = "spellcheck";
 629   } else {
 630     strType = "unknown";
 631   }
 632
 633   bool isIgnored = !aDocument || !aDocument->IsContentLoaded();
 634   printf(
 635       "\nSelection changed, selection type: %s, notification %s, reason: %d\n",
 636       strType, (isIgnored ? "ignored" : "pending"), aReason);
 637
 638   Stack();
 639 }
 640
 641 void logging::TreeInfo(const char* aMsg, uint32_t aExtraFlags, ...) {
 642   if (IsEnabledAll(logging::eTree | aExtraFlags)) {
 643     va_list vl;
 644     va_start(vl, aExtraFlags);
 645     const char* descr = va_arg(vl, const char*);
 646     if (descr) {
 647       LocalAccessible* acc = va_arg(vl, LocalAccessible*);
 648       MsgBegin("TREE", "%s; doc: %p", aMsg, acc ? acc->Document() : nullptr);
 649       AccessibleInfo(descr, acc);
 650       while ((descr = va_arg(vl, const char*))) {
 651         AccessibleInfo(descr, va_arg(vl, LocalAccessible*));
 652       }
 653     } else {
 654       MsgBegin("TREE", "%s", aMsg);
 655     }
 656     va_end(vl);
 657     MsgEnd();
 658
 659     if (aExtraFlags & eStack) {
 660       Stack();
 661     }
 662   }
 663 }
 664
 665 void logging::TreeInfo(const char* aMsg, uint32_t aExtraFlags,
 666                        const char* aMsg1, LocalAccessible* aAcc,
 667                        const char* aMsg2, nsINode* aNode) {
 668   if (IsEnabledAll(logging::eTree | aExtraFlags)) {
 669     MsgBegin("TREE", "%s; doc: %p", aMsg, aAcc ? aAcc->Document() : nullptr);
 670     AccessibleInfo(aMsg1, aAcc);
 671     LocalAccessible* acc =
 672         aAcc ? aAcc->Document()->GetAccessible(aNode) : nullptr;
 673     if (acc) {
 674       AccessibleInfo(aMsg2, acc);
 675     } else {
 676       Node(aMsg2, aNode);
 677     }
 678     MsgEnd();
 679   }
 680 }
 681
 682 void logging::TreeInfo(const char* aMsg, uint32_t aExtraFlags,
 683                        LocalAccessible* aParent) {
 684   if (IsEnabledAll(logging::eTree | aExtraFlags)) {
 685     MsgBegin("TREE", "%s; doc: %p", aMsg, aParent->Document());
 686     AccessibleInfo("container", aParent);
 687     for (uint32_t idx = 0; idx < aParent->ChildCount(); idx++) {
 688       AccessibleInfo("child", aParent->LocalChildAt(idx));
 689     }
 690     MsgEnd();
 691   }
 692 }
 693
 694 void logging::Tree(const char* aTitle, const char* aMsgText,
 695                    LocalAccessible* aRoot, GetTreePrefix aPrefixFunc,
 696                    void* aGetTreePrefixData) {
 697   logging::MsgBegin(aTitle, "%s", aMsgText);
 698
 699   nsAutoString level;
 700   LocalAccessible* root = aRoot;
 701   do {
 702     const char* prefix =
 703         aPrefixFunc ? aPrefixFunc(aGetTreePrefixData, root) : "";
 704     printf("%s", NS_ConvertUTF16toUTF8(level).get());
 705     logging::AccessibleInfo(prefix, root);
 706     if (root->LocalFirstChild() && !root->LocalFirstChild()->IsDoc()) {
 707       level.AppendLiteral(u"  ");
 708       root = root->LocalFirstChild();
 709       continue;
 710     }
 711     int32_t idxInParent = root != aRoot && root->mParent
 712                               ? root->mParent->mChildren.IndexOf(root)
 713                               : -1;
 714     if (idxInParent != -1 &&
 715         idxInParent <
 716             static_cast<int32_t>(root->mParent->mChildren.Length() - 1)) {
 717       root = root->mParent->mChildren.ElementAt(idxInParent + 1);
 718       continue;
 719     }
 720     while (root != aRoot && (root = root->LocalParent())) {
 721       level.Cut(0, 2);
 722       int32_t idxInParent = !root->IsDoc() && root->mParent
 723                                 ? root->mParent->mChildren.IndexOf(root)
 724                                 : -1;
 725       if (idxInParent != -1 &&
 726           idxInParent <
 727               static_cast<int32_t>(root->mParent->mChildren.Length() - 1)) {
 728         root = root->mParent->mChildren.ElementAt(idxInParent + 1);
 729         break;
 730       }
 731     }
 732   } while (root && root != aRoot);
 733
 734   logging::MsgEnd();
 735 }
 736
 737 void logging::DOMTree(const char* aTitle, const char* aMsgText,
 738                       DocAccessible* aDocument) {
 739   logging::MsgBegin(aTitle, "%s", aMsgText);
 740   nsAutoString level;
 741   nsINode* root = aDocument->DocumentNode();
 742   do {
 743     printf("%s", NS_ConvertUTF16toUTF8(level).get());
 744     logging::Node("", root);
 745     if (root->GetFirstChild()) {
 746       level.AppendLiteral(u"  ");
 747       root = root->GetFirstChild();
 748       continue;
 749     }
 750     if (root->GetNextSibling()) {
 751       root = root->GetNextSibling();
 752       continue;
 753     }
 754     while ((root = root->GetParentNode())) {
 755       level.Cut(0, 2);
 756       if (root->GetNextSibling()) {
 757         root = root->GetNextSibling();
 758         break;
 759       }
 760     }
 761   } while (root);
 762   logging::MsgEnd();
 763 }
 764
 765 void logging::TreeSize(const char* aTitle, const char* aMsgText,
 766                        LocalAccessible* aRoot) {
 767   logging::MsgBegin(aTitle, "%s", aMsgText);
 768   logging::AccessibleInfo("Logging tree size from: ", aRoot);
 769   size_t b = 0;
 770   size_t n = 0;
 771   LocalAccessible* root = aRoot;
 772   do {
 773     // Process the current acc
 774     b += AccessibleLoggingMallocSizeOf(root);
 775     n++;
 776
 777     // Get next acc
 778     if (root->LocalFirstChild() && !root->LocalFirstChild()->IsDoc()) {
 779       root = root->LocalFirstChild();
 780       continue;
 781     }
 782     int32_t idxInParent = root != aRoot && root->mParent
 783                               ? root->mParent->mChildren.IndexOf(root)
 784                               : -1;
 785     if (idxInParent != -1 &&
 786         idxInParent <
 787             static_cast<int32_t>(root->mParent->mChildren.Length() - 1)) {
 788       root = root->mParent->mChildren.ElementAt(idxInParent + 1);
 789       continue;
 790     }
 791     while (root != aRoot && (root = root->LocalParent())) {
 792       int32_t idxInParent = !root->IsDoc() && root->mParent
 793                                 ? root->mParent->mChildren.IndexOf(root)
 794                                 : -1;
 795       if (idxInParent != -1 &&
 796           idxInParent <
 797               static_cast<int32_t>(root->mParent->mChildren.Length() - 1)) {
 798         root = root->mParent->mChildren.ElementAt(idxInParent + 1);
 799         break;
 800       }
 801     }
 802   } while (root && root != aRoot);
 803
 804   printf("\nTree contains %zu accessibles and is %zu bytes\n", n, b);
 805   logging::MsgEnd();
 806 }
 807
 808 void logging::MsgBegin(const char* aTitle, const char* aMsgText, ...) {
 809   printf("\nA11Y %s: ", aTitle);
 810
 811   va_list argptr;
 812   va_start(argptr, aMsgText);
 813   vprintf(aMsgText, argptr);
 814   va_end(argptr);
 815
 816   PRIntervalTime time = PR_IntervalNow();
 817   uint32_t mins = (PR_IntervalToSeconds(time) / 60) % 60;
 818   uint32_t secs = PR_IntervalToSeconds(time) % 60;
 819   uint32_t msecs = PR_IntervalToMilliseconds(time) % 1000;
 820   printf("; %02u:%02u.%03u", mins, secs, msecs);
 821
 822   printf("\n  {\n");
 823 }
 824
 825 void logging::MsgEnd() { printf("  }\n"); }
 826
 827 void logging::SubMsgBegin() { printf("  {\n"); }
 828
 829 void logging::SubMsgEnd() { printf("  }\n"); }
 830
 831 void logging::MsgEntry(const char* aEntryText, ...) {
 832   printf("    ");
 833
 834   va_list argptr;
 835   va_start(argptr, aEntryText);
 836   vprintf(aEntryText, argptr);
 837   va_end(argptr);
 838
 839   printf("\n");
 840 }
 841
 842 void logging::Text(const char* aText) { printf("  %s\n", aText); }
 843
 844 void logging::Address(const char* aDescr, LocalAccessible* aAcc) {
 845   if (!aAcc->IsDoc()) {
 846     printf("    %s accessible: %p, node: %p\n", aDescr,
 847            static_cast<void*>(aAcc), static_cast<void*>(aAcc->GetNode()));
 848   }
 849
 850   DocAccessible* doc = aAcc->Document();
 851   dom::Document* docNode = doc->DocumentNode();
 852   printf("    document: %p, node: %p\n", static_cast<void*>(doc),
 853          static_cast<void*>(docNode));
 854
 855   printf("    ");
 856   LogDocURI(docNode);
 857   printf("\n");
 858 }
 859
 860 void logging::Node(const char* aDescr, nsINode* aNode) {
 861   Maybe<uint32_t> idxInParent = aNode->ComputeIndexInParentNode();
 862   nsAutoString nodeDesc;
 863   DescribeNode(aNode, nodeDesc);
 864   printf("    %s: %s, idx in parent %s\n", aDescr,
 865          NS_ConvertUTF16toUTF8(nodeDesc).get(), ToString(idxInParent).c_str());
 866 }
 867
 868 void logging::Document(DocAccessible* aDocument) {
 869   printf("    Document: %p, document node: %p\n", static_cast<void*>(aDocument),
 870          static_cast<void*>(aDocument->DocumentNode()));
 871
 872   printf("    Document ");
 873   LogDocURI(aDocument->DocumentNode());
 874   printf("\n");
 875 }
 876
 877 void logging::AccessibleInfo(const char* aDescr, LocalAccessible* aAccessible) {
 878   printf("    %s: %p; ", aDescr, static_cast<void*>(aAccessible));
 879   if (!aAccessible) {
 880     printf("\n");
 881     return;
 882   }
 883   if (aAccessible->IsDefunct()) {
 884     printf("defunct\n");
 885     return;
 886   }
 887   if (!aAccessible->Document() || aAccessible->Document()->IsDefunct()) {
 888     printf("document is shutting down, no info\n");
 889     return;
 890   }
 891
 892   nsAutoString role;
 893   GetAccService()->GetStringRole(aAccessible->Role(), role);
 894   printf("role: %s", NS_ConvertUTF16toUTF8(role).get());
 895
 896   nsAutoString name;
 897   aAccessible->Name(name);
 898   if (!name.IsEmpty()) {
 899     printf(", name: '%s'", NS_ConvertUTF16toUTF8(name).get());
 900   }
 901
 902   printf(", idx: %d", aAccessible->IndexInParent());
 903
 904   nsAutoString nodeDesc;
 905   DescribeNode(aAccessible->GetNode(), nodeDesc);
 906   printf(", node: %s\n", NS_ConvertUTF16toUTF8(nodeDesc).get());
 907 }
 908
 909 void logging::AccessibleNNode(const char* aDescr,
 910                               LocalAccessible* aAccessible) {
 911   printf("    %s: %p; ", aDescr, static_cast<void*>(aAccessible));
 912   if (!aAccessible) return;
 913
 914   nsAutoString role;
 915   GetAccService()->GetStringRole(aAccessible->Role(), role);
 916   nsAutoString name;
 917   aAccessible->Name(name);
 918
 919   printf("role: %s, name: '%s';\n", NS_ConvertUTF16toUTF8(role).get(),
 920          NS_ConvertUTF16toUTF8(name).get());
 921
 922   nsAutoCString nodeDescr(aDescr);
 923   nodeDescr.AppendLiteral(" node");
 924   Node(nodeDescr.get(), aAccessible->GetNode());
 925
 926   Document(aAccessible->Document());
 927 }
 928
 929 void logging::AccessibleNNode(const char* aDescr, nsINode* aNode) {
 930   DocAccessible* document =
 931       GetAccService()->GetDocAccessible(aNode->OwnerDoc());
 932
 933   if (document) {
 934     LocalAccessible* accessible = document->GetAccessible(aNode);
 935     if (accessible) {
 936       AccessibleNNode(aDescr, accessible);
 937       return;
 938     }
 939   }
 940
 941   nsAutoCString nodeDescr("[not accessible] ");
 942   nodeDescr.Append(aDescr);
 943   Node(nodeDescr.get(), aNode);
 944
 945   if (document) {
 946     Document(document);
 947     return;
 948   }
 949
 950   printf("    [contained by not accessible document]:\n");
 951   LogDocInfo(aNode->OwnerDoc(), document);
 952   printf("\n");
 953 }
 954
 955 void logging::DOMEvent(const char* aDescr, nsINode* aOrigTarget,
 956                        const nsAString& aEventType) {
 957   logging::MsgBegin("DOMEvents", "event '%s' %s",
 958                     NS_ConvertUTF16toUTF8(aEventType).get(), aDescr);
 959   logging::AccessibleNNode("Target", aOrigTarget);
 960   logging::MsgEnd();
 961 }
 962
 963 void logging::Stack() {
 964   if (IsEnabled(eStack)) {
 965     printf("  stack: \n");
 966     MozWalkTheStack(stdout);
 967   }
 968 }
 969
 970 ////////////////////////////////////////////////////////////////////////////////
 971 // namespace logging:: initialization
 972
 973 bool logging::IsEnabled(uint32_t aModules) { return sModules & aModules; }
 974
 975 bool logging::IsEnabledAll(uint32_t aModules) {
 976   return (sModules & aModules) == aModules;
 977 }
 978
 979 bool logging::IsEnabled(const nsAString& aModuleStr) {
 980   for (unsigned int idx = 0; idx < ArrayLength(sModuleMap); idx++) {
 981     if (aModuleStr.EqualsASCII(sModuleMap[idx].mStr)) {
 982       return sModules & sModuleMap[idx].mModule;
 983     }
 984   }
 985
 986   return false;
 987 }
 988
 989 void logging::Enable(const nsCString& aModules) {
 990   EnableLogging(aModules.get());
 991 }
 992
 993 void logging::CheckEnv() { EnableLogging(PR_GetEnv("A11YLOG")); }