[Cronet] Add metrics to RequestFinishedInfo.

Bug: 879208
Change-Id: If2934a611d583d6725b7a9cd170e3c0fcd63bf34
Reviewed-on: https://chromium-review.googlesource.com/c/1374158
Commit-Queue: Caleb Raitto <caraitto@chromium.org>
Reviewed-by: Paul Jensen <pauljensen@chromium.org>
Reviewed-by: Misha Efimov <mef@chromium.org>
Cr-Commit-Position: refs/heads/master@{#619439}

components/cronet/native/cronet.idl

@@ -1130,9 +1130,13 @@ struct UrlRequestParams {
   array<handle> annotations;
 };
 
+/**
+ * This value indicates an invalid time.
+ */
+const int64 kInvalidTime = -1;
+
 /**
  * Information about a finished request.
- * TODO(mef): Define this to include metrics.
  */
 struct RequestFinishedInfo {
   /**
@@ -1152,4 +1156,158 @@ struct RequestFinishedInfo {
      */
     CANCELED = 2,
   };
+
+  // TODO(caraitto): Move metrics fields to their own class once C generator
+  // supports struct within a struct.
+
+  /*
+   * The below fields represent metrics collected for a single request. Most of
+   * these metrics are timestamps for events during the lifetime of the request,
+   * which can be used to build a detailed timeline for investigating
+   * performance.
+   *
+   * Events happen in this order:
+   * <ol>
+   * <li>{@link #request_start request start}</li>
+   * <li>{@link #dns_start DNS start}</li>
+   * <li>{@link #dns_end DNS end}</li>
+   * <li>{@link #connect_start connect start}</li>
+   * <li>{@link #ssl_start SSL start}</li>
+   * <li>{@link #ssl_end SSL end}</li>
+   * <li>{@link #connect_end connect end}</li>
+   * <li>{@link #sending_start sending start}</li>
+   * <li>{@link #sending_end sending end}</li>
+   * <li>{@link #response_start response start}</li>
+   * <li>{@link #request_end request end}</li>
+   * </ol>
+   *
+   * Start times are reported as the time when a request started blocking on
+   * the event, not when the event actually occurred, with the exception of
+   * push start and end. If a metric is not meaningful or not available,
+   * including cases when a request finished before reaching that stage, start
+   * and end times will be kInvalidTime. If no time was spent blocking on an
+   * event, start and end will be the same time.
+   *
+   * Timestamps are recorded using a clock that is guaranteed not to run
+   * backwards. All timestamps are correct relative to the system clock at the
+   * time of request start, and taking the difference between two timestamps
+   * will give the correct difference between the events. In order to preserve
+   * this property, timestamps for events other than request start are not
+   * guaranteed to match the system clock at the times they represent.
+   *
+   * Most timing metrics are taken from
+   * <a
+   * href="https://cs.chromium.org/chromium/src/net/base/load_timing_info.h">LoadTimingInfo</a>,
+   * which holds the information for <a href="http://w3c.github.io/navigation-timing/"></a> and
+   * <a href="https://www.w3.org/TR/resource-timing/"></a>.
+   *
+   * All time fields are expressed as the number of milleseconds since the UNIX
+   * epoch, or kInvalidTime.
+   */
+
+  /**
+   * Time when the request started, which corresponds to calling
+   * Cronet_UrlRequest_Start(). This timestamp will match the system clock at
+   * the time it represents.
+   */
+  int64 request_start = kInvalidTime;
+
+  /**
+   * Time when DNS lookup started. This and {@link #dns_end} will be set to
+   * non-kInvalidTime regardless of whether the result came from a DNS server
+   * or the local cache. Will equal kInvalidTime if the socket was reused (see
+   * {@link #socket_reused}).
+   */
+  int64 dns_start = kInvalidTime;
+
+  /**
+   * Time when DNS lookup finished. This and {@link dns_start} will return
+   * non-kInvalidTime regardless of whether the result came from a DNS server
+   * or the local cache. Will equal kInvalidTime if the socket was reused (see
+   * {@link #socket_reused}).
+   */
+  int64 dns_end = kInvalidTime;
+
+  /**
+   * Time when connection establishment started, typically when DNS resolution
+   * finishes. Will equal kInvalidTime if the socket was reused (see {@link
+   * #socket_reused}).
+   */
+  int64 connect_start = kInvalidTime;
+
+  /**
+   * Time when connection establishment finished, after TCP connection is
+   * established and, if using HTTPS, SSL handshake is completed. For QUIC
+   * 0-RTT, this represents the time of handshake confirmation and might happen
+   * later than {@link #sending_start}. Will equal kInvalidTime if the socket
+   * was reused (see {@link #socket_reused}).
+   */
+  int64 connect_end = kInvalidTime;
+
+  /**
+   * Time when SSL handshake started. For QUIC, this will be the same time as
+   * {@link #connect_start}. Will equal kInvalidTime if SSL is not used or if
+   * the socket was reused (see {@link #socket_reused}).
+   */
+  int64 ssl_start = kInvalidTime;
+
+  /**
+   * Time when SSL handshake finished. For QUIC, this will be the same time as
+   * {@link #connect_end}. Will equal kInvalidTime if SSL is not used or if the
+   * socket was reused (see {@link #socket_reused}).
+   */
+  int64 ssl_end = kInvalidTime;
+
+  /**
+   * Time when sending HTTP request headers started.
+   */
+  int64 sending_start = kInvalidTime;
+
+  /**
+   * Time when sending HTTP request body finished. (Sending request body
+   * happens after sending request headers.)
+   */
+  int64 sending_end = kInvalidTime;
+
+  /**
+   * Time when first byte of HTTP/2 server push was received.  Will equal
+   * kInvalidTime if server push is not used.
+   */
+  int64 push_start = kInvalidTime;
+
+  /**
+   * Time when last byte of HTTP/2 server push was received.  Will equal
+   * kInvalidTime if server push is not used.
+   */
+  int64 push_end = kInvalidTime;
+
+  /**
+   * Time when the end of the response headers was received.
+   */
+  int64 response_start = kInvalidTime;
+
+  /**
+   * Time when the request finished.
+   */
+  int64 request_end = kInvalidTime;
+
+  /**
+   * True if the socket was reused from a previous request, false otherwise.
+   * In HTTP/2 or QUIC, if streams are multiplexed in a single connection,
+   * this will be {@code true} for all streams after the first.  When {@code
+   * true}, DNS, connection, and SSL times will be kInvalidTime.
+   */
+  bool socket_reused = false;
+
+  /**
+   * Returns total bytes sent over the network transport layer, or -1 if not
+   * collected.
+   */
+  int64 sent_byte_count = -1;
+
+  /**
+   * Total bytes received over the network transport layer, or -1 if not
+   * collected. Number of bytes does not include any previous redirects.
+   */
+  int64 received_byte_count = -1;
 };

