admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete MediaController class, move Call ownership to PeerConnection.

Browse Source 
BUG=webrtc:7135

Review-Url: https://codereview.webrtc.org/2794943002
Cr-Commit-Position: refs/heads/master@{#18026}
This commit is contained in:
nisse 2017-05-05 02:23:02 -07:00 committed by Commit bot
parent 999445a1bb
commit eaabdf6259
23 changed files with 181 additions and 351 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
webrtc/api/BUILD.gn
View File

@ -47,7 +47,6 @@ rtc_static_library("libjingle_peerconnection_api") {
"jsepsessiondescription.h",
"mediaconstraintsinterface.cc",
"mediaconstraintsinterface.h",
"mediacontroller.h",
"mediastream.h",
"mediastreaminterface.cc",
"mediastreaminterface.h",

18
webrtc/api/mediacontroller.h
View File

@ -1,18 +0,0 @@
/*
* Copyright 2015 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_API_MEDIACONTROLLER_H_
#define WEBRTC_API_MEDIACONTROLLER_H_
// Including this file is deprecated. It is no longer part of the public API.
// This only includes the file in its new location for backwards compatibility.
#include "webrtc/pc/mediacontroller.h"
#endif // WEBRTC_API_MEDIACONTROLLER_H_

54
webrtc/ortc/rtptransportcontrolleradapter.cc
View File

@ -121,6 +121,10 @@ RtpTransportControllerAdapter::~RtpTransportControllerAdapter() {
// been destroyed. This isn't safe (see error log above).
DestroyVideoChannel();
}
// Call must be destroyed on the worker thread.
worker_thread_->Invoke<void>(
RTC_FROM_HERE,
rtc::Bind(&RtpTransportControllerAdapter::Close_w, this));
}
RTCErrorOr<std::unique_ptr<RtpTransportInterface>>
@ -584,14 +588,11 @@ RtpTransportControllerAdapter::RtpTransportControllerAdapter(
rtc::Thread* worker_thread)
: signaling_thread_(signaling_thread),
worker_thread_(worker_thread),
media_controller_(MediaControllerInterface::Create(config,
worker_thread,
channel_manager,
event_log)) {
media_config_(config),
channel_manager_(channel_manager),
event_log_(event_log) {
RTC_DCHECK_RUN_ON(signaling_thread_);
RTC_DCHECK(channel_manager);
// MediaControllerInterface::Create should never fail.
RTC_DCHECK(media_controller_);
RTC_DCHECK(channel_manager_);
// Add "dummy" codecs to the descriptions, because the media engines
// currently reject empty lists of codecs. Note that these codecs will never
// actually be used, because when parameters are set, the dummy codecs will
@ -603,6 +604,33 @@ RtpTransportControllerAdapter::RtpTransportControllerAdapter(
remote_audio_description_.AddCodec(dummy_audio);
local_video_description_.AddCodec(dummy_video);
remote_video_description_.AddCodec(dummy_video);
worker_thread_->Invoke<void>(
RTC_FROM_HERE,
rtc::Bind(&RtpTransportControllerAdapter::Init_w, this));
}
// TODO(nisse): Duplicates corresponding method in PeerConnection (used
// to be in MediaController).
void RtpTransportControllerAdapter::Init_w() {
RTC_DCHECK(worker_thread_->IsCurrent());
RTC_DCHECK(!call_);
const int kMinBandwidthBps = 30000;
const int kStartBandwidthBps = 300000;
const int kMaxBandwidthBps = 2000000;
webrtc::Call::Config call_config(event_log_);
call_config.audio_state = channel_manager_->media_engine()->GetAudioState();
call_config.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
call_config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
call_config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
call_.reset(webrtc::Call::Create(call_config));
}
void RtpTransportControllerAdapter::Close_w() {
call_.reset();
}
RTCError RtpTransportControllerAdapter::AttachAudioSender(
@ -818,8 +846,8 @@ void RtpTransportControllerAdapter::OnVideoReceiverDestroyed() {
}
void RtpTransportControllerAdapter::CreateVoiceChannel() {
voice_channel_ = media_controller_->channel_manager()->CreateVoiceChannel(
media_controller_.get(),
voice_channel_ = channel_manager_->CreateVoiceChannel(
call_.get(), media_config_,
inner_audio_transport_->GetRtpPacketTransport()->GetInternal(),
inner_audio_transport_->GetRtcpPacketTransport()
? inner_audio_transport_->GetRtcpPacketTransport()->GetInternal()
@ -830,8 +858,8 @@ void RtpTransportControllerAdapter::CreateVoiceChannel() {
}
void RtpTransportControllerAdapter::CreateVideoChannel() {
video_channel_ = media_controller_->channel_manager()->CreateVideoChannel(
media_controller_.get(),
video_channel_ = channel_manager_->CreateVideoChannel(
call_.get(), media_config_,
inner_video_transport_->GetRtpPacketTransport()->GetInternal(),
inner_video_transport_->GetRtcpPacketTransport()
? inner_video_transport_->GetRtcpPacketTransport()->GetInternal()
@ -843,14 +871,14 @@ void RtpTransportControllerAdapter::CreateVideoChannel() {
void RtpTransportControllerAdapter::DestroyVoiceChannel() {
RTC_DCHECK(voice_channel_);
media_controller_->channel_manager()->DestroyVoiceChannel(voice_channel_);
channel_manager_->DestroyVoiceChannel(voice_channel_);
voice_channel_ = nullptr;
inner_audio_transport_ = nullptr;
}
void RtpTransportControllerAdapter::DestroyVideoChannel() {
RTC_DCHECK(video_channel_);
media_controller_->channel_manager()->DestroyVideoChannel(video_channel_);
channel_manager_->DestroyVideoChannel(video_channel_);
video_channel_ = nullptr;
inner_video_transport_ = nullptr;
}

8
webrtc/ortc/rtptransportcontrolleradapter.h
View File

@ -27,7 +27,6 @@
#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
#include "webrtc/media/base/mediachannel.h" // For MediaConfig.
#include "webrtc/pc/channelmanager.h"
#include "webrtc/pc/mediacontroller.h"
namespace webrtc {
@ -130,6 +129,8 @@ class RtpTransportControllerAdapter : public RtpTransportControllerInterface,
webrtc::RtcEventLog* event_log,
rtc::Thread* signaling_thread,
rtc::Thread* worker_thread);
void Init_w();
void Close_w();
// These return an error if another of the same type of object is already
// attached, or if |transport_proxy| can't be used with the sender/receiver
@ -191,7 +192,10 @@ class RtpTransportControllerAdapter : public RtpTransportControllerInterface,
std::vector<RtpTransportInterface*> transport_proxies_;
RtpTransportInterface* inner_audio_transport_ = nullptr;
RtpTransportInterface* inner_video_transport_ = nullptr;
std::unique_ptr<MediaControllerInterface> media_controller_;
const cricket::MediaConfig media_config_;
cricket::ChannelManager* channel_manager_;
webrtc::RtcEventLog* event_log_;
std::unique_ptr<Call> call_;
// BaseChannel takes content descriptions as input, so we store them here
// such that they can be updated when a new RtpSenderAdapter/

3
webrtc/pc/BUILD.gn
View File

@ -95,8 +95,6 @@ rtc_static_library("libjingle_peerconnection") {
"jsepsessiondescription.cc",
"localaudiosource.cc",
"localaudiosource.h",
"mediacontroller.cc",
"mediacontroller.h",
"mediastream.cc",
"mediastream.h",
"mediastreamobserver.cc",
@ -283,7 +281,6 @@ if (rtc_include_tests) {
sources = [
"datachannel_unittest.cc",
"dtmfsender_unittest.cc",
"fakemediacontroller.h",
"iceserverparsing_unittest.cc",
"jsepsessiondescription_unittest.cc",
"localaudiosource_unittest.cc",

48
webrtc/pc/channelmanager.cc
View File

@ -21,7 +21,6 @@
#include "webrtc/media/base/device.h"
#include "webrtc/media/base/rtpdataengine.h"
#include "webrtc/pc/srtpfilter.h"
#include "webrtc/pc/mediacontroller.h"
namespace cricket {
@ -179,7 +178,8 @@ void ChannelManager::Terminate_w() {
}
VoiceChannel* ChannelManager::CreateVoiceChannel(
webrtc::MediaControllerInterface* media_controller,
webrtc::Call* call,
const cricket::MediaConfig& media_config,
DtlsTransportInternal* rtp_transport,
DtlsTransportInternal* rtcp_transport,
rtc::Thread* signaling_thread,
@ -188,13 +188,14 @@ VoiceChannel* ChannelManager::CreateVoiceChannel(
const AudioOptions& options) {
return worker_thread_->Invoke<VoiceChannel*>(
RTC_FROM_HERE,
Bind(&ChannelManager::CreateVoiceChannel_w, this, media_controller,
Bind(&ChannelManager::CreateVoiceChannel_w, this, call, media_config,
rtp_transport, rtcp_transport, rtp_transport, rtcp_transport,
signaling_thread, content_name, srtp_required, options));
}
VoiceChannel* ChannelManager::CreateVoiceChannel(
webrtc::MediaControllerInterface* media_controller,
webrtc::Call* call,
const cricket::MediaConfig& media_config,
rtc::PacketTransportInternal* rtp_transport,
rtc::PacketTransportInternal* rtcp_transport,
rtc::Thread* signaling_thread,
@ -203,13 +204,14 @@ VoiceChannel* ChannelManager::CreateVoiceChannel(
const AudioOptions& options) {
return worker_thread_->Invoke<VoiceChannel*>(
RTC_FROM_HERE,
Bind(&ChannelManager::CreateVoiceChannel_w, this, media_controller,
Bind(&ChannelManager::CreateVoiceChannel_w, this, call, media_config,
nullptr, nullptr, rtp_transport, rtcp_transport, signaling_thread,
content_name, srtp_required, options));
}
VoiceChannel* ChannelManager::CreateVoiceChannel_w(
webrtc::MediaControllerInterface* media_controller,
webrtc::Call* call,
const cricket::MediaConfig& media_config,
DtlsTransportInternal* rtp_dtls_transport,
DtlsTransportInternal* rtcp_dtls_transport,
rtc::PacketTransportInternal* rtp_packet_transport,
@ -220,10 +222,10 @@ VoiceChannel* ChannelManager::CreateVoiceChannel_w(
const AudioOptions& options) {
RTC_DCHECK(initialized_);
RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
RTC_DCHECK(nullptr != media_controller);
RTC_DCHECK(nullptr != call);
VoiceMediaChannel* media_channel = media_engine_->CreateChannel(
media_controller->call_w(), media_controller->config(), options);
call, media_config, options);
if (!media_channel)
return nullptr;
@ -265,7 +267,8 @@ void ChannelManager::DestroyVoiceChannel_w(VoiceChannel* voice_channel) {
}
VideoChannel* ChannelManager::CreateVideoChannel(
webrtc::MediaControllerInterface* media_controller,
webrtc::Call* call,
const cricket::MediaConfig& media_config,
DtlsTransportInternal* rtp_transport,
DtlsTransportInternal* rtcp_transport,
rtc::Thread* signaling_thread,
@ -274,13 +277,14 @@ VideoChannel* ChannelManager::CreateVideoChannel(
const VideoOptions& options) {
return worker_thread_->Invoke<VideoChannel*>(
RTC_FROM_HERE,
Bind(&ChannelManager::CreateVideoChannel_w, this, media_controller,
Bind(&ChannelManager::CreateVideoChannel_w, this, call, media_config,
rtp_transport, rtcp_transport, rtp_transport, rtcp_transport,
signaling_thread, content_name, srtp_required, options));
}
VideoChannel* ChannelManager::CreateVideoChannel(
webrtc::MediaControllerInterface* media_controller,
webrtc::Call* call,
const cricket::MediaConfig& media_config,
rtc::PacketTransportInternal* rtp_transport,
rtc::PacketTransportInternal* rtcp_transport,
rtc::Thread* signaling_thread,
@ -289,13 +293,14 @@ VideoChannel* ChannelManager::CreateVideoChannel(
const VideoOptions& options) {
return worker_thread_->Invoke<VideoChannel*>(
RTC_FROM_HERE,
Bind(&ChannelManager::CreateVideoChannel_w, this, media_controller,
Bind(&ChannelManager::CreateVideoChannel_w, this, call, media_config,
nullptr, nullptr, rtp_transport, rtcp_transport, signaling_thread,
content_name, srtp_required, options));
}
VideoChannel* ChannelManager::CreateVideoChannel_w(
webrtc::MediaControllerInterface* media_controller,
webrtc::Call* call,
const cricket::MediaConfig& media_config,
DtlsTransportInternal* rtp_dtls_transport,
DtlsTransportInternal* rtcp_dtls_transport,
rtc::PacketTransportInternal* rtp_packet_transport,
@ -306,9 +311,9 @@ VideoChannel* ChannelManager::CreateVideoChannel_w(
const VideoOptions& options) {
RTC_DCHECK(initialized_);
RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
RTC_DCHECK(nullptr != media_controller);
RTC_DCHECK(nullptr != call);
VideoMediaChannel* media_channel = media_engine_->CreateVideoChannel(
media_controller->call_w(), media_controller->config(), options);
call, media_config, options);
if (media_channel == NULL) {
return NULL;
}
@ -350,7 +355,7 @@ void ChannelManager::DestroyVideoChannel_w(VideoChannel* video_channel) {
}
RtpDataChannel* ChannelManager::CreateRtpDataChannel(
webrtc::MediaControllerInterface* media_controller,
const cricket::MediaConfig& media_config,
DtlsTransportInternal* rtp_transport,
DtlsTransportInternal* rtcp_transport,
rtc::Thread* signaling_thread,
@ -358,12 +363,12 @@ RtpDataChannel* ChannelManager::CreateRtpDataChannel(
bool srtp_required) {
return worker_thread_->Invoke<RtpDataChannel*>(
RTC_FROM_HERE, Bind(&ChannelManager::CreateRtpDataChannel_w, this,
media_controller, rtp_transport, rtcp_transport,
media_config, rtp_transport, rtcp_transport,
signaling_thread, content_name, srtp_required));
}
RtpDataChannel* ChannelManager::CreateRtpDataChannel_w(
webrtc::MediaControllerInterface* media_controller,
const cricket::MediaConfig& media_config,
DtlsTransportInternal* rtp_transport,
DtlsTransportInternal* rtcp_transport,
rtc::Thread* signaling_thread,
@ -371,11 +376,8 @@ RtpDataChannel* ChannelManager::CreateRtpDataChannel_w(
bool srtp_required) {
// This is ok to alloc from a thread other than the worker thread.
RTC_DCHECK(initialized_);
MediaConfig config;
if (media_controller) {
config = media_controller->config();
}
DataMediaChannel* media_channel = data_media_engine_->CreateChannel(config);
DataMediaChannel* media_channel
= data_media_engine_->CreateChannel(media_config);
if (!media_channel) {
LOG(LS_WARNING) << "Failed to create RTP data channel.";
return nullptr;

25
webrtc/pc/channelmanager.h
View File

@ -20,9 +20,6 @@
#include "webrtc/media/base/mediaengine.h"
#include "webrtc/pc/voicechannel.h"
namespace webrtc {
class MediaControllerInterface;
}
namespace cricket {
class VoiceChannel;
@ -88,7 +85,8 @@ class ChannelManager {
// The operations below all occur on the worker thread.
// Creates a voice channel, to be associated with the specified session.
VoiceChannel* CreateVoiceChannel(
webrtc::MediaControllerInterface* media_controller,
webrtc::Call* call,
const cricket::MediaConfig& media_config,
DtlsTransportInternal* rtp_transport,
DtlsTransportInternal* rtcp_transport,
rtc::Thread* signaling_thread,
@ -97,7 +95,8 @@ class ChannelManager {
const AudioOptions& options);
// Version of the above that takes PacketTransportInternal.
VoiceChannel* CreateVoiceChannel(
webrtc::MediaControllerInterface* media_controller,
webrtc::Call* call,
const cricket::MediaConfig& media_config,
rtc::PacketTransportInternal* rtp_transport,
rtc::PacketTransportInternal* rtcp_transport,
rtc::Thread* signaling_thread,
@ -109,7 +108,8 @@ class ChannelManager {
// Creates a video channel, synced with the specified voice channel, and
// associated with the specified session.
VideoChannel* CreateVideoChannel(
webrtc::MediaControllerInterface* media_controller,
webrtc::Call* call,
const cricket::MediaConfig& media_config,
DtlsTransportInternal* rtp_transport,
DtlsTransportInternal* rtcp_transport,
rtc::Thread* signaling_thread,
@ -118,7 +118,8 @@ class ChannelManager {
const VideoOptions& options);
// Version of the above that takes PacketTransportInternal.
VideoChannel* CreateVideoChannel(
webrtc::MediaControllerInterface* media_controller,
webrtc::Call* call,
const cricket::MediaConfig& media_config,
rtc::PacketTransportInternal* rtp_transport,
rtc::PacketTransportInternal* rtcp_transport,
rtc::Thread* signaling_thread,
@ -128,7 +129,7 @@ class ChannelManager {
// Destroys a video channel created with the Create API.
void DestroyVideoChannel(VideoChannel* video_channel);
RtpDataChannel* CreateRtpDataChannel(
webrtc::MediaControllerInterface* media_controller,
const cricket::MediaConfig& media_config,
DtlsTransportInternal* rtp_transport,
DtlsTransportInternal* rtcp_transport,
rtc::Thread* signaling_thread,
@ -172,7 +173,8 @@ class ChannelManager {
void DestructorDeletes_w();
void Terminate_w();
VoiceChannel* CreateVoiceChannel_w(
webrtc::MediaControllerInterface* media_controller,
webrtc::Call* call,
const cricket::MediaConfig& media_config,
DtlsTransportInternal* rtp_dtls_transport,
DtlsTransportInternal* rtcp_dtls_transport,
rtc::PacketTransportInternal* rtp_packet_transport,
@ -183,7 +185,8 @@ class ChannelManager {
const AudioOptions& options);
void DestroyVoiceChannel_w(VoiceChannel* voice_channel);
VideoChannel* CreateVideoChannel_w(
webrtc::MediaControllerInterface* media_controller,
webrtc::Call* call,
const cricket::MediaConfig& media_config,
DtlsTransportInternal* rtp_dtls_transport,
DtlsTransportInternal* rtcp_dtls_transport,
rtc::PacketTransportInternal* rtp_packet_transport,
@ -194,7 +197,7 @@ class ChannelManager {
const VideoOptions& options);
void DestroyVideoChannel_w(VideoChannel* video_channel);
RtpDataChannel* CreateRtpDataChannel_w(
webrtc::MediaControllerInterface* media_controller,
const cricket::MediaConfig& media_config,
DtlsTransportInternal* rtp_transport,
DtlsTransportInternal* rtcp_transport,
rtc::Thread* signaling_thread,

19
webrtc/pc/channelmanager_unittest.cc
View File

@ -20,7 +20,6 @@
#include "webrtc/media/engine/fakewebrtccall.h"
#include "webrtc/p2p/base/faketransportcontroller.h"
#include "webrtc/pc/channelmanager.h"
#include "webrtc/pc/fakemediacontroller.h"
namespace {
const bool kDefaultSrtpRequired = true;
@ -46,7 +45,6 @@ class ChannelManagerTest : public testing::Test {
std::unique_ptr<DataEngineInterface>(fdme_),
rtc::Thread::Current())),
fake_call_(webrtc::Call::Config(&event_log_)),
fake_mc_(cm_.get(), &fake_call_),
transport_controller_(
new cricket::FakeTransportController(ICEROLE_CONTROLLING)) {
fme_->SetAudioCodecs(MAKE_VECTOR(kAudioCodecs));
@ -61,7 +59,6 @@ class ChannelManagerTest : public testing::Test {
cricket::FakeDataEngine* fdme_;
std::unique_ptr<cricket::ChannelManager> cm_;
cricket::FakeCall fake_call_;
cricket::FakeMediaController fake_mc_;
std::unique_ptr<cricket::FakeTransportController> transport_controller_;
};
@ -101,17 +98,19 @@ TEST_F(ChannelManagerTest, CreateDestroyChannels) {
transport_controller_->CreateDtlsTransport(
cricket::CN_AUDIO, cricket::ICE_CANDIDATE_COMPONENT_RTP);
cricket::VoiceChannel* voice_channel = cm_->CreateVoiceChannel(
&fake_mc_, rtp_transport, nullptr /*rtcp_transport*/,
&fake_call_, cricket::MediaConfig(),
rtp_transport, nullptr /*rtcp_transport*/,
rtc::Thread::Current(), cricket::CN_AUDIO, kDefaultSrtpRequired,
AudioOptions());
EXPECT_TRUE(voice_channel != nullptr);
cricket::VideoChannel* video_channel = cm_->CreateVideoChannel(
&fake_mc_, rtp_transport, nullptr /*rtcp_transport*/,
&fake_call_, cricket::MediaConfig(),
rtp_transport, nullptr /*rtcp_transport*/,
rtc::Thread::Current(), cricket::CN_VIDEO, kDefaultSrtpRequired,
VideoOptions());
EXPECT_TRUE(video_channel != nullptr);
cricket::RtpDataChannel* rtp_data_channel = cm_->CreateRtpDataChannel(
&fake_mc_, rtp_transport, nullptr /*rtcp_transport*/,
cricket::MediaConfig(), rtp_transport, nullptr /*rtcp_transport*/,
rtc::Thread::Current(), cricket::CN_DATA, kDefaultSrtpRequired);
EXPECT_TRUE(rtp_data_channel != nullptr);
cm_->DestroyVideoChannel(video_channel);
@ -133,17 +132,19 @@ TEST_F(ChannelManagerTest, CreateDestroyChannelsOnThread) {
transport_controller_->CreateDtlsTransport(
cricket::CN_AUDIO, cricket::ICE_CANDIDATE_COMPONENT_RTP);
cricket::VoiceChannel* voice_channel = cm_->CreateVoiceChannel(
&fake_mc_, rtp_transport, nullptr /*rtcp_transport*/,
&fake_call_, cricket::MediaConfig(),
rtp_transport, nullptr /*rtcp_transport*/,
rtc::Thread::Current(), cricket::CN_AUDIO, kDefaultSrtpRequired,
AudioOptions());
EXPECT_TRUE(voice_channel != nullptr);
cricket::VideoChannel* video_channel = cm_->CreateVideoChannel(
&fake_mc_, rtp_transport, nullptr /*rtcp_transport*/,
&fake_call_, cricket::MediaConfig(),
rtp_transport, nullptr /*rtcp_transport*/,
rtc::Thread::Current(), cricket::CN_VIDEO, kDefaultSrtpRequired,
VideoOptions());
EXPECT_TRUE(video_channel != nullptr);
cricket::RtpDataChannel* rtp_data_channel = cm_->CreateRtpDataChannel(
&fake_mc_, rtp_transport, nullptr /*rtcp_transport*/,
cricket::MediaConfig(), rtp_transport, nullptr /*rtcp_transport*/,
rtc::Thread::Current(), cricket::CN_DATA, kDefaultSrtpRequired);
EXPECT_TRUE(rtp_data_channel != nullptr);
cm_->DestroyVideoChannel(video_channel);

42
webrtc/pc/fakemediacontroller.h
View File

@ -1,42 +0,0 @@
/*
* Copyright 2015 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_PC_FAKEMEDIACONTROLLER_H_
#define WEBRTC_PC_FAKEMEDIACONTROLLER_H_
#include "webrtc/base/checks.h"
#include "webrtc/media/base/mediachannel.h"
#include "webrtc/pc/mediacontroller.h"
namespace cricket {
class FakeMediaController : public webrtc::MediaControllerInterface {
public:
explicit FakeMediaController(cricket::ChannelManager* channel_manager,
webrtc::Call* call)
: channel_manager_(channel_manager), call_(call) {
RTC_DCHECK(nullptr != channel_manager_);
RTC_DCHECK(nullptr != call_);
}
~FakeMediaController() override {}
void Close() override {}
webrtc::Call* call_w() override { return call_; }
cricket::ChannelManager* channel_manager() const override {
return channel_manager_;
}
const MediaConfig& config() const override { return media_config_; }
private:
const MediaConfig media_config_ = MediaConfig();
cricket::ChannelManager* channel_manager_;
webrtc::Call* call_;
};
} // namespace cricket
#endif // WEBRTC_PC_FAKEMEDIACONTROLLER_H_

99
webrtc/pc/mediacontroller.cc
View File

@ -1,99 +0,0 @@
/*
* Copyright 2015 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/pc/mediacontroller.h"
#include <memory>
#include "webrtc/base/bind.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/constructormagic.h"
#include "webrtc/call/call.h"
#include "webrtc/pc/channelmanager.h"
#include "webrtc/media/base/mediachannel.h"
namespace {
const int kMinBandwidthBps = 30000;
const int kStartBandwidthBps = 300000;
const int kMaxBandwidthBps = 2000000;
class MediaController : public webrtc::MediaControllerInterface,
public sigslot::has_slots<> {
public:
MediaController(const cricket::MediaConfig& media_config,
rtc::Thread* worker_thread,
cricket::ChannelManager* channel_manager,
webrtc::RtcEventLog* event_log)
: worker_thread_(worker_thread),
media_config_(media_config),
channel_manager_(channel_manager),
call_config_(event_log) {
RTC_DCHECK(worker_thread);
RTC_DCHECK(event_log);
worker_thread_->Invoke<void>(RTC_FROM_HERE,
rtc::Bind(&MediaController::Construct_w, this,
channel_manager_->media_engine()));
}
~MediaController() override {
Close();
}
// webrtc::MediaControllerInterface implementation.
void Close() override {
worker_thread_->Invoke<void>(RTC_FROM_HERE,
rtc::Bind(&MediaController::Close_w, this));
}
webrtc::Call* call_w() override {
RTC_DCHECK(worker_thread_->IsCurrent());
if (!call_) {
call_.reset(webrtc::Call::Create(call_config_));
}
return call_.get();
}
cricket::ChannelManager* channel_manager() const override {
return channel_manager_;
}
const cricket::MediaConfig& config() const override { return media_config_; }
private:
void Construct_w(cricket::MediaEngineInterface* media_engine) {
RTC_DCHECK(worker_thread_->IsCurrent());
RTC_DCHECK(media_engine);
call_config_.audio_state = media_engine->GetAudioState();
call_config_.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
call_config_.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
call_config_.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
}
void Close_w() {
RTC_DCHECK(worker_thread_->IsCurrent());
call_.reset();
}
rtc::Thread* const worker_thread_;
const cricket::MediaConfig media_config_;
cricket::ChannelManager* const channel_manager_;
webrtc::Call::Config call_config_;
std::unique_ptr<webrtc::Call> call_;
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(MediaController);
};
} // namespace {
namespace webrtc {
MediaControllerInterface* MediaControllerInterface::Create(
const cricket::MediaConfig& config,
rtc::Thread* worker_thread,
cricket::ChannelManager* channel_manager,
webrtc::RtcEventLog* event_log) {
return new MediaController(config, worker_thread, channel_manager, event_log);
}
} // namespace webrtc

46
webrtc/pc/mediacontroller.h
View File

@ -1,46 +0,0 @@
/*
* Copyright 2015 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_PC_MEDIACONTROLLER_H_
#define WEBRTC_PC_MEDIACONTROLLER_H_
#include "webrtc/base/thread.h"
namespace cricket {
class ChannelManager;
struct MediaConfig;
} // namespace cricket
namespace webrtc {
class Call;
class VoiceEngine;
class RtcEventLog;
// The MediaController currently owns shared state between media channels.
// Abstract interface is defined here such that it can be faked/mocked for
// tests, but no other real reason.
class MediaControllerInterface {
public:
// Will never return nullptr.
static MediaControllerInterface* Create(
const cricket::MediaConfig& config,
rtc::Thread* worker_thread,
cricket::ChannelManager* channel_manager,
webrtc::RtcEventLog* event_log);
virtual ~MediaControllerInterface() {}
virtual void Close() = 0;
virtual webrtc::Call* call_w() = 0;
virtual cricket::ChannelManager* channel_manager() const = 0;
virtual const cricket::MediaConfig& config() const = 0;
};
} // namespace webrtc
#endif // WEBRTC_PC_MEDIACONTROLLER_H_

36
webrtc/pc/peerconnection.cc
View File

@ -426,7 +426,10 @@ PeerConnection::~PeerConnection() {
session_.reset(nullptr);
// port_allocator_ lives on the network thread and should be destroyed there.
network_thread()->Invoke<void>(RTC_FROM_HERE,
[this] { port_allocator_.reset(nullptr); });
[this] { port_allocator_.reset(); });
// call_ must be destroyed on the worker thread.
factory_->worker_thread()->Invoke<void>(RTC_FROM_HERE,
[this] { call_.reset(); });
}
bool PeerConnection::Initialize(
@ -457,11 +460,15 @@ bool PeerConnection::Initialize(
return false;
}
media_controller_.reset(factory_->CreateMediaController(
configuration.media_config, event_log_.get()));
// Call must be constructed on the worker thread.
factory_->worker_thread()->Invoke<void>(
RTC_FROM_HERE, rtc::Bind(&PeerConnection::CreateCall_w,
this));
session_.reset(new WebRtcSession(
media_controller_.get(), factory_->network_thread(),
call_.get(), factory_->channel_manager(), configuration.media_config,
event_log_.get(),
factory_->network_thread(),
factory_->worker_thread(), factory_->signaling_thread(),
port_allocator_.get(),
std::unique_ptr<cricket::TransportController>(
@ -1287,6 +1294,9 @@ void PeerConnection::Close() {
RTC_FROM_HERE,
rtc::Bind(&cricket::PortAllocator::DiscardCandidatePool,
port_allocator_.get()));
factory_->worker_thread()->Invoke<void>(RTC_FROM_HERE,
[this] { call_.reset(); });
}
void PeerConnection::OnSessionStateChange(WebRtcSession* /*session*/,
@ -2314,4 +2324,22 @@ void PeerConnection::StopRtcEventLog_w() {
event_log_->StopLogging();
}
}
void PeerConnection::CreateCall_w() {
RTC_DCHECK(!call_);
const int kMinBandwidthBps = 30000;
const int kStartBandwidthBps = 300000;
const int kMaxBandwidthBps = 2000000;
webrtc::Call::Config call_config(event_log_.get());
call_config.audio_state =
factory_->channel_manager() ->media_engine()->GetAudioState();
call_config.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
call_config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
call_config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
call_.reset(webrtc::Call::Create(call_config));
}
} // namespace webrtc

