Interface RTCRtpReceiver and RTCPeerConnection.getReceivers() added.

content/renderer/media/rtc_peer_connection_handler_unittest.cc

 // Copyright (c) 2012 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/rtc_peer_connection_handler.h"
 
 #include <stddef.h>
 
+#include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 20 matching lines @@
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebRTCConfiguration.h"
 #include "third_party/WebKit/public/platform/WebRTCDTMFSenderHandler.h"
 #include "third_party/WebKit/public/platform/WebRTCDataChannelHandler.h"
 #include "third_party/WebKit/public/platform/WebRTCDataChannelInit.h"
 #include "third_party/WebKit/public/platform/WebRTCError.h"
 #include "third_party/WebKit/public/platform/WebRTCICECandidate.h"
 #include "third_party/WebKit/public/platform/WebRTCPeerConnectionHandlerClient.h"
+#include "third_party/WebKit/public/platform/WebRTCRtpReceiver.h"
 #include "third_party/WebKit/public/platform/WebRTCSessionDescription.h"
 #include "third_party/WebKit/public/platform/WebRTCSessionDescriptionRequest.h"
 #include "third_party/WebKit/public/platform/WebRTCStatsRequest.h"
 #include "third_party/WebKit/public/platform/WebRTCVoidRequest.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebHeap.h"
 #include "third_party/webrtc/api/peerconnectioninterface.h"
 #include "third_party/webrtc/stats/test/rtcteststats.h"
 
 static const char kDummySdp[] = "dummy sdp";
@@ skipping 811 matching lines @@
       }
       EXPECT_EQ(members.size(), static_cast<size_t>(14));
     } else {
       NOTREACHED();
     }
   }
   EXPECT_EQ(undefined_stats_count, 1);
   EXPECT_EQ(defined_stats_count, 1);
 }
 
+TEST_F(RTCPeerConnectionHandlerTest, GetReceivers) {
+  std::vector<blink::WebMediaStream> remote_streams;
+
+  pc_handler_->observer()->OnAddStream(
+      AddRemoteMockMediaStream("stream0", "video0", "audio0"));
+  base::RunLoop().RunUntilIdle();
+  remote_streams.push_back(mock_client_->remote_stream());
+  pc_handler_->observer()->OnAddStream(
+      AddRemoteMockMediaStream("stream1", "video1", "audio1"));
+  base::RunLoop().RunUntilIdle();
+  remote_streams.push_back(mock_client_->remote_stream());
+  pc_handler_->observer()->OnAddStream(
+      AddRemoteMockMediaStream("stream2", "video2", "audio2"));
+  base::RunLoop().RunUntilIdle();
+  remote_streams.push_back(mock_client_->remote_stream());
+
+  std::set<std::string> expected_remote_track_ids;
+  expected_remote_track_ids.insert("video0");
+  expected_remote_track_ids.insert("audio0");
+  expected_remote_track_ids.insert("video1");
+  expected_remote_track_ids.insert("audio1");
+  expected_remote_track_ids.insert("video2");
+  expected_remote_track_ids.insert("audio2");
+
+  std::set<std::string> remote_track_ids;
+  for (const auto& remote_stream : remote_streams) {
+    blink::WebVector<blink::WebMediaStreamTrack> tracks;
+    remote_stream.audioTracks(tracks);
+    for (const auto& audio_track : tracks) {
+      remote_track_ids.insert(audio_track.id().utf8());
+    }
+    remote_stream.videoTracks(tracks);
+    for (const auto& video_track : tracks) {
+      remote_track_ids.insert(video_track.id().utf8());
+    }
+  }
+  EXPECT_EQ(expected_remote_track_ids, remote_track_ids);
+
+  blink::WebVector<std::unique_ptr<blink::WebRTCRtpReceiver>> receivers =
+      pc_handler_->getReceivers();
+  EXPECT_EQ(remote_track_ids.size(), receivers.size());
+  std::set<uintptr_t> receiver_ids;
+  std::set<std::string> receiver_track_ids;
+  for (const auto& receiver : receivers) {
+    receiver_ids.insert(receiver->id());
+    receiver_track_ids.insert(receiver->track().id().utf8());
+  }
+  EXPECT_EQ(expected_remote_track_ids.size(), receiver_ids.size());
+  EXPECT_EQ(expected_remote_track_ids.size(), receiver_track_ids.size());
+}
+
 TEST_F(RTCPeerConnectionHandlerTest, OnSignalingChange) {
   testing::InSequence sequence;
 
   webrtc::PeerConnectionInterface::SignalingState new_state =
       webrtc::PeerConnectionInterface::kHaveRemoteOffer;
   EXPECT_CALL(*mock_tracker_.get(), TrackSignalingStateChange(
       pc_handler_.get(),
       WebRTCPeerConnectionHandlerClient::SignalingStateHaveRemoteOffer));
   EXPECT_CALL(*mock_client_.get(), didChangeSignalingState(
       WebRTCPeerConnectionHandlerClient::SignalingStateHaveRemoteOffer));
@@ skipping 416 matching lines @@
                                     testing::Ref(tracks[0])));
 
   std::unique_ptr<blink::WebRTCDTMFSenderHandler> sender(
       pc_handler_->createDTMFSender(tracks[0]));
   EXPECT_TRUE(sender.get());
 
   StopAllTracks(local_stream);
 }
 
 }  // namespace content