[Cronet] Make metrics reporting happen after terminal callbacks.

components/cronet/android/cronet_url_request_adapter.cc

 // Copyright 2014 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 "components/cronet/android/cronet_url_request_adapter.h"
 
 #include <limits>
 #include <utility>
 #include <vector>
 
@@ skipping 74 matching lines @@
     const GURL& url,
     net::RequestPriority priority,
     jboolean jdisable_cache,
     jboolean jdisable_connection_migration,
     jboolean jenable_metrics)
     : context_(context),
       initial_url_(url),
       initial_priority_(priority),
       initial_method_("GET"),
       load_flags_(context->default_load_flags()),
-      enable_metrics_(jenable_metrics == JNI_TRUE) {
+      enable_metrics_(jenable_metrics == JNI_TRUE),
+      metrics_reported_(false) {
   DCHECK(!context_->IsOnNetworkThread());
   owner_.Reset(env, jurl_request);
   if (jdisable_cache == JNI_TRUE)
     load_flags_ |= net::LOAD_DISABLE_CACHE;
   if (jdisable_connection_migration == JNI_TRUE)
     load_flags_ |= net::LOAD_DISABLE_CONNECTION_MIGRATION;
 }
 
 CronetURLRequestAdapter::~CronetURLRequestAdapter() {
   DCHECK(context_->IsOnNetworkThread());
@@ skipping 132 matching lines @@
   request->ContinueWithCertificate(nullptr, nullptr);
 }
 
 void CronetURLRequestAdapter::OnSSLCertificateError(
     net::URLRequest* request,
     const net::SSLInfo& ssl_info,
     bool fatal) {
   DCHECK(context_->IsOnNetworkThread());
   request->Cancel();
   int net_error = net::MapCertStatusToNetError(ssl_info.cert_status);
-  JNIEnv* env = base::android::AttachCurrentThread();
-  cronet::Java_CronetUrlRequest_onError(
-      env, owner_.obj(), NetErrorToUrlRequestError(net_error), net_error,
-      net::QUIC_NO_ERROR,
-      ConvertUTF8ToJavaString(env, net::ErrorToString(net_error)).obj(),
-      request->GetTotalReceivedBytes());
+  ReportError(request, net_error);
 }
 
 void CronetURLRequestAdapter::OnResponseStarted(net::URLRequest* request,
                                                 int net_error) {
   DCHECK_NE(net::ERR_IO_PENDING, net_error);
   DCHECK(context_->IsOnNetworkThread());
 
   if (net_error != net::OK) {
     ReportError(request, net_error);
     return;
@@ skipping 15 matching lines @@
                                               int bytes_read) {
   DCHECK(context_->IsOnNetworkThread());
 
   if (bytes_read < 0) {
     ReportError(request, bytes_read);
     return;
   }
 
   if (bytes_read == 0) {
     JNIEnv* env = base::android::AttachCurrentThread();
+    MaybeReportMetrics(env);
     cronet::Java_CronetUrlRequest_onSucceeded(
         env, owner_.obj(), url_request_->GetTotalReceivedBytes());
   } else {
     JNIEnv* env = base::android::AttachCurrentThread();
     cronet::Java_CronetUrlRequest_onReadCompleted(
         env, owner_.obj(), read_buffer_->byte_buffer(), bytes_read,
         read_buffer_->initial_position(), read_buffer_->initial_limit(),
         request->GetTotalReceivedBytes());
     // Free the read buffer. This lets the Java ByteBuffer be freed, if the
     // embedder releases it, too.
@@ skipping 70 matching lines @@
   // If IO is pending, wait for the URLRequest to call OnReadCompleted.
   if (result == net::ERR_IO_PENDING)
     return;
 
   OnReadCompleted(url_request_.get(), result);
 }
 
 void CronetURLRequestAdapter::DestroyOnNetworkThread(bool send_on_canceled) {
   DCHECK(context_->IsOnNetworkThread());
   JNIEnv* env = base::android::AttachCurrentThread();
-  if (send_on_canceled) {
+  MaybeReportMetrics(env);
+  if (send_on_canceled)
     cronet::Java_CronetUrlRequest_onCanceled(env, owner_.obj());
-  }
-  MaybeReportMetrics(env);
+  cronet::Java_CronetUrlRequest_onNativeAdapterDestroyed(env, owner_.obj());
   delete this;
 }
 
 void CronetURLRequestAdapter::ReportError(net::URLRequest* request,
                                           int net_error) {
   DCHECK_NE(net::ERR_IO_PENDING, net_error);
   DCHECK_LT(net_error, 0);
   DCHECK_EQ(request, url_request_.get());
 
   net::NetErrorDetails net_error_details;
   url_request_->PopulateNetErrorDetails(&net_error_details);
   VLOG(1) << "Error " << net::ErrorToString(net_error)
           << " on chromium request: " << initial_url_.possibly_invalid_spec();
   JNIEnv* env = base::android::AttachCurrentThread();
   cronet::Java_CronetUrlRequest_onError(
       env, owner_.obj(), NetErrorToUrlRequestError(net_error), net_error,
       net_error_details.quic_connection_error,
       ConvertUTF8ToJavaString(env, net::ErrorToString(net_error)).obj(),
       request->GetTotalReceivedBytes());
 }
 
-void CronetURLRequestAdapter::MaybeReportMetrics(JNIEnv* env) const {
+void CronetURLRequestAdapter::MaybeReportMetrics(JNIEnv* env) {
   // If there was an exception while starting the CronetUrlRequest, there won't
   // be a native URLRequest. In this case, the caller gets the exception
   // immediately, and the onFailed callback isn't called, so don't report
   // metrics either.
-  if (!enable_metrics_ || !url_request_) {
+  if (!enable_metrics_ || metrics_reported_ || !url_request_) {
     return;
   }
+  metrics_reported_ = true;
   net::LoadTimingInfo metrics;
   url_request_->GetLoadTimingInfo(&metrics);
   base::Time start_time = metrics.request_start_time;
   base::TimeTicks start_ticks = metrics.request_start;
   Java_CronetUrlRequest_onMetricsCollected(
       env, owner_.obj(),
       metrics_util::ConvertTime(start_ticks, start_ticks, start_time),
       metrics_util::ConvertTime(metrics.connect_timing.dns_start, start_ticks,
                                 start_time),
       metrics_util::ConvertTime(metrics.connect_timing.dns_end, start_ticks,
@@ skipping 12 matching lines @@
       metrics_util::ConvertTime(metrics.push_end, start_ticks, start_time),
       metrics_util::ConvertTime(metrics.receive_headers_end, start_ticks,
                                 start_time),
       metrics_util::ConvertTime(base::TimeTicks::Now(), start_ticks,
                                 start_time),
       metrics.socket_reused, url_request_->GetTotalSentBytes(),
       url_request_->GetTotalReceivedBytes());
 }
 
 }  // namespace cronet