Commit 0fc40f94 authored by sergeyu's avatar sergeyu Committed by Commit bot

Add WebrtcConnectionToClient.

The new WebrtcConnectionToClient implements ConnectionToClient for
WebRTC-based protocol.

BUG=547158

Review URL: https://codereview.chromium.org/1510343002

Cr-Commit-Position: refs/heads/master@{#364409}
parent b036e432
...@@ -46,8 +46,10 @@ source_set("protocol") { ...@@ -46,8 +46,10 @@ source_set("protocol") {
] ]
} else { } else {
sources -= [ sources -= [
"webrtc_connection_to_client.cc",
"webrtc_transport.cc", "webrtc_transport.cc",
"webrtc_video_capturer_adapter.cc", "webrtc_video_capturer_adapter.cc",
"webrtc_video_stream.cc",
] ]
} }
} }
...@@ -116,6 +118,7 @@ source_set("unit_tests") { ...@@ -116,6 +118,7 @@ source_set("unit_tests") {
"third_party_authenticator_unittest.cc", "third_party_authenticator_unittest.cc",
"v2_authenticator_unittest.cc", "v2_authenticator_unittest.cc",
"video_frame_pump_unittest.cc", "video_frame_pump_unittest.cc",
"webrtc_connection_to_client_unittest.cc",
"webrtc_transport_unittest.cc", "webrtc_transport_unittest.cc",
] ]
......
...@@ -73,7 +73,6 @@ class IceConnectionToClient : public ConnectionToClient, ...@@ -73,7 +73,6 @@ class IceConnectionToClient : public ConnectionToClient,
// Event handler for handling events sent from this object. // Event handler for handling events sent from this object.
ConnectionToClient::EventHandler* event_handler_; ConnectionToClient::EventHandler* event_handler_;
// The libjingle channel used to send and receive data from the remote client.
scoped_ptr<Session> session_; scoped_ptr<Session> session_;
scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner_; scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner_;
......
...@@ -409,7 +409,8 @@ void JingleSession::OnIncomingMessage(const JingleMessage& message, ...@@ -409,7 +409,8 @@ void JingleSession::OnIncomingMessage(const JingleMessage& message,
break; break;
case JingleMessage::TRANSPORT_INFO: case JingleMessage::TRANSPORT_INFO:
if (transport_->ProcessTransportInfo(message.transport_info.get())) { if (message.transport_info &&
transport_->ProcessTransportInfo(message.transport_info.get())) {
reply_callback.Run(JingleMessageReply::NONE); reply_callback.Run(JingleMessageReply::NONE);
} else { } else {
reply_callback.Run(JingleMessageReply::BAD_REQUEST); reply_callback.Run(JingleMessageReply::BAD_REQUEST);
......
...@@ -23,10 +23,11 @@ std::string TransportRoute::GetTypeString(RouteType type) { ...@@ -23,10 +23,11 @@ std::string TransportRoute::GetTypeString(RouteType type) {
return std::string(); return std::string();
} }
TransportRoute::TransportRoute() : type(DIRECT) { TransportRoute::TransportRoute() : type(DIRECT) {}
} TransportRoute::~TransportRoute() {}
TransportRoute::~TransportRoute() { WebrtcTransport* Transport::AsWebrtcTransport() {
return nullptr;
} }
} // namespace protocol } // namespace protocol
......
...@@ -22,6 +22,10 @@ namespace buzz { ...@@ -22,6 +22,10 @@ namespace buzz {
class XmlElement; class XmlElement;
} // namespace buzz } // namespace buzz
namespace webrtc {
class PeerConnectionInterface;
} // namespace webrtc
namespace remoting { namespace remoting {
namespace protocol { namespace protocol {
...@@ -29,6 +33,7 @@ class Authenticator; ...@@ -29,6 +33,7 @@ class Authenticator;
class DatagramChannelFactory; class DatagramChannelFactory;
class P2PDatagramSocket; class P2PDatagramSocket;
class StreamChannelFactory; class StreamChannelFactory;
class WebrtcTransport;
enum class TransportRole { enum class TransportRole {
SERVER, SERVER,
...@@ -92,6 +97,15 @@ class Transport { ...@@ -92,6 +97,15 @@ class Transport {
// channel. // channel.
virtual StreamChannelFactory* GetMultiplexedChannelFactory() = 0; virtual StreamChannelFactory* GetMultiplexedChannelFactory() = 0;
// Returns the transport as WebrtcTransport or nullptr if this is not a
// WebrtcTransport.
//
// TODO(sergeyu): Move creation and ownership of Transport objects to the
// Connection classes. That way the Connection classes will be able to ensure
// that correct transport implementation is used for the connection and this
// method will not be necessary.
virtual WebrtcTransport* AsWebrtcTransport();
private: private:
DISALLOW_COPY_AND_ASSIGN(Transport); DISALLOW_COPY_AND_ASSIGN(Transport);
}; };
......
...@@ -5,6 +5,8 @@ ...@@ -5,6 +5,8 @@
#ifndef REMOTING_PROTOCOL_VIDEO_STREAM_H_ #ifndef REMOTING_PROTOCOL_VIDEO_STREAM_H_
#define REMOTING_PROTOCOL_VIDEO_STREAM_H_ #define REMOTING_PROTOCOL_VIDEO_STREAM_H_
#include <cstdint>
#include "base/callback_forward.h" #include "base/callback_forward.h"
namespace webrtc { namespace webrtc {
......
// 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_client.h"
#include "base/bind.h"
#include "base/location.h"
#include "net/base/io_buffer.h"
#include "remoting/codec/video_encoder.h"
#include "remoting/codec/video_encoder_verbatim.h"
#include "remoting/codec/video_encoder_vpx.h"
#include "remoting/protocol/audio_writer.h"
#include "remoting/protocol/clipboard_stub.h"
#include "remoting/protocol/host_control_dispatcher.h"
#include "remoting/protocol/host_event_dispatcher.h"
#include "remoting/protocol/host_stub.h"
#include "remoting/protocol/input_stub.h"
#include "remoting/protocol/webrtc_transport.h"
#include "remoting/protocol/webrtc_video_capturer_adapter.h"
#include "remoting/protocol/webrtc_video_stream.h"
#include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
#include "third_party/libjingle/source/talk/app/webrtc/peerconnectioninterface.h"
#include "third_party/libjingle/source/talk/app/webrtc/test/fakeconstraints.h"
#include "third_party/libjingle/source/talk/app/webrtc/videosourceinterface.h"
namespace remoting {
namespace protocol {
const char kStreamLabel[] = "screen_stream";
const char kVideoLabel[] = "screen_video";
WebrtcConnectionToClient::WebrtcConnectionToClient(
scoped_ptr<protocol::Session> session)
: session_(session.Pass()) {
session_->SetEventHandler(this);
}
WebrtcConnectionToClient::~WebrtcConnectionToClient() {}
void WebrtcConnectionToClient::SetEventHandler(
ConnectionToClient::EventHandler* event_handler) {
DCHECK(thread_checker_.CalledOnValidThread());
event_handler_ = event_handler;
}
protocol::Session* WebrtcConnectionToClient::session() {
DCHECK(thread_checker_.CalledOnValidThread());
return session_.get();
}
void WebrtcConnectionToClient::Disconnect(ErrorCode error) {
DCHECK(thread_checker_.CalledOnValidThread());
control_dispatcher_.reset();
event_dispatcher_.reset();
// This should trigger OnConnectionClosed() event and this object
// may be destroyed as the result.
session_->Close(error);
}
void WebrtcConnectionToClient::OnInputEventReceived(int64_t timestamp) {
DCHECK(thread_checker_.CalledOnValidThread());
event_handler_->OnInputEventReceived(this, timestamp);
}
scoped_ptr<VideoStream> WebrtcConnectionToClient::StartVideoStream(
scoped_ptr<webrtc::DesktopCapturer> desktop_capturer) {
// TODO(sergeyu): Reconsider Transport interface and how it's used here.
WebrtcTransport* transport = session_->GetTransport()->AsWebrtcTransport();
CHECK(transport);
scoped_ptr<WebrtcVideoCapturerAdapter> video_capturer_adapter(
new WebrtcVideoCapturerAdapter(desktop_capturer.Pass()));
// Set video stream constraints.
webrtc::FakeConstraints video_constraints;
video_constraints.AddMandatory(
webrtc::MediaConstraintsInterface::kMinFrameRate, 5);
rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track =
transport->peer_connection_factory()->CreateVideoTrack(
kVideoLabel,
transport->peer_connection_factory()->CreateVideoSource(
video_capturer_adapter.release(), &video_constraints));
rtc::scoped_refptr<webrtc::MediaStreamInterface> video_stream =
transport->peer_connection_factory()->CreateLocalMediaStream(
kStreamLabel);
if (!video_stream->AddTrack(video_track) ||
!transport->peer_connection()->AddStream(video_stream)) {
return nullptr;
}
scoped_ptr<VideoStream> result(
new WebrtcVideoStream(transport->peer_connection(), video_stream));
return result.Pass();
}
AudioStub* WebrtcConnectionToClient::audio_stub() {
DCHECK(thread_checker_.CalledOnValidThread());
return nullptr;
}
// Return pointer to ClientStub.
ClientStub* WebrtcConnectionToClient::client_stub() {
DCHECK(thread_checker_.CalledOnValidThread());
return control_dispatcher_.get();
}
void WebrtcConnectionToClient::set_clipboard_stub(
protocol::ClipboardStub* clipboard_stub) {
DCHECK(thread_checker_.CalledOnValidThread());
control_dispatcher_->set_clipboard_stub(clipboard_stub);
}
void WebrtcConnectionToClient::set_host_stub(protocol::HostStub* host_stub) {
DCHECK(thread_checker_.CalledOnValidThread());
control_dispatcher_->set_host_stub(host_stub);
}
void WebrtcConnectionToClient::set_input_stub(protocol::InputStub* input_stub) {
DCHECK(thread_checker_.CalledOnValidThread());
event_dispatcher_->set_input_stub(input_stub);
}
void WebrtcConnectionToClient::OnSessionStateChange(Session::State state) {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(event_handler_);
switch(state) {
case Session::INITIALIZING:
case Session::CONNECTING:
case Session::ACCEPTING:
case Session::ACCEPTED:
// Don't care about these events.
break;
case Session::AUTHENTICATING:
event_handler_->OnConnectionAuthenticating(this);
break;
case Session::AUTHENTICATED: {
// Initialize channels.
control_dispatcher_.reset(new HostControlDispatcher());
control_dispatcher_->Init(
session_.get(),
ChannelConfig(ChannelConfig::TRANSPORT_STREAM, kDefaultStreamVersion,
ChannelConfig::CODEC_UNDEFINED),
this);
event_dispatcher_.reset(new HostEventDispatcher());
event_dispatcher_->Init(
session_.get(),
ChannelConfig(ChannelConfig::TRANSPORT_STREAM, kDefaultStreamVersion,
ChannelConfig::CODEC_UNDEFINED),
this);
event_dispatcher_->set_on_input_event_callback(base::Bind(
&ConnectionToClient::OnInputEventReceived, base::Unretained(this)));
// Notify the handler after initializing the channels, so that
// ClientSession can get a client clipboard stub.
event_handler_->OnConnectionAuthenticated(this);
break;
}
case Session::CONNECTED:
event_handler_->OnConnectionChannelsConnected(this);
break;
case Session::CLOSED:
case Session::FAILED:
control_dispatcher_.reset();
event_dispatcher_.reset();
event_handler_->OnConnectionClosed(
this, state == Session::CLOSED ? OK : session_->error());
break;
}
}
void WebrtcConnectionToClient::OnSessionRouteChange(
const std::string& channel_name,
const TransportRoute& route) {
event_handler_->OnRouteChange(this, channel_name, route);
}
void WebrtcConnectionToClient::OnChannelInitialized(
ChannelDispatcherBase* channel_dispatcher) {
DCHECK(thread_checker_.CalledOnValidThread());
}
void WebrtcConnectionToClient::OnChannelError(
ChannelDispatcherBase* channel_dispatcher,
ErrorCode error) {
DCHECK(thread_checker_.CalledOnValidThread());
LOG(ERROR) << "Failed to connect channel "
<< channel_dispatcher->channel_name();
session_->Close(CHANNEL_CONNECTION_ERROR);
}
} // namespace protocol
} // namespace remoting
// 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.
#ifndef REMOTING_PROTOCOL_WEBRTC_CONNECTION_TO_CLIENT_H_
#define REMOTING_PROTOCOL_WEBRTC_CONNECTION_TO_CLIENT_H_
#include <string>
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/threading/thread_checker.h"
#include "remoting/protocol/channel_dispatcher_base.h"
#include "remoting/protocol/connection_to_client.h"
#include "remoting/protocol/session.h"
namespace remoting {
namespace protocol {
class HostControlDispatcher;
class HostEventDispatcher;
class WebrtcConnectionToClient : public ConnectionToClient,
public Session::EventHandler,
public ChannelDispatcherBase::EventHandler {
public:
explicit WebrtcConnectionToClient(scoped_ptr<Session> session);
~WebrtcConnectionToClient() override;
// ConnectionToClient interface.
void SetEventHandler(
ConnectionToClient::EventHandler* event_handler) override;
Session* session() override;
void Disconnect(ErrorCode error) override;
void OnInputEventReceived(int64_t timestamp) override;
scoped_ptr<VideoStream> StartVideoStream(
scoped_ptr<webrtc::DesktopCapturer> desktop_capturer) override;
AudioStub* audio_stub() override;
ClientStub* client_stub() override;
void set_clipboard_stub(ClipboardStub* clipboard_stub) override;
void set_host_stub(HostStub* host_stub) override;
void set_input_stub(InputStub* input_stub) override;
// Session::EventHandler interface.
void OnSessionStateChange(Session::State state) override;
void OnSessionRouteChange(const std::string& channel_name,
const TransportRoute& route) override;
// ChannelDispatcherBase::EventHandler interface.
void OnChannelInitialized(ChannelDispatcherBase* channel_dispatcher) override;
void OnChannelError(ChannelDispatcherBase* channel_dispatcher,
ErrorCode error) override;
private:
base::ThreadChecker thread_checker_;
// Event handler for handling events sent from this object.
ConnectionToClient::EventHandler* event_handler_ = nullptr;
scoped_ptr<Session> session_;
scoped_ptr<HostControlDispatcher> control_dispatcher_;
scoped_ptr<HostEventDispatcher> event_dispatcher_;
DISALLOW_COPY_AND_ASSIGN(WebrtcConnectionToClient);
};
} // namespace protocol
} // namespace remoting
#endif // REMOTING_PROTOCOL_WEBRTC_CONNECTION_TO_CLIENT_H_
// 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_client.h"
#include "base/bind.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "remoting/base/constants.h"
#include "remoting/protocol/fake_session.h"
#include "remoting/protocol/message_serialization.h"
#include "remoting/protocol/protocol_mock_objects.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace remoting {
namespace protocol {
class WebrtcConnectionToClientTest : public testing::Test {
public:
WebrtcConnectionToClientTest() {}
protected:
void SetUp() override {
session_ = new FakeSession();
// Allocate a ClientConnection object with the mock objects.
connection_.reset(new WebrtcConnectionToClient(make_scoped_ptr(session_)));
connection_->SetEventHandler(&handler_);
EXPECT_CALL(handler_, OnConnectionAuthenticated(connection_.get()))
.WillOnce(InvokeWithoutArgs(
this, &WebrtcConnectionToClientTest::ConnectStubs));
EXPECT_CALL(handler_, OnConnectionChannelsConnected(connection_.get()));
session_->event_handler()->OnSessionStateChange(Session::ACCEPTED);
session_->event_handler()->OnSessionStateChange(Session::AUTHENTICATED);
session_->event_handler()->OnSessionStateChange(Session::CONNECTED);
base::RunLoop().RunUntilIdle();
}
void TearDown() override {
connection_.reset();
base::RunLoop().RunUntilIdle();
}
void ConnectStubs() {
connection_->set_clipboard_stub(&clipboard_stub_);
connection_->set_host_stub(&host_stub_);
connection_->set_input_stub(&input_stub_);
}
base::MessageLoop message_loop_;
MockConnectionToClientEventHandler handler_;
MockClipboardStub clipboard_stub_;
MockHostStub host_stub_;
MockInputStub input_stub_;
scoped_ptr<ConnectionToClient> connection_;
FakeSession* session_;
private:
DISALLOW_COPY_AND_ASSIGN(WebrtcConnectionToClientTest);
};
TEST_F(WebrtcConnectionToClientTest, SendCapabilitesMessage) {
Capabilities capabilities;
connection_->client_stub()->SetCapabilities(capabilities);
base::RunLoop().RunUntilIdle();
// Verify that something has been written.
// TODO(sergeyu): Verify that the correct data has been written.
FakeStreamSocket* channel =
session_->GetTransport()->GetStreamChannelFactory()->GetFakeChannel(
kControlChannelName);
ASSERT_TRUE(channel);
EXPECT_FALSE(channel->written_data().empty());
ControlMessage message;
message.mutable_capabilities()->CopyFrom(capabilities);
scoped_refptr<net::IOBufferWithSize> expected_message =
SerializeAndFrameMessage(message);
EXPECT_EQ(std::string(expected_message->data(), expected_message->size()),
channel->written_data());
// And then close the connection to ConnectionToClient.
connection_->Disconnect(protocol::OK);
base::RunLoop().RunUntilIdle();
}
// TODO(sergeyu): Add more tests here after Session is refactored not to own
// Transport, which will allow to use real WebrtcTransport with FakeSession.
} // namespace protocol
} // namespace remoting
...@@ -244,6 +244,10 @@ StreamChannelFactory* WebrtcTransport::GetMultiplexedChannelFactory() { ...@@ -244,6 +244,10 @@ StreamChannelFactory* WebrtcTransport::GetMultiplexedChannelFactory() {
return GetStreamChannelFactory(); return GetStreamChannelFactory();
} }
WebrtcTransport* WebrtcTransport::AsWebrtcTransport() {
return this;
}
void WebrtcTransport::OnLocalSessionDescriptionCreated( void WebrtcTransport::OnLocalSessionDescriptionCreated(
scoped_ptr<webrtc::SessionDescriptionInterface> description, scoped_ptr<webrtc::SessionDescriptionInterface> description,
const std::string& error) { const std::string& error) {
......
...@@ -45,6 +45,7 @@ class WebrtcTransport : public Transport, ...@@ -45,6 +45,7 @@ class WebrtcTransport : public Transport,
bool ProcessTransportInfo(buzz::XmlElement* transport_info) override; bool ProcessTransportInfo(buzz::XmlElement* transport_info) override;
StreamChannelFactory* GetStreamChannelFactory() override; StreamChannelFactory* GetStreamChannelFactory() override;
StreamChannelFactory* GetMultiplexedChannelFactory() override; StreamChannelFactory* GetMultiplexedChannelFactory() override;
WebrtcTransport* AsWebrtcTransport() override;
private: private:
void OnLocalSessionDescriptionCreated( void OnLocalSessionDescriptionCreated(
......
...@@ -9,7 +9,7 @@ ...@@ -9,7 +9,7 @@
namespace remoting { namespace remoting {
// Number of frames to be captured per second. // Number of frames to be captured per second.
const int kFramesPerSec = 10; const int kFramesPerSec = 30;
WebrtcVideoCapturerAdapter::WebrtcVideoCapturerAdapter( WebrtcVideoCapturerAdapter::WebrtcVideoCapturerAdapter(
scoped_ptr<webrtc::DesktopCapturer> capturer) scoped_ptr<webrtc::DesktopCapturer> capturer)
...@@ -157,6 +157,7 @@ void WebrtcVideoCapturerAdapter::Stop() { ...@@ -157,6 +157,7 @@ void WebrtcVideoCapturerAdapter::Stop() {
DCHECK_NE(capture_state(), cricket::CS_STOPPED); DCHECK_NE(capture_state(), cricket::CS_STOPPED);
capture_timer_.reset(); capture_timer_.reset();
desktop_capturer_.reset();
SetCaptureFormat(nullptr); SetCaptureFormat(nullptr);
SetCaptureState(cricket::CS_STOPPED); SetCaptureState(cricket::CS_STOPPED);
...@@ -164,7 +165,6 @@ void WebrtcVideoCapturerAdapter::Stop() { ...@@ -164,7 +165,6 @@ void WebrtcVideoCapturerAdapter::Stop() {
VLOG(1) << "WebrtcVideoCapturerAdapter stopped."; VLOG(1) << "WebrtcVideoCapturerAdapter stopped.";
} }
bool WebrtcVideoCapturerAdapter::IsRunning() { bool WebrtcVideoCapturerAdapter::IsRunning() {
DCHECK(thread_checker_.CalledOnValidThread()); DCHECK(thread_checker_.CalledOnValidThread());
......
// 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_video_stream.h"
#include "base/logging.h"
#include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
#include "third_party/libjingle/source/talk/app/webrtc/peerconnectioninterface.h"
#include "third_party/libjingle/source/talk/app/webrtc/videosourceinterface.h"
namespace remoting {
namespace protocol {
WebrtcVideoStream::WebrtcVideoStream(
rtc::scoped_refptr<webrtc::PeerConnectionInterface> connection,
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream)
: connection_(connection), stream_(stream) {}
WebrtcVideoStream::~WebrtcVideoStream() {
for (const auto& track : stream_->GetVideoTracks()) {
track->GetSource()->Stop();
stream_->RemoveTrack(track.get());
}
connection_->RemoveStream(stream_.get());
}
void WebrtcVideoStream::Pause(bool pause) {
NOTIMPLEMENTED();
}
void WebrtcVideoStream::OnInputEventReceived(int64_t event_timestamp) {
NOTIMPLEMENTED();
}
void WebrtcVideoStream::SetLosslessEncode(bool want_lossless) {
NOTIMPLEMENTED();
}
void WebrtcVideoStream::SetLosslessColor(bool want_lossless) {
NOTIMPLEMENTED();
}
void WebrtcVideoStream::SetSizeCallback(const SizeCallback& size_callback) {
NOTIMPLEMENTED();
}
} // namespace protocol
} // namespace remoting
// 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.
#ifndef REMOTING_PROTOCOL_WEBRTC_VIDEO_STREAM_H_
#define REMOTING_PROTOCOL_WEBRTC_VIDEO_STREAM_H_
#include "base/macros.h"
#include "remoting/protocol/video_stream.h"
#include "third_party/webrtc/base/scoped_ref_ptr.h"
namespace webrtc {
class MediaStreamInterface;
class PeerConnectionInterface;
} // namespace webrtc
namespace remoting {
namespace protocol {
class WebrtcVideoStream : public VideoStream {
public:
WebrtcVideoStream(
rtc::scoped_refptr<webrtc::PeerConnectionInterface> connection,
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream);
~WebrtcVideoStream() override;
// VideoStream interface.
void Pause(bool pause) override;
void OnInputEventReceived(int64_t event_timestamp) override;
void SetLosslessEncode(bool want_lossless) override;
void SetLosslessColor(bool want_lossless) override;
void SetSizeCallback(const SizeCallback& size_callback) override;
private:
rtc::scoped_refptr<webrtc::PeerConnectionInterface> connection_;
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream_;
DISALLOW_COPY_AND_ASSIGN(WebrtcVideoStream);
};
} // namespace protocol
} // namespace remoting
#endif // REMOTING_PROTOCOL_WEBRTC_VIDEO_STREAM_H_
...@@ -212,12 +212,16 @@ ...@@ -212,12 +212,16 @@
'protocol/ice_connection_to_client.h', 'protocol/ice_connection_to_client.h',
'protocol/video_frame_pump.cc', 'protocol/video_frame_pump.cc',
'protocol/video_frame_pump.h', 'protocol/video_frame_pump.h',
'protocol/webrtc_connection_to_client.cc',
'protocol/webrtc_connection_to_client.h',
'protocol/webrtc_data_stream_adapter.cc', 'protocol/webrtc_data_stream_adapter.cc',
'protocol/webrtc_data_stream_adapter.h', 'protocol/webrtc_data_stream_adapter.h',
'protocol/webrtc_transport.cc', 'protocol/webrtc_transport.cc',
'protocol/webrtc_transport.h', 'protocol/webrtc_transport.h',
'protocol/webrtc_video_capturer_adapter.cc', 'protocol/webrtc_video_capturer_adapter.cc',
'protocol/webrtc_video_capturer_adapter.h', 'protocol/webrtc_video_capturer_adapter.h',
'protocol/webrtc_video_stream.cc',
'protocol/webrtc_video_stream.h',
], ],
'remoting_signaling_sources': [ 'remoting_signaling_sources': [
......
...@@ -332,6 +332,7 @@ ...@@ -332,6 +332,7 @@
'protocol/third_party_authenticator_unittest.cc', 'protocol/third_party_authenticator_unittest.cc',
'protocol/v2_authenticator_unittest.cc', 'protocol/v2_authenticator_unittest.cc',
'protocol/video_frame_pump_unittest.cc', 'protocol/video_frame_pump_unittest.cc',
'protocol/webrtc_connection_to_client_unittest.cc',
'protocol/webrtc_transport_unittest.cc', 'protocol/webrtc_transport_unittest.cc',
'signaling/iq_sender_unittest.cc', 'signaling/iq_sender_unittest.cc',
'signaling/jid_util_unittest.cc', 'signaling/jid_util_unittest.cc',
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment