Process incoming IQs in the same order that they were sent.

remoting/protocol/jingle_session_manager.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/protocol/jingle_session_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/content_description.h"
 #include "remoting/protocol/jingle_messages.h"
 #include "remoting/protocol/jingle_session.h"
 #include "remoting/protocol/transport.h"
 #include "remoting/signaling/iq_sender.h"
 #include "remoting/signaling/signal_strategy.h"
 #include "third_party/webrtc/base/socketaddress.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
+#include "third_party/webrtc/libjingle/xmpp/constants.h"
 
 using buzz::QName;
 
 namespace remoting {
 namespace protocol {
 
 JingleSessionManager::JingleSessionManager(SignalStrategy* signal_strategy)
     : signal_strategy_(signal_strategy),
       protocol_config_(CandidateSessionConfig::CreateDefault()),
       iq_sender_(new IqSender(signal_strategy_)) {
@@ skipping 96 matching lines @@
 
     return true;
   }
 
   SessionsMap::iterator it = sessions_.find(message->sid);
   if (it == sessions_.end()) {
     SendReply(stanza, JingleMessageReply::INVALID_SID);
     return true;
   }
 
-  it->second->OnIncomingMessage(std::move(message), base::Bind(
-      &JingleSessionManager::SendReply, base::Unretained(this), stanza));
+  it->second->OnIncomingMessage(stanza->Attr(buzz::QN_ID), std::move(message),
+                                base::Bind(&JingleSessionManager::SendReply,
+                                           base::Unretained(this), stanza));
   return true;
 }
 
 void JingleSessionManager::SendReply(const buzz::XmlElement* original_stanza,
                                      JingleMessageReply::ErrorType error) {
   signal_strategy_->SendStanza(
       JingleMessageReply(error).ToXml(original_stanza));

[Sergey Ulanov, 2016/10/14 18:36:54]

Here original_stanza is not owned, so it may be deleted. Previously
OnIncomingMessage() was always calling SendReply() synchronously, so it was
guaranteed that original_stanza is still valid here, but this is not the case
anymore given that reply_callback can be called later.

We don't really need to attach original message content to the response (XMPP
spec says it's optional, see https://tools.ietf.org/html/rfc6120#section-8.3.2).

I suggest removing this feature, then this code can be cleaned up. It won't be
necessary to pass reply_callback to OnIncomingMessage(). Instead JingleSession
will be able to call session_manager_->SendReply() directly.

[kelvinp, 2016/10/14 22:49:18]

Good point on the point validity.

A couple notes, when sending message to a host that is offline, today the XMPP
framework sends an <network-unavailable> error stanza that includes the original
stanza.  The bot uses the from-endpoint-id in the original stanza to route the
error back to the LCS client.  It would be weird to expect the original stanza
in some cases but not others.

JingleMessageReply.toXml still needs the original stanza to figure out the the
ID, and the address to reply to.

So I would suggest leaving this change as is and invoke the copy constructor to
copy the stanza over.  WDYT?

 }
 
 void JingleSessionManager::SessionDestroyed(JingleSession* session) {
   sessions_.erase(session->session_id_);
 }
 
 }  // namespace protocol
 }  // namespace remoting