Java VideoRenderer.Callbacks: Make renderFrame() interface asynchronous

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

 /*
  * libjingle
  * Copyright 2015 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 30 matching lines @@
   static class RendererCallbacks implements VideoRenderer.Callbacks {
     private int framesRendered = 0;
     private Object frameLock = 0;
 
     @Override
     public void renderFrame(I420Frame frame) {
       synchronized (frameLock) {
         ++framesRendered;
         frameLock.notify();
       }
+      VideoRenderer.renderFrameDone(frame);
     }
 
     public int WaitForNextFrameToRender() throws InterruptedException {
       synchronized (frameLock) {
         frameLock.wait();
         return framesRendered;
       }
     }
   }
 
+  static class AsyncRenderer implements VideoRenderer.Callbacks {
+    private final List<I420Frame> pendingFrames = new ArrayList<I420Frame>();
+
+    @Override
+    public void renderFrame(I420Frame frame) {
+      synchronized (pendingFrames) {
+        pendingFrames.add(frame);
+        pendingFrames.notifyAll();
+      }
+    }
+
+    // Wait until at least one frame have been received, before returning them.
+    public List<I420Frame> WaitForFrames() {
+      synchronized (pendingFrames) {
+        while (pendingFrames.isEmpty()) {
+          try {
+            pendingFrames.wait();
+          } catch (InterruptedException e) {
+            // Ignore.
+          }
+        }
+        final List<I420Frame> frames = new ArrayList<I420Frame>(pendingFrames);
+        pendingFrames.clear();
+        return frames;
+      }
+    }
+  }
+
   static class FakeCapturerObserver implements
       VideoCapturerAndroid.CapturerObserver {
     private int framesCaptured = 0;
     private int frameSize = 0;
     private Object frameLock = 0;
     private Object capturerStartLock = 0;
     private boolean captureStartResult = false;
     private List<Long> timestamps = new ArrayList<Long>();
 
     @Override
@@ skipping 228 matching lines @@
 
     observer.WaitForNextCapturedFrame();
     capturer.stopCapture();
 
     listOftimestamps = observer.getCopyAndResetListOftimeStamps();
     assertTrue(listOftimestamps.size() >= 2);
     for (Long timeStamp : listOftimestamps) {
       capturer.returnBuffer(timeStamp);
     }
   }
+
+  @SmallTest
+  // This test that we can capture frames, stop capturing, keep the frames for rendering, and then
+  // return the frames. It tests both the Java and the C++ layer.
+  public void testCaptureAndAsyncRender() {
+    final VideoCapturerAndroid capturer = VideoCapturerAndroid.create("", null);
+    // Helper class that sets everything up, captures at least one frame, and then shuts
+    // everything down.
+    class CaptureFramesRunnable implements Runnable {
+      public List<I420Frame> frames;
+
+      @Override
+      public void run() {
+        PeerConnectionFactory factory = new PeerConnectionFactory();
+        VideoSource source = factory.createVideoSource(capturer, new MediaConstraints());
+        VideoTrack track = factory.createVideoTrack("dummy", source);
+        AsyncRenderer renderer = new AsyncRenderer();
+        track.addRenderer(new VideoRenderer(renderer));
+
+        // Wait until we get at least one frame.
+        frames = renderer.WaitForFrames();
+
+        // Stop everything.
+        track.dispose();
+        source.dispose();
+        factory.dispose();
+      }
+    }
+
+    // Capture frames on a separate thread.
+    CaptureFramesRunnable captureFramesRunnable = new CaptureFramesRunnable();
+    Thread captureThread = new Thread(captureFramesRunnable);
+    captureThread.start();
+
+    // Wait until frames are captured, and then kill the thread.
+    try {
+      captureThread.join();
+    } catch (InterruptedException e) {
+      fail("Capture thread was interrupted");
+    }
+    captureThread = null;
+
+    // Assert that we have frames that have not been returned.
+    assertTrue(!captureFramesRunnable.frames.isEmpty());
+    // Return the frame(s).
+    for (I420Frame frame : captureFramesRunnable.frames) {
+      VideoRenderer.renderFrameDone(frame);
+    }
+    assertEquals(capturer.pendingFramesTimeStamps(), "[]");
+  }
 }