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

Remove MetricsObserverInterface.

Browse Source 
The usage of MetricsObserverInterface to log metrics has been replaced
by RTC_HISTOGRAM_* macros in WebRTC.

Bug: webrtc:9409
Change-Id: I67df74a18942ac7ea4227e4affdf84f06258a287
Reviewed-on: https://webrtc-review.googlesource.com/86780
Commit-Queue: Qingsi Wang <qingsi@google.com>
Reviewed-by: Steve Anton <steveanton@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Qingsi Wang <qingsi@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24048}
This commit is contained in:
Qingsi Wang 2018-07-19 14:44:28 -07:00 committed by Commit Bot
parent a6bec58642
commit ee01a839d2
25 changed files with 0 additions and 236 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
api/peerconnectioninterface.h
View File

@ -914,15 +914,6 @@ class PeerConnectionInterface : public rtc::RefCountInterface {
virtual bool RemoveIceCandidates(
const std::vector<cricket::Candidate>& candidates);
// Register a metric observer (used by chromium). It's reference counted, and
// this method takes a reference. RegisterUMAObserver(nullptr) will release
// the reference.
// TODO(deadbeef): Take argument as scoped_refptr?
//
// This method is soon to be deprecated. This no-op default implementation
// allows the implementations of the interface to remove this method.
virtual void RegisterUMAObserver(UMAObserver* observer) {}
// 0 <= min <= current <= max should hold for set parameters.
struct BitrateParameters {
BitrateParameters();

1
api/peerconnectionproxy.h
View File

@ -127,7 +127,6 @@ PROXY_METHOD1(bool,
const std::vector<cricket::Candidate>&);
PROXY_METHOD1(void, SetAudioPlayout, bool)
PROXY_METHOD1(void, SetAudioRecording, bool)
PROXY_METHOD1(void, RegisterUMAObserver, UMAObserver*)
PROXY_METHOD1(RTCError, SetBitrate, const BitrateSettings&);
PROXY_METHOD1(void,
SetBitrateAllocationStrategy,

1
api/test/mock_peerconnectioninterface.h
View File

@ -118,7 +118,6 @@ class MockPeerConnectionInterface
MOCK_METHOD1(AddIceCandidate, bool(const IceCandidateInterface*));
MOCK_METHOD1(RemoveIceCandidates,
bool(const std::vector<cricket::Candidate>&));
MOCK_METHOD1(RegisterUMAObserver, void(UMAObserver*));
MOCK_METHOD1(SetBitrate, RTCError(const BitrateSettings&));
MOCK_METHOD1(SetBitrate, RTCError(const BitrateParameters&));
MOCK_METHOD1(SetBitrateAllocationStrategy,

53
api/umametrics.h
View File

@ -17,38 +17,6 @@
namespace webrtc {
// Used to specify which enum counter type we're incrementing in
// MetricsObserverInterface::IncrementEnumCounter.
enum PeerConnectionEnumCounterType {
kEnumCounterAddressFamily,
// For the next 2 counters, we track them separately based on the "first hop"
// protocol used by the local candidate. "First hop" means the local candidate
// type in the case of non-TURN candidates, and the protocol used to connect
// to the TURN server in the case of TURN candidates.
kEnumCounterIceCandidatePairTypeUdp,
kEnumCounterIceCandidatePairTypeTcp,
kEnumCounterAudioSrtpCipher,
kEnumCounterAudioSslCipher,
kEnumCounterVideoSrtpCipher,
kEnumCounterVideoSslCipher,
kEnumCounterDataSrtpCipher,
kEnumCounterDataSslCipher,
kEnumCounterDtlsHandshakeError,
kEnumCounterIceRegathering,
kEnumCounterIceRestart,
kEnumCounterKeyProtocol,
kEnumCounterSdpSemanticRequested,
kEnumCounterSdpSemanticNegotiated,
kEnumCounterKeyProtocolMediaType,
kEnumCounterSdpFormatReceived,
// The next 2 counters log the value of srtp_err_status_t defined in libsrtp.
kEnumCounterSrtpUnprotectError,
kEnumCounterSrtcpUnprotectError,
kEnumCounterUsagePattern,
kPeerConnectionEnumCounterMax
};
// Currently this contains information related to WebRTC network/transport
// information.
@ -182,27 +150,6 @@ enum AddIceCandidateResult {
kAddIceCandidateMax
};
class MetricsObserverInterface : public rtc::RefCountInterface {
public:
// |type| is the type of the enum counter to be incremented. |counter|
// is the particular counter in that type. |counter_max| is the next sequence
// number after the highest counter.
virtual void IncrementEnumCounter(PeerConnectionEnumCounterType type,
int counter,
int counter_max) = 0;
// This is used to handle sparse counters like SSL cipher suites.
// TODO(guoweis): Remove the implementation once the dependency's interface
// definition is updated.
virtual void IncrementSparseEnumCounter(PeerConnectionEnumCounterType type,
int counter) = 0;
virtual void AddHistogramSample(PeerConnectionMetricsName type,
int value) = 0;
};
typedef MetricsObserverInterface UMAObserver;
} // namespace webrtc
#endif // API_UMAMETRICS_H_

3
p2p/base/fakeicetransport.h
View File

@ -170,9 +170,6 @@ class FakeIceTransport : public IceTransportInternal {
absl::optional<int> GetRttEstimate() override { return absl::nullopt; }
void SetMetricsObserver(webrtc::MetricsObserverInterface* observer) override {
}
// Fake PacketTransportInternal implementation.
bool writable() const override { return writable_; }
bool receiving() const override { return receiving_; }

7
p2p/base/icetransportinternal.h
View File

@ -21,10 +21,6 @@
#include "p2p/base/transportdescription.h"
#include "rtc_base/stringencode.h"
namespace webrtc {
class MetricsObserverInterface;
}
namespace cricket {
typedef std::vector<Candidate> Candidates;
@ -226,9 +222,6 @@ class IceTransportInternal : public rtc::PacketTransportInternal {
// occurred.
virtual void MaybeStartGathering() = 0;
virtual void SetMetricsObserver(
webrtc::MetricsObserverInterface* observer) = 0;
virtual void AddRemoteCandidate(const Candidate& candidate) = 0;
virtual void RemoveRemoteCandidate(const Candidate& candidate) = 0;

2
p2p/base/mockicetransport.h
View File

@ -59,8 +59,6 @@ class MockIceTransport : public IceTransportInternal {
void SetIceConfig(const IceConfig& config) override {}
absl::optional<int> GetRttEstimate() override { return absl::nullopt; }
void MaybeStartGathering() override {}
void SetMetricsObserver(webrtc::MetricsObserverInterface* observer) override {
}
void AddRemoteCandidate(const Candidate& candidate) override {}
void RemoveRemoteCandidate(const Candidate& candidate) override {}
IceGatheringState gathering_state() const override {

6
p2p/base/p2ptransportchannel.cc
View File

@ -16,7 +16,6 @@
#include <utility>
#include "api/candidate.h"
#include "api/umametrics.h"
#include "logging/rtc_event_log/icelogger.h"
#include "p2p/base/candidatepairinterface.h"
#include "p2p/base/relayport.h" // For RELAY_PORT_TYPE.
@ -653,11 +652,6 @@ int P2PTransportChannel::check_receiving_interval() const {
config_.receiving_timeout_or_default() / 10);
}
void P2PTransportChannel::SetMetricsObserver(
webrtc::MetricsObserverInterface* observer) {
metrics_observer_ = observer;
}
void P2PTransportChannel::MaybeStartGathering() {
if (ice_parameters_.ufrag.empty() || ice_parameters_.pwd.empty()) {
RTC_LOG(LS_ERROR)

2
p2p/base/p2ptransportchannel.h
View File

@ -108,7 +108,6 @@ class P2PTransportChannel : public IceTransportInternal {
void SetIceConfig(const IceConfig& config) override;
const IceConfig& config() const;
static webrtc::RTCError ValidateIceConfig(const IceConfig& config);
void SetMetricsObserver(webrtc::MetricsObserverInterface* observer) override;
// From TransportChannel:
int SendPacket(const char* data,
@ -409,7 +408,6 @@ class P2PTransportChannel : public IceTransportInternal {
bool writable_ = false;
rtc::AsyncInvoker invoker_;
webrtc::MetricsObserverInterface* metrics_observer_ = nullptr;
absl::optional<rtc::NetworkRoute> network_route_;
webrtc::IceEventLog ice_event_log_;

12
p2p/base/portallocator.h
View File

@ -26,7 +26,6 @@
#include "rtc_base/thread_checker.h"
namespace webrtc {
class MetricsObserverInterface;
class TurnCustomizer;
} // namespace webrtc
@ -527,11 +526,6 @@ class PortAllocator : public sigslot::has_slots<> {
origin_ = origin;
}
void SetMetricsObserver(webrtc::MetricsObserverInterface* observer) {
CheckRunOnValidThreadIfInitialized();
metrics_observer_ = observer;
}
webrtc::TurnCustomizer* turn_customizer() {
CheckRunOnValidThreadIfInitialized();
return turn_customizer_;
@ -552,10 +546,6 @@ class PortAllocator : public sigslot::has_slots<> {
const std::string& ice_ufrag,
const std::string& ice_pwd) = 0;
webrtc::MetricsObserverInterface* metrics_observer() {
return metrics_observer_;
}
const std::deque<std::unique_ptr<PortAllocatorSession>>& pooled_sessions() {
return pooled_sessions_;
}
@ -591,8 +581,6 @@ class PortAllocator : public sigslot::has_slots<> {
bool candidate_pool_frozen_ = false;
bool prune_turn_ports_ = false;
webrtc::MetricsObserverInterface* metrics_observer_ = nullptr;
// Customizer for TURN messages.
// The instance is owned by application and will be shared among
// all TurnPort(s) created.

15
pc/channel.cc
View File

@ -141,12 +141,6 @@ bool BaseChannel::ConnectToRtpTransport() {
&BaseChannel::OnWritableState);
rtp_transport_->SignalSentPacket.connect(this,
&BaseChannel::SignalSentPacket_n);
// TODO(bugs.webrtc.org/8587): Set the metrics observer through
// JsepTransportController once it takes responsibility for creating
// RtpTransports.
if (metrics_observer_) {
rtp_transport_->SetMetricsObserver(metrics_observer_);
}
return true;
}
@ -158,7 +152,6 @@ void BaseChannel::DisconnectFromRtpTransport() {
rtp_transport_->SignalNetworkRouteChanged.disconnect(this);
rtp_transport_->SignalWritableState.disconnect(this);
rtp_transport_->SignalSentPacket.disconnect(this);
rtp_transport_->SetMetricsObserver(nullptr);
}
void BaseChannel::Init_w(webrtc::RtpTransportInternal* rtp_transport) {
@ -231,14 +224,6 @@ bool BaseChannel::SetRtpTransport(webrtc::RtpTransportInternal* rtp_transport) {
return true;
}
void BaseChannel::SetMetricsObserver(
rtc::scoped_refptr<webrtc::MetricsObserverInterface> metrics_observer) {
metrics_observer_ = metrics_observer;
if (rtp_transport_) {
rtp_transport_->SetMetricsObserver(metrics_observer);
}
}
bool BaseChannel::Enable(bool enable) {
worker_thread_->Invoke<void>(
RTC_FROM_HERE,

5
pc/channel.h
View File

@ -180,9 +180,6 @@ class BaseChannel : public rtc::MessageHandler,
transport_name_ = transport_name;
}
void SetMetricsObserver(
rtc::scoped_refptr<webrtc::MetricsObserverInterface> metrics_observer);
protected:
virtual MediaChannel* media_channel() const { return media_channel_.get(); }
@ -308,8 +305,6 @@ class BaseChannel : public rtc::MessageHandler,
// Won't be set when using raw packet transports. SDP-specific thing.
std::string transport_name_;
rtc::scoped_refptr<webrtc::MetricsObserverInterface> metrics_observer_;
webrtc::RtpTransportInternal* rtp_transport_ = nullptr;
std::vector<std::pair<rtc::Socket::Option, int> > socket_options_;

15
pc/jseptransportcontroller.cc
View File

@ -365,20 +365,6 @@ bool JsepTransportController::GetStats(const std::string& transport_name,
return transport->GetStats(stats);
}
void JsepTransportController::SetMetricsObserver(
webrtc::MetricsObserverInterface* metrics_observer) {
if (!network_thread_->IsCurrent()) {
network_thread_->Invoke<void>(
RTC_FROM_HERE, [=] { SetMetricsObserver(metrics_observer); });
return;
}
metrics_observer_ = metrics_observer;
for (auto& dtls : GetDtlsTransports()) {
dtls->ice_transport()->SetMetricsObserver(metrics_observer);
}
}
void JsepTransportController::SetActiveResetSrtpParams(
bool active_reset_srtp_params) {
if (!network_thread_->IsCurrent()) {
@ -419,7 +405,6 @@ JsepTransportController::CreateDtlsTransport(const std::string& transport_name,
RTC_DCHECK(dtls);
dtls->SetSslMaxProtocolVersion(config_.ssl_max_version);
dtls->ice_transport()->SetMetricsObserver(metrics_observer_);
dtls->ice_transport()->SetIceRole(ice_role_);
dtls->ice_transport()->SetIceTiebreaker(ice_tiebreaker_);
dtls->ice_transport()->SetIceConfig(ice_config_);

3
pc/jseptransportcontroller.h
View File

@ -152,7 +152,6 @@ class JsepTransportController : public sigslot::has_slots<>,
// OpenSSLStreamAdapter, GetSslCipherSuite and GetDtlsSrtpCryptoSuite are not
// const. Fix this.
bool GetStats(const std::string& mid, cricket::TransportStats* stats);
void SetMetricsObserver(webrtc::MetricsObserverInterface* metrics_observer);
bool initial_offerer() const { return initial_offerer_ && *initial_offerer_; }
@ -322,8 +321,6 @@ class JsepTransportController : public sigslot::has_slots<>,
rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
rtc::AsyncInvoker invoker_;
MetricsObserverInterface* metrics_observer_ = nullptr;
RTC_DISALLOW_COPY_AND_ASSIGN(JsepTransportController);
};

39
pc/peerconnection.cc
View File

@ -3094,32 +3094,6 @@ bool PeerConnection::RemoveIceCandidates(
return true;
}
void PeerConnection::RegisterUMAObserver(UMAObserver* observer) {
TRACE_EVENT0("webrtc", "PeerConnection::RegisterUmaObserver");
network_thread()->Invoke<void>(
RTC_FROM_HERE,
rtc::Bind(&PeerConnection::SetMetricObserver_n, this, observer));
}
void PeerConnection::SetMetricObserver_n(UMAObserver* observer) {
RTC_DCHECK(network_thread()->IsCurrent());
uma_observer_ = observer;
if (transport_controller_) {
transport_controller_->SetMetricsObserver(uma_observer_);
}
for (auto transceiver : transceivers_) {
auto* channel = transceiver->internal()->channel();
if (channel) {
channel->SetMetricsObserver(uma_observer_);
}
}
if (uma_observer_) {
port_allocator_->SetMetricsObserver(uma_observer_);
}
}
RTCError PeerConnection::SetBitrate(const BitrateSettings& bitrate) {
if (!worker_thread()->IsCurrent()) {
return worker_thread()->Invoke<RTCError>(
@ -4812,10 +4786,6 @@ cricket::ChannelManager* PeerConnection::channel_manager() const {
return factory_->channel_manager();
}
MetricsObserverInterface* PeerConnection::metrics_observer() const {
return uma_observer_;
}
bool PeerConnection::StartRtcEventLog_w(
std::unique_ptr<RtcEventLogOutput> output,
int64_t output_period_ms) {
@ -5576,9 +5546,6 @@ cricket::VoiceChannel* PeerConnection::CreateVoiceChannel(
voice_channel->SignalSentPacket.connect(this,
&PeerConnection::OnSentPacket_w);
voice_channel->SetRtpTransport(rtp_transport);
if (uma_observer_) {
voice_channel->SetMetricsObserver(uma_observer_);
}
return voice_channel;
}
@ -5601,9 +5568,6 @@ cricket::VideoChannel* PeerConnection::CreateVideoChannel(
video_channel->SignalSentPacket.connect(this,
&PeerConnection::OnSentPacket_w);
video_channel->SetRtpTransport(rtp_transport);
if (uma_observer_) {
video_channel->SetMetricsObserver(uma_observer_);
}
return video_channel;
}
@ -5640,9 +5604,6 @@ bool PeerConnection::CreateDataChannel(const std::string& mid) {
rtp_data_channel_->SignalSentPacket.connect(
this, &PeerConnection::OnSentPacket_w);
rtp_data_channel_->SetRtpTransport(rtp_transport);
if (uma_observer_) {
rtp_data_channel_->SetMetricsObserver(uma_observer_);
}
}
return true;

6
pc/peerconnection.h
View File

@ -185,8 +185,6 @@ class PeerConnection : public PeerConnectionInternal,
bool RemoveIceCandidates(
const std::vector<cricket::Candidate>& candidates) override;
void RegisterUMAObserver(UMAObserver* observer) override;
RTCError SetBitrate(const BitrateSettings& bitrate) override;
void SetBitrateAllocationStrategy(
@ -685,8 +683,6 @@ class PeerConnection : public PeerConnectionInternal,
webrtc::TurnCustomizer* turn_customizer,
absl::optional<int> stun_candidate_keepalive_interval);
void SetMetricObserver_n(UMAObserver* observer);
// Starts output of an RTC event log to the given output object.
// This function should only be called from the worker thread.
bool StartRtcEventLog_w(std::unique_ptr<RtcEventLogOutput> output,
@ -703,7 +699,6 @@ class PeerConnection : public PeerConnectionInternal,
RTCError ValidateConfiguration(const RTCConfiguration& config) const;
cricket::ChannelManager* channel_manager() const;
MetricsObserverInterface* metrics_observer() const;
enum class SessionError {
kNone, // No error.
@ -931,7 +926,6 @@ class PeerConnection : public PeerConnectionInternal,
// will refer to the same reference count.
rtc::scoped_refptr<PeerConnectionFactory> factory_;
PeerConnectionObserver* observer_ = nullptr;
rtc::scoped_refptr<UMAObserver> uma_observer_ = nullptr;
// The EventLog needs to outlive |call_| (and any other object that uses it).
std::unique_ptr<RtcEventLog> event_log_;

3
pc/rtptransport.h
View File

@ -83,9 +83,6 @@ class RtpTransport : public RtpTransportInternal {
bool UnregisterRtpDemuxerSink(RtpPacketSinkInterface* sink) override;
void SetMetricsObserver(
rtc::scoped_refptr<MetricsObserverInterface> metrics_observer) override {}
protected:
// TODO(zstein): Remove this when we remove RtpTransportAdapter.
RtpTransportAdapter* GetInternal() override;

4
pc/rtptransportinternal.h
View File

@ -14,7 +14,6 @@
#include <string>
#include "api/ortc/srtptransportinterface.h"
#include "api/umametrics.h"
#include "call/rtp_demuxer.h"
#include "p2p/base/icetransportinternal.h"
#include "pc/sessiondescription.h"
@ -100,9 +99,6 @@ class RtpTransportInternal : public SrtpTransportInterface,
virtual bool IsSrtpActive() const = 0;
virtual void SetMetricsObserver(
rtc::scoped_refptr<MetricsObserverInterface> metrics_observer) = 0;
virtual bool RegisterRtpDemuxerSink(const RtpDemuxerCriteria& criteria,
RtpPacketSinkInterface* sink) = 0;

5
pc/rtptransportinternaladapter.h
View File

@ -104,11 +104,6 @@ class RtpTransportInternalAdapter : public RtpTransportInternal {
RtpTransportAdapter* GetInternal() override { return nullptr; }
void SetMetricsObserver(
rtc::scoped_refptr<MetricsObserverInterface> metrics_observer) override {
transport_->SetMetricsObserver(metrics_observer);
}
protected:
// Owned by the subclasses.
RtpTransportInternal* transport_ = nullptr;

5
pc/srtpsession.cc
View File

@ -354,11 +354,6 @@ bool SrtpSession::UpdateKey(int type,
return DoSetKey(type, cs, key, len, extension_ids);
}
void SrtpSession::SetMetricsObserver(
rtc::scoped_refptr<webrtc::MetricsObserverInterface> metrics_observer) {
metrics_observer_ = metrics_observer;
}
int g_libsrtp_usage_count = 0;
rtc::GlobalLockPod g_libsrtp_lock;

5
pc/srtpsession.h
View File

@ -13,7 +13,6 @@
#include <vector>
#include "api/umametrics.h"
#include "rtc_base/scoped_ref_ptr.h"
#include "rtc_base/thread_checker.h"
@ -84,9 +83,6 @@ class SrtpSession {
// been set.
bool IsExternalAuthActive() const;
void SetMetricsObserver(
rtc::scoped_refptr<webrtc::MetricsObserverInterface> metrics_observer);
private:
bool DoSetKey(int type,
int cs,
@ -126,7 +122,6 @@ class SrtpSession {
int last_send_seq_num_ = -1;
bool external_auth_active_ = false;
bool external_auth_enabled_ = false;
rtc::scoped_refptr<webrtc::MetricsObserverInterface> metrics_observer_;
RTC_DISALLOW_COPY_AND_ASSIGN(SrtpSession);
};

27
pc/srtptransport.cc
View File

@ -325,11 +325,6 @@ bool SrtpTransport::SetRtcpParams(int send_cs,
return false;
}
if (metrics_observer_) {
send_rtcp_session_->SetMetricsObserver(metrics_observer_);
recv_rtcp_session_->SetMetricsObserver(metrics_observer_);
}
RTC_LOG(LS_INFO) << "SRTCP activated with negotiated parameters:"
" send cipher_suite "
<< send_cs << " recv cipher_suite " << recv_cs;
@ -357,11 +352,6 @@ void SrtpTransport::ResetParams() {
void SrtpTransport::CreateSrtpSessions() {
send_session_.reset(new cricket::SrtpSession());
recv_session_.reset(new cricket::SrtpSession());
if (metrics_observer_) {
send_session_->SetMetricsObserver(metrics_observer_);
recv_session_->SetMetricsObserver(metrics_observer_);
}
if (external_auth_enabled_) {
send_session_->EnableExternalAuth();
}
@ -506,23 +496,6 @@ bool SrtpTransport::ParseKeyParams(const std::string& key_params,
return true;
}
void SrtpTransport::SetMetricsObserver(
rtc::scoped_refptr<MetricsObserverInterface> metrics_observer) {
metrics_observer_ = metrics_observer;
if (send_session_) {
send_session_->SetMetricsObserver(metrics_observer_);
}
if (recv_session_) {
recv_session_->SetMetricsObserver(metrics_observer_);
}
if (send_rtcp_session_) {
send_rtcp_session_->SetMetricsObserver(metrics_observer_);
}
if (recv_rtcp_session_) {
recv_rtcp_session_->SetMetricsObserver(metrics_observer_);
}
}
void SrtpTransport::MaybeUpdateWritableState() {
bool writable = IsWritable(/*rtcp=*/true) && IsWritable(/*rtcp=*/false);
// Only fire the signal if the writable state changes.

5
pc/srtptransport.h
View File

@ -141,9 +141,6 @@ class SrtpTransport : public RtpTransport {
bool MaybeSetKeyParams();
bool ParseKeyParams(const std::string& key_params, uint8_t* key, size_t len);
void SetMetricsObserver(
rtc::scoped_refptr<MetricsObserverInterface> metrics_observer) override;
const std::string content_name_;
std::unique_ptr<cricket::SrtpSession> send_session_;
@ -163,8 +160,6 @@ class SrtpTransport : public RtpTransport {
bool external_auth_enabled_ = false;
int rtp_abs_sendtime_extn_id_ = -1;
rtc::scoped_refptr<MetricsObserverInterface> metrics_observer_;
};
} // namespace webrtc

2
pc/test/fakepeerconnectionbase.h
View File

@ -183,8 +183,6 @@ class FakePeerConnectionBase : public PeerConnectionInternal {
return false;
}
void RegisterUMAObserver(UMAObserver* observer) override {}
RTCError SetBitrate(const BitrateSettings& bitrate) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
}

1
pc/test/mock_peerconnection.h
View File

@ -148,7 +148,6 @@ class MockPeerConnection
MOCK_METHOD1(AddIceCandidate, bool(const IceCandidateInterface*));
MOCK_METHOD1(RemoveIceCandidates,
bool(const std::vector<cricket::Candidate>&));
MOCK_METHOD1(RegisterUMAObserver, void(UMAObserver*));
MOCK_METHOD1(SetBitrate, RTCError(const BitrateSettings&));
MOCK_METHOD1(SetBitrate, RTCError(const BitrateParameters&));
MOCK_METHOD1(SetBitrateAllocationStrategy,