docs: def HandleMessageBundles(self, request_comms, response_comms):
      """Processes a queue of messages as passed from the client.
  
      We basically dispatch all the GrrMessages in the queue to the task scheduler
      for backend processing. We then retrieve from the TS the messages destined
      for this client.
  
      Args:
         request_comms: A ClientCommunication rdfvalue with messages sent by the
           client. source should be set to the client CN.
         response_comms: A ClientCommunication rdfvalue of jobs destined to this
           client.
  
      Returns:
         tuple of (source, message_count) where message_count is the number of
         messages received from the client with common name source.
      """
      messages, source, timestamp = self._communicator.DecodeMessages(
          request_comms)
  
      now = time.time()
      if messages:
        # Receive messages in line.
        self.ReceiveMessages(source, messages)
  
      # We send the client a maximum of self.max_queue_size messages
      required_count = max(0, self.max_queue_size - request_comms.queue_size)
      tasks = []
  
      message_list = rdf_flows.MessageList()
      # Only give the client messages if we are able to receive them in a
      # reasonable time.
      if time.time() - now < 10:
        tasks = self.DrainTaskSchedulerQueueForClient(source, required_count)
        message_list.job = tasks
  
      # Encode the message_list in the response_comms using the same API version
      # the client used.
      self._communicator.EncodeMessages(
          message_list,
          response_comms,
          destination=source,
          timestamp=timestamp,
          api_version=request_comms.api_version)
  
      return source, len(messages)