Bug 1430608: Make nsMediaFeatures work with a document, not a pres context. r=heycam

Returning a zero-sized viewport in the case there's no shell / pres context.

For now, no other change yet. After this we can start tweaking the ShadowRoot
Stylist setup, and even try to return computed styles without a document \o/.

MozReview-Commit-ID: 3cT2PKQISri

dom/base/nsIDocument.h

@@ -2215,6 +2215,16 @@ public:
     mIsBeingUsedAsImage = true;
   }
 
+  bool IsSVGGlyphsDocument() const
+  {
+    return mIsSVGGlyphsDocument;
+  }
+
+  void SetIsSVGGlyphsDocument()
+  {
+    mIsSVGGlyphsDocument = true;
+  }
+
   bool IsResourceDoc() const {
     return IsBeingUsedAsImage() || // Are we a helper-doc for an SVG image?
       mHasDisplayDocument;         // Are we an external resource doc?
@@ -3542,6 +3552,9 @@ protected:
   // created.
   bool mIsShadowDOMEnabled : 1;
 
+  // True if this document is for an SVG-in-OpenType font.
+  bool mIsSVGGlyphsDocument : 1;
+
   // Whether <style scoped> support is enabled in this document.
   enum { eScopedStyle_Unknown, eScopedStyle_Disabled, eScopedStyle_Enabled };
   unsigned int mIsScopedStyleEnabled : 2;

gfx/thebes/gfxSVGGlyphs.cpp

@@ -157,11 +157,8 @@ gfxSVGGlyphsDocument::SetupPresentation()
     nsCOMPtr<nsIPresShell> presShell;
     rv = viewer->GetPresShell(getter_AddRefs(presShell));
     NS_ENSURE_SUCCESS(rv, rv);
-    nsPresContext* presContext = presShell->GetPresContext();
-    presContext->SetIsGlyph(true);
-
     if (!presShell->DidInitialize()) {
-        nsRect rect = presContext->GetVisibleArea();
+        nsRect rect = presShell->GetPresContext()->GetVisibleArea();
         rv = presShell->Initialize(rect.Width(), rect.Height());
         NS_ENSURE_SUCCESS(rv, rv);
     }
@@ -395,6 +392,7 @@ gfxSVGGlyphsDocument::ParseDocument(const uint8_t *aBuffer, uint32_t aBufLen)
 
     // Set this early because various decisions during page-load depend on it.
     document->SetIsBeingUsedAsImage();
+    document->SetIsSVGGlyphsDocument();
     document->SetReadyStateInternal(nsIDocument::READYSTATE_UNINITIALIZED);
 
     nsCOMPtr<nsIStreamListener> listener;

layout/base/nsPresContext.h

@@ -1131,14 +1131,6 @@ public:
 
   void NotifyNonBlankPaint();
 
-  bool IsGlyph() const {
-    return mIsGlyph;
-  }
-
-  void SetIsGlyph(bool aValue) {
-    mIsGlyph = aValue;
-  }
-
   bool UsesRootEMUnits() const {
     return mUsesRootEMUnits;
   }

layout/style/nsMediaFeatures.cpp

@@ -85,130 +85,145 @@ const OperatingSystemVersionInfo osVersionStrings[] = {
 };
 #endif
 
+static nsPresContext*
+GetPresContext(nsIDocument* aDocument)
+{
+  nsIPresShell* presShell = aDocument->GetShell();
+  if (!presShell) {
+    return nullptr;
+  }
+
+  return presShell->GetPresContext();
+}
+
 // A helper for four features below
 static nsSize
-GetSize(nsPresContext* aPresContext)
+GetSize(nsIDocument* aDocument)
 {
-  nsSize size;
+  nsPresContext* pc = GetPresContext(aDocument);
-  if (aPresContext->IsRootPaginatedDocument())
+
+  // Per spec, return a 0x0 viewport if we're not being rendered. See:
+  //
+  //  * https://github.com/w3c/csswg-drafts/issues/571
+  //  * https://github.com/whatwg/html/issues/1813
+  //
+  if (!pc) {
+    return { };
+  }
+
+  if (pc->IsRootPaginatedDocument()) {
     // We want the page size, including unprintable areas and margins.
-    size = aPresContext->GetPageSize();
+    //
-  else
+    // FIXME(emilio, bug 1414600): Not quite!
-    size = aPresContext->GetVisibleArea().Size();
+    return pc->GetPageSize();
-  return size;
+  }
+
+  return pc->GetVisibleArea().Size();
 }
 
 static void
-GetWidth(nsPresContext* aPresContext, const nsMediaFeature*,
+GetWidth(nsIDocument* aDocument, const nsMediaFeature*,
          nsCSSValue& aResult)
 {
-  nsSize size = GetSize(aPresContext);
+  nsSize size = GetSize(aDocument);
-  float pixelWidth = aPresContext->AppUnitsToFloatCSSPixels(size.width);
+  aResult.SetFloatValue(CSSPixel::FromAppUnits(size.width), eCSSUnit_Pixel);
-  aResult.SetFloatValue(pixelWidth, eCSSUnit_Pixel);
 }
 
 static void
-GetHeight(nsPresContext* aPresContext, const nsMediaFeature*,
+GetHeight(nsIDocument* aDocument, const nsMediaFeature*,
           nsCSSValue& aResult)
 {
-  nsSize size = GetSize(aPresContext);
+  nsSize size = GetSize(aDocument);
-  float pixelHeight = aPresContext->AppUnitsToFloatCSSPixels(size.height);
+  aResult.SetFloatValue(CSSPixel::FromAppUnits(size.height), eCSSUnit_Pixel);
-  aResult.SetFloatValue(pixelHeight, eCSSUnit_Pixel);
-}
-
-inline static nsDeviceContext*
-GetDeviceContextFor(nsPresContext* aPresContext)
-{
-  // It would be nice to call
-  // nsLayoutUtils::GetDeviceContextForScreenInfo here, except for two
-  // things:  (1) it can flush, and flushing is bad here, and (2) it
-  // doesn't really get us consistency in multi-monitor situations
-  // *anyway*.
-  return aPresContext->DeviceContext();
 }
 
 static bool
-ShouldResistFingerprinting(nsPresContext* aPresContext)
+ShouldResistFingerprinting(nsIDocument* aDocument)
 {
-  return nsContentUtils::ShouldResistFingerprinting(aPresContext->GetDocShell());
+  return nsContentUtils::ShouldResistFingerprinting(aDocument->GetDocShell());
+}
+
+static bool
+IsDeviceSizePageSize(nsIDocument* aDocument)
+{
+  nsIDocShell* docShell = aDocument->GetDocShell();
+  if (!docShell) {
+    return false;
+  }
+  return docShell->GetDeviceSizeIsPageSize();
 }
 
 // A helper for three features below.
 static nsSize
-GetDeviceSize(nsPresContext* aPresContext)
+GetDeviceSize(nsIDocument* aDocument)
 {
-  nsSize size;
+  if (ShouldResistFingerprinting(aDocument) || IsDeviceSizePageSize(aDocument)) {
+    return GetSize(aDocument);
+  }
 
-  if (ShouldResistFingerprinting(aPresContext) || aPresContext->IsDeviceSizePageSize()) {
+  nsPresContext* pc = GetPresContext(aDocument);
-    size = GetSize(aPresContext);
+  // NOTE(emilio): We should probably figure out how to return an appropriate
-  } else if (aPresContext->IsRootPaginatedDocument()) {
+  // device size here, though in a multi-screen world that makes no sense
+  // really.
+  if (!pc) {
+    return { };
+  }
+
+  if (pc->IsRootPaginatedDocument()) {
     // We want the page size, including unprintable areas and margins.
     // XXX The spec actually says we want the "page sheet size", but
     // how is that different?
-    size = aPresContext->GetPageSize();
+    return pc->GetPageSize();
-  } else {
-    GetDeviceContextFor(aPresContext)->
-      GetDeviceSurfaceDimensions(size.width, size.height);
   }
+
+  nsSize size;
+  pc->DeviceContext()->GetDeviceSurfaceDimensions(size.width, size.height);
   return size;
 }
 
 static void
-GetDeviceWidth(nsPresContext* aPresContext, const nsMediaFeature*,
+GetDeviceWidth(nsIDocument* aDocument, const nsMediaFeature*,
                nsCSSValue& aResult)
 {
-  nsSize size = GetDeviceSize(aPresContext);
+  nsSize size = GetDeviceSize(aDocument);
-  float pixelWidth = aPresContext->AppUnitsToFloatCSSPixels(size.width);
+  aResult.SetFloatValue(CSSPixel::FromAppUnits(size.width), eCSSUnit_Pixel);
-  aResult.SetFloatValue(pixelWidth, eCSSUnit_Pixel);
 }
 
 static void
-GetDeviceHeight(nsPresContext* aPresContext, const nsMediaFeature*,
+GetDeviceHeight(nsIDocument* aDocument, const nsMediaFeature*,
                 nsCSSValue& aResult)
 {
-  nsSize size = GetDeviceSize(aPresContext);
+  nsSize size = GetDeviceSize(aDocument);
-  float pixelHeight = aPresContext->AppUnitsToFloatCSSPixels(size.height);
+  aResult.SetFloatValue(CSSPixel::FromAppUnits(size.height), eCSSUnit_Pixel);
-  aResult.SetFloatValue(pixelHeight, eCSSUnit_Pixel);
 }
 
 static void
-GetOrientation(nsPresContext* aPresContext, const nsMediaFeature*,
+GetOrientation(nsIDocument* aDocument, const nsMediaFeature*,
                nsCSSValue& aResult)
 {
-  nsSize size = GetSize(aPresContext);
+  nsSize size = GetSize(aDocument);
-  int32_t orientation;
+  // Per spec, square viewports should be 'portrait'
-  if (size.width > size.height) {
+  int32_t orientation = size.width > size.height
-    orientation = NS_STYLE_ORIENTATION_LANDSCAPE;
+    ?  NS_STYLE_ORIENTATION_LANDSCAPE : NS_STYLE_ORIENTATION_PORTRAIT;
-  } else {
-    // Per spec, square viewports should be 'portrait'
-    orientation = NS_STYLE_ORIENTATION_PORTRAIT;
-  }
-
   aResult.SetIntValue(orientation, eCSSUnit_Enumerated);
 }
 
 static void
-GetDeviceOrientation(nsPresContext* aPresContext, const nsMediaFeature*,
+GetDeviceOrientation(nsIDocument* aDocument, const nsMediaFeature*,
                      nsCSSValue& aResult)
 {
-  nsSize size = GetDeviceSize(aPresContext);
+  nsSize size = GetDeviceSize(aDocument);
-  int32_t orientation;
+  // Per spec, square viewports should be 'portrait'
-  if (size.width > size.height) {
+  int32_t orientation = size.width > size.height
-    orientation = NS_STYLE_ORIENTATION_LANDSCAPE;
+    ? NS_STYLE_ORIENTATION_LANDSCAPE : NS_STYLE_ORIENTATION_PORTRAIT;
-  } else {
-    // Per spec, square viewports should be 'portrait'
-    orientation = NS_STYLE_ORIENTATION_PORTRAIT;
-  }
-
   aResult.SetIntValue(orientation, eCSSUnit_Enumerated);
 }
 
 static void
-GetIsResourceDocument(nsPresContext* aPresContext, const nsMediaFeature*,
+GetIsResourceDocument(nsIDocument* aDocument, const nsMediaFeature*,
                       nsCSSValue& aResult)
 {
-  nsIDocument* doc = aPresContext->Document();
+  aResult.SetIntValue(aDocument->IsResourceDoc() ? 1 : 0, eCSSUnit_Integer);
-  aResult.SetIntValue(doc && doc->IsResourceDoc() ? 1 : 0, eCSSUnit_Integer);
 }
 
 // Helper for two features below
@@ -224,32 +239,46 @@ MakeArray(const nsSize& aSize, nsCSSValue& aResult)
 }
 
 static void
-GetAspectRatio(nsPresContext* aPresContext, const nsMediaFeature*,
+GetAspectRatio(nsIDocument* aDocument, const nsMediaFeature*,
                nsCSSValue& aResult)
 {
-  MakeArray(GetSize(aPresContext), aResult);
+  MakeArray(GetSize(aDocument), aResult);
 }
 
 static void
-GetDeviceAspectRatio(nsPresContext* aPresContext, const nsMediaFeature*,
+GetDeviceAspectRatio(nsIDocument* aDocument, const nsMediaFeature*,
                      nsCSSValue& aResult)
 {
-  MakeArray(GetDeviceSize(aPresContext), aResult);
+  MakeArray(GetDeviceSize(aDocument), aResult);
+}
+
+static nsDeviceContext*
+GetDeviceContextFor(nsIDocument* aDocument)
+{
+  nsPresContext* pc = GetPresContext(aDocument);
+  if (!pc) {
+    return nullptr;
+  }
+
+  // It would be nice to call nsLayoutUtils::GetDeviceContextForScreenInfo here,
+  // except for two things:  (1) it can flush, and flushing is bad here, and (2)
+  // it doesn't really get us consistency in multi-monitor situations *anyway*.
+  return pc->DeviceContext();
 }
 
 static void
-GetColor(nsPresContext* aPresContext, const nsMediaFeature*,
+GetColor(nsIDocument* aDocument, const nsMediaFeature*,
          nsCSSValue& aResult)
 {
-  uint32_t depth = 24; // Use depth of 24 when resisting fingerprinting.
+  // Use depth of 24 when resisting fingerprinting, or when we're not being
+  // rendered.
+  uint32_t depth = 24;
 
-  if (!ShouldResistFingerprinting(aPresContext)) {
+  if (!ShouldResistFingerprinting(aDocument)) {
-    // FIXME:  This implementation is bogus.  nsDeviceContext
+    if (nsDeviceContext* dx = GetDeviceContextFor(aDocument)) {
-    // doesn't provide reliable information (should be fixed in bug
+      // FIXME: On a monochrome device, return 0!
-    // 424386).
+      dx->GetDepth(depth);
-    // FIXME: On a monochrome device, return 0!
+    }
-    nsDeviceContext *dx = GetDeviceContextFor(aPresContext);
-    dx->GetDepth(depth);
   }
 
   // The spec says to use bits *per color component*, so divide by 3,
@@ -260,7 +289,7 @@ GetColor(nsPresContext* aPresContext, const nsMediaFeature*,
 }
 
 static void
-GetColorIndex(nsPresContext* aPresContext, const nsMediaFeature*,
+GetColorIndex(nsIDocument* aDocument, const nsMediaFeature*,
               nsCSSValue& aResult)
 {
   // We should return zero if the device does not use a color lookup
@@ -273,7 +302,7 @@ GetColorIndex(nsPresContext* aPresContext, const nsMediaFeature*,
 }
 
 static void
-GetMonochrome(nsPresContext* aPresContext, const nsMediaFeature*,
+GetMonochrome(nsIDocument* aDocument, const nsMediaFeature*,
               nsCSSValue& aResult)
 {
   // For color devices we should return 0.
@@ -283,7 +312,7 @@ GetMonochrome(nsPresContext* aPresContext, const nsMediaFeature*,
 }
 
 static void
-GetResolution(nsPresContext* aPresContext, const nsMediaFeature*,
+GetResolution(nsIDocument* aDocument, const nsMediaFeature*,
               nsCSSValue& aResult)
 {
   // We're returning resolution in terms of device pixels per css pixel, since
@@ -291,23 +320,23 @@ GetResolution(nsPresContext* aPresContext, const nsMediaFeature*,
   // introducing precision error from conversion to and from less-used
   // physical units like inches.
 
-  float dppx;
+  float dppx = 1.;
 
-  if (!ShouldResistFingerprinting(aPresContext)) {
+  if (nsDeviceContext* dx = GetDeviceContextFor(aDocument)) {
-    // Get the actual device pixel ratio, which also takes zoom into account.
+    if (ShouldResistFingerprinting(aDocument)) {
-    dppx = float(nsPresContext::AppUnitsPerCSSPixel()) /
+      dppx = dx->GetFullZoom();
-             aPresContext->AppUnitsPerDevPixel();
+    } else {
-  } else {
+      // Get the actual device pixel ratio, which also takes zoom into account.
-    // We are resisting fingerprinting, so pretend we have a device pixel ratio
+      dppx =
-    // of 1. In that case, we simply report the zoom level.
+        float(nsPresContext::AppUnitsPerCSSPixel()) / dx->AppUnitsPerDevPixel();
-    dppx = aPresContext->GetDeviceFullZoom();
+    }
   }
 
   aResult.SetFloatValue(dppx, eCSSUnit_Pixel);
 }
 
 static void
-GetScan(nsPresContext* aPresContext, const nsMediaFeature*,
+GetScan(nsIDocument* aDocument, const nsMediaFeature*,
         nsCSSValue& aResult)
 {
   // Since Gecko doesn't support the 'tv' media type, the 'scan'
@@ -315,35 +344,27 @@ GetScan(nsPresContext* aPresContext, const nsMediaFeature*,
   aResult.Reset();
 }
 
+static nsIDocument*
+TopDocument(nsIDocument* aDocument)
+{
+  nsIDocument* current = aDocument;
+  while (nsIDocument* parent = current->GetParentDocument()) {
+    current = parent;
+  }
+  return current;
+}
+
 static void
-GetDisplayMode(nsPresContext* aPresContext, const nsMediaFeature*,
+GetDisplayMode(nsIDocument* aDocument, const nsMediaFeature*,
                nsCSSValue& aResult)
 {
-  nsCOMPtr<nsISupports> container;
+  nsIDocument* rootDocument = TopDocument(aDocument);
-  RefPtr<nsIDocShell> docShell;
 
-  if (!aPresContext) {
+  nsCOMPtr<nsISupports> container = rootDocument->GetContainer();
-    aResult.SetIntValue(NS_STYLE_DISPLAY_MODE_BROWSER, eCSSUnit_Enumerated);
+  if (nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(container)) {
-    return;
-  }
-
-  if (aPresContext) {
-    // Calling GetRootPresContext() can be slow, so make sure to call it
-    // just once.
-    nsRootPresContext* root = aPresContext->GetRootPresContext();
-    if (root && root->Document()) {
-      container = root->Document()->GetContainer();
-      docShell = root->GetDocShell();
-    }
-  }
-
-  nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(container);
-  if (baseWindow) {
     nsCOMPtr<nsIWidget> mainWidget;
     baseWindow->GetMainWidget(getter_AddRefs(mainWidget));
-    nsSizeMode mode = mainWidget ? mainWidget->SizeMode() : nsSizeMode_Normal;
+    if (mainWidget && mainWidget->SizeMode() == nsSizeMode_Fullscreen) {
-
-    if (mode == nsSizeMode_Fullscreen) {
       aResult.SetIntValue(NS_STYLE_DISPLAY_MODE_FULLSCREEN, eCSSUnit_Enumerated);
       return;
     }
@@ -356,7 +377,7 @@ GetDisplayMode(nsPresContext* aPresContext, const nsMediaFeature*,
                 "nsIDocShell display modes must mach nsStyleConsts.h");
 
   uint32_t displayMode = NS_STYLE_DISPLAY_MODE_BROWSER;
-  if (docShell) {
+  if (nsIDocShell* docShell = rootDocument->GetDocShell()) {
     docShell->GetDisplayMode(&displayMode);
   }
 
@@ -364,7 +385,7 @@ GetDisplayMode(nsPresContext* aPresContext, const nsMediaFeature*,
 }
 
 static void
-GetGrid(nsPresContext* aPresContext, const nsMediaFeature*,
+GetGrid(nsIDocument* aDocument, const nsMediaFeature*,
         nsCSSValue& aResult)
 {
   // Gecko doesn't support grid devices (e.g., ttys), so the 'grid'
@@ -373,19 +394,32 @@ GetGrid(nsPresContext* aPresContext, const nsMediaFeature*,
 }
 
 static void
-GetDevicePixelRatio(nsPresContext* aPresContext, const nsMediaFeature*,
+GetDevicePixelRatio(nsIDocument* aDocument, const nsMediaFeature*,
                     nsCSSValue& aResult)
 {
-  if (!ShouldResistFingerprinting(aPresContext)) {
+  if (ShouldResistFingerprinting(aDocument)) {
-    float ratio = aPresContext->CSSPixelsToDevPixels(1.0f);
-    aResult.SetFloatValue(ratio, eCSSUnit_Number);
-  } else {
     aResult.SetFloatValue(1.0, eCSSUnit_Number);
+    return;
   }
+
+  nsIPresShell* presShell = aDocument->GetShell();
+  if (!presShell) {
+    aResult.SetFloatValue(1.0, eCSSUnit_Number);
+    return;
+  }
+
+  nsPresContext* pc = presShell->GetPresContext();
+  if (!pc) {
+    aResult.SetFloatValue(1.0, eCSSUnit_Number);
+    return;
+  }
+
+  float ratio = pc->CSSPixelsToDevPixels(1.0f);
+  aResult.SetFloatValue(ratio, eCSSUnit_Number);
 }
 
 static void
-GetTransform3d(nsPresContext* aPresContext, const nsMediaFeature*,
+GetTransform3d(nsIDocument* aDocument, const nsMediaFeature*,
                nsCSSValue& aResult)
 {
   // Gecko supports 3d transforms, so this feature is always 1.
@@ -409,7 +443,7 @@ GetWindowsThemeIdentifier()
 #endif
 
 static void
-GetSystemMetric(nsPresContext* aPresContext, const nsMediaFeature* aFeature,
+GetSystemMetric(nsIDocument* aDocument, const nsMediaFeature* aFeature,
                 nsCSSValue& aResult)
 {
   aResult.Reset();
@@ -420,8 +454,7 @@ GetSystemMetric(nsPresContext* aPresContext, const nsMediaFeature* aFeature,
   MOZ_ASSERT(!isAccessibleFromContentPages ||
              *aFeature->mName == nsGkAtoms::_moz_touch_enabled);
 
-  if (isAccessibleFromContentPages &&
+  if (isAccessibleFromContentPages && ShouldResistFingerprinting(aDocument)) {
-      ShouldResistFingerprinting(aPresContext)) {
     // If "privacy.resistFingerprinting" is enabled, then we simply don't
     // return any system-backed media feature values. (No spoofed values
     // returned.)
@@ -437,13 +470,13 @@ GetSystemMetric(nsPresContext* aPresContext, const nsMediaFeature* aFeature,
 }
 
 static void
-GetWindowsTheme(nsPresContext* aPresContext, const nsMediaFeature* aFeature,
+GetWindowsTheme(nsIDocument* aDocument, const nsMediaFeature* aFeature,
                 nsCSSValue& aResult)
 {
   aResult.Reset();
 
   MOZ_ASSERT(aFeature->mReqFlags & nsMediaFeature::eUserAgentAndChromeOnly);
-  if (ShouldResistFingerprinting(aPresContext)) {
+  if (ShouldResistFingerprinting(aDocument)) {
     return;
   }
 
@@ -466,13 +499,13 @@ GetWindowsTheme(nsPresContext* aPresContext, const nsMediaFeature* aFeature,
 }
 
 static void
-GetOperatingSystemVersion(nsPresContext* aPresContext, const nsMediaFeature* aFeature,
+GetOperatingSystemVersion(nsIDocument* aDocument, const nsMediaFeature* aFeature,
                          nsCSSValue& aResult)
 {
   aResult.Reset();
 
   MOZ_ASSERT(aFeature->mReqFlags & nsMediaFeature::eUserAgentAndChromeOnly);
-  if (ShouldResistFingerprinting(aPresContext)) {
+  if (ShouldResistFingerprinting(aDocument)) {
     return;
   }
 
@@ -493,11 +526,11 @@ GetOperatingSystemVersion(nsPresContext* aPresContext, const nsMediaFeature* aFe
 }
 
 static void
-GetIsGlyph(nsPresContext* aPresContext, const nsMediaFeature* aFeature,
+GetIsGlyph(nsIDocument* aDocument, const nsMediaFeature* aFeature,
-          nsCSSValue& aResult)
+           nsCSSValue& aResult)
 {
   MOZ_ASSERT(aFeature->mReqFlags & nsMediaFeature::eUserAgentAndChromeOnly);
-  aResult.SetIntValue(aPresContext->IsGlyph() ? 1 : 0, eCSSUnit_Integer);
+  aResult.SetIntValue(aDocument->IsSVGGlyphsDocument() ? 1 : 0, eCSSUnit_Integer);
 }
 
 /* static */ void

layout/style/nsMediaFeatures.h

@@ -12,11 +12,11 @@
 #include "nsCSSProps.h"
 
 class nsAtom;
-class nsPresContext;
+class nsIDocument;
 class nsCSSValue;
 
 struct nsMediaFeature;
-typedef void (*nsMediaFeatureValueGetter)(nsPresContext* aPresContext,
+typedef void (*nsMediaFeatureValueGetter)(nsIDocument* aDocument,
                                           const nsMediaFeature* aFeature,
                                           nsCSSValue& aResult);
 

layout/style/nsMediaList.cpp

@@ -29,7 +29,7 @@ int32_t DoCompare(Numeric a, Numeric b)
 }
 
 bool
-nsMediaExpression::Matches(nsPresContext *aPresContext,
+nsMediaExpression::Matches(nsPresContext* aPresContext,
                            const nsCSSValue& aActualValue) const
 {
   const nsCSSValue& actual = aActualValue;
@@ -221,7 +221,7 @@ nsMediaQueryResultCacheKey::Matches(nsPresContext* aPresContext) const
     const FeatureEntry *entry = &mFeatureCache[i];
     nsCSSValue actual;
 
-    entry->mFeature->mGetter(aPresContext, entry->mFeature, actual);
+    entry->mFeature->mGetter(aPresContext->Document(), entry->mFeature, actual);
 
     for (uint32_t j = 0; j < entry->mExpressions.Length(); ++j) {
       const ExpressionEntry &eentry = entry->mExpressions[j];
@@ -476,7 +476,7 @@ nsMediaQuery::Matches(nsPresContext* aPresContext,
   for (uint32_t i = 0, i_end = mExpressions.Length(); match && i < i_end; ++i) {
     const nsMediaExpression &expr = mExpressions[i];
     nsCSSValue actual;
-    expr.mFeature->mGetter(aPresContext, expr.mFeature, actual);
+    expr.mFeature->mGetter(aPresContext->Document(), expr.mFeature, actual);
 
     match = expr.Matches(aPresContext, actual);
     if (aKey) {

layout/svg/nsSVGContainerFrame.cpp

@@ -260,7 +260,7 @@ nsSVGDisplayContainerFrame::PaintSVG(gfxContext& aContext,
 {
   NS_ASSERTION(!NS_SVGDisplayListPaintingEnabled() ||
                (mState & NS_FRAME_IS_NONDISPLAY) ||
-               PresContext()->IsGlyph(),
+               PresContext()->Document()->IsSVGGlyphsDocument(),
                "If display lists are enabled, only painting of non-display "
                "SVG should take this code path");
 

layout/svg/nsSVGUtils.cpp

@@ -657,7 +657,7 @@ nsSVGUtils::PaintFrameWithEffects(nsIFrame *aFrame,
 {
   NS_ASSERTION(!NS_SVGDisplayListPaintingEnabled() ||
                (aFrame->GetStateBits() & NS_FRAME_IS_NONDISPLAY) ||
-               aFrame->PresContext()->IsGlyph(),
+               aFrame->PresContext()->Document()->IsSVGGlyphsDocument(),
                "If display lists are enabled, only painting of non-display "
                "SVG should take this code path");