Add JingleSession::OnRouteChange(), and pass IP endpoint information to a

remoting/protocol/jingle_session.cc

 // Copyright (c) 2011 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/base64.h"
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "crypto/hmac.h"
+#include "jingle/glue/utils.h"
+#include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
+#include "net/base/net_util.h"
 #include "net/socket/stream_socket.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/auth_util.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/jingle_datagram_connector.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/jingle_stream_connector.h"
 #include "third_party/libjingle/source/talk/base/thread.h"
 #include "third_party/libjingle/source/talk/p2p/base/p2ptransportchannel.h"
@@ skipping 100 matching lines @@
   return session;
 }
 
 void JingleSession::SetStateChangeCallback(
     const StateChangeCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
   state_change_callback_ = callback;
 }
 
+void JingleSession::SetRouteChangeCallback(
+    const RouteChangeCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!callback.is_null());

[Sergey Ulanov, 2012/01/23 20:33:37]

I don't think we need this DCHECK. The caller may want to reset the callback.

[Lambros, 2012/01/24 19:50:50]

Done.

+  route_change_callback_ = callback;
+}
+
 Session::Error JingleSession::error() {
   DCHECK(CalledOnValidThread());
   return error_;
 }
 
 void JingleSession::CreateStreamChannel(
       const std::string& name, const StreamChannelCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   AddChannelConnector(
@@ skipping 314 matching lines @@
 }
 
 void JingleSession::AddChannelConnector(
     const std::string& name, JingleChannelConnector* connector) {
   DCHECK(channel_connectors_.find(name) == channel_connectors_.end());
 
   const std::string& content_name = GetContentInfo()->name;
   cricket::TransportChannel* raw_channel =
       cricket_session_->CreateChannel(content_name, name);
 
+  raw_channel->SignalRouteChange.connect(this, &JingleSession::OnRouteChange);
+
   if (!jingle_session_manager_->allow_nat_traversal_ &&
       !cricket_session_->initiator()) {
     // Don't make outgoing connections from the host to client when
     // NAT traversal is disabled.
     raw_channel->GetP2PChannel()->set_incoming_only(true);
   }
 
   channel_connectors_[name] = connector;
   scoped_ptr<ChannelAuthenticator> authenticator =
       authenticator_->CreateChannelAuthenticator();
   connector->Connect(authenticator.Pass(), raw_channel);
 
   // Workaround bug in libjingle - it doesn't connect channels if they
   // are created after the session is accepted. See crbug.com/89384.
   // TODO(sergeyu): Fix the bug and remove this line.
   cricket_session_->GetTransport(content_name)->ConnectChannels();
 }
 
 void JingleSession::OnChannelConnectorFinished(
     const std::string& name, JingleChannelConnector* connector) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(channel_connectors_[name], connector);
   channel_connectors_.erase(name);
 }
 
+void JingleSession::OnRouteChange(cricket::TransportChannel* channel,
+                                  const cricket::Candidate& candidate) {
+  net::IPEndPoint end_point;
+  if (!jingle_glue::SocketAddressToIPEndPoint(candidate.address(),
+                                              &end_point)) {
+    NOTREACHED();
+    return;
+  }
+
+  if (!route_change_callback_.is_null())
+    route_change_callback_.Run(channel->name(), end_point);
+}
+
 const cricket::ContentInfo* JingleSession::GetContentInfo() const {
   const cricket::SessionDescription* session_description;
   // If we initiate the session, we get to specify the content name. When
   // accepting one, the remote end specifies it.
   if (cricket_session_->initiator()) {
     session_description = cricket_session_->local_description();
   } else {
     session_description = cricket_session_->remote_description();
   }
   const cricket::ContentInfo* content =
@@ skipping 22 matching lines @@
   scoped_ptr<cricket::SessionDescription> desc(
       new cricket::SessionDescription());
   desc->AddContent(
       ContentDescription::kChromotingContentName, kChromotingXmlNamespace,
       new ContentDescription(config.Pass(), authenticator_message.Pass()));
   return desc.Pass();
 }
 
 }  // namespace protocol
 }  // namespace remoting