Remove leftovers

Author: FelonEkonom

lib/membrane/core/bin/state.ex

@@ -45,7 +45,6 @@ defmodule Membrane.Core.Bin.State do
           terminating?: boolean(),
           resource_guard: Membrane.ResourceGuard.t(),
           setup_incomplete?: boolean(),
-          # handling_action?: boolean(),
           stalker: Membrane.Core.Stalker.t()
         }
 
@@ -73,7 +72,6 @@ defmodule Membrane.Core.Bin.State do
             initialized?: false,
             terminating?: false,
             setup_incomplete?: false,
-            # handling_action?: false,
             stalker: nil,
             resource_guard: nil,
             subprocess_supervisor: nil,

lib/membrane/core/callback_handler.ex

@@ -132,7 +132,7 @@ defmodule Membrane.Core.CallbackHandler do
          %{context: context_fun},
          %{module: module, internal_state: internal_state} = state
        ) do
-    args = args ++ [context_fun.(state) |> Map.put(:s, state), internal_state]
+    args = args ++ [context_fun.(state), internal_state]
 
     callback_result =
       try do
@@ -188,9 +188,6 @@ defmodule Membrane.Core.CallbackHandler do
           reraise e, __STACKTRACE__
       end
 
-    # was_delay_demands? = Map.get(state, :delay_demands?, false)
-    # state = if Component.is_element?(state), do: %{state | delay_demands?: true}, else: state
-
     state =
       Enum.reduce(actions, state, fn action, state ->
         try do
@@ -205,11 +202,6 @@ defmodule Membrane.Core.CallbackHandler do
         end
       end)
 
-    # state =
-    #   if Component.is_element?(state) and not was_delay_demands?,
-    #     do: %{state | delay_demands?: false},
-    #     else: state
-
     handler_module.handle_end_of_actions(callback, state)
   end
 end

lib/membrane/core/element/action_handler.ex

@@ -45,45 +45,40 @@ defmodule Membrane.Core.Element.ActionHandler do
 
   defguardp is_demand_size(size) when is_integer(size) or is_function(size)
 
+  # Match in the function below is caused by a fact, that handle_spec_started is the only callback, that
+  # might be executed in between handling actions returned from other callbacks.
+  # This callback has been deprecated and should be removed in v2.0.0, along with the if statement below.
+
   @impl CallbackHandler
-  def handle_end_of_actions(callback, state) do
+  def handle_end_of_actions(:handle_spec_started, state), do: state
+
+  def handle_end_of_actions(_callback, state) do
     # Fixed order of handling demand of manual and auto pads would lead to
     # favoring manual pads over auto pads (or vice versa), especially after
     # introducting auto flow queues.
 
-    # Condition in if below is caused by a fact, that handle_spec_started is the only callback, that might
-    # be executed in between handling actions returned from other callbacks.
-    # This callback has been deprecated and should be removed in v2.0.0, along with the if statement below.
-
-    if callback != :handle_spec_started do
-      if Enum.random([1, 2]) == 1 do
-        snapshot(callback, state)
-        |> hdd()
-      else
-        state
-        |> hdd()
-        |> then(&snapshot(callback, &1))
-      end
+    if Enum.random([true, false]) do
+      state
+      |> handle_pads_to_snapshot()
+      |> maybe_handle_delayed_demands()
     else
       state
+      |> maybe_handle_delayed_demands()
+      |> handle_pads_to_snapshot()
     end
   end
 
-  defp hdd(state) do
+  defp maybe_handle_delayed_demands(state) do
     with %{delay_demands?: false} <- state do
       ManualFlowController.handle_delayed_demands(state)
     end
   end
 
-  defp snapshot(callback, state) do
-    if callback != :handle_spec_started do
-      state.pads_to_snapshot
-      |> Enum.shuffle()
-      |> Enum.reduce(state, &DemandController.snapshot_atomic_demand/2)
-      |> Map.put(:pads_to_snapshot, MapSet.new())
-    else
-      state
-    end
+  defp handle_pads_to_snapshot(state) do
+    state.pads_to_snapshot
+    |> Enum.shuffle()
+    |> Enum.reduce(state, &DemandController.snapshot_atomic_demand/2)
+    |> Map.put(:pads_to_snapshot, MapSet.new())
   end
 
   @impl CallbackHandler
@@ -245,7 +240,7 @@ defmodule Membrane.Core.Element.ActionHandler do
         %State{type: type} = state
       )
       when is_pad_ref(pad_ref) and is_demand_size(size) and type in [:sink, :filter, :endpoint] do