components/cronet/native/generated/cronet.idl_c.h

@@ -148,6 +148,9 @@ typedef enum Cronet_UrlRequestStatusListener_Status {
   Cronet_UrlRequestStatusListener_Status_READING_RESPONSE = 14,
 } Cronet_UrlRequestStatusListener_Status;
 
+// Declare constants
+const int64_t Cronet_kInvalidTime = -1;
+
 ///////////////////////
 // Concrete interface Cronet_Buffer.
 
@@ -970,7 +973,116 @@ CRONET_EXPORT Cronet_RequestFinishedInfoPtr Cronet_RequestFinishedInfo_Create();
 CRONET_EXPORT void Cronet_RequestFinishedInfo_Destroy(
     Cronet_RequestFinishedInfoPtr self);
 // Cronet_RequestFinishedInfo setters.
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_request_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t request_start);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_dns_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t dns_start);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_dns_end_set(Cronet_RequestFinishedInfoPtr self,
+                                            int64_t dns_end);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_connect_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t connect_start);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_connect_end_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t connect_end);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_ssl_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t ssl_start);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_ssl_end_set(Cronet_RequestFinishedInfoPtr self,
+                                            int64_t ssl_end);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_sending_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t sending_start);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_sending_end_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t sending_end);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_push_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t push_start);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_push_end_set(Cronet_RequestFinishedInfoPtr self,
+                                             int64_t push_end);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_response_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t response_start);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_request_end_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t request_end);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_socket_reused_set(
+    Cronet_RequestFinishedInfoPtr self,
+    bool socket_reused);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_sent_byte_count_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t sent_byte_count);
+CRONET_EXPORT
+void Cronet_RequestFinishedInfo_received_byte_count_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t received_byte_count);
 // Cronet_RequestFinishedInfo getters.
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_request_start_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_dns_start_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_dns_end_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_connect_start_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_connect_end_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_ssl_start_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_ssl_end_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_sending_start_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_sending_end_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_push_start_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_push_end_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_response_start_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_request_end_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+bool Cronet_RequestFinishedInfo_socket_reused_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_sent_byte_count_get(
+    Cronet_RequestFinishedInfoPtr self);
+CRONET_EXPORT
+int64_t Cronet_RequestFinishedInfo_received_byte_count_get(
+    Cronet_RequestFinishedInfoPtr self);
 
 #ifdef __cplusplus
 }

