Implement support for route change notifications in the Transport interface.

remoting/protocol/libjingle_transport_factory.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/libjingle_transport_factory.h"
 
 #include "jingle/glue/channel_socket_adapter.h"
 #include "jingle/glue/pseudotcp_adapter.h"
+#include "jingle/glue/utils.h"
 #include "net/base/net_errors.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/transport_config.h"
 #include "third_party/libjingle/source/talk/base/basicpacketsocketfactory.h"
 #include "third_party/libjingle/source/talk/base/network.h"
 #include "third_party/libjingle/source/talk/p2p/base/p2ptransportchannel.h"
 #include "third_party/libjingle/source/talk/p2p/client/httpportallocator.h"
 
 namespace remoting {
 namespace protocol {
@@ skipping 25 matching lines @@
   virtual void Connect(
       const StreamTransport::ConnectedCallback& callback) OVERRIDE;
   virtual void AddRemoteCandidate(const cricket::Candidate& candidate) OVERRIDE;
   virtual const std::string& name() const OVERRIDE;
   virtual bool is_connected() const OVERRIDE;
 
  private:
   void OnRequestSignaling();
   void OnCandidateReady(cricket::TransportChannelImpl* channel,
                         const cricket::Candidate& candidate);
+  void OnRouteChange(cricket::TransportChannel* channel,
+                     const cricket::Candidate& candidate);
 
   void OnTcpConnected(int result);
   void OnAuthenticationDone(net::Error error,
                             scoped_ptr<net::StreamSocket> socket);
 
   void OnChannelDestroyed();
 
   void NotifyConnected(scoped_ptr<net::StreamSocket> socket);
   void NotifyConnectFailed();
 
@@ skipping 78 matching lines @@
   port_allocator_->SetPortRange(config_.min_port, config_.max_port);
 
   // Create P2PTransportChannel, attach signal handlers and connect it.
   DCHECK(!channel_.get());
   channel_.reset(new cricket::P2PTransportChannel(
       name_, "", NULL, port_allocator_.get()));
   channel_->SignalRequestSignaling.connect(
       this, &LibjingleStreamTransport::OnRequestSignaling);
   channel_->SignalCandidateReady.connect(
       this, &LibjingleStreamTransport::OnCandidateReady);
+  channel_->SignalRouteChange.connect(
+      this, &LibjingleStreamTransport::OnRouteChange);
 
   channel_->Connect();
 
   // Create net::Socket adapter for the P2PTransportChannel.
   scoped_ptr<jingle_glue::TransportChannelSocketAdapter> channel_adapter(
       new jingle_glue::TransportChannelSocketAdapter(channel_.get()));
   channel_adapter->SetOnDestroyedCallback(base::Bind(
       &LibjingleStreamTransport::OnChannelDestroyed, base::Unretained(this)));
 
   // Configure and connect PseudoTCP adapter.
@@ skipping 32 matching lines @@
   channel_->OnSignalingReady();
 }
 
 void LibjingleStreamTransport::OnCandidateReady(
     cricket::TransportChannelImpl* channel,
     const cricket::Candidate& candidate) {
   DCHECK(CalledOnValidThread());
   event_handler_->OnTransportCandidate(this, candidate);
 }
 
+void LibjingleStreamTransport::OnRouteChange(
+    cricket::TransportChannel* channel,
+    const cricket::Candidate& candidate) {
+  TransportRoute route;
+
+  if (candidate.type() == "local") {
+    route.type = TransportRoute::DIRECT;
+  } else if (candidate.type() == "stun") {
+    route.type = TransportRoute::STUN;
+  } else if (candidate.type() == "relay") {
+    route.type = TransportRoute::RELAY;
+  } else {
+    LOG(FATAL) << "Unknown candidate type: " << candidate.type();
+  }
+
+  if (!jingle_glue::SocketAddressToIPEndPoint(
+          candidate.address(), &route.remote_address)) {
+    LOG(FATAL) << "Failed to convert peer IP address.";
+  }
+
+  DCHECK(channel->GetP2PChannel());
+  DCHECK(channel->GetP2PChannel()->best_connection());
+  const cricket::Candidate& local_candidate =
+      channel->GetP2PChannel()->best_connection()->local_candidate();
+  if (!jingle_glue::SocketAddressToIPEndPoint(
+          local_candidate.address(), &route.local_address)) {
+    LOG(FATAL) << "Failed to convert local IP address.";
+  }
+
+  event_handler_->OnTransportRouteChange(this, route);
+}
+
 void LibjingleStreamTransport::OnTcpConnected(int result) {
   DCHECK(CalledOnValidThread());
 
   if (result != net::OK) {
     NotifyConnectFailed();
     return;
   }
 
   authenticator_->SecureAndAuthenticate(
       socket_.PassAs<net::StreamSocket>(),
@@ skipping 53 matching lines @@
 
 scoped_ptr<DatagramTransport>
 LibjingleTransportFactory::CreateDatagramTransport() {
   NOTIMPLEMENTED();
   return scoped_ptr<DatagramTransport>(NULL);
 }
 
 
 }  // namespace protocol
 }  // namespace remoting