Revert of Use standard ICE in Chromoting.

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/single_thread_task_runner.h"
 #include "base/stl_util.h"
@@ skipping 14 matching lines @@
 #include "remoting/signaling/iq_sender.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 #include "third_party/webrtc/p2p/base/candidate.h"
 
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
-
-// Delay after candidate creation before sending transport-info message to
-// accumulate multiple candidates. This is an optimization to reduce number of
-// transport-info messages.
-const int kTransportInfoSendDelayMs = 20;
+// Delay after candidate creation before sending transport-info
+// message. This is neccessary to be able to pack multiple candidates
+// into one transport-info messages. The value needs to be greater
+// than zero because ports are opened asynchronously in the browser
+// process.
+const int kTransportInfoSendDelayMs = 2;
 
 // How long we should wait for a response from the other end. This value is used
 // for all requests except |transport-info|.
 const int kDefaultMessageTimeout = 10;
 
 // During a reconnection, it usually takes longer for the peer to respond due to
 // pending messages in the channel from the previous session.  From experiment,
 // it can take up to 20s for the session to reconnect. To make it safe, setting
 // the timeout to 30s.
 const int kSessionInitiateAndAcceptTimeout = kDefaultMessageTimeout * 3;
@@ skipping 16 matching lines @@
   return UNKNOWN_ERROR;
 }
 
 }  // namespace
 
 JingleSession::JingleSession(JingleSessionManager* session_manager)
     : session_manager_(session_manager),
       event_handler_(nullptr),
       state_(INITIALIZING),
       error_(OK),