components/cronet/native/generated/cronet.idl_impl_struct.cc

@@ -775,5 +775,208 @@ void Cronet_RequestFinishedInfo_Destroy(Cronet_RequestFinishedInfoPtr self) {
 }
 
 // Struct Cronet_RequestFinishedInfo setters.
+void Cronet_RequestFinishedInfo_request_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t request_start) {
+  DCHECK(self);
+  self->request_start = request_start;
+}
+
+void Cronet_RequestFinishedInfo_dns_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t dns_start) {
+  DCHECK(self);
+  self->dns_start = dns_start;
+}
+
+void Cronet_RequestFinishedInfo_dns_end_set(Cronet_RequestFinishedInfoPtr self,
+                                            int64_t dns_end) {
+  DCHECK(self);
+  self->dns_end = dns_end;
+}
+
+void Cronet_RequestFinishedInfo_connect_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t connect_start) {
+  DCHECK(self);
+  self->connect_start = connect_start;
+}
+
+void Cronet_RequestFinishedInfo_connect_end_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t connect_end) {
+  DCHECK(self);
+  self->connect_end = connect_end;
+}
+
+void Cronet_RequestFinishedInfo_ssl_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t ssl_start) {
+  DCHECK(self);
+  self->ssl_start = ssl_start;
+}
+
+void Cronet_RequestFinishedInfo_ssl_end_set(Cronet_RequestFinishedInfoPtr self,
+                                            int64_t ssl_end) {
+  DCHECK(self);
+  self->ssl_end = ssl_end;
+}
+
+void Cronet_RequestFinishedInfo_sending_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t sending_start) {
+  DCHECK(self);
+  self->sending_start = sending_start;
+}
+
+void Cronet_RequestFinishedInfo_sending_end_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t sending_end) {
+  DCHECK(self);
+  self->sending_end = sending_end;
+}
+
+void Cronet_RequestFinishedInfo_push_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t push_start) {
+  DCHECK(self);
+  self->push_start = push_start;
+}
+
+void Cronet_RequestFinishedInfo_push_end_set(Cronet_RequestFinishedInfoPtr self,
+                                             int64_t push_end) {
+  DCHECK(self);
+  self->push_end = push_end;
+}
+
+void Cronet_RequestFinishedInfo_response_start_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t response_start) {
+  DCHECK(self);
+  self->response_start = response_start;
+}
+
+void Cronet_RequestFinishedInfo_request_end_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t request_end) {
+  DCHECK(self);
+  self->request_end = request_end;
+}
+
+void Cronet_RequestFinishedInfo_socket_reused_set(
+    Cronet_RequestFinishedInfoPtr self,
+    bool socket_reused) {
+  DCHECK(self);
+  self->socket_reused = socket_reused;
+}
+
+void Cronet_RequestFinishedInfo_sent_byte_count_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t sent_byte_count) {
+  DCHECK(self);
+  self->sent_byte_count = sent_byte_count;
+}
+
+void Cronet_RequestFinishedInfo_received_byte_count_set(
+    Cronet_RequestFinishedInfoPtr self,
+    int64_t received_byte_count) {
+  DCHECK(self);
+  self->received_byte_count = received_byte_count;
+}
 
 // Struct Cronet_RequestFinishedInfo getters.