7
webrtc/pc/peerconnection.h
View File

@ -390,6 +390,9 @@ class PeerConnection : public PeerConnectionInterface,
// This function should only be called from the worker thread.
void StopRtcEventLog_w();
// Creates the |*call_| object. Must only be called from the worker thread.
void CreateCall_w();
// Storing the factory as a scoped reference pointer ensures that the memory
// in the PeerConnectionFactoryImpl remains available as long as the
// PeerConnection is running. It is passed to PeerConnection as a raw pointer.
@ -405,9 +408,8 @@ class PeerConnection : public PeerConnectionInterface,
PeerConnectionInterface::RTCConfiguration configuration_;
std::unique_ptr<cricket::PortAllocator> port_allocator_;
// The EventLog needs to outlive the media controller.
// The EventLog needs to outlive |call_|.
std::unique_ptr<RtcEventLog> event_log_;
std::unique_ptr<MediaControllerInterface> media_controller_;
// One PeerConnection has only one RTCP CNAME.
// https://tools.ietf.org/html/draft-ietf-rtcweb-rtp-usage-26#section-4.9
@ -440,6 +442,7 @@ class PeerConnection : public PeerConnectionInterface,
rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>>
receivers_;
std::unique_ptr<WebRtcSession> session_;
std::unique_ptr<Call> call_;
std::unique_ptr<StatsCollector> stats_;
rtc::scoped_refptr<RTCStatsCollector> stats_collector_;
};

