docs: def _send_backlog(self, connection, destination=None):
          """
          Sends any queued-up messages for the (optionally) specified destination to connection.
  
          If the destination is not provided, a destination is chosen using the 
          L{QueueManager.queue_scheduler} scheduler algorithm.
  
          (This method assumes it is being called from within a lock-guarded public
          method.)  
  
          @param connection: The client connection.
          @type connection: L{coilmq.server.StompConnection}
  
          @param destination: The topic/queue destination (e.g. '/queue/foo')
          @type destination: C{str} 
  
          @raise Exception: if the underlying connection object raises an error, the message
                              will be re-queued and the error will be re-raised.  
          """
          if destination is None:
              # Find all destinations that have frames and that contain this
              # connection (subscriber).
              eligible_queues = dict([(dest, q) for (dest, q) in self._queues.items()
                                      if connection in q and self.store.has_frames(dest)])
              destination = self.queue_scheduler.choice(
                  eligible_queues, connection)
              if destination is None:
                  self.log.debug(
                      "No eligible queues (with frames) for subscriber %s" % connection)
                  return
  
          self.log.debug("Sending backlog to %s for destination %s" %
                         (connection, destination))
          if connection.reliable_subscriber:
              # only send one message (waiting for ack)
              frame = self.store.dequeue(destination)
              if frame:
                  try:
                      self._send_frame(connection, frame)
                  except Exception as x:
                      self.log.error(
                          "Error sending message %s (requeueing): %s" % (frame, x))
                      self.store.requeue(destination, frame)
                      raise
          else:
              for frame in self.store.frames(destination):
                  try:
                      self._send_frame(connection, frame)
                  except Exception as x:
                      self.log.error(
                          "Error sending message %s (requeueing): %s" % (frame, x))
                      self.store.requeue(destination, frame)
                      raise