+int64_t Cronet_RequestFinishedInfo_request_start_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->request_start;
+}
+
+int64_t Cronet_RequestFinishedInfo_dns_start_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->dns_start;
+}
+
+int64_t Cronet_RequestFinishedInfo_dns_end_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->dns_end;
+}
+
+int64_t Cronet_RequestFinishedInfo_connect_start_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->connect_start;
+}
+
+int64_t Cronet_RequestFinishedInfo_connect_end_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->connect_end;
+}
+
+int64_t Cronet_RequestFinishedInfo_ssl_start_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->ssl_start;
+}
+
+int64_t Cronet_RequestFinishedInfo_ssl_end_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->ssl_end;
+}
+
+int64_t Cronet_RequestFinishedInfo_sending_start_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->sending_start;
+}
+
+int64_t Cronet_RequestFinishedInfo_sending_end_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->sending_end;
+}
+
+int64_t Cronet_RequestFinishedInfo_push_start_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->push_start;
+}
+
+int64_t Cronet_RequestFinishedInfo_push_end_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->push_end;
+}
+
+int64_t Cronet_RequestFinishedInfo_response_start_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->response_start;
+}
+
+int64_t Cronet_RequestFinishedInfo_request_end_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->request_end;
+}
+
+bool Cronet_RequestFinishedInfo_socket_reused_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->socket_reused;
+}
+
+int64_t Cronet_RequestFinishedInfo_sent_byte_count_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->sent_byte_count;
+}
+
+int64_t Cronet_RequestFinishedInfo_received_byte_count_get(
+    Cronet_RequestFinishedInfoPtr self) {
+  DCHECK(self);
+  return self->received_byte_count;
+}

components/cronet/native/generated/cronet.idl_impl_struct.h

@@ -161,6 +161,23 @@ struct Cronet_RequestFinishedInfo {
   explicit Cronet_RequestFinishedInfo(Cronet_RequestFinishedInfo&& from);
   ~Cronet_RequestFinishedInfo();
 
+  int64_t request_start = Cronet_kInvalidTime;
+  int64_t dns_start = Cronet_kInvalidTime;
+  int64_t dns_end = Cronet_kInvalidTime;
+  int64_t connect_start = Cronet_kInvalidTime;
+  int64_t connect_end = Cronet_kInvalidTime;
+  int64_t ssl_start = Cronet_kInvalidTime;
+  int64_t ssl_end = Cronet_kInvalidTime;
+  int64_t sending_start = Cronet_kInvalidTime;
+  int64_t sending_end = Cronet_kInvalidTime;
+  int64_t push_start = Cronet_kInvalidTime;
+  int64_t push_end = Cronet_kInvalidTime;
+  int64_t response_start = Cronet_kInvalidTime;
+  int64_t request_end = Cronet_kInvalidTime;
+  bool socket_reused = false;
+  int64_t sent_byte_count = -1;
+  int64_t received_byte_count = -1;
+
  private:
   DISALLOW_ASSIGN(Cronet_RequestFinishedInfo);
 };

components/cronet/native/generated/cronet.idl_impl_struct_unittest.cc

