Add PeerConnectionObserver#onRemoveTrack to android sdk

webrtc/sdk/android/instrumentationtests/src/org/webrtc/PeerConnectionTest.java

Index: webrtc/sdk/android/instrumentationtests/src/org/webrtc/PeerConnectionTest.java
diff --git a/webrtc/sdk/android/instrumentationtests/src/org/webrtc/PeerConnectionTest.java b/webrtc/sdk/android/instrumentationtests/src/org/webrtc/PeerConnectionTest.java
index 699c7de20579b19951e1c5189bb35e46579c32cb..62190640a31fa58c7e59d04219a1d59fb5d637f9 100644
--- a/webrtc/sdk/android/instrumentationtests/src/org/webrtc/PeerConnectionTest.java
+++ b/webrtc/sdk/android/instrumentationtests/src/org/webrtc/PeerConnectionTest.java
@@ -64,6 +64,7 @@ public class PeerConnectionTest {
     private int expectedHeight = 0;
     private int expectedFramesDelivered = 0;
     private int expectedTracksAdded = 0;
+    private int expectedTracksRemoved = 0;
     private LinkedList<SignalingState> expectedSignalingChanges = new LinkedList<SignalingState>();
     private LinkedList<IceConnectionState> expectedIceConnectionChanges =
         new LinkedList<IceConnectionState>();
@@ -72,8 +73,8 @@ public class PeerConnectionTest {
     private LinkedList<String> expectedAddStreamLabels = new LinkedList<String>();
     private LinkedList<String> expectedRemoveStreamLabels = new LinkedList<String>();
     private final LinkedList<IceCandidate> gotIceCandidates = new LinkedList<IceCandidate>();
-    private Map<MediaStream, WeakReference<VideoRenderer>> renderers =
-        new IdentityHashMap<MediaStream, WeakReference<VideoRenderer>>();
+    private Map<VideoTrack, WeakReference<VideoRenderer>> renderers =
+        new IdentityHashMap<VideoTrack, WeakReference<VideoRenderer>>();
     private DataChannel dataChannel;
     private LinkedList<DataChannel.Buffer> expectedBuffers = new LinkedList<DataChannel.Buffer>();
     private LinkedList<DataChannel.State> expectedStateChanges =
@@ -198,9 +199,6 @@ public class PeerConnectionTest {
       assertTrue(stream.audioTracks.get(0).id().endsWith("AudioTrack"));
       assertEquals("video", stream.videoTracks.get(0).kind());
       assertEquals("audio", stream.audioTracks.get(0).kind());
-      VideoRenderer renderer = createVideoRenderer(this);
-      stream.videoTracks.get(0).addRenderer(renderer);
-      assertNull(renderers.put(stream, new WeakReference<VideoRenderer>(renderer)));
       gotRemoteStreams.add(stream);
     }
 
@@ -211,11 +209,7 @@ public class PeerConnectionTest {
     @Override
     public synchronized void onRemoveStream(MediaStream stream) {
       assertEquals(expectedRemoveStreamLabels.removeFirst(), stream.label());
-      WeakReference<VideoRenderer> renderer = renderers.remove(stream);
-      assertNotNull(renderer);
-      assertNotNull(renderer.get());
-      assertEquals(1, stream.videoTracks.size());
-      stream.videoTracks.get(0).removeRenderer(renderer.get());
+      assertEquals(0, stream.videoTracks.size());
       gotRemoteStreams.remove(stream);
     }
 
@@ -243,9 +237,31 @@ public class PeerConnectionTest {
       this.expectedTracksAdded = expectedTracksAdded;
     }
 
+    public synchronized void expectRemoveTrack(int expectedTracksRemove) {
+      this.expectedTracksRemoved = expectedTracksRemove;
+    }
+
     @Override
     public synchronized void onAddTrack(RtpReceiver receiver, MediaStream[] mediaStreams) {
       expectedTracksAdded--;
+      if (receiver.track() instanceof VideoTrack) {
+        VideoTrack vt = (VideoTrack) receiver.track();
+        VideoRenderer renderer = createVideoRenderer(this);
+        vt.addRenderer(renderer);
+        assertNull(renderers.put(vt, new WeakReference<VideoRenderer>(renderer)));
+      }
+    }
+
+    @Override
+    public void onRemoveTrack(RtpReceiver receiver, MediaStream[] mediaStreams) {
+      expectedTracksRemoved--;
+      if (receiver.track() instanceof VideoTrack) {
+        VideoTrack vt = (VideoTrack) receiver.track();
+        WeakReference<VideoRenderer> renderer = renderers.remove(vt);
+        assertNotNull(renderer);
+        assertNotNull(renderer.get());
+        vt.removeRenderer(renderer.get());
+      }
     }
 
     public synchronized void expectMessage(ByteBuffer expectedBuffer, boolean expectedBinary) {
@@ -379,6 +395,9 @@ public class PeerConnectionTest {
       if (expectedTracksAdded != 0) {
         stillWaitingForExpectations.add("expectedAddedTrack: " + expectedTracksAdded);
       }
+      if (expectedTracksRemoved != 0) {
+        stillWaitingForExpectations.add("expectedTracksRemoved: " + expectedTracksRemoved);
+      }
       return stillWaitingForExpectations;
     }
 
@@ -1122,35 +1141,40 @@ public class PeerConnectionTest {
     VideoTrack offererVideoTrack = oLMS.get().videoTracks.get(0);
     // Note that when we call removeTrack, we regain responsibility for
     // disposing of the track.
+    offeringExpectations.expectRenegotiationNeeded();
+    answeringExpectations.expectRemoveTrack(1);
     oLMS.get().removeTrack(offererVideoTrack);
     negotiate(offeringPC, offeringExpectations, answeringPC, answeringExpectations);
 
     // Make sure the track was really removed.
-    // TODO(deadbeef): Currently the expectation is that the video track's
-    // state will be set to "ended". However, in the future, it's likely that
-    // the video track will be completely removed from the remote stream
-    // (as it is on the C++ level).
     MediaStream aRMS = answeringExpectations.gotRemoteStreams.iterator().next();
-    assertEquals(aRMS.videoTracks.get(0).state(), MediaStreamTrack.State.ENDED);
+    assertEquals(0, aRMS.videoTracks.size());
 
     // Add the video track to test if the answeringPC will create a new track
     // for the updated remote description.
+    offeringExpectations.expectRenegotiationNeeded();
     oLMS.get().addTrack(offererVideoTrack);
     // The answeringPC sets the updated remote description with a track added.
     // So the onAddTrack callback is expected to be called once.
     answeringExpectations.expectAddTrack(1);
     offeringExpectations.expectAddTrack(0);
     negotiate(offeringPC, offeringExpectations, answeringPC, answeringExpectations);
+    assertEquals(1, aRMS.videoTracks.size());
 
     // Finally, remove both the audio and video tracks, which should completely
     // remove the remote stream. This used to trigger an assert.
     // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5128
+    offeringExpectations.expectRenegotiationNeeded();
     oLMS.get().removeTrack(offererVideoTrack);
     AudioTrack offererAudioTrack = oLMS.get().audioTracks.get(0);
+    offeringExpectations.expectRenegotiationNeeded();
     oLMS.get().removeTrack(offererAudioTrack);
 
     answeringExpectations.expectRemoveStream("offeredMediaStream");
+    answeringExpectations.expectRemoveTrack(2);
     negotiate(offeringPC, offeringExpectations, answeringPC, answeringExpectations);
+    assertEquals(0, aRMS.videoTracks.size());
+    assertEquals(0, aRMS.audioTracks.size());
 
     // Make sure the stream was really removed.
     assertTrue(answeringExpectations.gotRemoteStreams.isEmpty());