Interface RTCRtpReceiver and RTCPeerConnection.getReceivers() added.

content/renderer/media/webrtc/rtc_rtp_receiver.cc

Index: content/renderer/media/webrtc/rtc_rtp_receiver.cc
diff --git a/content/renderer/media/webrtc/rtc_rtp_receiver.cc b/content/renderer/media/webrtc/rtc_rtp_receiver.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a5080ee8a545a290e7b5c6b4fb54bfe027b4b5b7
--- /dev/null
+++ b/content/renderer/media/webrtc/rtc_rtp_receiver.cc
@@ -0,0 +1,54 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/renderer/media/webrtc/rtc_rtp_receiver.h"
+
+#include "base/logging.h"
+#include "third_party/webrtc/base/scoped_ref_ptr.h"
+
+namespace content {
+
+namespace {
+
+inline bool operator==(const blink::WebMediaStreamTrack& web_track,
+                       const webrtc::MediaStreamTrackInterface& webrtc_track) {
+  return !web_track.isNull() && web_track.id() == webrtc_track.id().c_str();
+}
+
+}  // namespace
+
+uintptr_t RTCRtpReceiver::getId(
+    const webrtc::RtpReceiverInterface* webrtc_rtp_receiver) {
+  return reinterpret_cast<uintptr_t>(webrtc_rtp_receiver);
+}
+
+RTCRtpReceiver::RTCRtpReceiver(
+    webrtc::RtpReceiverInterface* webrtc_rtp_receiver,
+    const blink::WebMediaStreamTrack& web_track)
+    : webrtc_rtp_receiver_(webrtc_rtp_receiver), web_track_(web_track) {
+  DCHECK(webrtc_rtp_receiver_);
+  DCHECK(!web_track_.isNull());
+  DCHECK(web_track_ == webrtc_track());
+}
+
+RTCRtpReceiver::~RTCRtpReceiver() {}
+
+uintptr_t RTCRtpReceiver::id() const {
+  return getId(webrtc_rtp_receiver_.get());
+}
+
+const blink::WebMediaStreamTrack& RTCRtpReceiver::track() const {
+  DCHECK(web_track_ == webrtc_track());

[Guido Urdaneta, 2017/03/27 17:12:23]

Does DCHECK_EQ work in this case?

[hbos_chromium, 2017/03/28 10:12:55]

No. It only works if you define operator== in blink namespace and two operator<<
in std, which I think is more bloat and complexity than it's worth for two cases
of DCHECK, e.g:

namespace blink {

inline bool operator==(const WebMediaStreamTrack& web_track,
                       const webrtc::MediaStreamTrackInterface& webrtc_track) {
  return !web_track.isNull() && web_track.id() == webrtc_track.id().c_str();
}

}  // namespace blink

namespace std {

inline std::ostream& operator<<(
    std::ostream& out,
    const blink::WebMediaStreamTrack& web_track) {
  return (web_track.isNull() ? out << "null"
                             : out << web_track.id().utf8());
}

inline std::ostream& operator<<(
    std::ostream& out,
    const webrtc::MediaStreamTrackInterface& webrtc_track) {
  return out << webrtc_track.id();
}

}  // namespace std

I'll use DCHECK instead unless you object.

+  return web_track_;
+}
+
+const webrtc::MediaStreamTrackInterface& RTCRtpReceiver::webrtc_track() const {
+  const webrtc::MediaStreamTrackInterface* webrtc_track =
+      webrtc_rtp_receiver_->track();
+  DCHECK(webrtc_track);
+  DCHECK(web_track_ == *webrtc_track);
+  return *webrtc_track;
+}
+
+}  // namespace content