Fix CronetUrlRequestTest#testFailures flake

components/cronet/android/test/javatests/src/org/chromium/net/TestUrlRequestCallback.java

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.net;
 
 import android.os.ConditionVariable;
 import android.os.StrictMode;
 
 import static junit.framework.Assert.assertEquals;
 import static junit.framework.Assert.assertFalse;
 import static junit.framework.Assert.assertNotNull;
 import static junit.framework.Assert.assertNull;
 import static junit.framework.Assert.assertTrue;
 
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Callback that tracks information from different callbacks and and has a
  * method to block thread until the request completes on another thread.
  * Allows to cancel, block request or throw an exception from an arbitrary step.
  */
 class TestUrlRequestCallback extends UrlRequest.Callback {
     public ArrayList<UrlResponseInfo> mRedirectResponseInfoList = new ArrayList<UrlResponseInfo>();
     public ArrayList<String> mRedirectUrlList = new ArrayList<String>();
     public UrlResponseInfo mResponseInfo;
     public UrlRequestException mError;
 
     public ResponseStep mResponseStep = ResponseStep.NOTHING;
 
     public int mRedirectCount = 0;
     public boolean mOnErrorCalled = false;
     public boolean mOnCanceledCalled = false;
 
     public int mHttpResponseDataLength = 0;
     public String mResponseAsString = "";
 
     private static final int READ_BUFFER_SIZE = 32 * 1024;
 
     // When false, the consumer is responsible for all calls into the request
     // that advance it.
     private boolean mAutoAdvance = true;
+    // Whether an exception is thrown by maybeThrowCancelOrPause().
+    private boolean mListenerExceptionThrown;
 
     // Conditionally fail on certain steps.
     private FailureType mFailureType = FailureType.NONE;
     private ResponseStep mFailureStep = ResponseStep.NOTHING;
 
     // Signals when request is done either successfully or not.
     private final ConditionVariable mDone = new ConditionVariable();
 
     // Signaled on each step when mAutoAdvance is false.
     private final ConditionVariable mStepBlock = new ConditionVariable();
@@ skipping 26 matching lines @@
             });
             return mExecutorThread;
         }
     }
 
     public enum ResponseStep {
         NOTHING,
         ON_RECEIVED_REDIRECT,
         ON_RESPONSE_STARTED,
         ON_READ_COMPLETED,
-        ON_SUCCEEDED
+        ON_SUCCEEDED,
+        ON_FAILED,
+        ON_CANCELED,
     }
 
     public enum FailureType {
         NONE,
         CANCEL_SYNC,
         CANCEL_ASYNC,
         // Same as above, but continues to advance the request after posting
         // the cancellation task.
         CANCEL_ASYNC_WITHOUT_PAUSE,
         THROW_SYNC
@@ skipping 18 matching lines @@
     }
 
     public Executor getExecutor() {
         return mExecutorService;
     }
 
     public void shutdownExecutor() {
         mExecutorService.shutdown();
     }
 
+    /**
+     * Shuts down the ExecutorService and waits until it executes all posted
+     * tasks.
+     */
+    public void shutdownExecutorAndWait() {
+        mExecutorService.shutdown();
+        try {
+            // Termination shouldn't take long. Use 1 min which should be more than enough.
+            mExecutorService.awaitTermination(1, TimeUnit.MINUTES);
+        } catch (InterruptedException e) {
+            assertTrue("ExecutorService is interrupted while waiting for termination", false);
+        }
+        assertTrue(mExecutorService.isTerminated());
+    }
+
     @Override
     public void onRedirectReceived(
             UrlRequest request, UrlResponseInfo info, String newLocationUrl) {
         assertEquals(mExecutorThread, Thread.currentThread());
         assertFalse(request.isDone());
         assertTrue(mResponseStep == ResponseStep.NOTHING
                 || mResponseStep == ResponseStep.ON_RECEIVED_REDIRECT);
         assertNull(mError);
 
         mResponseStep = ResponseStep.ON_RECEIVED_REDIRECT;
@@ skipping 68 matching lines @@
     @Override
     public void onFailed(UrlRequest request, UrlResponseInfo info, UrlRequestException error) {
         assertEquals(mExecutorThread, Thread.currentThread());
         assertTrue(request.isDone());
         // Shouldn't happen after success.
         assertTrue(mResponseStep != ResponseStep.ON_SUCCEEDED);
         // Should happen at most once for a single request.
         assertFalse(mOnErrorCalled);
         assertFalse(mOnCanceledCalled);
         assertNull(mError);
-        if (mFailureType == FailureType.THROW_SYNC) {
+        if (mListenerExceptionThrown) {
             assertEquals(UrlRequestError.LISTENER_EXCEPTION_THROWN, error.getErrorCode());
             assertEquals(0, error.getCronetInternalErrorCode());
             assertEquals("Exception received from UrlRequest.Callback", error.getMessage());
             assertNotNull(error.getCause());
             assertTrue(error.getCause() instanceof IllegalStateException);
             assertEquals("Listener Exception.", error.getCause().getMessage());
             assertFalse(error.immediatelyRetryable());
         }
 
+        mResponseStep = ResponseStep.ON_FAILED;
         mOnErrorCalled = true;
         mError = error;
         openDone();
         maybeThrowCancelOrPause(request);
     }
 
     @Override
     public void onCanceled(UrlRequest request, UrlResponseInfo info) {
         assertEquals(mExecutorThread, Thread.currentThread());
         assertTrue(request.isDone());
         // Should happen at most once for a single request.
         assertFalse(mOnCanceledCalled);
         assertFalse(mOnErrorCalled);
         assertNull(mError);
 
+        mResponseStep = ResponseStep.ON_CANCELED;
         mOnCanceledCalled = true;
         openDone();
         maybeThrowCancelOrPause(request);
     }
 
     public void startNextRead(UrlRequest request) {
         startNextRead(request, ByteBuffer.allocateDirect(READ_BUFFER_SIZE));
     }
 
     public void startNextRead(UrlRequest request, ByteBuffer buffer) {
@@ skipping 10 matching lines @@
 
     protected void openDone() {
         mDone.open();
     }
 
     /**
      * Returns {@code false} if the listener should continue to advance the
      * request.
      */
     private boolean maybeThrowCancelOrPause(final UrlRequest request) {
+        assertEquals(mExecutorThread, Thread.currentThread());
         if (mResponseStep != mFailureStep || mFailureType == FailureType.NONE) {
             if (!mAutoAdvance) {
                 mStepBlock.open();
                 return true;
             }
             return false;
         }
 
         if (mFailureType == FailureType.THROW_SYNC) {
+            assertFalse(mListenerExceptionThrown);
+            mListenerExceptionThrown = true;
             throw new IllegalStateException("Listener Exception.");
         }
         Runnable task = new Runnable() {
             public void run() {
                 request.cancel();
             }
         };
         if (mFailureType == FailureType.CANCEL_ASYNC
                 || mFailureType == FailureType.CANCEL_ASYNC_WITHOUT_PAUSE) {
             getExecutor().execute(task);
         } else {
             task.run();
         }
         return mFailureType != FailureType.CANCEL_ASYNC_WITHOUT_PAUSE;
     }
 }