Fix flaky NQE QUIC test

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

 // Copyright 2015 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.support.test.filters.LargeTest;
 import android.support.test.filters.SmallTest;
 
 import org.json.JSONObject;
 
 import org.chromium.base.Log;
 import org.chromium.base.annotations.SuppressFBWarnings;
 import org.chromium.base.test.util.Feature;
 import org.chromium.net.CronetTestBase.OnlyRunNativeCronet;
 import org.chromium.net.MetricsTestUtil.TestRequestFinishedListener;
@@ skipping 124 matching lines @@
     private boolean fileContainsString(String filename, String content) throws IOException {
         File file =
                 new File(CronetTestFramework.getTestStorage(getContext()) + "/prefs/" + filename);
         FileInputStream fileInputStream = new FileInputStream(file);
         byte[] data = new byte[(int) file.length()];
         fileInputStream.read(data);
         fileInputStream.close();
         return new String(data, "UTF-8").contains(content);
     }
 
+    /**
+     * Tests that the network quality listeners are propoerly notified when QUIC is enabled.
+     */
     @LargeTest
     @Feature({"Cronet"})
     @OnlyRunNativeCronet
     @SuppressWarnings("deprecation")
-    public void testRealTimeNetworkQualityObservationsWithQuic() throws Exception {
+    public void testNQEWithQuic() throws Exception {
         mTestFramework = startCronetTestFrameworkWithUrlAndCronetEngineBuilder(null, mBuilder);
         String quicURL = QuicTestServer.getServerURL() + "/simple.txt";
-        ConditionVariable waitForThroughput = new ConditionVariable();
 
         TestNetworkQualityRttListener rttListener =
                 new TestNetworkQualityRttListener(Executors.newSingleThreadExecutor());
         TestNetworkQualityThroughputListener throughputListener =
-                new TestNetworkQualityThroughputListener(
-                        Executors.newSingleThreadExecutor(), waitForThroughput);
+                new TestNetworkQualityThroughputListener(Executors.newSingleThreadExecutor());
 
         mTestFramework.mCronetEngine.addRttListener(rttListener);
         mTestFramework.mCronetEngine.addThroughputListener(throughputListener);
 
         mTestFramework.mCronetEngine.configureNetworkQualityEstimatorForTesting(true, true, true);
         TestUrlRequestCallback callback = new TestUrlRequestCallback();
 
         // Although the native stack races QUIC and SPDY for the first request,
         // since there is no http server running on the corresponding TCP port,
         // QUIC will always succeed with a 200 (see
         // net::HttpStreamFactoryImpl::Request::OnStreamFailed).
         UrlRequest.Builder requestBuilder = mTestFramework.mCronetEngine.newUrlRequestBuilder(
                 quicURL, callback, callback.getExecutor());
         requestBuilder.build().start();
         callback.blockForDone();
 
         assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
         String expectedContent = "This is a simple text file served by QUIC.\n";
         assertEquals(expectedContent, callback.mResponseAsString);
         assertIsQuic(callback.mResponseInfo);
 
         // Throughput observation is posted to the network quality estimator on the network thread
         // after the UrlRequest is completed. The observations are then eventually posted to
         // throughput listeners on the executor provided to network quality.
-        waitForThroughput.block();
+        throughputListener.waitUntilFirstThroughputObservationReceived();
+
+        // Wait for RTT observation (at the URL request layer) to be posted.
+        rttListener.waitUntilFirstUrlRequestRTTReceived();
+
         assertTrue(throughputListener.throughputObservationCount() > 0);
 
         // Check RTT observation count after throughput observation has been received. This ensures
         // that executor has finished posting the RTT observation to the RTT listeners.
         // NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST
         assertTrue(rttListener.rttObservationCount(0) > 0);
 
         // NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC
         assertTrue(rttListener.rttObservationCount(2) > 0);
 
@@ skipping 72 matching lines @@
         MetricsTestUtil.checkNoConnectTiming(requestInfo.getMetrics());
 
         mTestFramework.mCronetEngine.shutdown();
     }
 
     // Helper method to assert that the request is negotiated over QUIC.
     private void assertIsQuic(UrlResponseInfo responseInfo) {
         assertTrue(responseInfo.getNegotiatedProtocol().startsWith(QUIC_PROTOCOL_STRING_PREFIX));
     }
 }