Fix build for LLVM/Clang 18+

Cargo.toml

@@ -191,3 +191,8 @@ uniffi_bindgen = "=0.23.0"
 uniffi_build = "=0.23.0"
 uniffi_macros = "=0.23.0"
 weedle2 = "=4.0.0"
+
+[patch.crates-io.bindgen_0_64_0]
+package = "bindgen"
+version = "0.64.0"
+path = "third_party/rust/bindgen"

dom/media/gmp-plugin-openh264/gmp-fake-openh264.cpp

@@ -99,7 +99,7 @@ struct EncodedFrame {
     uint8_t y_;
     uint8_t u_;
     uint8_t v_;
-    uint32_t timestamp_;
+    uint64_t timestamp_;
   } idr_nalu;
 };
 #pragma pack(pop)

dom/media/gtest/TestGMPRemoveAndDelete.cpp

@@ -361,7 +361,7 @@ void GMPRemoveTest::gmp_Decode() {
       uint8_t y_;
       uint8_t u_;
       uint8_t v_;
-      uint32_t timestamp_;
+      uint64_t timestamp_;
     } idr_nalu;
   };
 #pragma pack(pop)

dom/media/webrtc/libwebrtcglue/WebrtcGmpVideoCodec.cpp

@@ -540,7 +540,7 @@ void WebrtcGmpVideoEncoder::Encoded(
 
   webrtc::VideoFrameType ft;
   GmpFrameTypeToWebrtcFrameType(aEncodedFrame->FrameType(), &ft);
-  uint32_t timestamp = (aEncodedFrame->TimeStamp() * 90ll + 999) / 1000;
+  uint64_t timestamp = (aEncodedFrame->TimeStamp() * 90ll + 999) / 1000;
 
   GMP_LOG_DEBUG("GMP Encoded: %" PRIu64 ", type %d, len %d",
                 aEncodedFrame->TimeStamp(), aEncodedFrame->BufferType(),

dom/media/webrtc/libwebrtcglue/WebrtcGmpVideoCodec.h

@@ -302,7 +302,7 @@ class WebrtcGmpVideoEncoder : public GMPVideoEncoderCallbackProxy,
     int64_t timestamp_us;
   };
   // Map rtp time -> input image data
-  DataMutex<std::map<uint32_t, InputImageData>> mInputImageMap;
+  DataMutex<std::map<uint64_t, InputImageData>> mInputImageMap;
 
   MediaEventProducer<uint64_t> mInitPluginEvent;
   MediaEventProducer<uint64_t> mReleasePluginEvent;

third_party/rust/bindgen/ir/item.rs

@@ -1427,53 +1427,55 @@ impl Item {
             }
         }
 
-        // Guess how does clang treat extern "C" blocks?
-        if cursor.kind() == CXCursor_UnexposedDecl {
-            Err(ParseError::Recurse)
-        } else {
+        match cursor.kind() {
+            // On Clang 18+, extern "C" is reported accurately as a LinkageSpec.
+            // Older LLVM treat it as UnexposedDecl.
+            CXCursor_LinkageSpec | CXCursor_UnexposedDecl => {
+                Err(ParseError::Recurse)
+            }
+
             // We allowlist cursors here known to be unhandled, to prevent being
             // too noisy about this.
-            match cursor.kind() {
-                CXCursor_MacroDefinition |
-                CXCursor_MacroExpansion |
-                CXCursor_UsingDeclaration |
-                CXCursor_UsingDirective |
-                CXCursor_StaticAssert |
-                CXCursor_FunctionTemplate => {
-                    debug!(
-                        "Unhandled cursor kind {:?}: {:?}",
-                        cursor.kind(),
-                        cursor
-                    );
-                }
-                CXCursor_InclusionDirective => {
-                    let file = cursor.get_included_file_name();
-                    match file {
-                        None => {
-                            warn!(
-                                "Inclusion of a nameless file in {:?}",
-                                cursor
-                            );
-                        }
-                        Some(filename) => {
-                            ctx.include_file(filename);
-                        }
-                    }
-                }
-                _ => {
-                    // ignore toplevel operator overloads
-                    let spelling = cursor.spelling();
-                    if !spelling.starts_with("operator") {
+            CXCursor_MacroDefinition |
+            CXCursor_MacroExpansion |
+            CXCursor_UsingDeclaration |
+            CXCursor_UsingDirective |
+            CXCursor_StaticAssert |
+            CXCursor_FunctionTemplate => {
+                debug!(
+                    "Unhandled cursor kind {:?}: {:?}",
+                    cursor.kind(),
+                    cursor
+                );
+                Err(ParseError::Continue)
+            }
+            CXCursor_InclusionDirective => {
+                let file = cursor.get_included_file_name();
+                match file {
+                    None => {
                         warn!(
-                            "Unhandled cursor kind {:?}: {:?}",
-                            cursor.kind(),
+                            "Inclusion of a nameless file in {:?}",
                             cursor
                         );
                     }
+                    Some(filename) => {
+                        ctx.include_file(filename);
+                    }
                 }
+                Err(ParseError::Continue)
+            }
+            _ => {
+                // ignore toplevel operator overloads
+                let spelling = cursor.spelling();
+                if !spelling.starts_with("operator") {
+                    warn!(
+                        "Unhandled cursor kind {:?}: {:?}",
+                        cursor.kind(),
+                        cursor
+                    );
+                }
+                Err(ParseError::Continue)
             }
-
-            Err(ParseError::Continue)
         }
     }