code: def send_with_data_passthrough(self, event):
          
          if self.our_state is ERROR:
              raise LocalProtocolError(
                  "Can't send data when our state is ERROR")
          try:
              if type(event) is Response:
                  self._clean_up_response_headers_for_sending(event)
              # We want to call _process_event before calling the writer,
              # because if someone tries to do something invalid then this will
              # give a sensible error message, while our writers all just assume
              # they will only receive valid events. But, _process_event might
              # change self._writer. So we have to do a little dance:
              writer = self._writer
              self._process_event(self.our_role, event)
              if type(event) is ConnectionClosed:
                  return None
              else:
                  # In any situation where writer is None, process_event should
                  # have raised ProtocolError
                  assert writer is not None
                  data_list = []
                  writer(event, data_list.append)
                  return data_list
          except:
              self._process_error(self.our_role)
              raise
docs: Identical to :meth:`send`, except that in situations where
          :meth:`send` returns a single :term:`bytes-like object`, this instead
          returns a list of them -- and when sending a :class:`Data` event, this
          list is guaranteed to contain the exact object you passed in as
          :attr:`Data.data`. See :ref:`sendfile` for discussion.