Call java SurfaceTextureHelper.dispose from the corresponding C++ destructor.

webrtc/base/java/src/org/webrtc/ThreadUtils.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.
  */
 
@@ skipping 121 matching lines @@
     // Pass interruption information along.
     if (wasInterrupted) {
       Thread.currentThread().interrupt();
     }
     return result;
   }
 
   /**
    * Post |callable| to |handler| and wait for the result.
    */
-  public static <V> V invokeUninterruptibly(final Handler handler, final Callable<V> callable) {
+  public static <V> V invokeAtFrontUninterruptibly(
+      final Handler handler, final Callable<V> callable) {
+    if (handler.getLooper().getThread() == Thread.currentThread()) {
+      V value;
+      try {
+        value = callable.call();
+      } catch (Exception e) {
+        final RuntimeException runtimeException =
+            new RuntimeException("Callable threw exception: " + e);
+        runtimeException.setStackTrace(e.getStackTrace());
+        throw runtimeException;
+      }
+      return value;
+    }
     class Result {
       public V value;
     }
     final Result result = new Result();
     final CountDownLatch barrier = new CountDownLatch(1);
     handler.post(new Runnable() {
       @Override public void run() {
         try {
           result.value = callable.call();
         } catch (Exception e) {
           final RuntimeException runtimeException =
               new RuntimeException("Callable threw exception: " + e);
           runtimeException.setStackTrace(e.getStackTrace());
           throw runtimeException;
         }
         barrier.countDown();
       }
     });
     awaitUninterruptibly(barrier);
     return result.value;
   }
 
   /**
-   * Post |runner| to |handler| and wait for the result.
+   * Post |runner| to |handler|, at the front, and wait for
+   * completion.
    */
-  public static void invokeUninterruptibly(final Handler handler, final Runnable runner) {
+  public static void invokeAtFrontUninterruptibly(final Handler handler, final Runnable runner) {
+    if (handler.getLooper().getThread() == Thread.currentThread()) {
+      runner.run();
+      return;
+    }
     final CountDownLatch barrier = new CountDownLatch(1);
-    handler.post(new Runnable() {
-      @Override public void run() {
-          runner.run();
+    handler.postAtFrontOfQueue(new Runnable() {
+      @Override
+      public void run() {
+        runner.run();
         barrier.countDown();
       }
     });
     awaitUninterruptibly(barrier);
   }
 }