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 31 matching lines @@
 }
 
 void JingleSessionManager::OnSignalStrategyStateChange(
     SignalStrategy::State state) {}
 
 bool JingleSessionManager::OnSignalStrategyIncomingStanza(
     const buzz::XmlElement* stanza) {
   if (!JingleMessage::IsJingleMessage(stanza))
     return false;
 
+  std::unique_ptr<buzz::XmlElement> stanza_copy(new buzz::XmlElement(*stanza));
   std::unique_ptr<JingleMessage> message(new JingleMessage());
   std::string error;
   if (!message->ParseXml(stanza, &error)) {
-    SendReply(stanza, JingleMessageReply::BAD_REQUEST);
+    SendReply(std::move(stanza_copy), JingleMessageReply::BAD_REQUEST);
     return true;
   }
 
   if (message->action == JingleMessage::SESSION_INITIATE) {
     // Description must be present in session-initiate messages.
     DCHECK(message->description.get());
 
-    SendReply(stanza, JingleMessageReply::NONE);
+    SendReply(std::move(stanza_copy), JingleMessageReply::NONE);
 
     std::unique_ptr<Authenticator> authenticator =
         authenticator_factory_->CreateAuthenticator(
             signal_strategy_->GetLocalJid(), message->from.id());
 
     JingleSession* session = new JingleSession(this);
     session->InitializeIncomingConnection(*message,
                                           std::move(authenticator));
     sessions_[session->session_id_] = session;
 
@@ skipping 29 matching lines @@
       session->Close(error);
       delete session;
       DCHECK(sessions_.find(message->sid) == sessions_.end());
     }
 
     return true;
   }
 
   SessionsMap::iterator it = sessions_.find(message->sid);
   if (it == sessions_.end()) {
-    SendReply(stanza, JingleMessageReply::INVALID_SID);
+    SendReply(std::move(stanza_copy), 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),
+                 base::Passed(std::move(stanza_copy))));
   return true;
 }
 
-void JingleSessionManager::SendReply(const buzz::XmlElement* original_stanza,
-                                     JingleMessageReply::ErrorType error) {
+void JingleSessionManager::SendReply(
+    std::unique_ptr<buzz::XmlElement> original_stanza,
+    JingleMessageReply::ErrorType error) {
   signal_strategy_->SendStanza(
-      JingleMessageReply(error).ToXml(original_stanza));
+      JingleMessageReply(error).ToXml(original_stanza.get()));
 }
 
 void JingleSessionManager::SessionDestroyed(JingleSession* session) {
   sessions_.erase(session->session_id_);
 }
 
 }  // namespace protocol
 }  // namespace remoting