--- a/layout/style/CSSMozDocumentRule.cpp
+++ b/layout/style/CSSMozDocumentRule.cpp
@@ -23,30 +23,33 @@ CSSMozDocumentRule::WrapObject(JSContext
 bool
 CSSMozDocumentRule::Match(nsIDocument* aDoc,
                           nsIURI* aDocURI,
                           const nsACString& aDocURISpec,
                           const nsACString& aPattern,
                           DocumentMatchingFunction aMatchingFunction)
 {
   switch (aMatchingFunction) {
-    case DocumentMatchingFunction::AllMediaDocuments:
-      return aDoc->MediaDocumentKind() != nsIDocument::MediaDocumentKind::None;
-    case DocumentMatchingFunction::VideoMediaDocuments:
-    case DocumentMatchingFunction::ImageMediaDocuments:
-    case DocumentMatchingFunction::PluginMediaDocuments: {
-      switch (aDoc->MediaDocumentKind()) {
+    case DocumentMatchingFunction::MediaDocument: {
+      auto kind = aDoc->MediaDocumentKind();
+      if (aPattern.EqualsLiteral("all")) {
+        return kind != nsIDocument::MediaDocumentKind::None;
+      }
+      MOZ_ASSERT(aPattern.EqualsLiteral("plugin") ||
+                 aPattern.EqualsLiteral("image") ||
+                 aPattern.EqualsLiteral("video"));
+      switch (kind) {
         case nsIDocument::MediaDocumentKind::None:
           return false;
         case nsIDocument::MediaDocumentKind::Plugin:
-          return aMatchingFunction == DocumentMatchingFunction::PluginMediaDocuments;
+          return aPattern.EqualsLiteral("plugin");
         case nsIDocument::MediaDocumentKind::Image:
-          return aMatchingFunction == DocumentMatchingFunction::ImageMediaDocuments;
+          return aPattern.EqualsLiteral("image");
         case nsIDocument::MediaDocumentKind::Video:
-          return aMatchingFunction == DocumentMatchingFunction::VideoMediaDocuments;
+          return aPattern.EqualsLiteral("video");
       }
       MOZ_ASSERT_UNREACHABLE("Unknown media document kind");
       return false;
     }
     case DocumentMatchingFunction::URL:
       return aDocURISpec == aPattern;
     case DocumentMatchingFunction::URLPrefix:
       return StringBeginsWith(aDocURISpec, aPattern);

--- a/layout/style/DocumentMatchingFunction.h
+++ b/layout/style/DocumentMatchingFunction.h
@@ -14,18 +14,15 @@ namespace css {
  * Enum defining the type of matching function for a @-moz-document rule
  * condition.
  */
 enum class DocumentMatchingFunction {
   URL = 0,
   URLPrefix,
   Domain,
   RegExp,
-  AllMediaDocuments,
-  ImageMediaDocuments,
-  PluginMediaDocuments,
-  VideoMediaDocuments,
+  MediaDocument,
 };
 
 } // namespace css
 } // namespace mozilla
 
 #endif // mozilla_css_DocumentMatchingFunction_h

--- a/servo/components/style/stylesheets/document_rule.rs
+++ b/servo/components/style/stylesheets/document_rule.rs
@@ -172,32 +172,32 @@ impl DocumentMatchingFunction {
         use gecko_bindings::structs::DocumentMatchingFunction as GeckoDocumentMatchingFunction;
         use nsstring::nsCStr;
 
         let func = match *self {
             DocumentMatchingFunction::Url(_) => GeckoDocumentMatchingFunction::URL,
             DocumentMatchingFunction::UrlPrefix(_) => GeckoDocumentMatchingFunction::URLPrefix,
             DocumentMatchingFunction::Domain(_) => GeckoDocumentMatchingFunction::Domain,
             DocumentMatchingFunction::Regexp(_) => GeckoDocumentMatchingFunction::RegExp,
-            DocumentMatchingFunction::MediaDocument(kind) => {
-                match kind {
-                    MediaDocumentKind::All => GeckoDocumentMatchingFunction::AllMediaDocuments,
-                    MediaDocumentKind::Video => GeckoDocumentMatchingFunction::VideoMediaDocuments,
-                    MediaDocumentKind::Image => GeckoDocumentMatchingFunction::ImageMediaDocuments,
-                    MediaDocumentKind::Plugin => GeckoDocumentMatchingFunction::PluginMediaDocuments,
-                }
-            }
+            DocumentMatchingFunction::MediaDocument(_) => GeckoDocumentMatchingFunction::MediaDocument,
         };
 
         let pattern = nsCStr::from(match *self {
             DocumentMatchingFunction::Url(ref url) => url.as_str(),
             DocumentMatchingFunction::UrlPrefix(ref pat) |
             DocumentMatchingFunction::Domain(ref pat) |
             DocumentMatchingFunction::Regexp(ref pat) => pat,
-            DocumentMatchingFunction::MediaDocument(..) => "",
+            DocumentMatchingFunction::MediaDocument(kind) => {
+                match kind {
+                    MediaDocumentKind::All => "all",
+                    MediaDocumentKind::Image => "image",
+                    MediaDocumentKind::Plugin => "plugin",
+                    MediaDocumentKind::Video => "video",
+                }
+            }
         });
         unsafe { Gecko_DocumentRule_UseForPresentation(device.pres_context(), &*pattern, func) }
     }
 
     #[cfg(not(feature = "gecko"))]
     /// Evaluate a URL matching function.
     pub fn evaluate(&self, _: &Device) -> bool {
         false