12
webrtc/pc/peerconnectionfactory.cc
View File

@ -354,14 +354,6 @@ PeerConnectionFactory::CreateAudioTrack(const std::string& id,
return AudioTrackProxy::Create(signaling_thread_, track);
}
webrtc::MediaControllerInterface* PeerConnectionFactory::CreateMediaController(
const cricket::MediaConfig& config,
webrtc::RtcEventLog* event_log) const {
RTC_DCHECK(signaling_thread_->IsCurrent());
return MediaControllerInterface::Create(config, worker_thread_,
channel_manager_.get(), event_log);
}
cricket::TransportController* PeerConnectionFactory::CreateTransportController(
cricket::PortAllocator* port_allocator,
bool redetermine_role_on_ice_restart) {
@ -371,6 +363,10 @@ cricket::TransportController* PeerConnectionFactory::CreateTransportController(
redetermine_role_on_ice_restart, options_.crypto_options);
}
cricket::ChannelManager* PeerConnectionFactory::channel_manager() {
return channel_manager_.get();
}
rtc::Thread* PeerConnectionFactory::signaling_thread() {
// This method can be called on a different thread when the factory is
// created in CreatePeerConnectionFactory().

5
webrtc/pc/peerconnectionfactory.h
View File

@ -20,7 +20,6 @@
#include "webrtc/base/thread.h"
#include "webrtc/base/rtccertificategenerator.h"
#include "webrtc/pc/channelmanager.h"
#include "webrtc/pc/mediacontroller.h"
namespace rtc {
class BasicNetworkManager;
@ -96,12 +95,10 @@ class PeerConnectionFactory : public PeerConnectionFactoryInterface {
// TODO(ivoc) Remove after Chrome is updated.
void StopRtcEventLog() override {}
virtual webrtc::MediaControllerInterface* CreateMediaController(
const cricket::MediaConfig& config,
RtcEventLog* event_log) const;
virtual cricket::TransportController* CreateTransportController(
cricket::PortAllocator* port_allocator,
bool redetermine_role_on_ice_restart);
virtual cricket::ChannelManager* channel_manager();
virtual rtc::Thread* signaling_thread();
virtual rtc::Thread* worker_thread();
virtual rtc::Thread* network_thread();

21
webrtc/pc/peerconnectioninterface_unittest.cc
View File

@ -645,18 +645,6 @@ class PeerConnectionFactoryForTest : public webrtc::PeerConnectionFactory {
webrtc::CreateBuiltinAudioEncoderFactory(),
webrtc::CreateBuiltinAudioDecoderFactory()) {}
webrtc::MediaControllerInterface* CreateMediaController(
const cricket::MediaConfig& config,
webrtc::RtcEventLog* event_log) const override {
create_media_controller_called_ = true;
create_media_controller_config_ = config;
webrtc::MediaControllerInterface* mc =
PeerConnectionFactory::CreateMediaController(config, event_log);
EXPECT_TRUE(mc != nullptr);
return mc;
}
cricket::TransportController* CreateTransportController(
cricket::PortAllocator* port_allocator,
bool redetermine_role_on_ice_restart) override {
@ -667,9 +655,6 @@ class PeerConnectionFactoryForTest : public webrtc::PeerConnectionFactory {
}
cricket::TransportController* transport_controller;
// Mutable, so they can be modified in the above const-declared method.
mutable bool create_media_controller_called_ = false;
mutable cricket::MediaConfig create_media_controller_config_;
};
class PeerConnectionInterfaceTest : public testing::Test {
@ -3318,16 +3303,14 @@ class PeerConnectionMediaConfigTest : public testing::Test {
pcf_ = new rtc::RefCountedObject<PeerConnectionFactoryForTest>();
pcf_->Initialize();
}
const cricket::MediaConfig& TestCreatePeerConnection(
const cricket::MediaConfig TestCreatePeerConnection(
const PeerConnectionInterface::RTCConfiguration& config,
const MediaConstraintsInterface *constraints) {
pcf_->create_media_controller_called_ = false;
rtc::scoped_refptr<PeerConnectionInterface> pc(pcf_->CreatePeerConnection(
config, constraints, nullptr, nullptr, &observer_));
EXPECT_TRUE(pc.get());
EXPECT_TRUE(pcf_->create_media_controller_called_);
return pcf_->create_media_controller_config_;
return pc->GetConfiguration().media_config;
}
rtc::scoped_refptr<PeerConnectionFactoryForTest> pcf_;

8
webrtc/pc/rtcstatscollector_unittest.cc
View File

@ -281,12 +281,7 @@ class RTCStatsCollectorTestHelper : public SetSessionDescriptionObserver {
std::unique_ptr<cricket::MediaEngineInterface>(media_engine_),
worker_thread_,
network_thread_)),
media_controller_(
MediaControllerInterface::Create(cricket::MediaConfig(),
worker_thread_,
channel_manager_.get(),
&event_log_)),
session_(media_controller_.get()),
session_(channel_manager_.get(), cricket::MediaConfig()),
pc_() {
// Default return values for mocks.
EXPECT_CALL(pc_, local_streams()).WillRepeatedly(Return(nullptr));
@ -493,7 +488,6 @@ class RTCStatsCollectorTestHelper : public SetSessionDescriptionObserver {
// |media_engine_| is actually owned by |channel_manager_|.
cricket::FakeMediaEngine* media_engine_;
std::unique_ptr<cricket::ChannelManager> channel_manager_;
std::unique_ptr<MediaControllerInterface> media_controller_;
MockWebRtcSession session_;
MockPeerConnection pc_;

10
webrtc/pc/rtpsenderreceiver_unittest.cc
View File

@ -21,7 +21,6 @@
#include "webrtc/p2p/base/faketransportcontroller.h"
#include "webrtc/pc/audiotrack.h"
#include "webrtc/pc/channelmanager.h"
#include "webrtc/pc/fakemediacontroller.h"
#include "webrtc/pc/localaudiosource.h"
#include "webrtc/pc/mediastream.h"
#include "webrtc/pc/remoteaudiosource.h"
@ -49,7 +48,6 @@ static const uint32_t kVideoSsrc2 = 100;
static const uint32_t kAudioSsrc = 99;
static const uint32_t kAudioSsrc2 = 101;
static const int kDefaultTimeout = 10000; // 10 seconds.
} // namespace
namespace webrtc {
@ -66,7 +64,6 @@ class RtpSenderReceiverTest : public testing::Test,
rtc::Thread::Current(),
rtc::Thread::Current()),
fake_call_(Call::Config(&event_log_)),
fake_media_controller_(&channel_manager_, &fake_call_),
local_stream_(MediaStream::Create(kStreamLabel1)) {
// Create channels to be used by the RtpSenders and RtpReceivers.
channel_manager_.Init();
@ -75,10 +72,12 @@ class RtpSenderReceiverTest : public testing::Test,
fake_transport_controller_.CreateDtlsTransport(
cricket::CN_AUDIO, cricket::ICE_CANDIDATE_COMPONENT_RTP);
voice_channel_ = channel_manager_.CreateVoiceChannel(
&fake_media_controller_, rtp_transport, nullptr, rtc::Thread::Current(),
&fake_call_, cricket::MediaConfig(),
rtp_transport, nullptr, rtc::Thread::Current(),
cricket::CN_AUDIO, srtp_required, cricket::AudioOptions());
video_channel_ = channel_manager_.CreateVideoChannel(
&fake_media_controller_, rtp_transport, nullptr, rtc::Thread::Current(),
&fake_call_, cricket::MediaConfig(),
rtp_transport, nullptr, rtc::Thread::Current(),
cricket::CN_VIDEO, srtp_required, cricket::VideoOptions());
voice_channel_->Enable(true);
video_channel_->Enable(true);
@ -251,7 +250,6 @@ class RtpSenderReceiverTest : public testing::Test,
cricket::FakeTransportController fake_transport_controller_;
cricket::ChannelManager channel_manager_;
cricket::FakeCall fake_call_;
cricket::FakeMediaController fake_media_controller_;
cricket::VoiceChannel* voice_channel_;
cricket::VideoChannel* video_channel_;
cricket::FakeVoiceMediaChannel* voice_media_channel_;

9
webrtc/pc/statscollector_unittest.cc
View File

@ -508,12 +508,8 @@ class StatsCollectorTest : public testing::Test {
std::unique_ptr<cricket::MediaEngineInterface>(media_engine_),
worker_thread_,
network_thread_)),
media_controller_(
webrtc::MediaControllerInterface::Create(cricket::MediaConfig(),
worker_thread_,
channel_manager_.get(),
&event_log_)),
session_(media_controller_.get()) {
session_(channel_manager_.get(), cricket::MediaConfig()) {
// By default, we ignore session GetStats calls.
EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(ReturnNull());
// Add default returns for mock classes.
@ -784,7 +780,6 @@ class StatsCollectorTest : public testing::Test {
// |media_engine_| is actually owned by |channel_manager_|.
cricket::FakeMediaEngine* media_engine_;
std::unique_ptr<cricket::ChannelManager> channel_manager_;
std::unique_ptr<webrtc::MediaControllerInterface> media_controller_;
MockWebRtcSession session_;
MockPeerConnection pc_;
FakeDataChannelProvider data_channel_provider_;

9
webrtc/pc/test/mock_webrtcsession.h
View File

@ -26,9 +26,12 @@ class MockWebRtcSession : public webrtc::WebRtcSession {
// methods don't use any override declarations, and we want to avoid
// warnings from -Winconsistent-missing-override. See
// http://crbug.com/428099.
explicit MockWebRtcSession(MediaControllerInterface* media_controller)
: WebRtcSession(
media_controller,
explicit MockWebRtcSession(cricket::ChannelManager* channel_manager,
const cricket::MediaConfig& media_config)
: WebRtcSession(nullptr /* Call */,
channel_manager,
media_config,
nullptr, // event_log
rtc::Thread::Current(),
rtc::Thread::Current(),
rtc::Thread::Current(),

20
webrtc/pc/webrtcsession.cc
View File

@ -461,7 +461,10 @@ bool CheckForRemoteIceRestart(const SessionDescriptionInterface* old_desc,
}
WebRtcSession::WebRtcSession(
webrtc::MediaControllerInterface* media_controller,
Call* call,
cricket::ChannelManager* channel_manager,
const cricket::MediaConfig& media_config,
RtcEventLog* event_log,
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
rtc::Thread* signaling_thread,
@ -477,8 +480,10 @@ WebRtcSession::WebRtcSession(
sid_(rtc::ToString(rtc::CreateRandomId64() & LLONG_MAX)),
transport_controller_(std::move(transport_controller)),
sctp_factory_(std::move(sctp_factory)),
media_controller_(media_controller),
channel_manager_(media_controller_->channel_manager()),
media_config_(media_config),
event_log_(event_log),
call_(call),
channel_manager_(channel_manager),
ice_observer_(NULL),
ice_connection_state_(PeerConnectionInterface::kIceConnectionNew),
ice_connection_receiving_(true),
@ -630,7 +635,6 @@ void WebRtcSession::Close() {
RTC_DCHECK(!video_channel_);
RTC_DCHECK(!rtp_data_channel_);
RTC_DCHECK(!sctp_transport_);
media_controller_->Close();
}
cricket::BaseChannel* WebRtcSession::GetChannel(
@ -1757,7 +1761,7 @@ bool WebRtcSession::CreateVoiceChannel(const cricket::ContentInfo* content,
}
voice_channel_.reset(channel_manager_->CreateVoiceChannel(
media_controller_, rtp_dtls_transport, rtcp_dtls_transport,
call_, media_config_, rtp_dtls_transport, rtcp_dtls_transport,
transport_controller_->signaling_thread(), content->name, SrtpRequired(),
audio_options_));
if (!voice_channel_) {
@ -1799,7 +1803,7 @@ bool WebRtcSession::CreateVideoChannel(const cricket::ContentInfo* content,
}
video_channel_.reset(channel_manager_->CreateVideoChannel(
media_controller_, rtp_dtls_transport, rtcp_dtls_transport,
call_, media_config_, rtp_dtls_transport, rtcp_dtls_transport,
transport_controller_->signaling_thread(), content->name, SrtpRequired(),
video_options_));
@ -1864,7 +1868,7 @@ bool WebRtcSession::CreateDataChannel(const cricket::ContentInfo* content,
}
rtp_data_channel_.reset(channel_manager_->CreateRtpDataChannel(
media_controller_, rtp_dtls_transport, rtcp_dtls_transport,
media_config_, rtp_dtls_transport, rtcp_dtls_transport,
transport_controller_->signaling_thread(), content->name,
SrtpRequired()));
@ -2313,7 +2317,7 @@ void WebRtcSession::ReportNegotiatedCiphers(
void WebRtcSession::OnSentPacket_w(const rtc::SentPacket& sent_packet) {
RTC_DCHECK(worker_thread()->IsCurrent());
media_controller_->call_w()->OnSentPacket(sent_packet);
call_->OnSentPacket(sent_packet);
}
const std::string WebRtcSession::GetTransportName(

11
webrtc/pc/webrtcsession.h
View File

@ -27,7 +27,6 @@
#include "webrtc/p2p/base/candidate.h"
#include "webrtc/p2p/base/transportcontroller.h"
#include "webrtc/pc/datachannel.h"
#include "webrtc/pc/mediacontroller.h"
#include "webrtc/pc/mediasession.h"
#ifdef HAVE_QUIC
@ -55,6 +54,7 @@ namespace webrtc {
class IceRestartAnswerLatch;
class JsepIceCandidate;
class MediaStreamSignaling;
class RtcEventLog;
class WebRtcSessionDescriptionFactory;
extern const char kBundleWithoutRtcpMux[];
@ -159,7 +159,10 @@ class WebRtcSession :
// |sctp_factory| may be null, in which case SCTP is treated as unsupported.
WebRtcSession(
webrtc::MediaControllerInterface* media_controller,
Call* call,
cricket::ChannelManager* channel_manager,
const cricket::MediaConfig& media_config,
RtcEventLog* event_log,
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
rtc::Thread* signaling_thread,
@ -559,7 +562,9 @@ class WebRtcSession :
const std::unique_ptr<cricket::TransportController> transport_controller_;
const std::unique_ptr<cricket::SctpTransportInternalFactory> sctp_factory_;
MediaControllerInterface* media_controller_;
const cricket::MediaConfig media_config_;
RtcEventLog* event_log_;
Call* call_;
std::unique_ptr<cricket::VoiceChannel> voice_channel_;
std::unique_ptr<cricket::VideoChannel> video_channel_;
// |rtp_data_channel_| is used if in RTP data channel mode, |sctp_transport_|

21
webrtc/pc/webrtcsession_unittest.cc
View File

@ -41,7 +41,6 @@
#include "webrtc/p2p/client/basicportallocator.h"
#include "webrtc/pc/audiotrack.h"
#include "webrtc/pc/channelmanager.h"
#include "webrtc/pc/fakemediacontroller.h"
#include "webrtc/pc/mediasession.h"
#include "webrtc/pc/peerconnection.h"
#include "webrtc/pc/sctputils.h"
@ -255,7 +254,10 @@ class FakeSctpTransportFactory : public cricket::SctpTransportInternalFactory {
class WebRtcSessionForTest : public webrtc::WebRtcSession {
public:
WebRtcSessionForTest(
webrtc::MediaControllerInterface* media_controller,
webrtc::Call* fake_call,
cricket::ChannelManager* channel_manager,
const cricket::MediaConfig& media_config,
webrtc::RtcEventLog* event_log,
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
rtc::Thread* signaling_thread,
@ -263,7 +265,7 @@ class WebRtcSessionForTest : public webrtc::WebRtcSession {
webrtc::IceObserver* ice_observer,
std::unique_ptr<cricket::TransportController> transport_controller,
std::unique_ptr<FakeSctpTransportFactory> sctp_factory)
: WebRtcSession(media_controller,
: WebRtcSession(fake_call, channel_manager, media_config, event_log,
network_thread,
worker_thread,
signaling_thread,
@ -375,11 +377,6 @@ class WebRtcSessionTest
std::unique_ptr<cricket::DataEngineInterface>(data_engine_),
rtc::Thread::Current())),
fake_call_(webrtc::Call::Config(&event_log_)),
media_controller_(
webrtc::MediaControllerInterface::Create(cricket::MediaConfig(),
rtc::Thread::Current(),
channel_manager_.get(),
&event_log_)),
tdesc_factory_(new cricket::TransportDescriptionFactory()),
desc_factory_(
new cricket::MediaSessionDescriptionFactory(channel_manager_.get(),
@ -424,8 +421,9 @@ class WebRtcSessionTest
const rtc::CryptoOptions& crypto_options) {
ASSERT_TRUE(session_.get() == NULL);
fake_sctp_transport_factory_ = new FakeSctpTransportFactory();
session_.reset(new WebRtcSessionForTest(
media_controller_.get(), rtc::Thread::Current(), rtc::Thread::Current(),
session_.reset(new WebRtcSessionForTest(&fake_call_,
channel_manager_.get(), cricket::MediaConfig(), &event_log_,
rtc::Thread::Current(), rtc::Thread::Current(),
rtc::Thread::Current(), allocator_.get(), &observer_,
std::unique_ptr<cricket::TransportController>(
new cricket::TransportController(
@ -1380,8 +1378,6 @@ class WebRtcSessionTest
}
void TestPacketOptions() {
media_controller_.reset(
new cricket::FakeMediaController(channel_manager_.get(), &fake_call_));
LoopbackNetworkConfiguration config;
LoopbackNetworkManager loopback_network_manager(this, config);
@ -1515,7 +1511,6 @@ class WebRtcSessionTest
FakeSctpTransportFactory* fake_sctp_transport_factory_ = nullptr;
std::unique_ptr<cricket::ChannelManager> channel_manager_;
cricket::FakeCall fake_call_;
std::unique_ptr<webrtc::MediaControllerInterface> media_controller_;
std::unique_ptr<cricket::TransportDescriptionFactory> tdesc_factory_;
std::unique_ptr<cricket::MediaSessionDescriptionFactory> desc_factory_;
std::unique_ptr<rtc::PhysicalSocketServer> pss_;