Bug 1627398 Part 2 - Support printing frame tree in CSS pixels. r=heycam

Audit all the types related to app units [1] printed in
nsIFrame::List (and all the methods that override it), and use
ConvertToString to convert their printing format to CSS pixels if
needed.

In addition, add operator<< to BaseCoord so that it can cooperate with
mozilla::ToString, which is needed by ConvertToString.

[1] The types include nsRect, nsSize, nscoord, LogicalRect, and
LogicalSize.

Differential Revision: https://phabricator.services.mozilla.com/D69915

--HG--
extra : moz-landing-system : lando

gfx/2d/BaseCoord.h

@@ -7,6 +7,8 @@
 #ifndef MOZILLA_GFX_BASECOORD_H_
 #define MOZILLA_GFX_BASECOORD_H_
 
+#include <ostream>
+
 #include "mozilla/Attributes.h"
 
 namespace mozilla {
@@ -77,6 +79,11 @@ struct BaseCoord {
   friend T operator-(T aA, Sub aB) { return aA - aB.value; }
 
   Sub operator-() const { return Sub(-value); }
+
+  friend std::ostream& operator<<(std::ostream& aStream,
+                                  const BaseCoord<T, Sub>& aCoord) {
+    return aStream << aCoord.value;
+  }
 };
 
 }  // namespace gfx

layout/generic/nsFrame.cpp

@@ -8047,6 +8047,28 @@ nsAutoCString nsIFrame::ListTag() const {
   return tag;
 }
 
+std::string nsIFrame::ConvertToString(const LogicalRect& aRect,
+                                      const WritingMode aWM, ListFlags aFlags) {
+  if (aFlags.contains(ListFlag::DisplayInCSSPixels)) {
+    // Abuse CSSRect to store all LogicalRect's dimensions in CSS pixels.
+    return ToString(mozilla::CSSRect(CSSPixel::FromAppUnits(aRect.IStart(aWM)),
+                                     CSSPixel::FromAppUnits(aRect.BStart(aWM)),
+                                     CSSPixel::FromAppUnits(aRect.ISize(aWM)),
+                                     CSSPixel::FromAppUnits(aRect.BSize(aWM))));
+  }
+  return ToString(aRect);
+}
+
+std::string nsIFrame::ConvertToString(const LogicalSize& aSize,
+                                      const WritingMode aWM, ListFlags aFlags) {
+  if (aFlags.contains(ListFlag::DisplayInCSSPixels)) {
+    // Abuse CSSSize to store all LogicalSize's dimensions in CSS pixels.
+    return ToString(CSSSize(CSSPixel::FromAppUnits(aSize.ISize(aWM)),
+                            CSSPixel::FromAppUnits(aSize.BSize(aWM))));
+  }
+  return ToString(aSize);
+}
+
 // Debugging
 void nsIFrame::ListGeneric(nsACString& aTo, const char* aPrefix,
                            ListFlags aFlags) const {
@@ -8084,9 +8106,9 @@ void nsIFrame::ListGeneric(nsACString& aTo, const char* aPrefix,
       aTo += nsPrintfCString(" FFR");
       if (nsFontInflationData* data =
               nsFontInflationData::FindFontInflationDataFor(this)) {
-        aTo += nsPrintfCString(",enabled=%s,UIS=%s",
-                               data->InflationEnabled() ? "yes" : "no",
-                               ToString(data->UsableISize()).c_str());
+        aTo += nsPrintfCString(
+            ",enabled=%s,UIS=%s", data->InflationEnabled() ? "yes" : "no",
+            ConvertToString(data->UsableISize(), aFlags).c_str());
       }
     }
     if (HasAnyStateBits(NS_FRAME_FONT_INFLATION_CONTAINER)) {
@@ -8094,12 +8116,13 @@ void nsIFrame::ListGeneric(nsACString& aTo, const char* aPrefix,
     }
     aTo += nsPrintfCString(" FI=%f", nsLayoutUtils::FontSizeInflationFor(this));
   }
-  aTo += nsPrintfCString(" %s", ToString(mRect).c_str());
+  aTo += nsPrintfCString(" %s", ConvertToString(mRect, aFlags).c_str());
 
   mozilla::WritingMode wm = GetWritingMode();
   if (wm.IsVertical() || wm.IsBidiRTL()) {
-    aTo += nsPrintfCString(" wm=%s logical-size=(%s)", ToString(wm).c_str(),
-                           ToString(GetLogicalSize()).c_str());
+    aTo +=
+        nsPrintfCString(" wm=%s logical-size=(%s)", ToString(wm).c_str(),
+                        ConvertToString(GetLogicalSize(), wm, aFlags).c_str());
   }
 
   nsIFrame* parent = GetParent();
@@ -8108,27 +8131,30 @@ void nsIFrame::ListGeneric(nsACString& aTo, const char* aPrefix,
     if (pWM.IsVertical() || pWM.IsBidiRTL()) {
       nsSize containerSize = parent->mRect.Size();
       LogicalRect lr(pWM, mRect, containerSize);
-      aTo += nsPrintfCString(
-          " parent-wm=%s cs=(%s) logical-rect=%s", ToString(pWM).c_str(),
-          ToString(containerSize).c_str(), ToString(lr).c_str());
+      aTo += nsPrintfCString(" parent-wm=%s cs=(%s) logical-rect=%s",
+                             ToString(pWM).c_str(),
+                             ConvertToString(containerSize, aFlags).c_str(),
+                             ConvertToString(lr, pWM, aFlags).c_str());
     }
   }
   nsIFrame* f = const_cast<nsIFrame*>(this);
   if (f->HasOverflowAreas()) {
     nsRect vo = f->GetVisualOverflowRect();
     if (!vo.IsEqualEdges(mRect)) {
-      aTo += nsPrintfCString(" vis-overflow=%s", ToString(vo).c_str());
+      aTo += nsPrintfCString(" vis-overflow=%s",
+                             ConvertToString(vo, aFlags).c_str());
     }
     nsRect so = f->GetScrollableOverflowRect();
     if (!so.IsEqualEdges(mRect)) {
-      aTo += nsPrintfCString(" scr-overflow=%s", ToString(so).c_str());
+      aTo += nsPrintfCString(" scr-overflow=%s",
+                             ConvertToString(so, aFlags).c_str());
     }
   }
   bool hasNormalPosition;
   nsPoint normalPosition = GetNormalPosition(&hasNormalPosition);
   if (hasNormalPosition) {
     aTo += nsPrintfCString(" normal-position=%s",
-                           ToString(normalPosition).c_str());
+                           ConvertToString(normalPosition, aFlags).c_str());
   }
   if (0 != mState) {
     aTo += nsPrintfCString(" [state=%016llx]", (unsigned long long)mState);

layout/generic/nsIFrame.h

@@ -4732,8 +4732,23 @@ class nsIFrame : public nsQueryFrame {
   void ListTag(FILE* out) const { fputs(ListTag().get(), out); }
   nsAutoCString ListTag() const;
 
-  enum class ListFlag{TraverseSubdocumentFrames};
+  enum class ListFlag{TraverseSubdocumentFrames, DisplayInCSSPixels};
   using ListFlags = mozilla::EnumSet<ListFlag>;
+
+  template <typename T>
+  static std::string ConvertToString(const T& aValue, ListFlags aFlags) {
+    // This method can convert all physical types in app units to CSS pixels.
+    return aFlags.contains(ListFlag::DisplayInCSSPixels)
+               ? mozilla::ToString(mozilla::CSSPixel::FromAppUnits(aValue))
+               : mozilla::ToString(aValue);
+  }
+  static std::string ConvertToString(const mozilla::LogicalRect& aRect,
+                                     const mozilla::WritingMode aWM,
+                                     ListFlags aFlags);
+  static std::string ConvertToString(const mozilla::LogicalSize& aSize,
+                                     const mozilla::WritingMode aWM,
+                                     ListFlags aFlags);
+
   void ListGeneric(nsACString& aTo, const char* aPrefix = "",
                    ListFlags aFlags = ListFlags()) const;
   virtual void List(FILE* out = stderr, const char* aPrefix = "",

layout/generic/nsLineBox.cpp

@@ -241,22 +241,27 @@ void nsLineBox::List(FILE* out, const char* aPrefix,
                          static_cast<const void*>(this), GetChildCount(),
                          StateToString(cbuf, sizeof(cbuf)));
   if (IsBlock() && !GetCarriedOutBEndMargin().IsZero()) {
-    str += nsPrintfCString("bm=%d ", GetCarriedOutBEndMargin().get());
+    const nscoord bm = GetCarriedOutBEndMargin().get();
+    str += nsPrintfCString("bm=%s ",
+                           nsIFrame::ConvertToString(bm, aFlags).c_str());
   }
   nsRect bounds = GetPhysicalBounds();
-  str += nsPrintfCString("%s ", ToString(bounds).c_str());
+  str +=
+      nsPrintfCString("%s ", nsIFrame::ConvertToString(bounds, aFlags).c_str());
   if (mWritingMode.IsVertical() || mWritingMode.IsBidiRTL()) {
     str += nsPrintfCString(
         "wm=%s cs=(%s) logical-rect=%s ", ToString(mWritingMode).c_str(),
-        ToString(mContainerSize).c_str(), ToString(mBounds).c_str());
+        nsIFrame::ConvertToString(mContainerSize, aFlags).c_str(),
+        nsIFrame::ConvertToString(mBounds, mWritingMode, aFlags).c_str());
   }
-  if (mData &&
-      (!mData->mOverflowAreas.VisualOverflow().IsEqualEdges(bounds) ||
-       !mData->mOverflowAreas.ScrollableOverflow().IsEqualEdges(bounds))) {
-    str += nsPrintfCString(
-        "vis-overflow=%s scr-overflow=%s ",
-        ToString(mData->mOverflowAreas.VisualOverflow()).c_str(),
-        ToString(mData->mOverflowAreas.ScrollableOverflow()).c_str());
+  if (mData) {
+    const nsRect vo = mData->mOverflowAreas.VisualOverflow();
+    const nsRect so = mData->mOverflowAreas.ScrollableOverflow();
+    if (!vo.IsEqualEdges(bounds) || !so.IsEqualEdges(bounds)) {
+      str += nsPrintfCString("vis-overflow=%s scr-overflow=%s ",
+                             nsIFrame::ConvertToString(vo, aFlags).c_str(),
+                             nsIFrame::ConvertToString(so, aFlags).c_str());
+    }
   }
   fprintf_stderr(out, "%s<\n", str.get());