Add API for new Cronet metrics

This API is not yet connected to anything in the net stack. Most of
these new metrics will be plumbed through from net::LoadTimingInfo, and
a few from other places.

Includes a unit test for the big mess of longs/Dates in
RequestFinishedInfo.Metrics, but no other tests yet because nothing
works yet.

Leaves the old APIs in place for now, since those actually work.

BUG=629194

Review-Url: https://codereview.chromium.org/2220023002
Cr-Commit-Position: refs/heads/master@{#419185}

components/cronet/android/BUILD.gn

@@ -332,6 +332,7 @@ android_library("cronet_java") {
     "java/src/org/chromium/net/impl/ChromiumUrlRequestFactory.java",
     "java/src/org/chromium/net/impl/CronetBidirectionalStream.java",
     "java/src/org/chromium/net/impl/CronetLibraryLoader.java",
+    "java/src/org/chromium/net/impl/CronetMetrics.java",
     "java/src/org/chromium/net/impl/CronetUploadDataStream.java",
     "java/src/org/chromium/net/impl/CronetUrlRequest.java",
     "java/src/org/chromium/net/impl/CronetUrlRequestContext.java",

components/cronet/android/java/src/org/chromium/net/impl/CronetMetrics.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.impl;
+
+import android.support.annotation.Nullable;
+
+import org.chromium.base.VisibleForTesting;
+import org.chromium.net.RequestFinishedInfo;
+
+import java.util.Date;
+
+/**
+ * Implementation of {@link RequestFinishedInfo.Metrics}.
+ */
+@VisibleForTesting
+public final class CronetMetrics extends RequestFinishedInfo.Metrics {
+    private final long mRequestStartMs;
+    private final long mDnsStartMs;
+    private final long mDnsEndMs;
+    private final long mConnectStartMs;
+    private final long mConnectEndMs;
+    private final long mSslStartMs;
+    private final long mSslEndMs;
+    private final long mSendingStartMs;
+    private final long mSendingEndMs;
+    private final long mPushStartMs;
+    private final long mPushEndMs;
+    private final long mResponseStartMs;
+    private final long mResponseEndMs;
+    private final boolean mSocketReused;
+
+    // TODO(mgersh): Delete after the switch to the new API http://crbug.com/629194
+    @Nullable
+    private final Long mTtfbMs;
+    // TODO(mgersh): Delete after the switch to the new API http://crbug.com/629194
+    @Nullable
+    private final Long mTotalTimeMs;
+    @Nullable
+    private final Long mSentBytesCount;
+    @Nullable
+    private final Long mReceivedBytesCount;
+
+    @Nullable
+    private static Date toDate(long timestamp) {
+        if (timestamp != -1) {
+            return new Date(timestamp);
+        }
+        return null;
+    }
+
+    private static boolean checkOrder(long start, long end) {
+        // If end doesn't exist, start can be anything, including also not existing
+        // If end exists, start must also exist and be before end
+        return (end >= start && start != -1) || end == -1;
+    }
+
+    /**
+     * Old-style constructor
+     * TODO(mgersh): Delete after the switch to the new API http://crbug.com/629194
+     */
+    public CronetMetrics(@Nullable Long ttfbMs, @Nullable Long totalTimeMs,
+            @Nullable Long sentBytesCount, @Nullable Long receivedBytesCount) {
+        mTtfbMs = ttfbMs;
+        mTotalTimeMs = totalTimeMs;
+        mSentBytesCount = sentBytesCount;
+        mReceivedBytesCount = receivedBytesCount;
+
+        // Everything else is -1 (translates to null) for now
+        mRequestStartMs = -1;
+        mDnsStartMs = -1;
+        mDnsEndMs = -1;
+        mConnectStartMs = -1;
+        mConnectEndMs = -1;
+        mSslStartMs = -1;
+        mSslEndMs = -1;
+        mSendingStartMs = -1;
+        mSendingEndMs = -1;
+        mPushStartMs = -1;
+        mPushEndMs = -1;
+        mResponseStartMs = -1;
+        mResponseEndMs = -1;
+        mSocketReused = false;
+    }
+
+    /**
+     * New-style constructor
+     */
+    public CronetMetrics(long requestStartMs, long dnsStartMs, long dnsEndMs, long connectStartMs,
+            long connectEndMs, long sslStartMs, long sslEndMs, long sendingStartMs,
+            long sendingEndMs, long pushStartMs, long pushEndMs, long responseStartMs,
+            long responseEndMs, boolean socketReused, long sentBytesCount,
+            long receivedBytesCount) {
+        // Check that no end times are before corresponding start times,
+        // or exist when start time doesn't.
+        assert checkOrder(dnsStartMs, dnsEndMs);
+        assert checkOrder(connectStartMs, connectEndMs);
+        assert checkOrder(sslStartMs, sslEndMs);
+        assert checkOrder(sendingStartMs, sendingEndMs);
+        assert checkOrder(pushStartMs, pushEndMs);
+        assert checkOrder(responseStartMs, responseEndMs);
+        // Spot-check some of the other orderings
+        assert dnsStartMs >= requestStartMs || dnsStartMs == -1;
+        assert sendingStartMs >= requestStartMs || sendingStartMs == -1;
+        assert sslStartMs >= connectStartMs || sslStartMs == -1;
+        assert responseStartMs >= sendingStartMs || responseStartMs == -1;
+        mRequestStartMs = requestStartMs;
+        mDnsStartMs = dnsStartMs;
+        mDnsEndMs = dnsEndMs;
+        mConnectStartMs = connectStartMs;
+        mConnectEndMs = connectEndMs;
+        mSslStartMs = sslStartMs;
+        mSslEndMs = sslEndMs;
+        mSendingStartMs = sendingStartMs;
+        mSendingEndMs = sendingEndMs;
+        mPushStartMs = pushStartMs;
+        mPushEndMs = pushEndMs;
+        mResponseStartMs = responseStartMs;
+        mResponseEndMs = responseEndMs;
+        mSocketReused = socketReused;
+        mSentBytesCount = sentBytesCount;
+        mReceivedBytesCount = receivedBytesCount;
+
+        // Don't care about these anymore
+        mTtfbMs = null;
+        mTotalTimeMs = null;
+    }
+
+    @Nullable
+    public Date getRequestStart() {
+        return toDate(mRequestStartMs);
+    }
+
+    @Nullable
+    public Date getDnsStart() {
+        return toDate(mDnsStartMs);
+    }
+
+    @Nullable
+    public Date getDnsEnd() {
+        return toDate(mDnsEndMs);
+    }
+
+    @Nullable
+    public Date getConnectStart() {
+        return toDate(mConnectStartMs);
+    }
+
+    @Nullable
+    public Date getConnectEnd() {
+        return toDate(mConnectEndMs);
+    }
+
+    @Nullable
+    public Date getSslStart() {
+        return toDate(mSslStartMs);
+    }
+
+    @Nullable
+    public Date getSslEnd() {
+        return toDate(mSslEndMs);
+    }
+
+    @Nullable
+    public Date getSendingStart() {
+        return toDate(mSendingStartMs);
+    }
+
+    @Nullable
+    public Date getSendingEnd() {
+        return toDate(mSendingEndMs);
+    }
+
+    @Nullable
+    public Date getPushStart() {
+        return toDate(mPushStartMs);
+    }
+
+    @Nullable
+    public Date getPushEnd() {
+        return toDate(mPushEndMs);
+    }
+
+    @Nullable
+    public Date getResponseStart() {
+        return toDate(mResponseStartMs);
+    }
+
+    @Nullable
+    public Date getResponseEnd() {
+        return toDate(mResponseEndMs);
+    }
+
+    @Nullable
+    public boolean getSocketReused() {
+        return mSocketReused;
+    }
+
+    @Nullable
+    public Long getTtfbMs() {
+        return mTtfbMs;
+    }
+
+    @Nullable
+    public Long getTotalTimeMs() {
+        return mTotalTimeMs;
+    }
+
+    @Nullable
+    public Long getSentBytesCount() {
+        return mSentBytesCount;
+    }
+
+    @Nullable
+    public Long getReceivedBytesCount() {
+        return mReceivedBytesCount;
+    }
+}

components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequest.java

@@ -49,7 +49,7 @@ import javax.annotation.concurrent.GuardedBy;
 @VisibleForTesting
 public final class CronetUrlRequest implements UrlRequest {
     private static final RequestFinishedInfo.Metrics EMPTY_METRICS =
-            new RequestFinishedInfo.Metrics(null, null, null, null);
+            new CronetMetrics(null, null, null, null);
     private final boolean mAllowDirectExecutor;
 
     /* Native adapter object, owned by UrlRequest. */
@@ -700,10 +700,11 @@ public final class CronetUrlRequest implements UrlRequest {
     }
 
     RequestFinishedInfo getRequestFinishedInfo() {
+        // TODO(mgersh): fill in real values for finishedReason and exception
         return new RequestFinishedInfo(mInitialUrl, mRequestAnnotations,
                 (mRequestMetricsAccumulator != null ? mRequestMetricsAccumulator.getRequestMetrics()
                                                     : EMPTY_METRICS),
-                mResponseInfo);
+                RequestFinishedInfo.SUCCEEDED, mResponseInfo, null);
     }
 
     private final class UrlRequestMetricsAccumulator {
@@ -715,7 +716,7 @@ public final class CronetUrlRequest implements UrlRequest {
         private Long mTotalTimeMs;
 
         private RequestFinishedInfo.Metrics getRequestMetrics() {
-            return new RequestFinishedInfo.Metrics(mTtfbMs, mTotalTimeMs,
+            return new CronetMetrics(mTtfbMs, mTotalTimeMs,
                     null, // TODO(klm): Compute sentBytesCount.
                     (mResponseInfo != null ? mResponseInfo.getReceivedBytesCount() : 0));
         }

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

@@ -9,9 +9,11 @@ import static org.chromium.base.CollectionUtil.newHashSet;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import org.chromium.base.test.util.Feature;
+import org.chromium.net.impl.CronetMetrics;
 import org.chromium.net.test.EmbeddedTestServer;
 
 import java.util.ArrayList;
+import java.util.Date;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
@@ -259,4 +261,45 @@ public class RequestFinishedInfoTest extends CronetTestBase {
                 requestFinishedListener.mRequestInfo);
         mTestFramework.mCronetEngine.shutdown();
     }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    public void testMetricsGetters() throws Exception {
+        long requestStart = 1;
+        long dnsStart = 2;
+        long dnsEnd = -1;
+        long connectStart = 4;
+        long connectEnd = 5;
+        long sslStart = 6;
+        long sslEnd = 7;
+        long sendingStart = 8;
+        long sendingEnd = 9;
+        long pushStart = 10;
+        long pushEnd = 11;
+        long responseStart = 12;
+        long responseEnd = 13;
+        boolean socketReused = true;
+        long sentBytesCount = 14;
+        long receivedBytesCount = 15;
+        // Make sure nothing gets reordered inside the Metrics class
+        RequestFinishedInfo.Metrics metrics = new CronetMetrics(requestStart, dnsStart, dnsEnd,
+                connectStart, connectEnd, sslStart, sslEnd, sendingStart, sendingEnd, pushStart,
+                pushEnd, responseStart, responseEnd, socketReused, sentBytesCount,
+                receivedBytesCount);
+        assertEquals(new Date(requestStart), metrics.getRequestStart());
+        // -1 timestamp should translate to null
+        assertNull(metrics.getDnsEnd());
+        assertEquals(new Date(dnsStart), metrics.getDnsStart());
+        assertEquals(new Date(connectStart), metrics.getConnectStart());
+        assertEquals(new Date(connectEnd), metrics.getConnectEnd());
+        assertEquals(new Date(sslStart), metrics.getSslStart());
+        assertEquals(new Date(sslEnd), metrics.getSslEnd());
+        assertEquals(new Date(pushStart), metrics.getPushStart());
+        assertEquals(new Date(pushEnd), metrics.getPushEnd());
+        assertEquals(new Date(responseStart), metrics.getResponseStart());
+        assertEquals(new Date(responseEnd), metrics.getResponseEnd());
+        assertEquals(socketReused, metrics.getSocketReused());
+        assertEquals(sentBytesCount, (long) metrics.getSentBytesCount());
+        assertEquals(receivedBytesCount, (long) metrics.getReceivedBytesCount());
+    }
 }