@@ -259,6 +259,70 @@ TEST_F(CronetStructTest, TestCronet_RequestFinishedInfo) {
   Cronet_RequestFinishedInfoPtr second = Cronet_RequestFinishedInfo_Create();
 
   // Copy values from |first| to |second|.
+  Cronet_RequestFinishedInfo_request_start_set(
+      second, Cronet_RequestFinishedInfo_request_start_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_request_start_get(first),
+            Cronet_RequestFinishedInfo_request_start_get(second));
+  Cronet_RequestFinishedInfo_dns_start_set(
+      second, Cronet_RequestFinishedInfo_dns_start_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_dns_start_get(first),
+            Cronet_RequestFinishedInfo_dns_start_get(second));
+  Cronet_RequestFinishedInfo_dns_end_set(
+      second, Cronet_RequestFinishedInfo_dns_end_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_dns_end_get(first),
+            Cronet_RequestFinishedInfo_dns_end_get(second));
+  Cronet_RequestFinishedInfo_connect_start_set(
+      second, Cronet_RequestFinishedInfo_connect_start_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_connect_start_get(first),
+            Cronet_RequestFinishedInfo_connect_start_get(second));
+  Cronet_RequestFinishedInfo_connect_end_set(
+      second, Cronet_RequestFinishedInfo_connect_end_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_connect_end_get(first),
+            Cronet_RequestFinishedInfo_connect_end_get(second));
+  Cronet_RequestFinishedInfo_ssl_start_set(
+      second, Cronet_RequestFinishedInfo_ssl_start_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_ssl_start_get(first),
+            Cronet_RequestFinishedInfo_ssl_start_get(second));
+  Cronet_RequestFinishedInfo_ssl_end_set(
+      second, Cronet_RequestFinishedInfo_ssl_end_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_ssl_end_get(first),
+            Cronet_RequestFinishedInfo_ssl_end_get(second));
+  Cronet_RequestFinishedInfo_sending_start_set(
+      second, Cronet_RequestFinishedInfo_sending_start_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_sending_start_get(first),
+            Cronet_RequestFinishedInfo_sending_start_get(second));
+  Cronet_RequestFinishedInfo_sending_end_set(
+      second, Cronet_RequestFinishedInfo_sending_end_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_sending_end_get(first),
+            Cronet_RequestFinishedInfo_sending_end_get(second));
+  Cronet_RequestFinishedInfo_push_start_set(
+      second, Cronet_RequestFinishedInfo_push_start_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_push_start_get(first),
+            Cronet_RequestFinishedInfo_push_start_get(second));
+  Cronet_RequestFinishedInfo_push_end_set(
+      second, Cronet_RequestFinishedInfo_push_end_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_push_end_get(first),
+            Cronet_RequestFinishedInfo_push_end_get(second));
+  Cronet_RequestFinishedInfo_response_start_set(
+      second, Cronet_RequestFinishedInfo_response_start_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_response_start_get(first),
+            Cronet_RequestFinishedInfo_response_start_get(second));
+  Cronet_RequestFinishedInfo_request_end_set(
+      second, Cronet_RequestFinishedInfo_request_end_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_request_end_get(first),
+            Cronet_RequestFinishedInfo_request_end_get(second));
+  Cronet_RequestFinishedInfo_socket_reused_set(
+      second, Cronet_RequestFinishedInfo_socket_reused_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_socket_reused_get(first),
+            Cronet_RequestFinishedInfo_socket_reused_get(second));
+  Cronet_RequestFinishedInfo_sent_byte_count_set(
+      second, Cronet_RequestFinishedInfo_sent_byte_count_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_sent_byte_count_get(first),
+            Cronet_RequestFinishedInfo_sent_byte_count_get(second));
+  Cronet_RequestFinishedInfo_received_byte_count_set(
+      second, Cronet_RequestFinishedInfo_received_byte_count_get(first));
+  EXPECT_EQ(Cronet_RequestFinishedInfo_received_byte_count_get(first),
+            Cronet_RequestFinishedInfo_received_byte_count_get(second));
   Cronet_RequestFinishedInfo_Destroy(first);
   Cronet_RequestFinishedInfo_Destroy(second);
 }