Add PeerConnectionObserver#onRemoveTrack to android sdk

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

 /*
  *  Copyright 2013 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.
  */
 
@@ skipping 46 matching lines @@
       implements PeerConnection.Observer, VideoRenderer.Callbacks, DataChannel.Observer,
                  StatsObserver, RTCStatsCollectorCallback, RtpReceiver.Observer {
     private final String name;
     private int expectedIceCandidates = 0;
     private int expectedErrors = 0;
     private int expectedRenegotiations = 0;
     private int expectedWidth = 0;
     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>();
     private LinkedList<IceGatheringState> expectedIceGatheringChanges =
         new LinkedList<IceGatheringState>();
     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 =
         new LinkedList<DataChannel.State>();
     private LinkedList<String> expectedRemoteDataChannelLabels = new LinkedList<String>();
     private int expectedOldStatsCallbacks = 0;
     private int expectedNewStatsCallbacks = 0;
     private LinkedList<StatsReport[]> gotStatsReports = new LinkedList<StatsReport[]>();
     private final HashSet<MediaStream> gotRemoteStreams = new HashSet<MediaStream>();
     private int expectedFirstAudioPacket = 0;
@@ skipping 104 matching lines @@
 
     @Override
     public synchronized void onAddStream(MediaStream stream) {
       assertEquals(expectedAddStreamLabels.removeFirst(), stream.label());
       assertEquals(1, stream.videoTracks.size());
       assertEquals(1, stream.audioTracks.size());
       assertTrue(stream.videoTracks.get(0).id().endsWith("VideoTrack"));
       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);
     }
 
     public synchronized void expectRemoveStream(String label) {
       expectedRemoveStreamLabels.add(label);
     }
 
     @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);
     }
 
     public synchronized void expectDataChannel(String label) {
       expectedRemoteDataChannelLabels.add(label);
     }
 
     @Override
     public synchronized void onDataChannel(DataChannel remoteDataChannel) {
       assertEquals(expectedRemoteDataChannelLabels.removeFirst(), remoteDataChannel.label());
       setDataChannel(remoteDataChannel);
       assertEquals(DataChannel.State.CONNECTING, dataChannel.state());
     }
 
     public synchronized void expectRenegotiationNeeded() {
       ++expectedRenegotiations;
     }
 
     @Override
     public synchronized void onRenegotiationNeeded() {
       assertTrue(--expectedRenegotiations >= 0);
     }
 
     public synchronized void expectAddTrack(int expectedTracksAdded) {
       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) {
       expectedBuffers.add(new DataChannel.Buffer(expectedBuffer, expectedBinary));
     }
 
     @Override
     public synchronized void onMessage(DataChannel.Buffer buffer) {
       DataChannel.Buffer expected = expectedBuffers.removeFirst();
       assertEquals(expected.binary, buffer.binary);
@@ skipping 113 matching lines @@
       }
       if (expectedFirstAudioPacket > 0) {
         stillWaitingForExpectations.add("expectedFirstAudioPacket: " + expectedFirstAudioPacket);
       }
       if (expectedFirstVideoPacket > 0) {
         stillWaitingForExpectations.add("expectedFirstVideoPacket: " + expectedFirstVideoPacket);
       }
       if (expectedTracksAdded != 0) {
         stillWaitingForExpectations.add("expectedAddedTrack: " + expectedTracksAdded);
       }
+      if (expectedTracksRemoved != 0) {
+        stillWaitingForExpectations.add("expectedTracksRemoved: " + expectedTracksRemoved);
+      }
       return stillWaitingForExpectations;
     }
 
     public boolean waitForAllExpectationsToBeSatisfied(int timeoutSeconds) {
       // TODO(fischman): problems with this approach:
       // - come up with something better than a poll loop
       // - avoid serializing expectations explicitly; the test is not as robust
       //   as it could be because it must place expectations between wait
       //   statements very precisely (e.g. frame must not arrive before its
       //   expectation, and expectation must not be registered so early as to
@@ skipping 723 matching lines @@
 
     assertEquals(PeerConnection.SignalingState.STABLE, offeringPC.signalingState());
     assertEquals(PeerConnection.SignalingState.STABLE, answeringPC.signalingState());
 
     // Now do another negotiation, removing the video track from one peer.
     // This previously caused a crash on pc.dispose().
     // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5128
     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());
 
     // Free the Java-land objects and collect them.
     shutdownPC(offeringPC, offeringExpectations);
     offeringPC = null;
     shutdownPC(answeringPC, answeringExpectations);
     answeringPC = null;
     offererVideoTrack.dispose();
@@ skipping 109 matching lines @@
     TreeSet<String> threads = new TreeSet<String>();
     // This pokes at /proc instead of using the Java APIs because we're also
     // looking for libjingle/webrtc native threads, most of which won't have
     // attached to the JVM.
     for (String threadId : (new File("/proc/self/task")).list()) {
       threads.add(threadId);
     }
     return threads;
   }
 }