Enabling clang::find_bad_constructs for libjingle_peerconnection_api.
This CL removes //build/config/clang:find_bad_constructs from the
suppressed_configs list, which means that clang:find_bad_constructs
is now enabled on these translation units.
Bug: webrtc:9251, webrtc:163
Change-Id: I5475e574353c772910181495fdb3400b5f0e7399
Reviewed-on: https://webrtc-review.googlesource.com/87240
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24040}diff --git a/api/BUILD.gn b/api/BUILD.gn
index b6caeaa..539c222 100644
--- a/api/BUILD.gn
+++ b/api/BUILD.gn
@@ -52,6 +52,7 @@
"candidate.cc",
"candidate.h",
"cryptoparams.h",
+ "datachannelinterface.cc",
"datachannelinterface.h",
"dtmfsenderinterface.h",
"jsep.cc",
@@ -68,6 +69,7 @@
"mediatypes.h",
"notifier.h",
"peerconnectionfactoryproxy.h",
+ "peerconnectioninterface.cc",
"peerconnectioninterface.h",
"peerconnectionproxy.h",
"proxy.cc",
@@ -81,6 +83,7 @@
"rtpreceiverinterface.cc",
"rtpreceiverinterface.h",
"rtpsenderinterface.h",
+ "rtptransceiverinterface.cc",
"rtptransceiverinterface.h",
"setremotedescriptionobserverinterface.h",
"statstypes.cc",
@@ -90,11 +93,6 @@
"videosourceproxy.h",
]
- if (!build_with_chromium && is_clang) {
- # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
- suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
- }
-
deps = [
":array_view",
":audio_options_api",
diff --git a/api/datachannelinterface.cc b/api/datachannelinterface.cc
new file mode 100644
index 0000000..141462d
--- /dev/null
+++ b/api/datachannelinterface.cc
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2018 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 "api/datachannelinterface.h"
+
+namespace webrtc {
+
+bool DataChannelInterface::ordered() const {
+ return false;
+}
+
+uint16_t DataChannelInterface::maxRetransmitTime() const {
+ return 0;
+}
+
+uint16_t DataChannelInterface::maxRetransmits() const {
+ return 0;
+}
+
+std::string DataChannelInterface::protocol() const {
+ return std::string();
+}
+
+bool DataChannelInterface::negotiated() const {
+ return false;
+}
+
+} // namespace webrtc
diff --git a/api/datachannelinterface.h b/api/datachannelinterface.h
index 5cbe717..a0d2b3b 100644
--- a/api/datachannelinterface.h
+++ b/api/datachannelinterface.h
@@ -88,7 +88,7 @@
virtual void OnBufferedAmountChange(uint64_t previous_amount) {}
protected:
- virtual ~DataChannelObserver() {}
+ virtual ~DataChannelObserver() = default;
};
class DataChannelInterface : public rtc::RefCountInterface {
@@ -134,11 +134,11 @@
// TODO(deadbeef): Remove these dummy implementations when all classes have
// implemented these APIs. They should all just return the values the
// DataChannel was created with.
- virtual bool ordered() const { return false; }
- virtual uint16_t maxRetransmitTime() const { return 0; }
- virtual uint16_t maxRetransmits() const { return 0; }
- virtual std::string protocol() const { return std::string(); }
- virtual bool negotiated() const { return false; }
+ virtual bool ordered() const;
+ virtual uint16_t maxRetransmitTime() const;
+ virtual uint16_t maxRetransmits() const;
+ virtual std::string protocol() const;
+ virtual bool negotiated() const;
// Returns the ID from the DataChannelInit, if it was negotiated out-of-band.
// If negotiated in-band, this ID will be populated once the DTLS role is
@@ -170,7 +170,7 @@
virtual bool Send(const DataBuffer& buffer) = 0;
protected:
- virtual ~DataChannelInterface() {}
+ ~DataChannelInterface() override = default;
};
} // namespace webrtc
diff --git a/api/dtmfsenderinterface.h b/api/dtmfsenderinterface.h
index 217f9d2..b79bb31 100644
--- a/api/dtmfsenderinterface.h
+++ b/api/dtmfsenderinterface.h
@@ -29,7 +29,7 @@
virtual void OnToneChange(const std::string& tone) = 0;
protected:
- virtual ~DtmfSenderObserverInterface() {}
+ virtual ~DtmfSenderObserverInterface() = default;
};
// The interface of native implementation of the RTCDTMFSender defined by the
@@ -85,7 +85,7 @@
virtual int inter_tone_gap() const = 0;
protected:
- virtual ~DtmfSenderInterface() {}
+ ~DtmfSenderInterface() override = default;
};
} // namespace webrtc
diff --git a/api/jsep.cc b/api/jsep.cc
index 1f4afba..52a60f9 100644
--- a/api/jsep.cc
+++ b/api/jsep.cc
@@ -21,4 +21,21 @@
return 0;
}
+void CreateSessionDescriptionObserver::OnFailure(RTCError error) {
+ OnFailure(error.message());
+}
+
+void CreateSessionDescriptionObserver::OnFailure(const std::string& error) {
+ OnFailure(RTCError(RTCErrorType::INTERNAL_ERROR, std::string(error)));
+}
+
+void SetSessionDescriptionObserver::OnFailure(RTCError error) {
+ std::string message(error.message());
+ OnFailure(message);
+}
+
+void SetSessionDescriptionObserver::OnFailure(const std::string& error) {
+ OnFailure(RTCError(RTCErrorType::INTERNAL_ERROR, std::string(error)));
+}
+
} // namespace webrtc
diff --git a/api/jsep.h b/api/jsep.h
index dbf97f6..b07f858 100644
--- a/api/jsep.h
+++ b/api/jsep.h
@@ -205,10 +205,8 @@
// is deprecated; in order to let clients remove the old version, it has a
// default implementation. If both versions are unimplemented, the
// result will be a runtime error (stack overflow). This is intentional.
- virtual void OnFailure(RTCError error) { OnFailure(error.message()); }
- virtual void OnFailure(const std::string& error) {
- OnFailure(RTCError(RTCErrorType::INTERNAL_ERROR, std::string(error)));
- }
+ virtual void OnFailure(RTCError error);
+ virtual void OnFailure(const std::string& error);
protected:
~CreateSessionDescriptionObserver() override = default;
@@ -219,13 +217,9 @@
public:
virtual void OnSuccess() = 0;
// See description in CreateSessionDescriptionObserver for OnFailure.
- virtual void OnFailure(RTCError error) {
- std::string message(error.message());
- OnFailure(message);
- }
- virtual void OnFailure(const std::string& error) {
- OnFailure(RTCError(RTCErrorType::INTERNAL_ERROR, std::string(error)));
- }
+ virtual void OnFailure(RTCError error);
+
+ virtual void OnFailure(const std::string& error);
protected:
~SetSessionDescriptionObserver() override = default;
diff --git a/api/peerconnectioninterface.cc b/api/peerconnectioninterface.cc
new file mode 100644
index 0000000..aa23da3
--- /dev/null
+++ b/api/peerconnectioninterface.cc
@@ -0,0 +1,248 @@
+/*
+ * Copyright 2018 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 "api/peerconnectioninterface.h"
+
+namespace webrtc {
+
+PeerConnectionInterface::IceServer::IceServer() = default;
+PeerConnectionInterface::IceServer::IceServer(const IceServer& rhs) = default;
+PeerConnectionInterface::IceServer::~IceServer() = default;
+
+PeerConnectionInterface::RTCConfiguration::RTCConfiguration() = default;
+
+PeerConnectionInterface::RTCConfiguration::RTCConfiguration(
+ const RTCConfiguration& rhs) = default;
+
+PeerConnectionInterface::RTCConfiguration::RTCConfiguration(
+ RTCConfigurationType type) {
+ if (type == RTCConfigurationType::kAggressive) {
+ // These parameters are also defined in Java and IOS configurations,
+ // so their values may be overwritten by the Java or IOS configuration.
+ bundle_policy = kBundlePolicyMaxBundle;
+ rtcp_mux_policy = kRtcpMuxPolicyRequire;
+ ice_connection_receiving_timeout = kAggressiveIceConnectionReceivingTimeout;
+
+ // These parameters are not defined in Java or IOS configuration,
+ // so their values will not be overwritten.
+ enable_ice_renomination = true;
+ redetermine_role_on_ice_restart = false;
+ }
+}
+
+PeerConnectionInterface::RTCConfiguration::~RTCConfiguration() = default;
+
+RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>>
+PeerConnectionInterface::AddTrack(
+ rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ const std::vector<std::string>& stream_ids) {
+ return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+}
+
+RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
+PeerConnectionInterface::AddTransceiver(
+ rtc::scoped_refptr<MediaStreamTrackInterface> track) {
+ return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
+}
+
+RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
+PeerConnectionInterface::AddTransceiver(
+ rtc::scoped_refptr<MediaStreamTrackInterface> track,
+ const RtpTransceiverInit& init) {
+ return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
+}
+
+RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
+PeerConnectionInterface::AddTransceiver(cricket::MediaType media_type) {
+ return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
+}
+
+RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
+PeerConnectionInterface::AddTransceiver(cricket::MediaType media_type,
+ const RtpTransceiverInit& init) {
+ return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
+}
+
+rtc::scoped_refptr<RtpSenderInterface> PeerConnectionInterface::CreateSender(
+ const std::string& kind,
+ const std::string& stream_id) {
+ return rtc::scoped_refptr<RtpSenderInterface>();
+}
+
+std::vector<rtc::scoped_refptr<RtpSenderInterface>>
+PeerConnectionInterface::GetSenders() const {
+ return std::vector<rtc::scoped_refptr<RtpSenderInterface>>();
+}
+
+std::vector<rtc::scoped_refptr<RtpReceiverInterface>>
+PeerConnectionInterface::GetReceivers() const {
+ return std::vector<rtc::scoped_refptr<RtpReceiverInterface>>();
+}
+
+std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>
+PeerConnectionInterface::GetTransceivers() const {
+ return {};
+}
+
+const SessionDescriptionInterface*
+PeerConnectionInterface::current_local_description() const {
+ return nullptr;
+}
+
+const SessionDescriptionInterface*
+PeerConnectionInterface::current_remote_description() const {
+ return nullptr;
+}
+
+const SessionDescriptionInterface*
+PeerConnectionInterface::pending_local_description() const {
+ return nullptr;
+}
+
+const SessionDescriptionInterface*
+PeerConnectionInterface::pending_remote_description() const {
+ return nullptr;
+}
+
+PeerConnectionInterface::RTCConfiguration
+PeerConnectionInterface::GetConfiguration() {
+ return PeerConnectionInterface::RTCConfiguration();
+}
+
+bool PeerConnectionInterface::SetConfiguration(
+ const PeerConnectionInterface::RTCConfiguration& config,
+ RTCError* error) {
+ return false;
+}
+
+bool PeerConnectionInterface::SetConfiguration(
+ const PeerConnectionInterface::RTCConfiguration& config) {
+ return false;
+}
+
+bool PeerConnectionInterface::RemoveIceCandidates(
+ const std::vector<cricket::Candidate>& candidates) {
+ return false;
+}
+
+RTCError PeerConnectionInterface::SetBitrate(const BitrateSettings& bitrate) {
+ BitrateParameters bitrate_parameters;
+ bitrate_parameters.min_bitrate_bps = bitrate.min_bitrate_bps;
+ bitrate_parameters.current_bitrate_bps = bitrate.start_bitrate_bps;
+ bitrate_parameters.max_bitrate_bps = bitrate.max_bitrate_bps;
+ return SetBitrate(bitrate_parameters);
+}
+
+RTCError PeerConnectionInterface::SetBitrate(
+ const BitrateParameters& bitrate_parameters) {
+ BitrateSettings bitrate;
+ bitrate.min_bitrate_bps = bitrate_parameters.min_bitrate_bps;
+ bitrate.start_bitrate_bps = bitrate_parameters.current_bitrate_bps;
+ bitrate.max_bitrate_bps = bitrate_parameters.max_bitrate_bps;
+ return SetBitrate(bitrate);
+}
+
+bool PeerConnectionInterface::StartRtcEventLog(rtc::PlatformFile file,
+ int64_t max_size_bytes) {
+ return false;
+}
+
+bool PeerConnectionInterface::StartRtcEventLog(
+ std::unique_ptr<RtcEventLogOutput> output,
+ int64_t output_period_ms) {
+ return false;
+}
+
+PeerConnectionInterface::BitrateParameters::BitrateParameters() = default;
+
+PeerConnectionInterface::BitrateParameters::~BitrateParameters() = default;
+
+PeerConnectionDependencies::PeerConnectionDependencies(
+ PeerConnectionObserver* observer_in)
+ : observer(observer_in) {}
+
+PeerConnectionDependencies::PeerConnectionDependencies(
+ PeerConnectionDependencies&&) = default;
+
+PeerConnectionDependencies::~PeerConnectionDependencies() = default;
+
+PeerConnectionFactoryDependencies::PeerConnectionFactoryDependencies() =
+ default;
+
+PeerConnectionFactoryDependencies::PeerConnectionFactoryDependencies(
+ PeerConnectionFactoryDependencies&&) = default;
+
+PeerConnectionFactoryDependencies::~PeerConnectionFactoryDependencies() =
+ default;
+
+rtc::scoped_refptr<PeerConnectionInterface>
+PeerConnectionFactoryInterface::CreatePeerConnection(
+ const PeerConnectionInterface::RTCConfiguration& configuration,
+ const MediaConstraintsInterface* constraints,
+ std::unique_ptr<cricket::PortAllocator> allocator,
+ std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
+ PeerConnectionObserver* observer) {
+ return nullptr;
+}
+
+rtc::scoped_refptr<PeerConnectionInterface>
+PeerConnectionFactoryInterface::CreatePeerConnection(
+ const PeerConnectionInterface::RTCConfiguration& configuration,
+ std::unique_ptr<cricket::PortAllocator> allocator,
+ std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
+ PeerConnectionObserver* observer) {
+ return nullptr;
+}
+
+rtc::scoped_refptr<PeerConnectionInterface>
+PeerConnectionFactoryInterface::CreatePeerConnection(
+ const PeerConnectionInterface::RTCConfiguration& configuration,
+ PeerConnectionDependencies dependencies) {
+ return nullptr;
+}
+
+RtpCapabilities PeerConnectionFactoryInterface::GetRtpSenderCapabilities(
+ cricket::MediaType kind) const {
+ return {};
+}
+
+RtpCapabilities PeerConnectionFactoryInterface::GetRtpReceiverCapabilities(
+ cricket::MediaType kind) const {
+ return {};
+}
+
+rtc::scoped_refptr<VideoTrackSourceInterface>
+PeerConnectionFactoryInterface::CreateVideoSource(
+ std::unique_ptr<cricket::VideoCapturer> capturer) {
+ return nullptr;
+}
+
+rtc::scoped_refptr<VideoTrackSourceInterface>
+PeerConnectionFactoryInterface::CreateVideoSource(
+ std::unique_ptr<cricket::VideoCapturer> capturer,
+ const MediaConstraintsInterface* constraints) {
+ return nullptr;
+}
+
+rtc::scoped_refptr<VideoTrackSourceInterface>
+PeerConnectionFactoryInterface::CreateVideoSource(
+ cricket::VideoCapturer* capturer) {
+ return CreateVideoSource(std::unique_ptr<cricket::VideoCapturer>(capturer));
+}
+
+rtc::scoped_refptr<VideoTrackSourceInterface>
+PeerConnectionFactoryInterface::CreateVideoSource(
+ cricket::VideoCapturer* capturer,
+ const MediaConstraintsInterface* constraints) {
+ return CreateVideoSource(std::unique_ptr<cricket::VideoCapturer>(capturer),
+ constraints);
+}
+
+} // namespace webrtc
diff --git a/api/peerconnectioninterface.h b/api/peerconnectioninterface.h
index 90a99a6..786fdef 100644
--- a/api/peerconnectioninterface.h
+++ b/api/peerconnectioninterface.h
@@ -102,6 +102,7 @@
// TODO(bugs.webrtc.org/7447): We plan to provide a way to let applications
// inject a PacketSocketFactory and/or NetworkManager, and not expose
// PortAllocator in the PeerConnection api.
+#include "media/base/mediaengine.h" // nogncheck
#include "p2p/base/portallocator.h" // nogncheck
// TODO(nisse): The interface for bitrate allocation strategy belongs in api/.
#include "rtc_base/bitrateallocationstrategy.h"
@@ -119,7 +120,6 @@
} // namespace rtc
namespace cricket {
-class MediaEngineInterface;
class WebRtcVideoDecoderFactory;
class WebRtcVideoEncoderFactory;
} // namespace cricket
@@ -144,7 +144,7 @@
protected:
// Dtor protected as objects shouldn't be deleted via this interface.
- ~StreamCollectionInterface() {}
+ ~StreamCollectionInterface() override = default;
};
class StatsObserver : public rtc::RefCountInterface {
@@ -152,7 +152,7 @@
virtual void OnComplete(const StatsReports& reports) = 0;
protected:
- virtual ~StatsObserver() {}
+ ~StatsObserver() override = default;
};
enum class SdpSemantics { kPlanB, kUnifiedPlan };
@@ -198,6 +198,10 @@
};
struct IceServer {
+ IceServer();
+ IceServer(const IceServer&);
+ ~IceServer();
+
// TODO(jbauch): Remove uri when all code using it has switched to urls.
// List of URIs associated with this server. Valid formats are described
// in RFC7064 and RFC7065, and more may be added in the future. The "host"
@@ -284,22 +288,10 @@
// methods for all settings which are of interest to applications,
// Chrome in particular.
- RTCConfiguration() = default;
- explicit RTCConfiguration(RTCConfigurationType type) {
- if (type == RTCConfigurationType::kAggressive) {
- // These parameters are also defined in Java and IOS configurations,
- // so their values may be overwritten by the Java or IOS configuration.
- bundle_policy = kBundlePolicyMaxBundle;
- rtcp_mux_policy = kRtcpMuxPolicyRequire;
- ice_connection_receiving_timeout =
- kAggressiveIceConnectionReceivingTimeout;
-
- // These parameters are not defined in Java or IOS configuration,
- // so their values will not be overwritten.
- enable_ice_renomination = true;
- redetermine_role_on_ice_restart = false;
- }
- }
+ RTCConfiguration();
+ RTCConfiguration(const RTCConfiguration&);
+ explicit RTCConfiguration(RTCConfigurationType type);
+ ~RTCConfiguration();
bool operator==(const RTCConfiguration& o) const;
bool operator!=(const RTCConfiguration& o) const;
@@ -668,7 +660,7 @@
// - INVALID_STATE: The PeerConnection is closed.
virtual RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack(
rtc::scoped_refptr<MediaStreamTrackInterface> track,
- const std::vector<std::string>& stream_ids) = 0;
+ const std::vector<std::string>& stream_ids);
// Remove an RtpSender from this PeerConnection.
// Returns true on success.
@@ -701,14 +693,10 @@
// Errors:
// - INVALID_PARAMETER: |track| is null.
virtual RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
- AddTransceiver(rtc::scoped_refptr<MediaStreamTrackInterface> track) {
- return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
- }
+ AddTransceiver(rtc::scoped_refptr<MediaStreamTrackInterface> track);
virtual RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
AddTransceiver(rtc::scoped_refptr<MediaStreamTrackInterface> track,
- const RtpTransceiverInit& init) {
- return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
- }
+ const RtpTransceiverInit& init);
// Adds a transceiver with the given kind. Can either be MEDIA_TYPE_AUDIO or
// MEDIA_TYPE_VIDEO.
@@ -716,14 +704,9 @@
// - INVALID_PARAMETER: |media_type| is not MEDIA_TYPE_AUDIO or
// MEDIA_TYPE_VIDEO.
virtual RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
- AddTransceiver(cricket::MediaType media_type) {
- return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
- }
+ AddTransceiver(cricket::MediaType media_type);
virtual RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
- AddTransceiver(cricket::MediaType media_type,
- const RtpTransceiverInit& init) {
- return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
- }
+ AddTransceiver(cricket::MediaType media_type, const RtpTransceiverInit& init);
// TODO(deadbeef): Make these pure virtual once all subclasses implement them.
@@ -743,9 +726,7 @@
// AddTransceiver instead.
virtual rtc::scoped_refptr<RtpSenderInterface> CreateSender(
const std::string& kind,
- const std::string& stream_id) {
- return rtc::scoped_refptr<RtpSenderInterface>();
- }
+ const std::string& stream_id);
// If Plan B semantics are specified, gets all RtpSenders, created either
// through AddStream, AddTrack, or CreateSender. All senders of a specific
@@ -754,9 +735,7 @@
// If Unified Plan semantics are specified, gets the RtpSender for each
// RtpTransceiver.
virtual std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
- const {
- return std::vector<rtc::scoped_refptr<RtpSenderInterface>>();
- }
+ const;
// If Plan B semantics are specified, gets all RtpReceivers created when a
// remote description is applied. All receivers of a specific media type share
@@ -767,9 +746,7 @@
// If Unified Plan semantics are specified, gets the RtpReceiver for each
// RtpTransceiver.
virtual std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers()
- const {
- return std::vector<rtc::scoped_refptr<RtpReceiverInterface>>();
- }
+ const;
// Get all RtpTransceivers, created either through AddTransceiver, AddTrack or
// by a remote description applied with SetRemoteDescription.
@@ -777,9 +754,7 @@
// Note: This method is only available when Unified Plan is enabled (see
// RTCConfiguration).
virtual std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>
- GetTransceivers() const {
- return {};
- }
+ GetTransceivers() const;
// The legacy non-compliant GetStats() API. This correspond to the
// callback-based version of getStats() in JavaScript. The returned metrics
@@ -844,24 +819,14 @@
// A "current" description the one currently negotiated from a complete
// offer/answer exchange.
- virtual const SessionDescriptionInterface* current_local_description() const {
- return nullptr;
- }
- virtual const SessionDescriptionInterface* current_remote_description()
- const {
- return nullptr;
- }
+ virtual const SessionDescriptionInterface* current_local_description() const;
+ virtual const SessionDescriptionInterface* current_remote_description() const;
// A "pending" description is one that's part of an incomplete offer/answer
// exchange (thus, either an offer or a pranswer). Once the offer/answer
// exchange is finished, the "pending" description will become "current".
- virtual const SessionDescriptionInterface* pending_local_description() const {
- return nullptr;
- }
- virtual const SessionDescriptionInterface* pending_remote_description()
- const {
- return nullptr;
- }
+ virtual const SessionDescriptionInterface* pending_local_description() const;
+ virtual const SessionDescriptionInterface* pending_remote_description() const;
// Create a new offer.
// The CreateSessionDescriptionObserver callback will be called when done.
@@ -903,9 +868,7 @@
// TODO(deadbeef): Make this pure virtual once all Chrome subclasses of
// PeerConnectionInterface implement it.
- virtual PeerConnectionInterface::RTCConfiguration GetConfiguration() {
- return PeerConnectionInterface::RTCConfiguration();
- }
+ virtual PeerConnectionInterface::RTCConfiguration GetConfiguration();
// Sets the PeerConnection's global configuration to |config|.
//
@@ -932,15 +895,12 @@
// PeerConnectionInterface implement it.
virtual bool SetConfiguration(
const PeerConnectionInterface::RTCConfiguration& config,
- RTCError* error) {
- return false;
- }
+ RTCError* error);
+
// Version without error output param for backwards compatibility.
// TODO(deadbeef): Remove once chromium is updated.
virtual bool SetConfiguration(
- const PeerConnectionInterface::RTCConfiguration& config) {
- return false;
- }
+ const PeerConnectionInterface::RTCConfiguration& config);
// Provides a remote candidate to the ICE Agent.
// A copy of the |candidate| will be created and added to the remote
@@ -952,9 +912,7 @@
// continual gathering, to avoid an ever-growing list of candidates as
// networks come and go.
virtual bool RemoveIceCandidates(
- const std::vector<cricket::Candidate>& candidates) {
- return false;
- }
+ 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
@@ -967,6 +925,9 @@
// 0 <= min <= current <= max should hold for set parameters.
struct BitrateParameters {
+ BitrateParameters();
+ ~BitrateParameters();
+
absl::optional<int> min_bitrate_bps;
absl::optional<int> current_bitrate_bps;
absl::optional<int> max_bitrate_bps;
@@ -978,24 +939,12 @@
//
// Setting |current_bitrate_bps| will reset the current bitrate estimate
// to the provided value.
- virtual RTCError SetBitrate(const BitrateSettings& bitrate) {
- BitrateParameters bitrate_parameters;
- bitrate_parameters.min_bitrate_bps = bitrate.min_bitrate_bps;
- bitrate_parameters.current_bitrate_bps = bitrate.start_bitrate_bps;
- bitrate_parameters.max_bitrate_bps = bitrate.max_bitrate_bps;
- return SetBitrate(bitrate_parameters);
- }
+ virtual RTCError SetBitrate(const BitrateSettings& bitrate);
// TODO(nisse): Deprecated - use version above. These two default
// implementations require subclasses to implement one or the other
// of the methods.
- virtual RTCError SetBitrate(const BitrateParameters& bitrate_parameters) {
- BitrateSettings bitrate;
- bitrate.min_bitrate_bps = bitrate_parameters.min_bitrate_bps;
- bitrate.start_bitrate_bps = bitrate_parameters.current_bitrate_bps;
- bitrate.max_bitrate_bps = bitrate_parameters.max_bitrate_bps;
- return SetBitrate(bitrate);
- }
+ virtual RTCError SetBitrate(const BitrateParameters& bitrate_parameters);
// Sets current strategy. If not set default WebRTC allocator will be used.
// May be changed during an active session. The strategy
@@ -1037,19 +986,14 @@
// automatically after 10 minutes have passed, or when the StopRtcEventLog
// function is called.
// TODO(eladalon): Deprecate and remove this.
- virtual bool StartRtcEventLog(rtc::PlatformFile file,
- int64_t max_size_bytes) {
- return false;
- }
+ virtual bool StartRtcEventLog(rtc::PlatformFile file, int64_t max_size_bytes);
// Start RtcEventLog using an existing output-sink. Takes ownership of
// |output| and passes it on to Call, which will take the ownership. If the
// operation fails the output will be closed and deallocated. The event log
// will send serialized events to the output object every |output_period_ms|.
virtual bool StartRtcEventLog(std::unique_ptr<RtcEventLogOutput> output,
- int64_t output_period_ms) {
- return false;
- }
+ int64_t output_period_ms);
// Stops logging the RtcEventLog.
// TODO(ivoc): Make this pure virtual when Chrome is updated.
@@ -1065,7 +1009,7 @@
protected:
// Dtor protected as objects shouldn't be deleted via this interface.
- ~PeerConnectionInterface() {}
+ ~PeerConnectionInterface() override = default;
};
// PeerConnection callback interface, used for RTCPeerConnection events.
@@ -1159,15 +1103,15 @@
// PeerConnection object to be the definitive owner of the dependencies
// lifetime making injection safer.
struct PeerConnectionDependencies final {
- explicit PeerConnectionDependencies(PeerConnectionObserver* observer_in)
- : observer(observer_in) {}
+ explicit PeerConnectionDependencies(PeerConnectionObserver* observer_in);
// This object is not copyable or assignable.
PeerConnectionDependencies(const PeerConnectionDependencies&) = delete;
PeerConnectionDependencies& operator=(const PeerConnectionDependencies&) =
delete;
// This object is only moveable.
- PeerConnectionDependencies(PeerConnectionDependencies&&) = default;
+ PeerConnectionDependencies(PeerConnectionDependencies&&);
PeerConnectionDependencies& operator=(PeerConnectionDependencies&&) = default;
+ ~PeerConnectionDependencies();
// Mandatory dependencies
PeerConnectionObserver* observer = nullptr;
// Optional dependencies
@@ -1183,17 +1127,17 @@
// connection factory to take ownership of the dependency by adding a unique_ptr
// to this structure.
struct PeerConnectionFactoryDependencies final {
- PeerConnectionFactoryDependencies() = default;
+ PeerConnectionFactoryDependencies();
// This object is not copyable or assignable.
PeerConnectionFactoryDependencies(const PeerConnectionFactoryDependencies&) =
delete;
PeerConnectionFactoryDependencies& operator=(
const PeerConnectionFactoryDependencies&) = delete;
// This object is only moveable.
- PeerConnectionFactoryDependencies(PeerConnectionFactoryDependencies&&) =
- default;
+ PeerConnectionFactoryDependencies(PeerConnectionFactoryDependencies&&);
PeerConnectionFactoryDependencies& operator=(
PeerConnectionFactoryDependencies&&) = default;
+ ~PeerConnectionFactoryDependencies();
// Optional dependencies
rtc::Thread* network_thread = nullptr;
@@ -1264,9 +1208,7 @@
// are updated.
virtual rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
const PeerConnectionInterface::RTCConfiguration& configuration,
- PeerConnectionDependencies dependencies) {
- return nullptr;
- }
+ PeerConnectionDependencies dependencies);
// Deprecated; |allocator| and |cert_generator| may be null, in which case
// default implementations will be used.
@@ -1281,9 +1223,8 @@
const PeerConnectionInterface::RTCConfiguration& configuration,
std::unique_ptr<cricket::PortAllocator> allocator,
std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
- PeerConnectionObserver* observer) {
- return nullptr;
- }
+ PeerConnectionObserver* observer);
+
// Deprecated; should use RTCConfiguration for everything that previously
// used constraints.
virtual rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
@@ -1291,25 +1232,19 @@
const MediaConstraintsInterface* constraints,
std::unique_ptr<cricket::PortAllocator> allocator,
std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
- PeerConnectionObserver* observer) {
- return nullptr;
- }
+ PeerConnectionObserver* observer);
// Returns the capabilities of an RTP sender of type |kind|.
// If for some reason you pass in MEDIA_TYPE_DATA, returns an empty structure.
// TODO(orphis): Make pure virtual when all subclasses implement it.
virtual RtpCapabilities GetRtpSenderCapabilities(
- cricket::MediaType kind) const {
- return {};
- }
+ cricket::MediaType kind) const;
// Returns the capabilities of an RTP receiver of type |kind|.
// If for some reason you pass in MEDIA_TYPE_DATA, returns an empty structure.
// TODO(orphis): Make pure virtual when all subclasses implement it.
virtual RtpCapabilities GetRtpReceiverCapabilities(
- cricket::MediaType kind) const {
- return {};
- }
+ cricket::MediaType kind) const;
virtual rtc::scoped_refptr<MediaStreamInterface> CreateLocalMediaStream(
const std::string& stream_id) = 0;
@@ -1327,9 +1262,7 @@
// TODO(deadbeef): Make pure virtual once downstream mock PC factory classes
// are updated.
virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource(
- std::unique_ptr<cricket::VideoCapturer> capturer) {
- return nullptr;
- }
+ std::unique_ptr<cricket::VideoCapturer> capturer);
// A video source creator that allows selection of resolution and frame rate.
// |constraints| decides video resolution and frame rate but can be null.
@@ -1339,22 +1272,15 @@
// safely be destroyed afterwards.
virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource(
std::unique_ptr<cricket::VideoCapturer> capturer,
- const MediaConstraintsInterface* constraints) {
- return nullptr;
- }
+ const MediaConstraintsInterface* constraints);
// Deprecated; please use the versions that take unique_ptrs above.
// TODO(deadbeef): Remove these once safe to do so.
virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource(
- cricket::VideoCapturer* capturer) {
- return CreateVideoSource(std::unique_ptr<cricket::VideoCapturer>(capturer));
- }
+ cricket::VideoCapturer* capturer);
virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource(
cricket::VideoCapturer* capturer,
- const MediaConstraintsInterface* constraints) {
- return CreateVideoSource(std::unique_ptr<cricket::VideoCapturer>(capturer),
- constraints);
- }
+ const MediaConstraintsInterface* constraints);
// Creates a new local VideoTrack. The same |source| can be used in several
// tracks.
@@ -1383,7 +1309,7 @@
// Dtor and ctor protected as objects shouldn't be created or deleted via
// this interface.
PeerConnectionFactoryInterface() {}
- ~PeerConnectionFactoryInterface() {} // NOLINT
+ ~PeerConnectionFactoryInterface() override = default;
};
// Create a new instance of PeerConnectionFactoryInterface.
diff --git a/api/rtpsenderinterface.h b/api/rtpsenderinterface.h
index 6003aa0..a7eec49 100644
--- a/api/rtpsenderinterface.h
+++ b/api/rtpsenderinterface.h
@@ -64,7 +64,7 @@
virtual rtc::scoped_refptr<DtmfSenderInterface> GetDtmfSender() const = 0;
protected:
- virtual ~RtpSenderInterface() {}
+ ~RtpSenderInterface() override = default;
};
// Define proxy for RtpSenderInterface.
diff --git a/api/rtptransceiverinterface.cc b/api/rtptransceiverinterface.cc
new file mode 100644
index 0000000..7f94c75
--- /dev/null
+++ b/api/rtptransceiverinterface.cc
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2018 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 "api/rtptransceiverinterface.h"
+
+namespace webrtc {
+
+RtpTransceiverInit::RtpTransceiverInit() = default;
+
+RtpTransceiverInit::~RtpTransceiverInit() = default;
+
+absl::optional<RtpTransceiverDirection>
+RtpTransceiverInterface::fired_direction() const {
+ return absl::nullopt;
+}
+
+} // namespace webrtc
diff --git a/api/rtptransceiverinterface.h b/api/rtptransceiverinterface.h
index 26f1fdf..025e8e3 100644
--- a/api/rtptransceiverinterface.h
+++ b/api/rtptransceiverinterface.h
@@ -34,6 +34,8 @@
// PeerConnectionInterface::AddTransceiver.
// https://w3c.github.io/webrtc-pc/#dom-rtcrtptransceiverinit
struct RtpTransceiverInit final {
+ RtpTransceiverInit();
+ ~RtpTransceiverInit();
// Direction of the RtpTransceiver. See RtpTransceiverInterface::direction().
RtpTransceiverDirection direction = RtpTransceiverDirection::kSendRecv;
@@ -112,9 +114,7 @@
// OnAddTrack only get fired once even if the same session description is
// applied again.
// Exposed in the public interface for use by Chromium.
- virtual absl::optional<RtpTransceiverDirection> fired_direction() const {
- return absl::nullopt;
- }
+ virtual absl::optional<RtpTransceiverDirection> fired_direction() const;
// The Stop method irreversibly stops the RtpTransceiver. The sender of this
// transceiver will no longer send, the receiver will no longer receive.
@@ -129,7 +129,7 @@
rtc::ArrayView<RtpCodecCapability> codecs) = 0;
protected:
- virtual ~RtpTransceiverInterface() = default;
+ ~RtpTransceiverInterface() override = default;
};
} // namespace webrtc
diff --git a/api/stats/rtcstatscollectorcallback.h b/api/stats/rtcstatscollectorcallback.h
index 2c67bb8..9242217 100644
--- a/api/stats/rtcstatscollectorcallback.h
+++ b/api/stats/rtcstatscollectorcallback.h
@@ -19,7 +19,7 @@
class RTCStatsCollectorCallback : public virtual rtc::RefCountInterface {
public:
- virtual ~RTCStatsCollectorCallback() {}
+ ~RTCStatsCollectorCallback() override = default;
virtual void OnStatsDelivered(
const rtc::scoped_refptr<const RTCStatsReport>& report) = 0;
diff --git a/media/base/videocapturer.cc b/media/base/videocapturer.cc
index a03f903..643134c 100644
--- a/media/base/videocapturer.cc
+++ b/media/base/videocapturer.cc
@@ -40,6 +40,8 @@
Construct();
}
+VideoCapturer::~VideoCapturer() {}
+
void VideoCapturer::Construct() {
enable_camera_list_ = false;
capture_state_ = CS_STOPPED;
@@ -65,6 +67,10 @@
return true;
}
+bool VideoCapturer::apply_rotation() {
+ return apply_rotation_;
+}
+
void VideoCapturer::SetSupportedFormats(
const std::vector<VideoFormat>& formats) {
// This method is OK to call during initialization on a separate thread.
diff --git a/media/base/videocapturer.h b/media/base/videocapturer.h
index ee2f5ca..84f9565 100644
--- a/media/base/videocapturer.h
+++ b/media/base/videocapturer.h
@@ -77,7 +77,7 @@
public:
VideoCapturer();
- virtual ~VideoCapturer() {}
+ ~VideoCapturer() override;
// Gets the id of the underlying device, which is available after the capturer
// is initialized. Can be used to determine if two capturers reference the
@@ -134,7 +134,7 @@
virtual bool IsRunning() = 0;
CaptureState capture_state() const { return capture_state_; }
- virtual bool apply_rotation() { return apply_rotation_; }
+ virtual bool apply_rotation();
// Returns true if the capturer is screencasting. This can be used to
// implement screencast specific behavior.
