Allow transport candidates to arrive after the authentication accepted message.

remoting/protocol/jingle_session.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.h"
 
 #include "base/bind.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 219 matching lines @@
       const std::string& name,
       const StreamChannelCallback& callback) {
   DCHECK(!channels_[name]);
 
   scoped_ptr<ChannelAuthenticator> channel_authenticator =
       authenticator_->CreateChannelAuthenticator();
   scoped_ptr<StreamTransport> channel =
       session_manager_->transport_factory_->CreateStreamTransport();
   channel->Initialize(name, this, channel_authenticator.Pass());
   channel->Connect(callback);
+  // Check if any remote candidates were already received for this channel.

[Wez, 2013/07/12 22:43:24]

nit: Blank line before this comment.

[rmsousa, 2013/07/13 00:11:47]

Moved to the header for the new function.

+  std::list<JingleMessage::NamedCandidate>::iterator it =

[Wez, 2013/07/12 22:43:24]

nit: This code fragment is identical to the one in CreateDatagramChannel(), so
factor it out into a static helper function.

[rmsousa, 2013/07/13 00:11:47]

Done.

+      pending_remote_candidates_.begin();
+  while(it != pending_remote_candidates_.end()) {
+    if (it->name == name) {
+      channel->AddRemoteCandidate(it->candidate);
+      it = pending_remote_candidates_.erase(it);
+    } else {
+      ++it;
+    }
+  }
   channels_[name] = channel.release();
 }
 
 void JingleSession::CreateDatagramChannel(
     const std::string& name,
     const DatagramChannelCallback& callback) {
   DCHECK(!channels_[name]);
 
   scoped_ptr<ChannelAuthenticator> channel_authenticator =
       authenticator_->CreateChannelAuthenticator();
   scoped_ptr<DatagramTransport> channel =
       session_manager_->transport_factory_->CreateDatagramTransport();
   channel->Initialize(name, this, channel_authenticator.Pass());
   channel->Connect(callback);

[Wez, 2013/07/12 22:43:24]

nit: Blank line before this comment.

[rmsousa, 2013/07/13 00:11:47]

Moved to the header for the new function.

+  // Check if any remote candidates were already received for this channel.
+  std::list<JingleMessage::NamedCandidate>::iterator it =
+      pending_remote_candidates_.begin();
+  while(it != pending_remote_candidates_.end()) {
+    if (it->name == name) {
+      channel->AddRemoteCandidate(it->candidate);
+      it = pending_remote_candidates_.erase(it);
+    } else {
+      ++it;
+    }
+  }
   channels_[name] = channel.release();
 }
 
 void JingleSession::CancelChannelCreation(const std::string& name) {
   ChannelsMap::iterator it = channels_.find(name);
   if (it != channels_.end() && !it->second->is_connected()) {

[Wez, 2013/07/12 22:43:24]

nit: Clear any candidates received for cancelled channels here?

[rmsousa, 2013/07/13 00:11:47]

The candidates are removed from the list and added to the channel at the moment
we create it. At this point they're already gone from the pending list.

     delete it->second;
     DCHECK(!channels_[name]);
   }
 }
 
 void JingleSession::OnTransportCandidate(Transport* transport,
                                          const cricket::Candidate& candidate) {
   pending_candidates_.push_back(JingleMessage::NamedCandidate(
       transport->name(), candidate));
 
@@ skipping 212 matching lines @@
 
   authenticator_->ProcessMessage(message.info.get(), base::Bind(
       &JingleSession::ProcessAuthenticationStep, base::Unretained(this)));
 }
 
 void JingleSession::ProcessTransportInfo(const JingleMessage& message) {
   for (std::list<JingleMessage::NamedCandidate>::const_iterator it =
            message.candidates.begin();
        it != message.candidates.end(); ++it) {
     ChannelsMap::iterator channel = channels_.find(it->name);
-    if (channel == channels_.end()) {
-      LOG(WARNING) << "Received candidate for unknown channel " << it->name;
-      continue;
+    if (channel != channels_.end()) {
+      channel->second->AddRemoteCandidate(it->candidate);
+    } else {
+      // Transport info was received before the channel was created.
+      // This could happen due to messages being reordered on the wire.
+      pending_remote_candidates_.push_back(*it);
     }
-    channel->second->AddRemoteCandidate(it->candidate);
   }
 }
 
 void JingleSession::OnTerminate(const JingleMessage& message,
                                 const ReplyCallback& reply_callback) {
   if (state_ != CONNECTING && state_ != ACCEPTING && state_ != CONNECTED &&
       state_ != AUTHENTICATED) {
     LOG(WARNING) << "Received unexpected session-terminate message.";
     reply_callback.Run(JingleMessageReply::UNEXPECTED_REQUEST);
     return;
@@ skipping 125 matching lines @@
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (event_handler_)
       event_handler_->OnSessionStateChange(new_state);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting