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

components/cronet/android/cronet_bidirectional_stream_adapter.cc

 // 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.
 
 #include "cronet_bidirectional_stream_adapter.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 31 matching lines @@
 // may be -1 if |array| is not a valid Java array), provide a safe wrapper
 // that always returns a valid, non-negative size.
 template <typename JavaArrayType>
 size_t SafeGetArrayLength(JNIEnv* env, JavaArrayType jarray) {
   DCHECK(jarray);
   jsize length = env->GetArrayLength(jarray);
   DCHECK_GE(length, 0) << "Invalid array length: " << length;
   return static_cast<size_t>(std::max(0, length));
 }
 
+int64_t ConvertTime(base::TimeTicks ticks,
+                    base::Time start_time,
+                    base::TimeTicks start_ticks) {
+  if (ticks.is_null()) {
+    return -1;
+  }
+  return (start_time + (ticks - start_ticks)).ToJavaTime();
+}
+
 }  // namespace
 
 PendingWriteData::PendingWriteData(JNIEnv* env,
                                    jobjectArray jwrite_buffer_list,
                                    jintArray jwrite_buffer_pos_list,
                                    jintArray jwrite_buffer_limit_list,
                                    jboolean jwrite_end_of_stream) {
   this->jwrite_buffer_list.Reset(env, jwrite_buffer_list);
   this->jwrite_buffer_pos_list.Reset(env, jwrite_buffer_pos_list);
   this->jwrite_buffer_limit_list.Reset(env, jwrite_buffer_limit_list);
   this->jwrite_end_of_stream = jwrite_end_of_stream;
 }
 
 PendingWriteData::~PendingWriteData() {
   // Reset global references.
   jwrite_buffer_list.Reset();
   jwrite_buffer_pos_list.Reset();
   jwrite_buffer_limit_list.Reset();
 }
 
 static jlong CreateBidirectionalStream(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& jbidi_stream,
     jlong jurl_request_context_adapter,
-    jboolean jsend_request_headers_automatically) {
+    jboolean jsend_request_headers_automatically,
+    jboolean jenable_metrics) {
   CronetURLRequestContextAdapter* context_adapter =
       reinterpret_cast<CronetURLRequestContextAdapter*>(
           jurl_request_context_adapter);
   DCHECK(context_adapter);
 
   CronetBidirectionalStreamAdapter* adapter =
       new CronetBidirectionalStreamAdapter(context_adapter, env, jbidi_stream,
-                                           jsend_request_headers_automatically);
+                                           jsend_request_headers_automatically,
+                                           jenable_metrics);
 
   return reinterpret_cast<jlong>(adapter);
 }
 
 // static
 bool CronetBidirectionalStreamAdapter::RegisterJni(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 CronetBidirectionalStreamAdapter::CronetBidirectionalStreamAdapter(
     CronetURLRequestContextAdapter* context,
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& jbidi_stream,
-    bool send_request_headers_automatically)
+    bool send_request_headers_automatically,
+    bool enable_metrics)
     : context_(context),
       owner_(env, jbidi_stream),
       send_request_headers_automatically_(send_request_headers_automatically),
+      enable_metrics_(enable_metrics),
       stream_failed_(false) {}
 
 CronetBidirectionalStreamAdapter::~CronetBidirectionalStreamAdapter() {
   DCHECK(context_->IsOnNetworkThread());
 }
 
 void CronetBidirectionalStreamAdapter::SendRequestHeaders(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& jcaller) {
   context_->PostTaskToNetworkThread(
@@ skipping 292 matching lines @@
   }
 }
 
 void CronetBidirectionalStreamAdapter::DestroyOnNetworkThread(
     bool send_on_canceled) {
   DCHECK(context_->IsOnNetworkThread());
   if (send_on_canceled) {
     JNIEnv* env = base::android::AttachCurrentThread();
     cronet::Java_CronetBidirectionalStream_onCanceled(env, owner_.obj());
   }
+  MaybeReportMetrics();
   delete this;
 }
 
 base::android::ScopedJavaLocalRef<jobjectArray>
 CronetBidirectionalStreamAdapter::GetHeadersArray(
     JNIEnv* env,
     const net::SpdyHeaderBlock& header_block) {
   DCHECK(context_->IsOnNetworkThread());
 
   std::vector<std::string> headers;
   for (const auto& header : header_block) {
     headers.push_back(header.first.as_string());
     headers.push_back(header.second.as_string());
   }
   return base::android::ToJavaArrayOfStrings(env, headers);
 }
 
+void CronetBidirectionalStreamAdapter::MaybeReportMetrics() {
+  if (!enable_metrics_)
+    return;
+
+  if (!bidi_stream_)
+    return;
+  net::LoadTimingInfo load_timing_info;
+  bidi_stream_->GetLoadTimingInfo(&load_timing_info);
+  JNIEnv* env = base::android::AttachCurrentThread();
+  base::Time start_time = load_timing_info.request_start_time;
+  base::TimeTicks start_ticks = load_timing_info.request_start;
+  cronet::Java_CronetBidirectionalStream_onMetricsCollected(
+      env, owner_.obj(), start_time.ToJavaTime(),
+      ConvertTime(load_timing_info.connect_timing.dns_start, start_time,
+                  start_ticks),
+      ConvertTime(load_timing_info.connect_timing.dns_end, start_time,
+                  start_ticks),
+      ConvertTime(load_timing_info.connect_timing.connect_start, start_time,
+                  start_ticks),
+      ConvertTime(load_timing_info.connect_timing.connect_end, start_time,
+                  start_ticks),
+      ConvertTime(load_timing_info.connect_timing.ssl_start, start_time,
+                  start_ticks),
+      ConvertTime(load_timing_info.connect_timing.ssl_end, start_time,
+                  start_ticks),
+      ConvertTime(load_timing_info.send_start, start_time, start_ticks),
+      ConvertTime(load_timing_info.send_end, start_time, start_ticks),
+      ConvertTime(load_timing_info.push_start, start_time, start_ticks),
+      ConvertTime(load_timing_info.push_end, start_time, start_ticks),
+      ConvertTime(load_timing_info.receive_headers_end, start_time,
+                  start_ticks),
+      ConvertTime(base::TimeTicks::Now(), start_time, start_ticks),
+      load_timing_info.socket_reused, bidi_stream_->GetTotalSentBytes(),
+      bidi_stream_->GetTotalReceivedBytes());
+}
+
 }  // namespace cronet