Implement client-side video stream support for WebRTC-based protocol.

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 "jingle/glue/thread_wrapper.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/transport_context.h"
+#include "remoting/protocol/video_renderer.h"
 #include "remoting/protocol/webrtc_transport.h"
+#include "remoting/protocol/webrtc_video_renderer_adapter.h"
 
 namespace remoting {
 namespace protocol {
 
 WebrtcConnectionToHost::WebrtcConnectionToHost() {}
 WebrtcConnectionToHost::~WebrtcConnectionToHost() {}
 
 void WebrtcConnectionToHost::Connect(
     scoped_ptr<Session> session,
     scoped_refptr<TransportContext> transport_context,
@@ skipping 31 matching lines @@
 
 void WebrtcConnectionToHost::set_client_stub(ClientStub* client_stub) {
   client_stub_ = client_stub;
 }
 
 void WebrtcConnectionToHost::set_clipboard_stub(ClipboardStub* clipboard_stub) {
   clipboard_stub_ = clipboard_stub;
 }
 
 void WebrtcConnectionToHost::set_video_renderer(VideoRenderer* video_renderer) {
-  NOTIMPLEMENTED();
+  video_renderer_ = video_renderer;
 }
 
 void WebrtcConnectionToHost::set_audio_stub(AudioStub* audio_stub) {
   NOTIMPLEMENTED();
 }
 
 void WebrtcConnectionToHost::OnSessionStateChange(Session::State state) {
   DCHECK(event_callback_);
 
   switch (state) {
     case Session::INITIALIZING:
     case Session::CONNECTING:
     case Session::ACCEPTING:
     case Session::ACCEPTED:
     case Session::AUTHENTICATING:
       // Don't care about these events.
       break;
 
     case Session::AUTHENTICATED:
       SetState(AUTHENTICATED, OK);
       break;
 
     case Session::CLOSED:
+      CloseChannels();
+      SetState(CLOSED,  OK);
+      break;
+
     case Session::FAILED:
       CloseChannels();
-      SetState(CLOSED, state == Session::FAILED ? session_->error() : OK);
+      SetState(FAILED, session_->error());
       break;
   }
 }
 
 void WebrtcConnectionToHost::OnWebrtcTransportConnecting() {
   control_dispatcher_.reset(new ClientControlDispatcher());
   control_dispatcher_->Init(transport_->incoming_channel_factory(), this);
   control_dispatcher_->set_client_stub(client_stub_);
   control_dispatcher_->set_clipboard_stub(clipboard_stub_);
 
   event_dispatcher_.reset(new ClientEventDispatcher());
   event_dispatcher_->Init(transport_->outgoing_channel_factory(), this);
 }
 
 void WebrtcConnectionToHost::OnWebrtcTransportConnected() {}
 
 void WebrtcConnectionToHost::OnWebrtcTransportError(ErrorCode error) {
   CloseChannels();
   SetState(FAILED, error);
 }
 
+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_->GetFrameConsumer()));
+}
+
+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) {
   NotifyIfChannelsReady();
 }
 
 void WebrtcConnectionToHost::OnChannelError(
     ChannelDispatcherBase* channel_dispatcher,
     ErrorCode error) {
   LOG(ERROR) << "Failed to connect channel " << channel_dispatcher;
   CloseChannels();
@@ skipping 29 matching lines @@
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting