anchor.diff:      NewState = wrap_and_send(transport(State), exml:to_iolist(StreamEnd), Ref, State),
       {noreply, NewState#state{ waiting_requesters = [{Ref, From} | WaitingRequesters] }}.
   
  +-spec handle_cast(term(), state()) -> {noreply, state()} | {stop, normal, state()}.
   handle_cast(stop, State) ->
       {stop, normal, State};
  +
   handle_cast({send_raw, Transport, Body}, State) ->
       NewState = send(Transport, Body, State),
       {noreply, NewState};
  +
   handle_cast({resend_raw, Transport, Body}, State) ->
       NewState = send(Transport, Body, make_ref(), State#state.rid, State),
       {noreply, NewState};
  +
   handle_cast({pause, Transport, Seconds},
               #state{rid = Rid, sid = Sid} = State) ->
       NewState = send(Transport, pause_body(Rid, Sid, Seconds), State),
       {noreply, NewState};
  +
   handle_cast(reset_parser, #state{parser = Parser} = State) ->
       {ok, NewParser} = exml_stream:reset_parser(Parser),
       {noreply, State#state{parser = NewParser}}.
   
   
   %% Handle async HTTP request replies.
  +-spec handle_info(term(), state()) -> {noreply, state()}.
   handle_info(_, #state{ terminated = true } = S) ->
       {noreply, S};
   handle_info({http_reply, Ref, Body, Transport} = HttpReply,
  
positive.code: %%
  %% Sometimes it's necessary to intercept the whole BOSH wrapper
  %% not only the wrapped stanzas. That's when this mechanism proves useful.
  get_active(#client{rcv_pid = Pid}) ->
      gen_server:call(Pid, get_active).
  
  set_active(#client{rcv_pid = Pid}, Active) ->
      gen_server:call(Pid, {set_active, Active}).
  
  
negative.code: %%
  %% Otherwise, the non-matching request IDs will
  %% confuse the server and possibly cause errors.
  -spec send_raw(escalus:client(), exml:element()) -> ok.
  send_raw(#client{rcv_pid = Pid} = Transport, Body) ->
      gen_server:cast(Pid, {send_raw, Transport, Body}).
  
  