Added implementation of RemoteMediaStreams.

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 <string>
+#include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/renderer/media/media_stream_extra_data.h"
 #include "content/renderer/media/mock_media_stream_dependency_factory.h"
 #include "content/renderer/media/mock_peer_connection_impl.h"
 #include "content/renderer/media/mock_web_rtc_peer_connection_handler_client.h"
 #include "content/renderer/media/peer_connection_tracker.h"
 #include "content/renderer/media/rtc_media_constraints.h"
@@ skipping 631 matching lines @@
                         UTF8ToUTF16(remote_stream_label)),
       PeerConnectionTracker::SOURCE_REMOTE));
   EXPECT_CALL(*mock_client_.get(), didRemoveRemoteStream(
       testing::Property(&WebKit::WebMediaStream::label,
                         UTF8ToUTF16(remote_stream_label))));
 
   pc_handler_->OnAddStream(remote_stream);
   pc_handler_->OnRemoveStream(remote_stream);
 }
 
+// This test that WebKit is notified about remote track state changes.
+TEST_F(RTCPeerConnectionHandlerTest, RemoteTrackState) {
+  std::string remote_stream_label("remote_stream");
+  scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
+      AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
+
+  testing::InSequence sequence;
+  EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
+      testing::Property(&WebKit::WebMediaStream::label,
+                        UTF8ToUTF16(remote_stream_label))));
+  pc_handler_->OnAddStream(remote_stream);
+  const WebKit::WebMediaStream& webkit_stream = mock_client_->remote_stream();
+
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> audio_tracks;
+  webkit_stream.audioTracks(audio_tracks);
+  EXPECT_EQ(WebKit::WebMediaStreamSource::ReadyStateLive,
+            audio_tracks[0].source().readyState());
+
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> video_tracks;
+    webkit_stream.videoTracks(video_tracks);
+  EXPECT_EQ(WebKit::WebMediaStreamSource::ReadyStateLive,
+            video_tracks[0].source().readyState());
+
+  remote_stream->GetAudioTracks()[0]->set_state(
+      webrtc::MediaStreamTrackInterface::kEnded);
+  EXPECT_EQ(WebKit::WebMediaStreamSource::ReadyStateEnded,
+            audio_tracks[0].source().readyState());
+
+  remote_stream->GetVideoTracks()[0]->set_state(
+      webrtc::MediaStreamTrackInterface::kEnded);
+  EXPECT_EQ(WebKit::WebMediaStreamSource::ReadyStateEnded,
+            video_tracks[0].source().readyState());
+}
+
+TEST_F(RTCPeerConnectionHandlerTest, RemoveAndAddAudioTrackFromRemoteStream) {
+  std::string remote_stream_label("remote_stream");
+  scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
+      AddRemoteMockMediaStream(remote_stream_label, "video", "audio"));
+
+  EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
+      testing::Property(&WebKit::WebMediaStream::label,
+                        UTF8ToUTF16(remote_stream_label))));
+  pc_handler_->OnAddStream(remote_stream);
+  const WebKit::WebMediaStream& webkit_stream = mock_client_->remote_stream();
+
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> audio_tracks;
+  webkit_stream.audioTracks(audio_tracks);
+  EXPECT_EQ(1u, audio_tracks.size());
+
+  // Remove the Webrtc audio track from the Webrtc MediaStream.
+  scoped_refptr<webrtc::AudioTrackInterface> webrtc_track =
+      remote_stream->GetAudioTracks()[0].get();
+  remote_stream->RemoveTrack(webrtc_track);
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> modified_audio_tracks1;
+  webkit_stream.audioTracks(modified_audio_tracks1);
+  EXPECT_EQ(0u, modified_audio_tracks1.size());
+
+  // Add the WebRtc audio track again.
+  remote_stream->AddTrack(webrtc_track);
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> modified_audio_tracks2;
+  webkit_stream.audioTracks(modified_audio_tracks2);
+  EXPECT_EQ(1u, modified_audio_tracks2.size());
+}
+
+TEST_F(RTCPeerConnectionHandlerTest, RemoveAndAddVideoTrackFromRemoteStream) {
+  std::string remote_stream_label("remote_stream");
+  scoped_refptr<webrtc::MediaStreamInterface> remote_stream(
+      AddRemoteMockMediaStream(remote_stream_label, "video", "video"));
+
+  EXPECT_CALL(*mock_client_.get(), didAddRemoteStream(
+      testing::Property(&WebKit::WebMediaStream::label,
+                        UTF8ToUTF16(remote_stream_label))));
+  pc_handler_->OnAddStream(remote_stream);
+  const WebKit::WebMediaStream& webkit_stream = mock_client_->remote_stream();
+
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> video_tracks;
+  webkit_stream.videoTracks(video_tracks);
+  EXPECT_EQ(1u, video_tracks.size());
+
+  // Remove the Webrtc video track from the Webrtc MediaStream.
+  scoped_refptr<webrtc::VideoTrackInterface> webrtc_track =
+      remote_stream->GetVideoTracks()[0].get();
+  remote_stream->RemoveTrack(webrtc_track);
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> modified_video_tracks1;
+  webkit_stream.videoTracks(modified_video_tracks1);
+  EXPECT_EQ(0u, modified_video_tracks1.size());
+
+  // Add the WebRtc video track again.
+  remote_stream->AddTrack(webrtc_track);
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> modified_video_tracks2;
+  webkit_stream.videoTracks(modified_video_tracks2);
+  EXPECT_EQ(1u, modified_video_tracks2.size());
+}
+
 TEST_F(RTCPeerConnectionHandlerTest, OnIceCandidate) {
   testing::InSequence sequence;
   EXPECT_CALL(*mock_tracker_.get(),
               TrackAddIceCandidate(pc_handler_.get(), _,
                                    PeerConnectionTracker::SOURCE_LOCAL));
   EXPECT_CALL(*mock_client_.get(), didGenerateICECandidate(_));
 
   scoped_ptr<webrtc::IceCandidateInterface> native_candidate(
       mock_dependency_factory_->CreateIceCandidate("mid", 1, kDummySdp));
   pc_handler_->OnIceCandidate(native_candidate.get());
@@ skipping 40 matching lines @@
   EXPECT_CALL(*mock_tracker_.get(),
               TrackCreateDTMFSender(pc_handler_.get(),
                                     testing::Ref(tracks[0])));
 
   scoped_ptr<WebKit::WebRTCDTMFSenderHandler> sender(
       pc_handler_->createDTMFSender(tracks[0]));
   EXPECT_TRUE(sender.get());
 }
 
 }  // namespace content