Update everything for element factory builder API changes

And set properties as part of object construction wherever it makes
sense.

9 files changed, 246 insertions, 192 deletions

diff --git a/utils/fallbackswitch/examples/gtk_fallbackswitch.rs b/utils/fallbackswitch/examples/gtk_fallbackswitch.rs
index 7f9787d54..82eab8b8a 100644
--- a/utils/fallbackswitch/examples/gtk_fallbackswitch.rs
+++ b/utils/fallbackswitch/examples/gtk_fallbackswitch.rs
@@ -32,11 +32,13 @@ fn create_pipeline() -> (gst::Pipeline, gst::Pad, gst::Element) {
         .unwrap()
         .upcast();
 
-    let fallbackswitch = gst::ElementFactory::make("fallbackswitch", None).unwrap();
-    fallbackswitch.set_property("timeout", gst::ClockTime::SECOND);
+    let fallbackswitch = gst::ElementFactory::make("fallbackswitch")
+        .property("timeout", gst::ClockTime::SECOND)
+        .build()
+        .unwrap();
 
-    let decodebin = gst::ElementFactory::make("decodebin", None).unwrap();
-    let videoconvert = gst::ElementFactory::make("videoconvert", None).unwrap();
+    let decodebin = gst::ElementFactory::make("decodebin").build().unwrap();
+    let videoconvert = gst::ElementFactory::make("videoconvert").build().unwrap();
 
     let videoconvert_clone = videoconvert.clone();
     decodebin.connect_pad_added(move |_, pad| {
@@ -50,7 +52,9 @@ fn create_pipeline() -> (gst::Pipeline, gst::Pad, gst::Element) {
         }
     });
 
-    let video_sink = gst::ElementFactory::make("gtk4paintablesink", None).unwrap();
+    let video_sink = gst::ElementFactory::make("gtk4paintablesink")
+        .build()
+        .unwrap();
 
     pipeline
         .add_many(&[
diff --git a/utils/fallbackswitch/src/fallbacksrc/imp.rs b/utils/fallbackswitch/src/fallbacksrc/imp.rs
index e8f2ff939..3ec4f757e 100644
--- a/utils/fallbackswitch/src/fallbacksrc/imp.rs
+++ b/utils/fallbackswitch/src/fallbacksrc/imp.rs
@@ -896,30 +896,35 @@ impl FallbackSrc {
     fn create_dummy_audio_source(filter_caps: &gst::Caps, min_latency: gst::ClockTime) -> gst::Bin {
         let bin = gst::Bin::new(None);
 
-        let audiotestsrc = gst::ElementFactory::make("audiotestsrc", Some("audiosrc"))
+        let audiotestsrc = gst::ElementFactory::make("audiotestsrc")
+            .name("audiosrc")
+            .property_from_str("wave", "silence")
+            .property("is-live", true)
+            .build()
             .expect("No audiotestsrc found");
 
-        let audioconvert = gst::ElementFactory::make("audioconvert", Some("audio_audioconvert"))
+        let audioconvert = gst::ElementFactory::make("audioconvert")
+            .name("audio_audioconvert")
+            .build()
             .expect("No audioconvert found");
 
-        let audioresample = gst::ElementFactory::make("audioresample", Some("audio_audioresample"))
+        let audioresample = gst::ElementFactory::make("audioresample")
+            .name("audio_audioresample")
+            .build()
             .expect("No audioresample found");
 
-        let capsfilter = gst::ElementFactory::make("capsfilter", Some("audio_capsfilter"))
+        let capsfilter = gst::ElementFactory::make("capsfilter")
+            .name("audio_capsfilter")
+            .property("caps", filter_caps)
+            .build()
             .expect("No capsfilter found");
 
-        let queue = gst::ElementFactory::make("queue", None).expect("No queue found");
-
-        audiotestsrc.set_property_from_str("wave", "silence");
-        audiotestsrc.set_property("is-live", true);
-
-        capsfilter.set_property("caps", filter_caps);
-
-        queue.set_properties(&[
-            ("max-size-bytes", &0u32),
-            ("max-size-buffers", &0u32),
-            ("max-size-time", &(cmp::max(min_latency, 1.seconds()))),
-        ]);
+        let queue = gst::ElementFactory::make("queue")
+            .property("max-size-bytes", 0u32)
+            .property("max-size-buffers", 0u32)
+            .property("max-size-time", cmp::max(min_latency, 1.seconds()))
+            .build()
+            .expect("No queue found");
 
         bin.add_many(&[
             &audiotestsrc,
@@ -950,30 +955,35 @@ impl FallbackSrc {
     fn create_dummy_video_source(filter_caps: &gst::Caps, min_latency: gst::ClockTime) -> gst::Bin {
         let bin = gst::Bin::new(None);
 
-        let videotestsrc = gst::ElementFactory::make("videotestsrc", Some("videosrc"))
+        let videotestsrc = gst::ElementFactory::make("videotestsrc")
+            .name("videosrc")
+            .property_from_str("pattern", "black")
+            .property("is-live", true)
+            .build()
             .expect("No videotestsrc found");
 
-        let videoconvert = gst::ElementFactory::make("videoconvert", Some("video_videoconvert"))
+        let videoconvert = gst::ElementFactory::make("videoconvert")
+            .name("video_videoconvert")
+            .build()
             .expect("No videoconvert found");
 
-        let videoscale = gst::ElementFactory::make("videoscale", Some("video_videoscale"))
+        let videoscale = gst::ElementFactory::make("videoscale")
+            .name("video_videoscale")
+            .build()
             .expect("No videoscale found");
 
-        let capsfilter = gst::ElementFactory::make("capsfilter", Some("video_capsfilter"))
+        let capsfilter = gst::ElementFactory::make("capsfilter")
+            .name("video_capsfilter")
+            .property("caps", filter_caps)
+            .build()
             .expect("No capsfilter found");
 
-        let queue = gst::ElementFactory::make("queue", None).expect("No queue found");
-
-        videotestsrc.set_property_from_str("pattern", "black");
-        videotestsrc.set_property("is-live", true);
-
-        capsfilter.set_property("caps", filter_caps);
-
-        queue.set_properties(&[
-            ("max-size-bytes", &0u32),
-            ("max-size-buffers", &0u32),
-            ("max-size-time", &(cmp::max(min_latency, 1.seconds()))),
-        ]);
+        let queue = gst::ElementFactory::make("queue")
+            .property("max-size-bytes", 0u32)
+            .property("max-size-buffers", 0u32)
+            .property("max-size-time", cmp::max(min_latency, 1.seconds()))
+            .build()
+            .expect("No queue found");
 
         bin.add_many(&[
             &videotestsrc,
@@ -1006,16 +1016,17 @@ impl FallbackSrc {
 
         let source = match source {
             Source::Uri(ref uri) => {
-                let source = gst::ElementFactory::make("uridecodebin3", Some("uridecodebin"))
-                    .expect("No uridecodebin3 found");
-
                 let uri = self
                     .instance()
                     .emit_by_name::<glib::GString>("update-uri", &[uri]);
 
-                source.set_property("uri", uri);
-                source.set_property("use-buffering", true);
-                source.set_property("buffer-duration", buffer_duration);
+                let source = gst::ElementFactory::make("uridecodebin3")
+                    .name("uridecodebin")
+                    .property("uri", uri)
+                    .property("use-buffering", true)
+                    .property("buffer-duration", buffer_duration)
+                    .build()
+                    .expect("No uridecodebin3 found");
 
                 source
             }
@@ -1081,11 +1092,13 @@ impl FallbackSrc {
     ) -> Option<SourceBin> {
         let source: gst::Element = match fallback_uri {
             Some(uri) => {
-                let dbin = gst::ElementFactory::make("uridecodebin3", Some("uridecodebin"))
+                let dbin = gst::ElementFactory::make("uridecodebin3")
+                    .name("uridecodebin")
+                    .property("uri", uri)
+                    .property("use-buffering", true)
+                    .property("buffer-duration", buffer_duration)
+                    .build()
                     .expect("No uridecodebin3 found");
-                dbin.set_property("uri", uri);
-                dbin.set_property("use-buffering", true);
-                dbin.set_property("buffer-duration", buffer_duration);
 
                 dbin
             }
@@ -1156,15 +1169,15 @@ impl FallbackSrc {
         dummy_source: &gst::Bin,
         filter_caps: &gst::Caps,
     ) -> Stream {
-        let switch =
-            gst::ElementFactory::make("fallbackswitch", None).expect("No fallbackswitch found");
+        let switch = gst::ElementFactory::make("fallbackswitch")
+            .property("timeout", timeout.nseconds())
+            .property("min-upstream-latency", min_latency.nseconds())
+            .property("immediate-fallback", immediate_fallback)
+            .build()
+            .expect("No fallbackswitch found");
 
         self.instance().add(&switch).unwrap();
 
-        switch.set_property("timeout", timeout.nseconds());
-        switch.set_property("min-upstream-latency", min_latency.nseconds());
-        switch.set_property("immediate-fallback", immediate_fallback);
-
         let dummy_srcpad = dummy_source.static_pad("src").unwrap();
         let dummy_sinkpad = switch.request_pad_simple("sink_%u").unwrap();
         dummy_srcpad.link(&dummy_sinkpad).unwrap();
@@ -1686,14 +1699,19 @@ impl FallbackSrc {
         let converters = if is_video {
             let bin = gst::Bin::new(None);
 
-            let videoconvert =
-                gst::ElementFactory::make("videoconvert", Some("video_videoconvert"))
-                    .expect("No videoconvert found");
+            let videoconvert = gst::ElementFactory::make("videoconvert")
+                .name("video_videoconvert")
+                .build()
+                .expect("No videoconvert found");
 
-            let videoscale = gst::ElementFactory::make("videoscale", Some("video_videoscale"))
+            let videoscale = gst::ElementFactory::make("videoscale")
+                .name("video_videoscale")
+                .build()
                 .expect("No videoscale found");
 
-            let capsfilter = gst::ElementFactory::make("capsfilter", Some("video_capsfilter"))
+            let capsfilter = gst::ElementFactory::make("capsfilter")
+                .name("video_capsfilter")
+                .build()
                 .expect("No capsfilter found");
 
             if fallback_source {
@@ -1721,15 +1739,19 @@ impl FallbackSrc {
         } else {
             let bin = gst::Bin::new(None);
 
-            let audioconvert =
-                gst::ElementFactory::make("audioconvert", Some("audio_audioconvert"))
-                    .expect("No audioconvert found");
+            let audioconvert = gst::ElementFactory::make("audioconvert")
+                .name("audio_audioconvert")
+                .build()
+                .expect("No audioconvert found");
 
-            let audioresample =
-                gst::ElementFactory::make("audioresample", Some("audio_audioresample"))
-                    .expect("No audioresample found");
+            let audioresample = gst::ElementFactory::make("audioresample")
+                .name("audio_audioresample")
+                .build()
+                .expect("No audioresample found");
 
-            let capsfilter = gst::ElementFactory::make("capsfilter", Some("audio_capsfilter"))
+            let capsfilter = gst::ElementFactory::make("capsfilter")
+                .name("audio_capsfilter")
+                .build()
                 .expect("No capsfilter found");
 
             if fallback_source {
@@ -1756,20 +1778,24 @@ impl FallbackSrc {
             bin.upcast()
         };
 
-        let queue = gst::ElementFactory::make("queue", None).unwrap();
-        queue.set_properties(&[
-            ("max-size-bytes", &0u32),
-            ("max-size-buffers", &0u32),
-            (
+        let queue = gst::ElementFactory::make("queue")
+            .property("max-size-bytes", 0u32)
+            .property("max-size-buffers", 0u32)
+            .property(
                 "max-size-time",
-                &(cmp::max(state.settings.min_latency, 1.seconds())),
-            ),
-        ]);
-        let clocksync = gst::ElementFactory::make("clocksync", None).unwrap_or_else(|_| {
-            let identity = gst::ElementFactory::make("identity", None).unwrap();
-            identity.set_property("sync", true);
-            identity
-        });
+                cmp::max(state.settings.min_latency, 1.seconds()),
+            )
+            .build()
+            .unwrap();
+        let clocksync = gst::ElementFactory::make("clocksync")
+            .build()
+            .unwrap_or_else(|_| {
+                let identity = gst::ElementFactory::make("identity")
+                    .property("sync", true)
+                    .build()
+                    .unwrap();
+                identity
+            });
 
         source
             .source
@@ -1790,10 +1816,11 @@ impl FallbackSrc {
 
         let imagefreeze = if is_image {
             gst::debug!(CAT, imp: self, "Image stream, inserting imagefreeze");
-            let imagefreeze =
-                gst::ElementFactory::make("imagefreeze", None).expect("no imagefreeze found");
+            let imagefreeze = gst::ElementFactory::make("imagefreeze")
+                .property("is-live", true)
+                .build()
+                .expect("no imagefreeze found");
             source.source.add(&imagefreeze).unwrap();
-            imagefreeze.set_property("is-live", true);
 
             if imagefreeze.sync_state_with_parent().is_err() {
                 gst::error!(CAT, imp: self, "imagefreeze failed to change state",);
diff --git a/utils/fallbackswitch/tests/fallbackswitch.rs b/utils/fallbackswitch/tests/fallbackswitch.rs
index 1c35fb05c..089d725d7 100644
--- a/utils/fallbackswitch/tests/fallbackswitch.rs
+++ b/utils/fallbackswitch/tests/fallbackswitch.rs
@@ -473,25 +473,30 @@ fn setup_pipeline(
     pipeline.set_base_time(gst::ClockTime::SECOND);
     pipeline.set_start_time(gst::ClockTime::NONE);
 
-    let src = gst::ElementFactory::make("appsrc", Some("src"))
+    let src = gst::ElementFactory::make("appsrc")
+        .name("src")
+        .build()
         .unwrap()
         .downcast::<gst_app::AppSrc>()
         .unwrap();
-    src.set_property("is-live", true);
-    src.set_property("format", gst::Format::Time);
-    src.set_property("min-latency", LATENCY.nseconds() as i64);
-    src.set_property(
-        "caps",
-        gst_video::VideoCapsBuilder::new()
+    src.set_is_live(true);
+    src.set_format(gst::Format::Time);
+    src.set_min_latency(LATENCY.nseconds() as i64);
+    src.set_caps(Some(
+        &gst_video::VideoCapsBuilder::new()
             .format(gst_video::VideoFormat::Argb)
             .width(320)
             .height(240)
             .framerate((0, 1).into())
             .build(),
-    );
+    ));
+
+    let switch = gst::ElementFactory::make("fallbackswitch")
+        .name("switch")
+        .property("timeout", 3.seconds())
+        .build()
+        .unwrap();
 
-    let switch = gst::ElementFactory::make("fallbackswitch", Some("switch")).unwrap();
-    switch.set_property("timeout", 3.seconds());
     if let Some(imm) = immediate_fallback {
         switch.set_property("immediate-fallback", imm);
     }
@@ -499,13 +504,15 @@ fn setup_pipeline(
         switch.set_property("auto-switch", auto_switch);
     }
 
-    let sink = gst::ElementFactory::make("appsink", Some("sink"))
+    let sink = gst::ElementFactory::make("appsink")
+        .name("sink")
+        .build()
         .unwrap()
         .downcast::<gst_app::AppSink>()
         .unwrap();
-    sink.set_property("sync", false);
+    sink.set_sync(false);
 
-    let queue = gst::ElementFactory::make("queue", None).unwrap();
+    let queue = gst::ElementFactory::make("queue").build().unwrap();
 
     pipeline
         .add_many(&[src.upcast_ref(), &switch, &queue, sink.upcast_ref()])
@@ -518,22 +525,23 @@ fn setup_pipeline(
     sink_pad.set_property("priority", 0u32);
 
     if let Some(live) = with_live_fallback {
-        let fallback_src = gst::ElementFactory::make("appsrc", Some("fallback-src"))
+        let fallback_src = gst::ElementFactory::make("appsrc")
+            .name("fallback-src")
+            .build()
             .unwrap()
             .downcast::<gst_app::AppSrc>()
             .unwrap();
-        fallback_src.set_property("is-live", live);
-        fallback_src.set_property("format", gst::Format::Time);
-        fallback_src.set_property("min-latency", LATENCY.nseconds() as i64);
-        fallback_src.set_property(
-            "caps",
-            gst_video::VideoCapsBuilder::new()
+        fallback_src.set_is_live(live);
+        fallback_src.set_format(gst::Format::Time);
+        fallback_src.set_min_latency(LATENCY.nseconds() as i64);
+        fallback_src.set_caps(Some(
+            &gst_video::VideoCapsBuilder::new()
                 .format(gst_video::VideoFormat::Argb)
                 .width(160)
                 .height(120)
                 .framerate((0, 1).into())
                 .build(),
-        );
+        ));
 
         pipeline.add(&fallback_src).unwrap();
 
diff --git a/utils/togglerecord/examples/gtk_recording.rs b/utils/togglerecord/examples/gtk_recording.rs
index a5ce8d1d1..5816eefda 100644
--- a/utils/togglerecord/examples/gtk_recording.rs
+++ b/utils/togglerecord/examples/gtk_recording.rs
@@ -23,54 +23,66 @@ fn create_pipeline() -> (
 ) {
     let pipeline = gst::Pipeline::new(None);
 
-    let video_src = gst::ElementFactory::make("videotestsrc", None).unwrap();
-    video_src.set_property("is-live", true);
-    video_src.set_property_from_str("pattern", "ball");
+    let video_src = gst::ElementFactory::make("videotestsrc")
+        .property("is-live", true)
+        .property_from_str("pattern", "ball")
+        .build()
+        .unwrap();
 
-    let timeoverlay = gst::ElementFactory::make("timeoverlay", None).unwrap();
-    timeoverlay.set_property("font-desc", "Monospace 20");
+    let timeoverlay = gst::ElementFactory::make("timeoverlay")
+        .property("font-desc", "Monospace 20")
+        .build()
+        .unwrap();
 
-    let video_tee = gst::ElementFactory::make("tee", None).unwrap();
-    let video_queue1 = gst::ElementFactory::make("queue", None).unwrap();
-    let video_queue2 = gst::ElementFactory::make("queue", None).unwrap();
+    let video_tee = gst::ElementFactory::make("tee").build().unwrap();
+    let video_queue1 = gst::ElementFactory::make("queue").build().unwrap();
+    let video_queue2 = gst::ElementFactory::make("queue").build().unwrap();
 
-    let video_convert1 = gst::ElementFactory::make("videoconvert", None).unwrap();
-    let video_convert2 = gst::ElementFactory::make("videoconvert", None).unwrap();
+    let video_convert1 = gst::ElementFactory::make("videoconvert").build().unwrap();
+    let video_convert2 = gst::ElementFactory::make("videoconvert").build().unwrap();
 
-    let video_sink = gst::ElementFactory::make("gtk4paintablesink", None).unwrap();
+    let video_sink = gst::ElementFactory::make("gtk4paintablesink")
+        .build()
+        .unwrap();
 
-    let video_enc = gst::ElementFactory::make("x264enc", None).unwrap();
-    video_enc.set_property("rc-lookahead", 10i32);
-    video_enc.set_property("key-int-max", 30u32);
-    let video_parse = gst::ElementFactory::make("h264parse", None).unwrap();
+    let video_enc = gst::ElementFactory::make("x264enc")
+        .property("rc-lookahead", 10i32)
+        .property("key-int-max", 30u32)
+        .build()
+        .unwrap();
+    let video_parse = gst::ElementFactory::make("h264parse").build().unwrap();
 
-    let audio_src = gst::ElementFactory::make("audiotestsrc", None).unwrap();
-    audio_src.set_property("is-live", true);
-    audio_src.set_property_from_str("wave", "ticks");
+    let audio_src = gst::ElementFactory::make("audiotestsrc")
+        .property("is-live", true)
+        .property_from_str("wave", "ticks")
+        .build()
+        .unwrap();
 
-    let audio_tee = gst::ElementFactory::make("tee", None).unwrap();
-    let audio_queue1 = gst::ElementFactory::make("queue", None).unwrap();
-    let audio_queue2 = gst::ElementFactory::make("queue", None).unwrap();
+    let audio_tee = gst::ElementFactory::make("tee").build().unwrap();
+    let audio_queue1 = gst::ElementFactory::make("queue").build().unwrap();
+    let audio_queue2 = gst::ElementFactory::make("queue").build().unwrap();
 
-    let audio_convert1 = gst::ElementFactory::make("audioconvert", None).unwrap();
-    let audio_convert2 = gst::ElementFactory::make("audioconvert", None).unwrap();
+    let audio_convert1 = gst::ElementFactory::make("audioconvert").build().unwrap();
+    let audio_convert2 = gst::ElementFactory::make("audioconvert").build().unwrap();
 
-    let audio_sink = gst::ElementFactory::make("autoaudiosink", None).unwrap();
+    let audio_sink = gst::ElementFactory::make("autoaudiosink").build().unwrap();
 
-    let audio_enc = gst::ElementFactory::make("lamemp3enc", None).unwrap();
-    let audio_parse = gst::ElementFactory::make("mpegaudioparse", None).unwrap();
+    let audio_enc = gst::ElementFactory::make("lamemp3enc").build().unwrap();
+    let audio_parse = gst::ElementFactory::make("mpegaudioparse").build().unwrap();
 
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
 
-    let mux_queue1 = gst::ElementFactory::make("queue", None).unwrap();
-    let mux_queue2 = gst::ElementFactory::make("queue", None).unwrap();
+    let mux_queue1 = gst::ElementFactory::make("queue").build().unwrap();
+    let mux_queue2 = gst::ElementFactory::make("queue").build().unwrap();
 
-    let mux = gst::ElementFactory::make("mp4mux", None).unwrap();
+    let mux = gst::ElementFactory::make("mp4mux").build().unwrap();
 
-    let file_sink = gst::ElementFactory::make("filesink", None).unwrap();
-    file_sink.set_property("location", "recording.mp4");
-    file_sink.set_property("async", false);
-    file_sink.set_property("sync", false);
+    let file_sink = gst::ElementFactory::make("filesink")
+        .property("location", "recording.mp4")
+        .property("async", false)
+        .property("sync", false)
+        .build()
+        .unwrap();
 
     pipeline
         .add_many(&[
diff --git a/utils/togglerecord/tests/tests.rs b/utils/togglerecord/tests/tests.rs
index 8e16990d6..e5511f5f3 100644
--- a/utils/togglerecord/tests/tests.rs
+++ b/utils/togglerecord/tests/tests.rs
@@ -43,8 +43,10 @@ fn setup_sender_receiver(
     mpsc::Receiver<Either<gst::Buffer, gst::Event>>,
     thread::JoinHandle<()>,
 ) {
-    let fakesink = gst::ElementFactory::make("fakesink", None).unwrap();
-    fakesink.set_property("async", false);
+    let fakesink = gst::ElementFactory::make("fakesink")
+        .property("async", false)
+        .build()
+        .unwrap();
     pipeline.add(&fakesink).unwrap();
 
     let main_stream = pad == "src";
@@ -250,13 +252,13 @@ fn recv_buffers(
 #[test]
 fn test_create() {
     init();
-    assert!(gst::ElementFactory::make("togglerecord", None).is_ok());
+    assert!(gst::ElementFactory::make("togglerecord").build().is_ok());
 }
 
 #[test]
 fn test_create_pads() {
     init();
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
 
     let sinkpad = togglerecord.request_pad_simple("sink_%u").unwrap();
     let srcpad = sinkpad.iterate_internal_links().next().unwrap().unwrap();
@@ -274,7 +276,7 @@ fn test_one_stream_open() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input, _, receiver_output, thread) =
@@ -306,7 +308,7 @@ fn test_one_stream_gaps_open() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input, _, receiver_output, thread) =
@@ -339,7 +341,7 @@ fn test_one_stream_close_open() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input, receiver_input_done, receiver_output, thread) =
@@ -373,7 +375,7 @@ fn test_one_stream_open_close() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input, receiver_input_done, receiver_output, thread) =
@@ -408,7 +410,7 @@ fn test_one_stream_open_close_open() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input, receiver_input_done, receiver_output, thread) =
@@ -452,7 +454,7 @@ fn test_two_stream_open() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
@@ -505,7 +507,7 @@ fn test_two_stream_open_shift() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
@@ -562,7 +564,7 @@ fn test_two_stream_open_shift_main() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
@@ -627,7 +629,7 @@ fn test_two_stream_open_close() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
@@ -696,7 +698,7 @@ fn test_two_stream_close_open() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
@@ -765,7 +767,7 @@ fn test_two_stream_open_close_open() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
@@ -859,7 +861,7 @@ fn test_two_stream_open_close_open_gaps() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
@@ -959,7 +961,7 @@ fn test_two_stream_close_open_close_delta() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
@@ -1048,7 +1050,7 @@ fn test_three_stream_open_close_open() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
@@ -1172,7 +1174,7 @@ fn test_two_stream_main_eos() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
@@ -1247,7 +1249,7 @@ fn test_two_stream_secondary_eos_first() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
@@ -1315,7 +1317,7 @@ fn test_three_stream_main_eos() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
@@ -1416,7 +1418,7 @@ fn test_three_stream_main_and_second_eos() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
@@ -1517,7 +1519,7 @@ fn test_three_stream_secondary_eos_first() {
     init();
 
     let pipeline = gst::Pipeline::new(None);
-    let togglerecord = gst::ElementFactory::make("togglerecord", None).unwrap();
+    let togglerecord = gst::ElementFactory::make("togglerecord").build().unwrap();
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
diff --git a/utils/tracers/src/queue_levels/imp.rs b/utils/tracers/src/queue_levels/imp.rs
index 626305c92..1662d05fb 100644
--- a/utils/tracers/src/queue_levels/imp.rs
+++ b/utils/tracers/src/queue_levels/imp.rs
@@ -64,8 +64,8 @@ static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
 });
 
 static QUEUE_TYPE: Lazy<glib::Type> = Lazy::new(|| {
-    if let Ok(queue) = gst::ElementFactory::make("queue", None) {
-        queue.type_()
+    if let Some(queue) = gst::ElementFactory::find("queue").and_then(|f| f.load().ok()) {
+        queue.element_type()
     } else {
         gst::warning!(CAT, "Can't instantiate queue element");
         glib::Type::INVALID
@@ -73,8 +73,8 @@ static QUEUE_TYPE: Lazy<glib::Type> = Lazy::new(|| {
 });
 
 static QUEUE2_TYPE: Lazy<glib::Type> = Lazy::new(|| {
-    if let Ok(queue) = gst::ElementFactory::make("queue2", None) {
-        queue.type_()
+    if let Some(queue) = gst::ElementFactory::find("queue2").and_then(|f| f.load().ok()) {
+        queue.element_type()
     } else {
         gst::warning!(CAT, "Can't instantiate queue2 element");
         glib::Type::INVALID
@@ -82,8 +82,8 @@ static QUEUE2_TYPE: Lazy<glib::Type> = Lazy::new(|| {
 });
 
 static MULTIQUEUE_TYPE: Lazy<glib::Type> = Lazy::new(|| {
-    if let Ok(queue) = gst::ElementFactory::make("multiqueue", None) {
-        queue.type_()
+    if let Some(queue) = gst::ElementFactory::find("multiqueue").and_then(|f| f.load().ok()) {
+        queue.element_type()
     } else {
         gst::warning!(CAT, "Can't instantiate multiqueue element");
         glib::Type::INVALID
diff --git a/utils/uriplaylistbin/examples/playlist.rs b/utils/uriplaylistbin/examples/playlist.rs
index 3ea879c64..6b23a211b 100644
--- a/utils/uriplaylistbin/examples/playlist.rs
+++ b/utils/uriplaylistbin/examples/playlist.rs
@@ -25,13 +25,13 @@ struct Opt {
 
 fn create_pipeline(uris: Vec<String>, iterations: u32) -> anyhow::Result<gst::Pipeline> {
     let pipeline = gst::Pipeline::new(None);
-    let playlist = gst::ElementFactory::make("uriplaylistbin", None)?;
+    let playlist = gst::ElementFactory::make("uriplaylistbin")
+        .property("uris", &uris)
+        .property("iterations", &iterations)
+        .build()?;
 
     pipeline.add(&playlist)?;
 
-    playlist.set_property("uris", &uris);
-    playlist.set_property("iterations", &iterations);
-
     let sink_bins = Arc::new(Mutex::new(HashMap::new()));
     let sink_bins_clone = sink_bins.clone();
 
diff --git a/utils/uriplaylistbin/src/uriplaylistbin/imp.rs b/utils/uriplaylistbin/src/uriplaylistbin/imp.rs
index 890b42665..a47bdf7b3 100644
--- a/utils/uriplaylistbin/src/uriplaylistbin/imp.rs
+++ b/utils/uriplaylistbin/src/uriplaylistbin/imp.rs
@@ -441,12 +441,11 @@ impl Item {
     fn set_waiting_for_stream_collection(&self) -> Result<(), PlaylistError> {
         let mut inner = self.inner.lock().unwrap();
 
-        let uridecodebin = gst::ElementFactory::make(
-            "uridecodebin3",
-            Some(&format!("playlist-decodebin-{}", inner.index)),
-        )
-        .map_err(|e| PlaylistError::PluginMissing { error: e.into() })?;
-        uridecodebin.set_property("uri", &inner.uri);
+        let uridecodebin = gst::ElementFactory::make("uridecodebin3")
+            .name(&format!("playlist-decodebin-{}", inner.index))
+            .property("uri", &inner.uri)
+            .build()
+            .map_err(|e| PlaylistError::PluginMissing { error: e.into() })?;
 
         assert!(matches!(inner.state, ItemState::Pending));
         inner.state = ItemState::WaitingForStreamCollection { uridecodebin };
@@ -974,9 +973,10 @@ impl UriPlaylistBin {
             let mut state_guard = self.state.lock().unwrap();
             assert!(state_guard.is_none());
 
-            let streamsynchronizer =
-                gst::ElementFactory::make("streamsynchronizer", Some("playlist-streamsync"))
-                    .map_err(|e| PlaylistError::PluginMissing { error: e.into() })?;
+            let streamsynchronizer = gst::ElementFactory::make("streamsynchronizer")
+                .name("playlist-streamsync")
+                .build()
+                .map_err(|e| PlaylistError::PluginMissing { error: e.into() })?;
 
             self.instance().add(&streamsynchronizer).unwrap();
 
@@ -1261,14 +1261,14 @@ impl UriPlaylistBin {
                         item.index()
                     );
 
-                    let concat = match gst::ElementFactory::make(
-                        "concat",
-                        Some(&format!(
+                    let concat = match gst::ElementFactory::make("concat")
+                        .name(&format!(
                             "playlist-concat-{}-{}",
                             stream_type.name(),
                             stream_index
-                        )),
-                    ) {
+                        ))
+                        .build()
+                    {
                         Ok(concat) => concat,
                         Err(_) => {
                             drop(state_guard);
diff --git a/utils/uriplaylistbin/tests/uriplaylistbin.rs b/utils/uriplaylistbin/tests/uriplaylistbin.rs
index f86005b2f..fca4fa476 100644
--- a/utils/uriplaylistbin/tests/uriplaylistbin.rs
+++ b/utils/uriplaylistbin/tests/uriplaylistbin.rs
@@ -81,18 +81,19 @@ fn test(
 
     let playlist_len = medias.len() * (iterations as usize);
 
-    let pipeline = gst::Pipeline::new(None);
-    let playlist = gst::ElementFactory::make("uriplaylistbin", None).unwrap();
-    let mq = gst::ElementFactory::make("multiqueue", None).unwrap();
-
-    pipeline.add_many(&[&playlist, &mq]).unwrap();
-
     let total_len: gst::ClockTime = medias.iter().map(|t| t.len * (iterations as u64)).sum();
 
     let uris: Vec<String> = medias.iter().map(|t| t.uri.clone()).collect();
 
-    playlist.set_property("uris", &uris);
-    playlist.set_property("iterations", &iterations);
+    let pipeline = gst::Pipeline::new(None);
+    let playlist = gst::ElementFactory::make("uriplaylistbin")
+        .property("uris", &uris)
+        .property("iterations", &iterations)
+        .build()
+        .unwrap();
+    let mq = gst::ElementFactory::make("multiqueue").build().unwrap();
+
+    pipeline.add_many(&[&playlist, &mq]).unwrap();
 
     assert_eq!(playlist.property::<u32>("current-iteration"), 0);
     assert_eq!(playlist.property::<u64>("current-uri-index"), 0);
@@ -114,7 +115,7 @@ fn test(
             None => return,
         };
 
-        let sink = gst::ElementFactory::make("fakesink", None).unwrap();
+        let sink = gst::ElementFactory::make("fakesink").build().unwrap();
         pipeline.add(&sink).unwrap();
         sink.sync_state_with_parent().unwrap();