Implement support for route change notifications in the Transport interface.

remoting/protocol/transport.h

 // 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.
 //
 // This file defines the interface for peer-to-peer transport. There
 // are two types of transport: StreamTransport and DatagramTransport.
 // They must both be created using TransportFactory instances and they
 // provide the same interface, except that one should be used for
 // reliable stream connection and the other one for unreliable
 // datagram connection. The Transport interface itself doesn't provide
@@ skipping 10 matching lines @@
 
 #ifndef REMOTING_PROTOCOL_TRANSPORT_H_
 #define REMOTING_PROTOCOL_TRANSPORT_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/non_thread_safe.h"
+#include "net/base/ip_endpoint.h"
 
 namespace cricket {
 class Candidate;
 }  // namespace cricket
 
 namespace net {
 class Socket;
 class StreamSocket;
 }  // namespace net
 
 namespace remoting {
 namespace protocol {
 
 class ChannelAuthenticator;
 struct TransportConfig;
 
+struct TransportRoute {
+  enum RouteType {
+    DIRECT,
+    STUN,
+    RELAY,
+  };
+
+  RouteType type;
+  net::IPEndPoint remote_address;
+  net::IPEndPoint local_address;
+};
+
 class Transport : public base::NonThreadSafe {
  public:
   class EventHandler {
    public:
     EventHandler() {};
     virtual ~EventHandler() {};
 
     // Called when the transport generates a new candidate that needs
     // to be passed to the AddRemoteCandidate() method on the remote
     // end of the connection.
     virtual void OnTransportCandidate(Transport* transport,
                                       const cricket::Candidate& candidate) = 0;
 
+    // Called when transport route changes. Can be called even before
+    // the transport is connected.
+    virtual void OnTransportRouteChange(Transport* transport,
+                                        const TransportRoute& route) = 0;
+
     // Called when the transport is about to be deleted.
     virtual void OnTransportDeleted(Transport* transport) = 0;
   };
 
   Transport() {}
   virtual ~Transport() {}
 
   // Intialize the transport with the specified parameters.
   // |authenticator| is used to secure and authenticate the connection.
   virtual void Initialize(const std::string& name,
@@ skipping 51 matching lines @@
   virtual scoped_ptr<DatagramTransport> CreateDatagramTransport() = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TransportFactory);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_TRANSPORT_H_