+      config_is_set_(false),
       weak_factory_(this) {
 }
 
 JingleSession::~JingleSession() {
   channel_multiplexer_.reset();
   STLDeleteContainerPointers(pending_requests_.begin(),
                              pending_requests_.end());
   STLDeleteContainerPointers(transport_info_requests_.begin(),
                              transport_info_requests_.end());
 
@@ skipping 54 matching lines @@
   peer_jid_ = initiate_message.from;
   authenticator_ = authenticator.Pass();
   session_id_ = initiate_message.sid;
   candidate_config_ = initiate_message.description->config()->Clone();
 
   SetState(ACCEPTING);
 }
 
 void JingleSession::AcceptIncomingConnection(
     const JingleMessage& initiate_message) {
-  DCHECK(config_);
+  DCHECK(config_is_set_);
 
   // Process the first authentication message.
   const buzz::XmlElement* first_auth_message =
       initiate_message.description->authenticator_message();
 
   if (!first_auth_message) {
     CloseInternal(INCOMPATIBLE_PROTOCOL);
     return;
   }
 
@@ skipping 14 matching lines @@
 
   // Send the session-accept message.
   JingleMessage message(peer_jid_, JingleMessage::SESSION_ACCEPT,
                         session_id_);
 
   scoped_ptr<buzz::XmlElement> auth_message;
   if (authenticator_->state() == Authenticator::MESSAGE_READY)
     auth_message = authenticator_->GetNextMessage();
 
   message.description.reset(
-      new ContentDescription(CandidateSessionConfig::CreateFrom(*config_),
+      new ContentDescription(CandidateSessionConfig::CreateFrom(config_),
                              auth_message.Pass()));
   SendMessage(message);
 
   // Update state.
   SetState(CONNECTED);
 
   if (authenticator_->state() == Authenticator::ACCEPTED) {
     OnAuthenticated();
   } else {
     DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
     if (authenticator_->started()) {
       SetState(AUTHENTICATING);
     }
   }
 }
 
 const std::string& JingleSession::jid() {
   DCHECK(CalledOnValidThread());
   return peer_jid_;
 }
 
 const CandidateSessionConfig* JingleSession::candidate_config() {
   DCHECK(CalledOnValidThread());
   return candidate_config_.get();
 }
 
 const SessionConfig& JingleSession::config() {
   DCHECK(CalledOnValidThread());
-  return *config_;
+  return config_;
 }
 
-void JingleSession::set_config(scoped_ptr<SessionConfig> config) {
+void JingleSession::set_config(const SessionConfig& config) {
   DCHECK(CalledOnValidThread());
-  DCHECK(!config_);
-  config_ = config.Pass();
+  DCHECK(!config_is_set_);
+  config_ = config;
+  config_is_set_ = true;
 }
 
 StreamChannelFactory* JingleSession::GetTransportChannelFactory() {
   DCHECK(CalledOnValidThread());
   return secure_channel_factory_.get();
 }
 
 StreamChannelFactory* JingleSession::GetMultiplexedChannelFactory() {
   DCHECK(CalledOnValidThread());
   if (!channel_multiplexer_.get()) {
     channel_multiplexer_.reset(
         new ChannelMultiplexer(GetTransportChannelFactory(), kMuxChannelName));
   }
   return channel_multiplexer_.get();
 }
 
 void JingleSession::Close() {
   DCHECK(CalledOnValidThread());
 
   CloseInternal(OK);
 }
 
-void JingleSession::AddPendingRemoteTransportInfo(Transport* channel) {
-  std::list<JingleMessage::IceCredentials>::iterator credentials =
-      pending_remote_ice_credentials_.begin();
-  while (credentials != pending_remote_ice_credentials_.end()) {
-    if (credentials->channel == channel->name()) {
-      channel->SetRemoteCredentials(credentials->ufrag, credentials->password);
-      credentials = pending_remote_ice_credentials_.erase(credentials);
+void JingleSession::AddPendingRemoteCandidates(Transport* channel,
+                                               const std::string& name) {
+  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 {
-      ++credentials;
-    }
-  }
-
-  std::list<JingleMessage::NamedCandidate>::iterator candidate =
-      pending_remote_candidates_.begin();
-  while (candidate != pending_remote_candidates_.end()) {
-    if (candidate->name == channel->name()) {
-      channel->AddRemoteCandidate(candidate->candidate);
-      candidate = pending_remote_candidates_.erase(candidate);
-    } else {
-      ++candidate;
+      ++it;
     }
   }
 }
 
 void JingleSession::CreateChannel(const std::string& name,
                                   const ChannelCreatedCallback& callback) {
   DCHECK(!channels_[name]);
 
   scoped_ptr<Transport> channel =
       session_manager_->transport_factory_->CreateTransport();
-  channel->SetUseStandardIce(config_->standard_ice());
   channel->Connect(name, this, callback);
-  AddPendingRemoteTransportInfo(channel.get());
+  AddPendingRemoteCandidates(channel.get(), name);
   channels_[name] = channel.release();
 }
 
 void JingleSession::CancelChannelCreation(const std::string& name) {
   ChannelsMap::iterator it = channels_.find(name);
   if (it != channels_.end()) {
     DCHECK(!it->second->is_connected());
     delete it->second;
     DCHECK(channels_.find(name) == channels_.end());
   }
 }
 
-void JingleSession::OnTransportIceCredentials(Transport* transport,
-                                              const std::string& ufrag,
-                                              const std::string& password) {
-  EnsurePendingTransportInfoMessage();
-  pending_transport_info_message_->ice_credentials.push_back(
-      JingleMessage::IceCredentials(transport->name(), ufrag, password));
-}
-
 void JingleSession::OnTransportCandidate(Transport* transport,
                                          const cricket::Candidate& candidate) {
-  EnsurePendingTransportInfoMessage();
-  pending_transport_info_message_->candidates.push_back(
-      JingleMessage::NamedCandidate(transport->name(), candidate));
+  pending_candidates_.push_back(JingleMessage::NamedCandidate(
+      transport->name(), candidate));
+
+  if (!transport_infos_timer_.IsRunning()) {
+    // Delay sending the new candidates in case we get more candidates
+    // that we can send in one message.
+    transport_infos_timer_.Start(
+        FROM_HERE, base::TimeDelta::FromMilliseconds(kTransportInfoSendDelayMs),
+        this, &JingleSession::SendTransportInfo);
+  }
 }
 
 void JingleSession::OnTransportRouteChange(Transport* transport,
                                            const TransportRoute& route) {
   if (event_handler_)
     event_handler_->OnSessionRouteChange(transport->name(), route);
 }
 
 void JingleSession::OnTransportFailed(Transport* transport) {
   CloseInternal(CHANNEL_CONNECTION_ERROR);
@@ skipping 53 matching lines @@
                  << " message: \"" << response->Str()
                  << "\". Terminating the session.";
 
       // TODO(sergeyu): There may be different reasons for error
       // here. Parse the response stanza to find failure reason.
       CloseInternal(PEER_IS_OFFLINE);
     }
   }
 }
 
-void JingleSession::EnsurePendingTransportInfoMessage() {
-  // |transport_info_timer_| must be running iff
-  // |pending_transport_info_message_| exists.
-  DCHECK_EQ(pending_transport_info_message_ != nullptr,
-            transport_info_timer_.IsRunning());
-
-  if (!pending_transport_info_message_) {
-    pending_transport_info_message_.reset(new JingleMessage(
-        peer_jid_, JingleMessage::TRANSPORT_INFO, session_id_));
-    pending_transport_info_message_->standard_ice = config_->standard_ice();
-
-    // Delay sending the new candidates in case we get more candidates
-    // that we can send in one message.
-    transport_info_timer_.Start(
-        FROM_HERE, base::TimeDelta::FromMilliseconds(kTransportInfoSendDelayMs),
-        this, &JingleSession::SendTransportInfo);
-  }
-}
-
 void JingleSession::SendTransportInfo() {
-  DCHECK(pending_transport_info_message_);
+  JingleMessage message(peer_jid_, JingleMessage::TRANSPORT_INFO, session_id_);
+  message.candidates.swap(pending_candidates_);
 
   scoped_ptr<IqRequest> request = session_manager_->iq_sender()->SendIq(
-      pending_transport_info_message_->ToXml(),
+      message.ToXml(),
       base::Bind(&JingleSession::OnTransportInfoResponse,
                  base::Unretained(this)));
-  pending_transport_info_message_.reset();
   if (request) {
     request->SetTimeout(base::TimeDelta::FromSeconds(kTransportInfoTimeout));
     transport_info_requests_.push_back(request.release());
   } else {
     LOG(ERROR) << "Failed to send a transport-info message";
   }
 }
 
 void JingleSession::OnTransportInfoResponse(IqRequest* request,
                                             const buzz::XmlElement* response) {
@@ skipping 73 matching lines @@
     DLOG(WARNING) << "Received session-accept without authentication message ";
     CloseInternal(INCOMPATIBLE_PROTOCOL);
     return;
   }
 
   if (!InitializeConfigFromDescription(message.description.get())) {
     CloseInternal(INCOMPATIBLE_PROTOCOL);
     return;
   }
 
+  // In case there is transport information in the accept message.
+  ProcessTransportInfo(message);
+
   SetState(CONNECTED);
 
   DCHECK(authenticator_->state() == Authenticator::WAITING_MESSAGE);
   authenticator_->ProcessMessage(auth_message, base::Bind(
       &JingleSession::ProcessAuthenticationStep,base::Unretained(this)));
 }
 
 void JingleSession::OnSessionInfo(const JingleMessage& message,
                                   const ReplyCallback& reply_callback) {
   if (!message.info.get() ||
@@ skipping 11 matching lines @@
     return;
   }
 
   reply_callback.Run(JingleMessageReply::NONE);
 
   authenticator_->ProcessMessage(message.info.get(), base::Bind(
       &JingleSession::ProcessAuthenticationStep, base::Unretained(this)));
 }
 
 void JingleSession::ProcessTransportInfo(const JingleMessage& message) {
-  // Check if the transport information version matches what was negotiated.
-  if (message.standard_ice != config_->standard_ice()) {
-    LOG(ERROR) << "Received transport-info message in format different from "
-                  "negotiated.";
-    CloseInternal(INCOMPATIBLE_PROTOCOL);
-    return;
-  }
-
-  for (std::list<JingleMessage::IceCredentials>::const_iterator it =
-           message.ice_credentials.begin();
-       it != message.ice_credentials.end(); ++it) {
-    ChannelsMap::iterator channel = channels_.find(it->channel);
-    if (channel != channels_.end()) {
-      channel->second->SetRemoteCredentials(it->ufrag, it->password);
-    } else {
-      // Transport info was received before the channel was created.
-      // This could happen due to messages being reordered on the wire.
-      pending_remote_ice_credentials_.push_back(*it);
-    }
-  }
-
   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()) {
       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);
@@ skipping 38 matching lines @@
   if (error_ != OK) {
     SetState(FAILED);
   } else {
     SetState(CLOSED);
   }
 }
 
 bool JingleSession::InitializeConfigFromDescription(
     const ContentDescription* description) {
   DCHECK(description);
-  config_ = SessionConfig::GetFinalConfig(description->config());
-  if (!config_) {
+
+  if (!description->config()->GetFinalConfig(&config_)) {
     LOG(ERROR) << "session-accept does not specify configuration";
     return false;
   }
-  if (!candidate_config()->IsSupported(*config_)) {
+  if (!candidate_config()->IsSupported(config_)) {
     LOG(ERROR) << "session-accept specifies an invalid configuration";
     return false;
   }
 
   return true;
 }
 
 void JingleSession::ProcessAuthenticationStep() {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(authenticator_->state(), Authenticator::PROCESSING_MESSAGE);
@@ skipping 99 matching lines @@
   }
 }
 
 bool JingleSession::is_session_active() {
   return state_ == CONNECTING || state_ == ACCEPTING || state_ == CONNECTED ||
         state_ == AUTHENTICATING || state_ == AUTHENTICATED;
 }
 
 }  // namespace protocol
 }  // namespace remoting