Enable video stats reporting when using WebRTC

remoting/protocol/webrtc_connection_to_host.cc

 // Copyright 2015 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/webrtc_connection_to_host.h"
 
 #include <utility>
 
+#include "base/strings/string_util.h"
 #include "jingle/glue/thread_wrapper.h"
+#include "remoting/base/constants.h"
 #include "remoting/protocol/client_control_dispatcher.h"
 #include "remoting/protocol/client_event_dispatcher.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/message_pipe.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/video_renderer.h"
 #include "remoting/protocol/webrtc_transport.h"
 #include "remoting/protocol/webrtc_video_renderer_adapter.h"
 
@@ skipping 94 matching lines @@
 void WebrtcConnectionToHost::OnWebrtcTransportError(ErrorCode error) {
   CloseChannels();
   SetState(FAILED, error);
 }
 
 void WebrtcConnectionToHost::OnWebrtcTransportIncomingDataChannel(
     const std::string& name,
     std::unique_ptr<MessagePipe> pipe) {
   if (!control_dispatcher_)
     control_dispatcher_.reset(new ClientControlDispatcher());
+
   if (name == control_dispatcher_->channel_name() &&
       !control_dispatcher_->is_connected()) {
     control_dispatcher_->set_client_stub(client_stub_);
     control_dispatcher_->set_clipboard_stub(clipboard_stub_);
     control_dispatcher_->Init(std::move(pipe), this);
+  } else if (base::StartsWith(name, kVideoStatsChannelNamePrefix,
+                              base::CompareCase::SENSITIVE)) {
+    std::string video_stream_label =
+        name.substr(strlen(kVideoStatsChannelNamePrefix));
+    GetOrCreateVideoAdapter(video_stream_label)
+        ->SetVideoStatsChannel(std::move(pipe));
+  } else {
+    LOG(WARNING) << "Received unknown incoming data channel " << name;
   }
 }
 
 void WebrtcConnectionToHost::OnWebrtcTransportMediaStreamAdded(
     scoped_refptr<webrtc::MediaStreamInterface> stream) {
-  if (video_adapter_) {
-    LOG(WARNING)
-        << "Received multiple media streams. Ignoring all except the last one.";
-  }
-  video_adapter_.reset(new WebrtcVideoRendererAdapter(stream, video_renderer_));
+  GetOrCreateVideoAdapter(stream->label())->SetMediaStream(stream);
 }
 
 void WebrtcConnectionToHost::OnWebrtcTransportMediaStreamRemoved(
     scoped_refptr<webrtc::MediaStreamInterface> stream) {
   if (video_adapter_ && video_adapter_->label() == stream->label())
     video_adapter_.reset();
 }
 
 void WebrtcConnectionToHost::OnChannelInitialized(
     ChannelDispatcherBase* channel_dispatcher) {
@@ skipping 16 matching lines @@
     return;
   if (!event_dispatcher_.get() || !event_dispatcher_->is_connected())
     return;
 
   // Start forwarding clipboard and input events.
   clipboard_forwarder_.set_clipboard_stub(control_dispatcher_.get());
   event_forwarder_.set_input_stub(event_dispatcher_.get());
   SetState(CONNECTED, OK);
 }
 
+WebrtcVideoRendererAdapter* WebrtcConnectionToHost::GetOrCreateVideoAdapter(
+    const std::string& label) {
+  if (!video_adapter_ || video_adapter_->label() != label) {
+    if (video_adapter_) {
+      LOG(WARNING) << "Received multiple media streams. Ignoring all except "
+                      "the last one.";
+    }
+    video_adapter_.reset(
+        new WebrtcVideoRendererAdapter(label, video_renderer_));
+  }
+  return video_adapter_.get();
+}
+
 void WebrtcConnectionToHost::CloseChannels() {
   clipboard_forwarder_.set_clipboard_stub(nullptr);
   control_dispatcher_.reset();
   event_forwarder_.set_input_stub(nullptr);
   event_dispatcher_.reset();
 }
 
 void WebrtcConnectionToHost::SetState(State state, ErrorCode error) {
   // |error| should be specified only when |state| is set to FAILED.
   DCHECK(state == FAILED || error == OK);
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting