[remoting] Log route-change events for WebRTC clients.

WebRTC provides a native C++ API for getting notified of changes to
the selected ICE candidate-pair. This CL uses it to notify the
HostStatusObserver of route changes, which enables the HostEventLogger
to log the connecting client's IP address.

Bug: 1119960
Change-Id: Ifa22faaeeddbf4f19e8ed422a581b840ec4caa33
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2368428
Commit-Queue: Lambros Lambrou <lambroslambrou@chromium.org>
Reviewed-by: Jamie Walch <jamiewalch@chromium.org>
Cr-Commit-Position: refs/heads/master@{#800706}

remoting/host/host_status_logger.cc

@@ -57,8 +57,10 @@ void HostStatusLogger::OnClientRouteChange(
     const std::string& channel_name,
     const protocol::TransportRoute& route) {
   // Store connection type for the video channel. It is logged later
-  // when client authentication is finished.
-  if (channel_name == kVideoChannelName) {
+  // when client authentication is finished. For WebRTC clients, the
+  // route-change notification is not per-channel, so the channel_name is
+  // empty.
+  if (channel_name.empty() || channel_name == kVideoChannelName) {
     connection_route_type_[jid] = route.type;
   }
 }

remoting/protocol/webrtc_connection_to_client.cc

@@ -234,6 +234,17 @@ void WebrtcConnectionToClient::OnWebrtcTransportMediaStreamRemoved(
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
+void WebrtcConnectionToClient::OnWebrtcTransportRouteChanged(
+    const TransportRoute& route) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(event_handler_);
+
+  // WebRTC route-change events are triggered at the transport level, so the
+  // channel name is not meaningful here.
+  std::string channel_name;
+  event_handler_->OnRouteChange(channel_name, route);
+}
+
 void WebrtcConnectionToClient::OnChannelInitialized(
     ChannelDispatcherBase* channel_dispatcher) {
   DCHECK(thread_checker_.CalledOnValidThread());

remoting/protocol/webrtc_connection_to_client.h

@@ -68,6 +68,7 @@ class WebrtcConnectionToClient : public ConnectionToClient,
       scoped_refptr<webrtc::MediaStreamInterface> stream) override;
   void OnWebrtcTransportMediaStreamRemoved(
       scoped_refptr<webrtc::MediaStreamInterface> stream) override;
+  void OnWebrtcTransportRouteChanged(const TransportRoute& route) override;
 
   // ChannelDispatcherBase::EventHandler interface.
   void OnChannelInitialized(ChannelDispatcherBase* channel_dispatcher) override;

remoting/protocol/webrtc_connection_to_host.cc

@@ -172,6 +172,9 @@ void WebrtcConnectionToHost::OnWebrtcTransportMediaStreamRemoved(
     video_adapter_.reset();
 }
 
+void WebrtcConnectionToHost::OnWebrtcTransportRouteChanged(
+    const TransportRoute& route) {}
+
 void WebrtcConnectionToHost::OnChannelInitialized(
     ChannelDispatcherBase* channel_dispatcher) {
   NotifyIfChannelsReady();

remoting/protocol/webrtc_connection_to_host.h

@@ -68,6 +68,7 @@ class WebrtcConnectionToHost : public ConnectionToHost,
       scoped_refptr<webrtc::MediaStreamInterface> stream) override;
   void OnWebrtcTransportMediaStreamRemoved(
       scoped_refptr<webrtc::MediaStreamInterface> stream) override;
+  void OnWebrtcTransportRouteChanged(const TransportRoute& route) override;
 
   // ChannelDispatcherBase::EventHandler interface.
   void OnChannelInitialized(ChannelDispatcherBase* channel_dispatcher) override;

remoting/protocol/webrtc_transport.cc

@@ -4,6 +4,7 @@
 
 #include "remoting/protocol/webrtc_transport.h"
 
+#include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ -22,11 +23,13 @@
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
+#include "jingle/glue/utils.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/port_allocator_factory.h"
 #include "remoting/protocol/sdp_message.h"
 #include "remoting/protocol/stream_message_pipe_adapter.h"
+#include "remoting/protocol/transport.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/webrtc_audio_module.h"
 #include "remoting/protocol/webrtc_dummy_video_encoder.h"
@@ -190,6 +193,22 @@ base::Optional<bool> IsConnectionRelayed(
   return local_candidate_type == "relay" || remote_candidate_type == "relay";
 }
 
+// Utility function to map a cricket::Candidate string type to a
+// TransportRoute::RouteType enum value.
+TransportRoute::RouteType CandidateTypeToTransportRouteType(
+    const std::string& candidate_type) {
+  if (candidate_type == "local") {
+    return TransportRoute::DIRECT;
+  } else if (candidate_type == "stun" || candidate_type == "prflx") {
+    return TransportRoute::STUN;
+  } else if (candidate_type == "relay") {
+    return TransportRoute::RELAY;
+  } else {
+    LOG(ERROR) << "Unknown candidate type: " << candidate_type;
+    return TransportRoute::DIRECT;
+  }
+}
+
 // A webrtc::CreateSessionDescriptionObserver implementation used to receive the
 // results of creating descriptions for this end of the PeerConnection.
 class CreateSessionDescriptionObserver
@@ -401,6 +420,11 @@ class WebrtcTransport::PeerConnectionWrapper
     if (transport_)
       transport_->OnIceCandidate(candidate);
   }
+  void OnIceSelectedCandidatePairChanged(
+      const cricket::CandidatePairChangeEvent& event) override {
+    if (transport_)
+      transport_->OnIceSelectedCandidatePairChanged(event);
+  }
 
  private:
   rtc::scoped_refptr<WebrtcAudioModule> audio_module_;
@@ -951,6 +975,37 @@ void WebrtcTransport::OnIceCandidate(
   pending_transport_info_message_->AddElement(candidate_element.release());
 }
 
+void WebrtcTransport::OnIceSelectedCandidatePairChanged(
+    const cricket::CandidatePairChangeEvent& event) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  const cricket::Candidate& local_candidate =
+      event.selected_candidate_pair.local_candidate();
+  const cricket::Candidate& remote_candidate =
+      event.selected_candidate_pair.remote_candidate();
+
+  TransportRoute route;
+  static_assert(TransportRoute::DIRECT < TransportRoute::STUN &&
+                    TransportRoute::STUN < TransportRoute::RELAY,
+                "Route type enum values are ordered by 'indirectness'");
+  route.type =
+      std::max(CandidateTypeToTransportRouteType(local_candidate.type()),
+               CandidateTypeToTransportRouteType(remote_candidate.type()));
+
+  if (!jingle_glue::SocketAddressToIPEndPoint(remote_candidate.address(),
+                                              &route.remote_address)) {
+    LOG(ERROR) << "Failed to convert peer IP address.";
+    return;
+  }
+  if (!jingle_glue::SocketAddressToIPEndPoint(local_candidate.address(),
+                                              &route.local_address)) {
+    LOG(ERROR) << "Failed to convert local IP address.";
+    return;
+  }
+
+  event_handler_->OnWebrtcTransportRouteChanged(route);
+}
+
 void WebrtcTransport::OnStatsDelivered(
     const rtc::scoped_refptr<const webrtc::RTCStatsReport>& report) {
   if (!connected_)

remoting/protocol/webrtc_transport.h

@@ -69,6 +69,10 @@ class WebrtcTransport : public Transport,
         scoped_refptr<webrtc::MediaStreamInterface> stream) = 0;
     virtual void OnWebrtcTransportMediaStreamRemoved(
         scoped_refptr<webrtc::MediaStreamInterface> stream) = 0;
+
+    // Called when the transport route changes (for example, from relayed to
+    // direct connection). Also called on initial connection.
+    virtual void OnWebrtcTransportRouteChanged(const TransportRoute& route) = 0;
   };
 
   WebrtcTransport(rtc::Thread* worker_thread,
@@ -159,6 +163,8 @@ class WebrtcTransport : public Transport,
   void OnIceGatheringChange(
       webrtc::PeerConnectionInterface::IceGatheringState new_state);
   void OnIceCandidate(const webrtc::IceCandidateInterface* candidate);
+  void OnIceSelectedCandidatePairChanged(
+      const cricket::CandidatePairChangeEvent& event);
   void OnStatsDelivered(
       const rtc::scoped_refptr<const webrtc::RTCStatsReport>& report);
 

remoting/protocol/webrtc_transport_unittest.cc

@@ -86,6 +86,7 @@ class TestTransportEventHandler : public WebrtcTransport::EventHandler {
       scoped_refptr<webrtc::MediaStreamInterface> stream) override {}
   void OnWebrtcTransportMediaStreamRemoved(
       scoped_refptr<webrtc::MediaStreamInterface> stream) override {}
+  void OnWebrtcTransportRouteChanged(const TransportRoute& route) override {}
 
  private:
   base::RepeatingClosure connecting_callback_;

remoting/test/fake_webrtc_connection.cc

@@ -47,5 +47,7 @@ void FakeWebrtcConnection::OnWebrtcTransportMediaStreamAdded(
 void FakeWebrtcConnection::OnWebrtcTransportMediaStreamRemoved(
     scoped_refptr<webrtc::MediaStreamInterface> stream) {}
 
+void FakeWebrtcConnection::OnWebrtcTransportRouteChanged(
+    const protocol::TransportRoute& route) {}
 }  // namespace test
 }  // namespace remoting

remoting/test/fake_webrtc_connection.h

@@ -36,6 +36,8 @@ class FakeWebrtcConnection final
       scoped_refptr<webrtc::MediaStreamInterface> stream) override;
   void OnWebrtcTransportMediaStreamRemoved(
       scoped_refptr<webrtc::MediaStreamInterface> stream) override;
+  void OnWebrtcTransportRouteChanged(
+      const protocol::TransportRoute& route) override;
 
   std::unique_ptr<protocol::WebrtcTransport> transport_;
   base::OnceClosure on_closed_;