Refactor stopCapture to be asynchronous in VideoCapturerAndroid.

webrtc/api/androidtests/src/org/webrtc/CameraVideoCapturerTestFixtures.java

 /*
  *  Copyright 2015 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.
  */
 package org.webrtc;
@@ skipping 384 matching lines @@
   private void createCapturerAndRender(String name) throws InterruptedException {
     if (name == null) {
       Logging.w(TAG, "Skipping video capturer test because device name is null.");
       return;
     }
 
     final CapturerInstance capturerInstance = createCapturer(name, false /* initialize */);
     final VideoTrackWithRenderer videoTrackWithRenderer =
         createVideoTrackWithRenderer(capturerInstance.capturer);
     assertTrue(videoTrackWithRenderer.rendererCallbacks.waitForNextFrameToRender() > 0);
+    disposeCapturer(capturerInstance);
     disposeVideoTrackWithRenderer(videoTrackWithRenderer);
-    disposeCapturer(capturerInstance);
   }
 
   // Test methods
   public void createCapturerAndDispose() {
     disposeCapturer(createCapturer(true /* initialize */));
   }
 
   public void createNonExistingCamera() {
     try {
       disposeCapturer(createCapturer("non-existing camera", false /* initialize */));
@@ skipping 42 matching lines @@
         barrier.countDown();
       }
     });
     // Wait until the camera has been switched.
     barrier.await();
 
     // Check result.
     assertTrue(cameraSwitchSuccessful[0]);
     // Ensure that frames are received.
     assertTrue(videoTrackWithRenderer.rendererCallbacks.waitForNextFrameToRender() > 0);
+    disposeCapturer(capturerInstance);
     disposeVideoTrackWithRenderer(videoTrackWithRenderer);
-    disposeCapturer(capturerInstance);
   }
 
   public void cameraEventsInvoked() throws InterruptedException {
     final CapturerInstance capturerInstance = createCapturer(true /* initialize */);
     startCapture(capturerInstance);
     // Make sure camera is started and first frame is received and then stop it.
     assertTrue(capturerInstance.observer.waitForCapturerToStart());
     capturerInstance.observer.waitForNextCapturedFrame();
     capturerInstance.capturer.stopCapture();
     disposeCapturer(capturerInstance);
@@ skipping 26 matching lines @@
     assertTrue(videoTrackWithRenderer.rendererCallbacks.waitForNextFrameToRender() > 0);
     assertEquals(MediaSource.State.LIVE, videoTrackWithRenderer.source.state());
 
     videoTrackWithRenderer.source.stop();
     assertEquals(MediaSource.State.ENDED, videoTrackWithRenderer.source.state());
 
     videoTrackWithRenderer.source.restart();
     assertTrue(videoTrackWithRenderer.rendererCallbacks.waitForNextFrameToRender() > 0);
     assertEquals(MediaSource.State.LIVE, videoTrackWithRenderer.source.state());
 
+    disposeCapturer(capturerInstance);
     disposeVideoTrackWithRenderer(videoTrackWithRenderer);
-    disposeCapturer(capturerInstance);
   }
 
   public void startStopWithDifferentResolutions() throws InterruptedException {
     final CapturerInstance capturerInstance = createCapturer(true /* initialize */);
 
     for(int i = 0; i < 3 ; ++i) {
       startCapture(capturerInstance, i);
       assertTrue(capturerInstance.observer.waitForCapturerToStart());
       capturerInstance.observer.waitForNextCapturedFrame();
 
@@ skipping 49 matching lines @@
       throws InterruptedException {
     final CapturerInstance capturerInstance = createCapturer(false /* initialize */);
     final VideoTrackWithRenderer videoTrackWithRenderer =
         createVideoTrackWithFakeAsyncRenderer(capturerInstance.capturer);
     // Wait for at least one frame that has not been returned.
     assertFalse(videoTrackWithRenderer.fakeAsyncRenderer.waitForPendingFrames().isEmpty());
 
     capturerInstance.capturer.stopCapture();
 
     // Dispose everything.
+    disposeCapturer(capturerInstance);
     disposeVideoTrackWithRenderer(videoTrackWithRenderer);
-    disposeCapturer(capturerInstance);
 
     // Return the frame(s), on a different thread out of spite.
     final List<I420Frame> pendingFrames =
         videoTrackWithRenderer.fakeAsyncRenderer.waitForPendingFrames();
     final Thread returnThread = new Thread(new Runnable() {
       @Override
       public void run() {
         for (I420Frame frame : pendingFrames) {
           VideoRenderer.renderFrameDone(frame);
         }
@@ skipping 36 matching lines @@
     int numberOfInspectedFrames = 0;
 
     do {
       videoTrackWithRenderer.rendererCallbacks.waitForNextFrameToRender();
       ++numberOfInspectedFrames;
 
       gotExpectedResolution = (videoTrackWithRenderer.rendererCallbacks.frameWidth() == scaledWidth
           &&  videoTrackWithRenderer.rendererCallbacks.frameHeight() == scaledHeight);
     } while (!gotExpectedResolution && numberOfInspectedFrames < 30);
 
+    disposeCapturer(capturerInstance);
     disposeVideoTrackWithRenderer(videoTrackWithRenderer);
-    disposeCapturer(capturerInstance);
 
     assertTrue(gotExpectedResolution);
   }
 
   public void startWhileCameraIsAlreadyOpen() throws InterruptedException {
     final String cameraName = testObjectFactory.getNameOfBackFacingDevice();
     // At this point camera is not actually opened.
     final CapturerInstance capturerInstance = createCapturer(cameraName, true /* initialize */);
 
     final Object competingCamera = testObjectFactory.rawOpenCamera(cameraName);
@@ skipping 44 matching lines @@
     final Object competingCamera = testObjectFactory.rawOpenCamera(cameraName);
 
     startCapture(capturerInstance);
 
     capturerInstance.capturer.stopCapture();
     disposeCapturer(capturerInstance);
 
     testObjectFactory.rawCloseCamera(competingCamera);
   }
 }