Remove Java PC support.

talk/app/webrtc/androidtests/src/org/webrtc/PeerConnectionTest.java

 /*
  * libjingle
  * Copyright 2013 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 13 matching lines @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 package org.webrtc;
 
 import org.webrtc.PeerConnection.IceConnectionState;
 import org.webrtc.PeerConnection.IceGatheringState;
 import org.webrtc.PeerConnection.SignalingState;
 
+import android.test.suitebuilder.annotation.MediumTest;
+
 import java.io.File;
 import java.lang.ref.WeakReference;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.util.Arrays;
 import java.util.IdentityHashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeSet;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
-import static junit.framework.Assert.*;
+/** End-to-end tests for PeerConnection.java. */
+import android.test.ActivityTestCase;
 
-/** End-to-end tests for PeerConnection.java. */
-public class PeerConnectionTest {
-  // Set to true to render video.
-  private static final boolean RENDER_TO_GUI = false;
+public class PeerConnectionTest extends ActivityTestCase {
   private static final int TIMEOUT_SECONDS = 20;
   private TreeSet<String> threadsBeforeTest = null;
 
+  @Override
+  protected void setUp() {
+    assertTrue(PeerConnectionFactory.initializeAndroidGlobals(
+        getInstrumentation().getContext(), true, true, true));
+  }
+
   private static class ObserverExpectations implements PeerConnection.Observer,
                                                        VideoRenderer.Callbacks,
                                                        DataChannel.Observer,
                                                        StatsObserver {
     private final String name;
     private int expectedIceCandidates = 0;
     private int expectedErrors = 0;
     private int expectedRenegotiations = 0;
     private int previouslySeenWidth = 0;
     private int previouslySeenHeight = 0;
@@ skipping 45 matching lines @@
       // We don't assert expectedIceCandidates >= 0 because it's hard to know
       // how many to expect, in general.  We only use expectIceCandidates to
       // assert a minimal count.
       synchronized (gotIceCandidates) {
         gotIceCandidates.add(candidate);
         gotIceCandidates.notifyAll();
       }
     }
 
     private synchronized void setSize(int width, int height) {
-      assertFalse(RENDER_TO_GUI);
       // Because different camera devices (fake & physical) produce different
       // resolutions, we only sanity-check the set sizes,
       assertTrue(width > 0);
       assertTrue(height > 0);
       if (previouslySeenWidth > 0) {
         assertEquals(previouslySeenWidth, width);
         assertEquals(previouslySeenHeight, height);
       } else {
         previouslySeenWidth = width;
         previouslySeenHeight = height;
       }
     }
 
     public synchronized void expectFramesDelivered(int count) {
-      assertFalse(RENDER_TO_GUI);
       expectedFramesDelivered += count;
     }
 
     @Override
     public synchronized void renderFrame(VideoRenderer.I420Frame frame) {
       setSize(frame.rotatedWidth(), frame.rotatedHeight());
       --expectedFramesDelivered;
       VideoRenderer.renderFrameDone(frame);
     }
 
@@ skipping 304 matching lines @@
 
     public String getError() {
       return error;
     }
   }
 
   static int videoWindowsMapped = -1;
 
   private static VideoRenderer createVideoRenderer(
       VideoRenderer.Callbacks videoCallbacks) {
-    if (!RENDER_TO_GUI) {
-      return new VideoRenderer(videoCallbacks);
-    }
-    ++videoWindowsMapped;
-    assertTrue(videoWindowsMapped < 4);
-    int x = videoWindowsMapped % 2 != 0 ? 700 : 0;
-    int y = videoWindowsMapped >= 2 ? 0 : 500;
-    return VideoRenderer.createGui(x, y);
+    return new VideoRenderer(videoCallbacks);
   }
 
   // Return a weak reference to test that ownership is correctly held by
   // PeerConnection, not by test code.
   private static WeakReference<MediaStream> addTracksToPC(
       PeerConnectionFactory factory, PeerConnection pc,
       VideoSource videoSource,
       String streamLabel, String videoTrackId, String audioTrackId,
       VideoRenderer.Callbacks videoCallbacks) {
     MediaStream lMS = factory.createLocalMediaStream(streamLabel);
@@ skipping 30 matching lines @@
     // 2.  before contains 3 threads that do not exist in after.
     // 3.  after contains 3 threads that do not exist in before.
     //
     // Maybe it would be better to do the thread enumeration from C++ and get
     // the thread names as well, in order to determine what these 3 threads are.
 
     // assertEquals(threadsBeforeTest, threadsAfterTest);
     // Thread.sleep(100);
   }
 
-  void doTest() throws Exception {
+  @MediumTest
+  public void testCompleteSession() throws Exception {
     // Allow loopback interfaces too since our Android devices often don't
     // have those.
     PeerConnectionFactory.Options options = new PeerConnectionFactory.Options();
     options.networkIgnoreMask = 0;
     PeerConnectionFactory factory = new PeerConnectionFactory(options);
     // Uncomment to get ALL WebRTC tracing and SENSITIVE libjingle logging.
     // NOTE: this _must_ happen while |factory| is alive!
     // Logging.enableTracing(
     //     "/tmp/PeerConnectionTest-log.txt",
     //     EnumSet.of(Logging.TraceLevel.TRACE_ALL),
@@ skipping 17 matching lines @@
 
     ObserverExpectations answeringExpectations =
         new ObserverExpectations("PCTest:answerer");
     PeerConnection answeringPC = factory.createPeerConnection(
         iceServers, pcConstraints, answeringExpectations);
     assertNotNull(answeringPC);
 
     // We want to use the same camera for offerer & answerer, so create it here
     // instead of in addTracksToPC.
     VideoSource videoSource = factory.createVideoSource(
-        VideoCapturer.create(""), new MediaConstraints());
+        VideoCapturerAndroid.create("", null), new MediaConstraints());
 
     offeringExpectations.expectRenegotiationNeeded();
     WeakReference<MediaStream> oLMS = addTracksToPC(
         factory, offeringPC, videoSource, "offeredMediaStream",
         "offeredVideoTrack", "offeredAudioTrack", offeringExpectations);
 
     offeringExpectations.expectRenegotiationNeeded();
     DataChannel offeringDC = offeringPC.createDataChannel(
         "offeringDC", new DataChannel.Init());
     assertEquals("offeringDC", offeringDC.label());
@@ skipping 73 matching lines @@
     assertEquals(offeringPC.getLocalDescription().type, offerSdp.type);
     assertEquals(offeringPC.getRemoteDescription().type, answerSdp.type);
     assertEquals(answeringPC.getLocalDescription().type, answerSdp.type);
     assertEquals(answeringPC.getRemoteDescription().type, offerSdp.type);
 
     assertEquals(offeringPC.getSenders().size(), 2);
     assertEquals(offeringPC.getReceivers().size(), 2);
     assertEquals(answeringPC.getSenders().size(), 2);
     assertEquals(answeringPC.getReceivers().size(), 2);
 
-    if (!RENDER_TO_GUI) {
-      // Wait for at least some frames to be delivered at each end (number
-      // chosen arbitrarily).
-      offeringExpectations.expectFramesDelivered(10);
-      answeringExpectations.expectFramesDelivered(10);
-    }
+
+    // Wait for at least some frames to be delivered at each end (number
+    // chosen arbitrarily).
+    offeringExpectations.expectFramesDelivered(10);
+    answeringExpectations.expectFramesDelivered(10);
 
     offeringExpectations.expectStateChange(DataChannel.State.OPEN);
     // See commentary about SCTP DataChannels above for why this is here.
     answeringExpectations.expectDataChannel("offeringDC");
     answeringExpectations.expectStateChange(DataChannel.State.OPEN);
 
     // Wait for at least one ice candidate from the offering PC and forward them to the answering
     // PC.
     for (IceCandidate candidate : offeringExpectations.getAtLeastOneIceCandidate()) {
       answeringPC.addIceCandidate(candidate);
@@ skipping 34 matching lines @@
             ByteBuffer.wrap(new byte[] { 1, 2, 3, 4, 5 }), true)));
     assertTrue(offeringExpectations.waitForAllExpectationsToBeSatisfied(TIMEOUT_SECONDS));
 
     offeringExpectations.expectStateChange(DataChannel.State.CLOSING);
     answeringExpectations.expectStateChange(DataChannel.State.CLOSING);
     offeringExpectations.expectStateChange(DataChannel.State.CLOSED);
     answeringExpectations.expectStateChange(DataChannel.State.CLOSED);
     answeringExpectations.dataChannel.close();
     offeringExpectations.dataChannel.close();
 
-    if (RENDER_TO_GUI) {
-      try {
-        Thread.sleep(3000);
-      } catch (Throwable t) {
-        throw new RuntimeException(t);
-      }
-    }
-
     // TODO(fischman) MOAR test ideas:
     // - Test that PC.removeStream() works; requires a second
     //   createOffer/createAnswer dance.
     // - audit each place that uses |constraints| for specifying non-trivial
     //   constraints (and ensure they're honored).
     // - test error cases
     // - ensure reasonable coverage of _jni.cc is achieved.  Coverage is
     //   extra-important because of all the free-text (class/method names, etc)
     //   in JNI-style programming; make sure no typos!
     // - Test that shutdown mid-interaction is crash-free.
@@ skipping 44 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;
   }
 }