Move from `imp.instance()` to `imp.obj()`

It's doing the same thing and is shorter.

8 files changed, 109 insertions, 120 deletions

diff --git a/utils/fallbackswitch/src/fallbacksrc/custom_source/imp.rs b/utils/fallbackswitch/src/fallbacksrc/custom_source/imp.rs
index b0b7cc24..a536a154 100644
--- a/utils/fallbackswitch/src/fallbacksrc/custom_source/imp.rs
+++ b/utils/fallbackswitch/src/fallbacksrc/custom_source/imp.rs
@@ -73,7 +73,7 @@ impl ObjectImpl for CustomSource {
             "source" => {
                 let source = value.get::<gst::Element>().unwrap();
                 self.source.set(source.clone()).unwrap();
-                self.instance().add(&source).unwrap();
+                self.obj().add(&source).unwrap();
             }
             _ => unreachable!(),
         }
@@ -82,7 +82,7 @@ impl ObjectImpl for CustomSource {
     fn constructed(&self) {
         self.parent_constructed();
 
-        let obj = self.instance();
+        let obj = self.obj();
         obj.set_suppressed_flags(gst::ElementFlags::SOURCE | gst::ElementFlags::SINK);
         obj.set_element_flags(gst::ElementFlags::SOURCE);
         obj.set_bin_flags(gst::BinFlags::STREAMS_AWARE);
@@ -285,11 +285,11 @@ impl CustomSource {
         let (templ, name) = if stream_type.contains(gst::StreamType::AUDIO) {
             let name = format!("audio_{}", state.num_audio);
             state.num_audio += 1;
-            (self.instance().pad_template("audio_%u").unwrap(), name)
+            (self.obj().pad_template("audio_%u").unwrap(), name)
         } else {
             let name = format!("video_{}", state.num_video);
             state.num_video += 1;
-            (self.instance().pad_template("video_%u").unwrap(), name)
+            (self.obj().pad_template("video_%u").unwrap(), name)
         };
 
         let ghost_pad = gst::GhostPad::builder_with_template(&templ, Some(&name))
@@ -306,7 +306,7 @@ impl CustomSource {
         drop(state);
 
         ghost_pad.set_active(true).unwrap();
-        self.instance().add_pad(&ghost_pad).unwrap();
+        self.obj().add_pad(&ghost_pad).unwrap();
 
         Ok(())
     }
@@ -331,7 +331,7 @@ impl CustomSource {
 
         ghost_pad.set_active(false).unwrap();
         let _ = ghost_pad.set_target(None::<&gst::Pad>);
-        let _ = self.instance().remove_pad(&ghost_pad);
+        let _ = self.obj().remove_pad(&ghost_pad);
     }
 
     fn handle_source_no_more_pads(&self) {
@@ -348,11 +348,11 @@ impl CustomSource {
             .build();
         drop(state);
 
-        self.instance().no_more_pads();
+        self.obj().no_more_pads();
 
-        let _ = self.instance().post_message(
+        let _ = self.obj().post_message(
             gst::message::StreamsSelected::builder(&collection)
-                .src(&*self.instance())
+                .src(&*self.obj())
                 .build(),
         );
     }
@@ -381,7 +381,7 @@ impl CustomSource {
 
         for pad in pads {
             let _ = pad.ghost_pad.set_target(None::<&gst::Pad>);
-            let _ = self.instance().remove_pad(&pad.ghost_pad);
+            let _ = self.obj().remove_pad(&pad.ghost_pad);
         }
     }
 }
diff --git a/utils/fallbackswitch/src/fallbacksrc/imp.rs b/utils/fallbackswitch/src/fallbacksrc/imp.rs
index 7567fa64..7c011273 100644
--- a/utils/fallbackswitch/src/fallbacksrc/imp.rs
+++ b/utils/fallbackswitch/src/fallbacksrc/imp.rs
@@ -705,7 +705,7 @@ impl ObjectImpl for FallbackSrc {
     fn constructed(&self) {
         self.parent_constructed();
 
-        let obj = self.instance();
+        let obj = self.obj();
         obj.set_suppressed_flags(gst::ElementFlags::SOURCE | gst::ElementFlags::SINK);
         obj.set_element_flags(gst::ElementFlags::SOURCE);
         obj.set_bin_flags(gst::BinFlags::STREAMS_AWARE);
@@ -1016,7 +1016,7 @@ impl FallbackSrc {
         let source = match source {
             Source::Uri(ref uri) => {
                 let uri = self
-                    .instance()
+                    .obj()
                     .emit_by_name::<glib::GString>("update-uri", &[uri]);
 
                 let source = gst::ElementFactory::make("uridecodebin3")
@@ -1070,7 +1070,7 @@ impl FallbackSrc {
             imp.handle_source_pad_removed(pad, false);
         });
 
-        self.instance().add(&bin).unwrap();
+        self.obj().add(&bin).unwrap();
 
         SourceBin {
             source: bin,
@@ -1132,8 +1132,7 @@ impl FallbackSrc {
                 None => return,
                 Some(element) => element,
             };
-            let src = FallbackSrc::from_instance(&element);
-
+            let src = element.imp();
             src.handle_source_pad_removed(pad, true);
         });
 
@@ -1144,7 +1143,7 @@ impl FallbackSrc {
         // possible errors and retry, without causing the whole bin state change to fail
         bin.set_locked_state(true);
 
-        self.instance().add(&bin).unwrap();
+        self.obj().add(&bin).unwrap();
 
         Some(SourceBin {
             source: bin,
@@ -1175,7 +1174,7 @@ impl FallbackSrc {
             .build()
             .expect("No fallbackswitch found");
 
-        self.instance().add(&switch).unwrap();
+        self.obj().add(&switch).unwrap();
 
         let dummy_srcpad = dummy_source.static_pad("src").unwrap();
         let dummy_sinkpad = switch.request_pad_simple("sink_%u").unwrap();
@@ -1197,7 +1196,7 @@ impl FallbackSrc {
 
         let srcpad = switch.static_pad("src").unwrap();
         let templ = self
-            .instance()
+            .obj()
             .pad_template(if is_audio { "audio" } else { "video" })
             .unwrap();
         let ghostpad = gst::GhostPad::builder_with_template(&templ, Some(&templ.name()))
@@ -1216,7 +1215,7 @@ impl FallbackSrc {
 
         let _ = ghostpad.set_active(true);
 
-        self.instance().add_pad(&ghostpad).unwrap();
+        self.obj().add_pad(&ghostpad).unwrap();
 
         Stream {
             main_branch: None,
@@ -1271,7 +1270,7 @@ impl FallbackSrc {
                 &settings.fallback_video_caps,
                 settings.min_latency,
             );
-            self.instance().add(&video_dummy_source).unwrap();
+            self.obj().add(&video_dummy_source).unwrap();
 
             let stream = self.create_stream(
                 settings.timeout,
@@ -1294,7 +1293,7 @@ impl FallbackSrc {
                 &settings.fallback_audio_caps,
                 settings.min_latency,
             );
-            self.instance().add(&audio_dummy_source).unwrap();
+            self.obj().add(&audio_dummy_source).unwrap();
 
             let stream = self.create_stream(
                 settings.timeout,
@@ -1332,9 +1331,9 @@ impl FallbackSrc {
 
         drop(state_guard);
 
-        self.instance().no_more_pads();
+        self.obj().no_more_pads();
 
-        self.instance().notify("status");
+        self.obj().notify("status");
 
         gst::debug!(CAT, imp: self, "Started");
         Ok(())
@@ -1349,7 +1348,7 @@ impl FallbackSrc {
         };
         drop(state_guard);
 
-        self.instance().notify("status");
+        self.obj().notify("status");
 
         // In theory all streams should've been removed from the source's pad-removed signal
         // handler when going from Paused to Ready but better safe than sorry here
@@ -1357,7 +1356,7 @@ impl FallbackSrc {
             .iter()
             .filter_map(|v| v.as_ref())
         {
-            let element = self.instance();
+            let element = self.obj();
 
             for branch in [&stream.main_branch, &stream.fallback_branch]
                 .iter()
@@ -1395,7 +1394,7 @@ impl FallbackSrc {
             .iter_mut()
             .flatten()
         {
-            self.instance().remove(&source.source).unwrap();
+            self.obj().remove(&source.source).unwrap();
 
             if let Some(timeout) = source.pending_restart_timeout.take() {
                 timeout.unschedule();
@@ -1418,7 +1417,7 @@ impl FallbackSrc {
         .flatten()
         {
             let _ = source.set_state(gst::State::Null);
-            self.instance().remove(source).unwrap();
+            self.obj().remove(source).unwrap();
         }
 
         gst::debug!(CAT, imp: self, "Stopped");
@@ -1471,7 +1470,7 @@ impl FallbackSrc {
         let source = source.source.clone();
         drop(state_guard);
 
-        self.instance().notify("status");
+        self.obj().notify("status");
 
         let res = source.set_state(transition.next());
         match res {
@@ -1493,7 +1492,7 @@ impl FallbackSrc {
                         fallback_source,
                     );
                     drop(state_guard);
-                    self.instance().notify("statistics");
+                    self.obj().notify("statistics");
                 }
             }
             Ok(res) => {
@@ -1560,7 +1559,7 @@ impl FallbackSrc {
         pad: &gst::ProxyPad,
         buffer: gst::Buffer,
     ) -> Result<gst::FlowSuccess, gst::FlowError> {
-        let res = gst::ProxyPad::chain_default(pad, Some(&*self.instance()), buffer);
+        let res = gst::ProxyPad::chain_default(pad, Some(&*self.obj()), buffer);
 
         let mut state_guard = self.state.lock();
         let state = match &mut *state_guard {
@@ -1998,7 +1997,7 @@ impl FallbackSrc {
         });
 
         drop(state_guard);
-        self.instance().notify("status");
+        self.obj().notify("status");
 
         Ok(())
     }
@@ -2189,7 +2188,7 @@ impl FallbackSrc {
             gst::debug!(CAT, imp: self, "Live source, unblocking directly");
 
             drop(state_guard);
-            self.instance().notify("status");
+            self.obj().notify("status");
 
             return Ok(());
         }
@@ -2236,13 +2235,13 @@ impl FallbackSrc {
         self.unblock_pads(state, fallback_source);
 
         drop(state_guard);
-        self.instance().notify("status");
+        self.obj().notify("status");
 
         Ok(())
     }
 
     fn unblock_pads(&self, state: &mut State, fallback_source: bool) {
-        let current_running_time = match self.instance().current_running_time() {
+        let current_running_time = match self.obj().current_running_time() {
             Some(current_running_time) => current_running_time,
             None => {
                 gst::debug!(CAT, imp: self, "Waiting for current_running_time");
@@ -2590,7 +2589,7 @@ impl FallbackSrc {
         self.unblock_pads(state, fallback_source);
 
         drop(state_guard);
-        self.instance().notify("status");
+        self.obj().notify("status");
     }
 
     fn handle_buffering(&self, m: &gst::message::Buffering) {
@@ -2683,8 +2682,8 @@ impl FallbackSrc {
         }
 
         drop(state_guard);
-        self.instance().notify("status");
-        self.instance().notify("statistics");
+        self.obj().notify("status");
+        self.obj().notify("statistics");
     }
 
     fn handle_streams_selected(&self, m: &gst::message::StreamsSelected) {
@@ -2767,7 +2766,7 @@ impl FallbackSrc {
         self.unblock_pads(state, fallback_source);
 
         drop(state_guard);
-        self.instance().notify("status");
+        self.obj().notify("status");
     }
 
     fn handle_error(&self, m: &gst::message::Error) -> bool {
@@ -2794,8 +2793,8 @@ impl FallbackSrc {
         if src == state.source.source || src.has_as_ancestor(&state.source.source) {
             self.handle_source_error(state, RetryReason::Error, false);
             drop(state_guard);
-            self.instance().notify("status");
-            self.instance().notify("statistics");
+            self.obj().notify("status");
+            self.obj().notify("statistics");
             return true;
         }
 
@@ -2804,8 +2803,8 @@ impl FallbackSrc {
             if src == source.source || src.has_as_ancestor(&source.source) {
                 self.handle_source_error(state, RetryReason::Error, true);
                 drop(state_guard);
-                self.instance().notify("status");
-                self.instance().notify("statistics");
+                self.obj().notify("status");
+                self.obj().notify("statistics");
                 return true;
             }
         }
@@ -2887,7 +2886,7 @@ impl FallbackSrc {
         }
 
         let source_weak = source.source.downgrade();
-        self.instance().call_async(move |element| {
+        self.obj().call_async(move |element| {
             let imp = element.imp();
 
             let source = match source_weak.upgrade() {
@@ -3299,7 +3298,7 @@ impl FallbackSrc {
         );
 
         let timeout = clock.new_single_shot_id(wait_time);
-        let element_weak = self.instance().downgrade();
+        let element_weak = self.obj().downgrade();
         timeout
             .wait_async(move |_clock, _time, _id| {
                 let element = match element_weak.upgrade() {
@@ -3469,7 +3468,7 @@ impl FallbackSrc {
         }
 
         drop(state_guard);
-        self.instance().notify("status");
+        self.obj().notify("status");
     }
 
     fn stats(&self) -> gst::Structure {
diff --git a/utils/fallbackswitch/src/fallbackswitch/imp.rs b/utils/fallbackswitch/src/fallbackswitch/imp.rs
index 8d6c6881..5a9e86de 100644
--- a/utils/fallbackswitch/src/fallbackswitch/imp.rs
+++ b/utils/fallbackswitch/src/fallbackswitch/imp.rs
@@ -318,8 +318,8 @@ impl SinkState {
         extra_time: gst::ClockTime,
     ) -> Option<gst::SingleShotClockId> {
         let running_time = running_time?;
-        let clock = imp.instance().clock()?;
-        let base_time = imp.instance().base_time()?;
+        let clock = imp.obj().clock()?;
+        let base_time = imp.obj().base_time()?;
 
         let wait_until = running_time + base_time;
         let wait_until = wait_until.saturating_add(extra_time);
@@ -412,7 +412,7 @@ impl FallbackSwitch {
         let mut best_priority = 0u32;
         let mut best_pad = None;
 
-        for pad in self.instance().sink_pads() {
+        for pad in self.obj().sink_pads() {
             /* Don't consider the active sinkpad */
             let pad = pad.downcast_ref::<super::FallbackSwitchSinkPad>().unwrap();
             let pad_imp = pad.imp();
@@ -461,7 +461,7 @@ impl FallbackSwitch {
     }
 
     fn cancel_waits(&self) {
-        for pad in self.instance().sink_pads() {
+        for pad in self.obj().sink_pads() {
             let pad = pad.downcast_ref::<super::FallbackSwitchSinkPad>().unwrap();
             let pad_imp = pad.imp();
             let mut pad_state = pad_imp.state.lock();
@@ -477,12 +477,12 @@ impl FallbackSwitch {
     ) {
         state.cancel_timeout();
 
-        let clock = match self.instance().clock() {
+        let clock = match self.obj().clock() {
             None => return,
             Some(clock) => clock,
         };
 
-        let base_time = match self.instance().base_time() {
+        let base_time = match self.obj().base_time() {
             Some(base_time) => base_time,
             None => return,
         };
@@ -777,7 +777,7 @@ impl FallbackSwitch {
                 std::ops::ControlFlow::Continue(gst::EventForeachAction::Keep)
             });
 
-            self.instance().notify(PROP_ACTIVE_PAD);
+            self.obj().notify(PROP_ACTIVE_PAD);
         }
 
         if discont_pending && !buffer.flags().contains(gst::BufferFlags::DISCONT) {
@@ -931,7 +931,7 @@ impl FallbackSwitch {
                 std::ops::ControlFlow::Continue(gst::EventForeachAction::Keep)
             });
 
-            self.instance().notify(PROP_ACTIVE_PAD);
+            self.obj().notify(PROP_ACTIVE_PAD);
         }
         self.src_pad.push_event(event)
     }
@@ -953,7 +953,7 @@ impl FallbackSwitch {
                 self.active_sinkpad.lock().as_ref() == Some(pad)
             }
             _ => {
-                gst::Pad::query_default(pad, Some(&*self.instance()), query);
+                gst::Pad::query_default(pad, Some(&*self.obj()), query);
                 false
             }
         };
@@ -983,7 +983,7 @@ impl FallbackSwitch {
                 let mut min_latency = gst::ClockTime::ZERO;
                 let mut max_latency = gst::ClockTime::NONE;
 
-                for pad in self.instance().sink_pads() {
+                for pad in self.obj().sink_pads() {
                     let mut peer_query = gst::query::Latency::new();
 
                     ret = pad.peer_query(&mut peer_query);
@@ -1017,7 +1017,7 @@ impl FallbackSwitch {
                 if let Some(sinkpad) = sinkpad {
                     sinkpad.peer_query(query)
                 } else {
-                    gst::Pad::query_default(pad, Some(&*self.instance()), query)
+                    gst::Pad::query_default(pad, Some(&*self.obj()), query)
                 }
             }
             _ => {
@@ -1144,11 +1144,9 @@ impl ObjectImpl for FallbackSwitch {
                 settings.timeout = new_value;
                 debug!(CAT, imp: self, "Timeout now {}", settings.timeout);
                 drop(settings);
-                let _ = self.instance().post_message(
-                    gst::message::Latency::builder()
-                        .src(&*self.instance())
-                        .build(),
-                );
+                let _ = self
+                    .obj()
+                    .post_message(gst::message::Latency::builder().src(&*self.obj()).build());
             }
             PROP_LATENCY => {
                 let mut settings = self.settings.lock();
@@ -1156,11 +1154,9 @@ impl ObjectImpl for FallbackSwitch {
 
                 settings.latency = new_value;
                 drop(settings);
-                let _ = self.instance().post_message(
-                    gst::message::Latency::builder()
-                        .src(&*self.instance())
-                        .build(),
-                );
+                let _ = self
+                    .obj()
+                    .post_message(gst::message::Latency::builder().src(&*self.obj()).build());
             }
             PROP_MIN_UPSTREAM_LATENCY => {
                 let mut settings = self.settings.lock();
@@ -1168,11 +1164,9 @@ impl ObjectImpl for FallbackSwitch {
 
                 settings.min_upstream_latency = new_value;
                 drop(settings);
-                let _ = self.instance().post_message(
-                    gst::message::Latency::builder()
-                        .src(&*self.instance())
-                        .build(),
-                );
+                let _ = self
+                    .obj()
+                    .post_message(gst::message::Latency::builder().src(&*self.obj()).build());
             }
             PROP_IMMEDIATE_FALLBACK => {
                 let mut settings = self.settings.lock();
@@ -1221,7 +1215,7 @@ impl ObjectImpl for FallbackSwitch {
     fn constructed(&self) {
         self.parent_constructed();
 
-        let obj = self.instance();
+        let obj = self.obj();
         obj.add_pad(&self.src_pad).unwrap();
         obj.set_element_flags(gst::ElementFlags::REQUIRE_CLOCK);
     }
@@ -1284,7 +1278,7 @@ impl ElementImpl for FallbackSwitch {
                 let mut state = self.state.lock();
                 let prev_active_pad = self.active_sinkpad.lock().take();
                 *state = State::default();
-                let pads = self.instance().sink_pads();
+                let pads = self.obj().sink_pads();
 
                 if let Some(pad) = pads.first() {
                     let pad = pad.downcast_ref::<super::FallbackSwitchSinkPad>().unwrap();
@@ -1295,7 +1289,7 @@ impl ElementImpl for FallbackSwitch {
                     drop(state);
 
                     if prev_active_pad.as_ref() != Some(pad) {
-                        self.instance().notify(PROP_ACTIVE_PAD);
+                        self.obj().notify(PROP_ACTIVE_PAD);
                     }
                 }
                 for pad in pads {
@@ -1318,7 +1312,7 @@ impl ElementImpl for FallbackSwitch {
             }
             gst::StateChange::PausedToReady => {
                 *self.state.lock() = State::default();
-                for pad in self.instance().sink_pads() {
+                for pad in self.obj().sink_pads() {
                     let pad = pad.downcast_ref::<super::FallbackSwitchSinkPad>().unwrap();
                     let pad_imp = pad.imp();
                     *pad_imp.state.lock() = SinkState::default();
@@ -1378,7 +1372,7 @@ impl ElementImpl for FallbackSwitch {
         .build();
 
         pad.set_active(true).unwrap();
-        self.instance().add_pad(&pad).unwrap();
+        self.obj().add_pad(&pad).unwrap();
 
         let notify_active_pad = match &mut *self.active_sinkpad.lock() {
             active_sinkpad @ None => {
@@ -1396,16 +1390,14 @@ impl ElementImpl for FallbackSwitch {
         drop(state);
 
         if notify_active_pad {
-            self.instance().notify(PROP_ACTIVE_PAD);
+            self.obj().notify(PROP_ACTIVE_PAD);
         }
 
-        let _ = self.instance().post_message(
-            gst::message::Latency::builder()
-                .src(&*self.instance())
-                .build(),
-        );
+        let _ = self
+            .obj()
+            .post_message(gst::message::Latency::builder().src(&*self.obj()).build());
 
-        self.instance().child_added(&pad, &pad.name());
+        self.obj().child_added(&pad, &pad.name());
         Some(pad.upcast())
     }
 
@@ -1416,14 +1408,12 @@ impl ElementImpl for FallbackSwitch {
         drop(pad_state);
 
         let _ = pad.set_active(false);
-        self.instance().remove_pad(pad).unwrap();
+        self.obj().remove_pad(pad).unwrap();
 
-        self.instance().child_removed(pad, &pad.name());
-        let _ = self.instance().post_message(
-            gst::message::Latency::builder()
-                .src(&*self.instance())
-                .build(),
-        );
+        self.obj().child_removed(pad, &pad.name());
+        let _ = self
+            .obj()
+            .post_message(gst::message::Latency::builder().src(&*self.obj()).build());
     }
 }
 
@@ -1432,12 +1422,12 @@ impl ElementImpl for FallbackSwitch {
 // This allows accessing the pads and their properties from e.g. gst-launch.
 impl ChildProxyImpl for FallbackSwitch {
     fn children_count(&self) -> u32 {
-        let object = self.instance();
+        let object = self.obj();
         object.num_pads() as u32
     }
 
     fn child_by_name(&self, name: &str) -> Option<glib::Object> {
-        let object = self.instance();
+        let object = self.obj();
         object
             .pads()
             .into_iter()
@@ -1446,7 +1436,7 @@ impl ChildProxyImpl for FallbackSwitch {
     }
 
     fn child_by_index(&self, index: u32) -> Option<glib::Object> {
-        let object = self.instance();
+        let object = self.obj();
         object
             .pads()
             .into_iter()
diff --git a/utils/togglerecord/src/togglerecord/imp.rs b/utils/togglerecord/src/togglerecord/imp.rs
index 24b193a1..b15cd569 100644
--- a/utils/togglerecord/src/togglerecord/imp.rs
+++ b/utils/togglerecord/src/togglerecord/imp.rs
@@ -497,7 +497,7 @@ impl ToggleRecord {
 
                 drop(rec_state);
                 drop(state);
-                self.instance().notify("recording");
+                self.obj().notify("recording");
 
                 Ok(HandleResult::Drop)
             }
@@ -583,7 +583,7 @@ impl ToggleRecord {
 
                 drop(rec_state);
                 drop(state);
-                self.instance().notify("recording");
+                self.obj().notify("recording");
 
                 Ok(HandleResult::Pass(data))
             }
@@ -1187,7 +1187,7 @@ impl ToggleRecord {
                 );
 
                 if recording_state_updated {
-                    self.instance().notify("recording");
+                    self.obj().notify("recording");
                 }
 
                 return Err(gst::FlowError::Eos);
@@ -1444,7 +1444,7 @@ impl ToggleRecord {
         };
 
         if recording_state_changed {
-            self.instance().notify("recording");
+            self.obj().notify("recording");
         }
 
         // If a serialized event and coming after Segment and a new Segment is pending,
@@ -1859,7 +1859,7 @@ impl ObjectImpl for ToggleRecord {
     fn constructed(&self) {
         self.parent_constructed();
 
-        let obj = self.instance();
+        let obj = self.obj();
         obj.add_pad(&self.main_stream.sinkpad).unwrap();
         obj.add_pad(&self.main_stream.srcpad).unwrap();
     }
@@ -1982,7 +1982,7 @@ impl ElementImpl for ToggleRecord {
             let mut rec_state = self.state.lock();
             *rec_state = State::default();
             drop(rec_state);
-            self.instance().notify("recording");
+            self.obj().notify("recording");
         }
 
         Ok(success)
@@ -2001,7 +2001,7 @@ impl ElementImpl for ToggleRecord {
         let id = *pad_count;
         *pad_count += 1;
 
-        let templ = self.instance().pad_template("sink_%u").unwrap();
+        let templ = self.obj().pad_template("sink_%u").unwrap();
         let sinkpad =
             gst::Pad::builder_with_template(&templ, Some(format!("sink_{}", id).as_str()))
                 .chain_function(|pad, parent, buffer| {
@@ -2034,7 +2034,7 @@ impl ElementImpl for ToggleRecord {
                 })
                 .build();
 
-        let templ = self.instance().pad_template("src_%u").unwrap();
+        let templ = self.obj().pad_template("src_%u").unwrap();
         let srcpad = gst::Pad::builder_with_template(&templ, Some(format!("src_{}", id).as_str()))
             .event_function(|pad, parent, event| {
                 ToggleRecord::catch_panic_pad_function(
@@ -2072,8 +2072,8 @@ impl ElementImpl for ToggleRecord {
         drop(pads);
         drop(other_streams_guard);
 
-        self.instance().add_pad(&sinkpad).unwrap();
-        self.instance().add_pad(&srcpad).unwrap();
+        self.obj().add_pad(&sinkpad).unwrap();
+        self.obj().add_pad(&srcpad).unwrap();
 
         Some(sinkpad)
     }
@@ -2105,7 +2105,7 @@ impl ElementImpl for ToggleRecord {
         stream.srcpad.set_active(false).unwrap();
         stream.sinkpad.set_active(false).unwrap();
 
-        self.instance().remove_pad(&stream.sinkpad).unwrap();
-        self.instance().remove_pad(&stream.srcpad).unwrap();
+        self.obj().remove_pad(&stream.sinkpad).unwrap();
+        self.obj().remove_pad(&stream.srcpad).unwrap();
     }
 }
diff --git a/utils/tracers/src/buffer_lateness/imp.rs b/utils/tracers/src/buffer_lateness/imp.rs
index 2df287df..5a5f6c81 100644
--- a/utils/tracers/src/buffer_lateness/imp.rs
+++ b/utils/tracers/src/buffer_lateness/imp.rs
@@ -174,7 +174,7 @@ impl ObjectImpl for BufferLateness {
     fn constructed(&self) {
         self.parent_constructed();
 
-        if let Some(params) = self.instance().property::<Option<String>>("params") {
+        if let Some(params) = self.obj().property::<Option<String>>("params") {
             let mut state = self.state.lock().unwrap();
             state.settings.update_from_params(self, params);
         }
diff --git a/utils/tracers/src/pipeline_snapshot/imp.rs b/utils/tracers/src/pipeline_snapshot/imp.rs
index 49e2f559..f3f537ae 100644
--- a/utils/tracers/src/pipeline_snapshot/imp.rs
+++ b/utils/tracers/src/pipeline_snapshot/imp.rs
@@ -134,7 +134,7 @@ impl ObjectImpl for PipelineSnapshot {
         self.parent_constructed();
 
         let mut settings = Settings::default();
-        if let Some(params) = self.instance().property::<Option<String>>("params") {
+        if let Some(params) = self.obj().property::<Option<String>>("params") {
             settings.update_from_params(self, params);
         }
 
@@ -185,7 +185,7 @@ impl PipelineSnapshot {
         let mut signals = Signals::new(&[SIGUSR1])?;
         let signal_handle = signals.handle();
 
-        let tracer_weak = self.instance().downgrade();
+        let tracer_weak = self.obj().downgrade();
         let pipelines = self.pipelines.clone();
 
         let thread_handle = std::thread::spawn(move || {
diff --git a/utils/tracers/src/queue_levels/imp.rs b/utils/tracers/src/queue_levels/imp.rs
index 1662d05f..959ee195 100644
--- a/utils/tracers/src/queue_levels/imp.rs
+++ b/utils/tracers/src/queue_levels/imp.rs
@@ -201,7 +201,7 @@ impl ObjectImpl for QueueLevels {
     fn constructed(&self) {
         self.parent_constructed();
 
-        if let Some(params) = self.instance().property::<Option<String>>("params") {
+        if let Some(params) = self.obj().property::<Option<String>>("params") {
             let mut state = self.state.lock().unwrap();
             state.settings.update_from_params(self, params);
         }
diff --git a/utils/uriplaylistbin/src/uriplaylistbin/imp.rs b/utils/uriplaylistbin/src/uriplaylistbin/imp.rs
index 8ee1f449..fc016e1b 100644
--- a/utils/uriplaylistbin/src/uriplaylistbin/imp.rs
+++ b/utils/uriplaylistbin/src/uriplaylistbin/imp.rs
@@ -205,7 +205,7 @@ impl State {
 
             // send pending messages then unblock pads
             for msg in messages {
-                let _ = imp.instance().post_message(msg);
+                let _ = imp.obj().post_message(msg);
             }
 
             channels.send(true);
@@ -826,7 +826,7 @@ impl ObjectImpl for UriPlaylistBin {
     fn constructed(&self) {
         self.parent_constructed();
 
-        let obj = self.instance();
+        let obj = self.obj();
         obj.set_suppressed_flags(gst::ElementFlags::SOURCE | gst::ElementFlags::SINK);
         obj.set_element_flags(gst::ElementFlags::SOURCE);
     }
@@ -978,7 +978,7 @@ impl UriPlaylistBin {
                 .build()
                 .map_err(|e| PlaylistError::PluginMissing { error: e.into() })?;
 
-            self.instance().add(&streamsynchronizer).unwrap();
+            self.obj().add(&streamsynchronizer).unwrap();
 
             let settings = self.settings.lock().unwrap();
 
@@ -1015,7 +1015,7 @@ impl UriPlaylistBin {
                 let _ = uridecodebin.set_state(gst::State::Null);
             });
 
-            self.instance().remove(&uridecodebin).unwrap();
+            self.obj().remove(&uridecodebin).unwrap();
         }
 
         if state.waiting_for_stream_collection.is_some()
@@ -1062,7 +1062,7 @@ impl UriPlaylistBin {
 
         let uridecodebin = item.uridecodebin();
 
-        self.instance().add(&uridecodebin).unwrap();
+        self.obj().add(&uridecodebin).unwrap();
 
         let item_clone = item.clone();
         assert!(state.waiting_for_stream_collection.is_none());
@@ -1217,7 +1217,7 @@ impl UriPlaylistBin {
     }
 
     fn process_decodebin_pad(&self, src_pad: &gst::Pad) {
-        let element = self.instance();
+        let element = self.obj();
 
         let start_next = {
             let mut state_guard = self.state.lock().unwrap();
@@ -1561,7 +1561,7 @@ impl UriPlaylistBin {
                     streamsynchronizer.release_request_pad(&ss_sink);
 
                     // remove associated ghost pad
-                    let src_pads = imp.instance().src_pads();
+                    let src_pads = imp.obj().src_pads();
                     let ghost = src_pads
                         .iter()
                         .find(|pad| {
@@ -1569,9 +1569,9 @@ impl UriPlaylistBin {
                             ghost.target().is_none()
                         })
                         .unwrap();
-                    imp.instance().remove_pad(ghost).unwrap();
+                    imp.obj().remove_pad(ghost).unwrap();
 
-                    imp.instance().remove(&concat).unwrap();
+                    imp.obj().remove(&concat).unwrap();
                     let _ = concat.set_state(gst::State::Null);
                 }
             }
@@ -1636,7 +1636,7 @@ impl UriPlaylistBin {
                 uridecodebin.call_async(move |uridecodebin| {
                     let _ = uridecodebin.set_state(gst::State::Null);
                 });
-                let _ = self.instance().remove(&uridecodebin);
+                let _ = self.obj().remove(&uridecodebin);
 
                 let details = gst::Structure::builder("details");
                 let details = details.field("uri", item.uri());
@@ -1672,7 +1672,7 @@ impl UriPlaylistBin {
                     current_iteration = 0;
                 }
 
-                let element = self.instance();
+                let element = self.obj();
                 if current_iteration != state.current_iteration {
                     state.current_iteration = current_iteration;
                     element.notify("current-iteration");