[Cronet] Pass metrics information from C++ BidirectionalStream to Java

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

 // Copyright 2016 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 static junit.framework.Assert.assertNotNull;
 import static junit.framework.Assert.assertNull;
 import static junit.framework.Assert.assertTrue;
 
@@ skipping 31 matching lines @@
             }
         }
     }
 
     /**
      * RequestFinishedInfo.Listener for testing, which saves the RequestFinishedInfo
      */
     public static class TestRequestFinishedListener extends RequestFinishedInfo.Listener {
         private RequestFinishedInfo mRequestInfo;
         private ConditionVariable mBlock;
-        private int mNumExpectedRequests = -1;
 
         // TODO(mgersh): it's weird that you can use either this constructor or blockUntilDone() but
         // not both. Either clean it up or document why it has to work this way.
         public TestRequestFinishedListener(Executor executor) {
             super(executor);
         }
 
-        public TestRequestFinishedListener(int numExpectedRequests) {
-            super(Executors.newSingleThreadExecutor());
-            mNumExpectedRequests = numExpectedRequests;
-            mBlock = new ConditionVariable();
-        }
-
         public TestRequestFinishedListener() {
             super(Executors.newSingleThreadExecutor());
-            mNumExpectedRequests = 1;
             mBlock = new ConditionVariable();
         }
 
         public RequestFinishedInfo getRequestInfo() {
             return mRequestInfo;
         }
 
         @Override
         public void onRequestFinished(RequestFinishedInfo requestInfo) {
             assertNull("onRequestFinished called repeatedly", mRequestInfo);
             assertNotNull(requestInfo);
             mRequestInfo = requestInfo;
-            mNumExpectedRequests--;
-            if (mNumExpectedRequests == 0) {
-                mBlock.open();
-            }
+            mBlock.open();
         }
 
         public void blockUntilDone() {
             mBlock.block();
         }
 
         public void reset() {
             mBlock.close();
-            mNumExpectedRequests = 1;
             mRequestInfo = null;
         }
     }
 
+    // Helper method to assert date2 is equals to or after date1.
+    // Some implementation of java.util.Date broke asymmetric property, so

[mgersh, 2016/10/06 14:44:09]

Huh, weird. I'm curious where?

nit: "asymmetric property" -> "the symmetric property"

[xunjieli, 2016/10/06 16:14:21]

Done. ah, you are right!

http://stackoverflow.com/questions/27661640/java-util-date-equals-doesnt-seem...

I think I am being paranoia. But I think it might be good to assert both
directions.

[xunjieli, 2016/10/06 16:16:17]

s/paranoia/paranoid

+    // check both directions.
+    public static void assertAfter(Date date1, Date date2) {

[mgersh, 2016/10/06 14:44:09]

Thanks for adding this. There are a few places in RequestFinishedInfoTest that
should also be switched to it. You can do that now if you want, otherwise I'll
get to it later.

[xunjieli, 2016/10/06 16:14:21]

Acknowledged. I will leave it to you then. My brain is still a bit fuzzy after
the redeye flight :)

+        assertTrue("date1: " + date1.getTime() + ", date2: " + date2.getTime(),
+                date1.after(date2) || date1.equals(date2) || date2.equals(date1));
+    }
+
     /**
      * Check existence of all the timing metrics that apply to most test requests,
      * except those that come from net::LoadTimingInfo::ConnectTiming.
      * Also check some timing differences, focusing on things we can't check with asserts in the
      * CronetMetrics constructor.
      * Don't check push times here.
      */
     public static void checkTimingMetrics(
             RequestFinishedInfo.Metrics metrics, Date startTime, Date endTime) {
         assertNotNull(metrics.getRequestStart());
-        assertTrue(metrics.getRequestStart().after(startTime)
-                || metrics.getRequestStart().equals(startTime));
+        assertAfter(metrics.getRequestStart(), startTime);
         assertNotNull(metrics.getSendingStart());
-        assertTrue(metrics.getSendingStart().after(startTime)
-                || metrics.getSendingStart().equals(startTime));
+        assertAfter(metrics.getSendingStart(), startTime);
         assertNotNull(metrics.getSendingEnd());
         assertTrue(metrics.getSendingEnd().before(endTime));
         assertNotNull(metrics.getResponseStart());
         assertTrue(metrics.getResponseStart().after(startTime));
         assertNotNull(metrics.getResponseEnd());
-        assertTrue(metrics.getResponseEnd().before(endTime)
-                || metrics.getResponseEnd().equals(endTime));
+        assertAfter(endTime, metrics.getResponseEnd());
         // Entire request should take more than 0 ms
         assertTrue(metrics.getResponseEnd().getTime() - metrics.getRequestStart().getTime() > 0);
     }
 
     /**
      * Check that the timing metrics which come from net::LoadTimingInfo::ConnectTiming exist,
      * except SSL times in the case of non-https requests.
      */
     public static void checkHasConnectTiming(
             RequestFinishedInfo.Metrics metrics, Date startTime, Date endTime, boolean isSsl) {
         assertNotNull(metrics.getDnsStart());
-        assertTrue(
-                metrics.getDnsStart().after(startTime) || metrics.getDnsStart().equals(startTime));
+        assertAfter(metrics.getDnsStart(), startTime);
         assertNotNull(metrics.getDnsEnd());
         assertTrue(metrics.getDnsEnd().before(endTime));
         assertNotNull(metrics.getConnectStart());
-        assertTrue(metrics.getConnectStart().after(startTime)
-                || metrics.getConnectStart().equals(startTime));
+        assertAfter(metrics.getConnectStart(), startTime);
         assertNotNull(metrics.getConnectEnd());
         assertTrue(metrics.getConnectEnd().before(endTime));
         if (isSsl) {
             assertNotNull(metrics.getSslStart());
-            assertTrue(metrics.getSslStart().after(startTime)
-                    || metrics.getSslStart().equals(startTime));
+            assertAfter(metrics.getSslStart(), startTime);
             assertNotNull(metrics.getSslEnd());
             assertTrue(metrics.getSslEnd().before(endTime));
         } else {
             assertNull(metrics.getSslStart());
             assertNull(metrics.getSslEnd());
         }
     }
 
     /**
      * Check that the timing metrics from net::LoadTimingInfo::ConnectTiming don't exist.
      */
     public static void checkNoConnectTiming(RequestFinishedInfo.Metrics metrics) {
         assertNull(metrics.getDnsStart());
         assertNull(metrics.getDnsEnd());
         assertNull(metrics.getSslStart());
         assertNull(metrics.getSslEnd());
         assertNull(metrics.getConnectStart());
         assertNull(metrics.getConnectEnd());
     }
 }