-        delay_supplying_demand(pad_ref, size, state)
+    delay_supplying_demand(pad_ref, size, state)
   end
 
   @impl CallbackHandler

lib/membrane/core/element/state.ex

@@ -42,7 +42,6 @@ defmodule Membrane.Core.Element.State do
           terminating?: boolean(),
           setup_incomplete?: boolean(),
           effective_flow_control: EffectiveFlowController.effective_flow_control(),
-          # handling_action?: boolean(),
           popping_auto_flow_queue?: boolean(),
           pads_to_snapshot: MapSet.t(),
           stalker: Membrane.Core.Stalker.t(),
@@ -75,7 +74,6 @@ defmodule Membrane.Core.Element.State do
             terminating?: false,
             setup_incomplete?: false,
             delay_demands?: false,
-            # handling_action?: false,
             popping_auto_flow_queue?: false,
             stalker: nil,
             resource_guard: nil,

lib/membrane/core/pipeline/state.ex

@@ -32,7 +32,6 @@ defmodule Membrane.Core.Pipeline.State do
           terminating?: boolean(),
           resource_guard: Membrane.ResourceGuard.t(),
           setup_incomplete?: boolean(),
-          # handling_action?: boolean(),
           stalker: Membrane.Core.Stalker.t(),
           subprocess_supervisor: pid(),
           awaiting_setup_completition?: boolean()
@@ -56,7 +55,6 @@ defmodule Membrane.Core.Pipeline.State do
             initialized?: false,
             terminating?: false,
             setup_incomplete?: false,
-            # handling_action?: false,
             stalker: nil,
             resource_guard: nil,
             subprocess_supervisor: nil,

test/membrane/core/element/action_handler_test.exs

@@ -25,7 +25,6 @@ defmodule Membrane.Core.Element.ActionHandlerTest do
         playback: :stopped,
         synchronization: %{clock: nil, parent_clock: nil},
         delayed_demands: MapSet.new(),
-        # handling_action?: false,
         pads_to_snapshot: MapSet.new(),
         pads_data: %{
           input:
@@ -110,7 +109,6 @@ defmodule Membrane.Core.Element.ActionHandlerTest do
         synchronization: %{clock: nil, parent_clock: nil},
         delayed_demands: MapSet.new(),
         playback: :stopped,
-        # handling_action?: false,
         pads_to_snapshot: MapSet.new(),
         pads_data: %{
           output: %{
@@ -512,7 +510,6 @@ defmodule Membrane.Core.Element.ActionHandlerTest do
         name: :elem_name,
         synchronization: %{clock: nil, parent_clock: nil},
         type: :source,
-        # handling_action?: false,
         pads_to_snapshot: MapSet.new(),
         pads_data: %{
           output: %{

test/membrane/core/element/event_controller_test.exs

@@ -51,7 +51,6 @@ defmodule Membrane.Core.Element.EventControllerTest do
         playback: :playing,
         parent_pid: self(),
         synchronization: %{clock: nil, parent_clock: nil, stream_sync: nil},
-        # handling_action?: false,
         delay_demands?: false,
         pads_to_snapshot: MapSet.new(),
         delayed_demands: MapSet.new(),

test/membrane/core/element/lifecycle_controller_test.exs

@@ -50,7 +50,6 @@ defmodule Membrane.Core.Element.LifecycleControllerTest do
         playback: :playing,
         parent_pid: self(),
         synchronization: %{clock: nil, parent_clock: nil},
-        # handling_action?: false,
         delay_demands?: false,
         pads_to_snapshot: MapSet.new(),
         delayed_demands: MapSet.new(),

test/membrane/core/element/pad_controller_test.exs

@@ -18,7 +18,6 @@ defmodule Membrane.Core.Element.PadControllerTest do
     struct!(State,
       name: name,
       module: elem_module,
-      # handling_action?: false,
       delay_demands?: false,
       pads_to_snapshot: MapSet.new(),
       delayed_demands: MapSet.new(),

test/membrane/core/element/stream_format_controller_test.exs

@@ -42,7 +42,6 @@ defmodule Membrane.Core.Element.StreamFormatControllerTest do
         type: :filter,
         playback: :playing,
         synchronization: %{clock: nil, parent_clock: nil},
-        # handling_action?: false,
         delay_demands?: false,
         pads_to_snapshot: MapSet.new(),
         delayed_demands: MapSet.new(),