Store net::ProxyServer in HttpResponseInfo object

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>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "components/cronet/android/cronet_url_request_context_adapter.h"
 #include "components/cronet/android/io_buffer_with_byte_buffer.h"
 #include "components/cronet/android/url_request_error.h"
 #include "jni/CronetUrlRequest_jni.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/cert/cert_status_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/http/http_util.h"
+#include "net/proxy/proxy_server.h"
 #include "net/quic/core/quic_protocol.h"
 #include "net/ssl/ssl_info.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request_context.h"
 
 using base::android::ConvertUTF8ToJavaString;
 using base::android::JavaParamRef;
 
 namespace cronet {
 
 namespace {
 
 // Converts timing metrics stored as TimeTicks into the format expected by the
 // Java layer: ms since Unix epoch, or -1 for null
 int64_t ConvertTime(const base::TimeTicks& ticks,
                     const base::TimeTicks& start_ticks,
                     const base::Time& start_time) {
   if (ticks.is_null() || start_ticks.is_null()) {
     return -1;
   }
   DCHECK(!start_time.is_null());
   return (start_time + (ticks - start_ticks)).ToJavaTime();
 }
 
+// Returns the string representation of the HostPortPair of the proxy server
+// that was used to fetch the response.
+std::string GetProxy(const net::HttpResponseInfo& info) {
+  if (!info.proxy_server.is_valid() || info.proxy_server.is_direct())
+    return net::HostPortPair().ToString();
+  return info.proxy_server.host_port_pair().ToString();
+}
+
 }  // namespace
 
 // Explicitly register static JNI functions.
 bool CronetUrlRequestAdapterRegisterJni(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 static jlong CreateRequestAdapter(JNIEnv* env,
                                   const JavaParamRef<jobject>& jurl_request,
                                   jlong jurl_request_context_adapter,
@@ skipping 160 matching lines @@
       env, owner_.obj(),
       ConvertUTF8ToJavaString(env, redirect_info.new_url.spec()).obj(),
       redirect_info.status_code,
       ConvertUTF8ToJavaString(env, request->response_headers()->GetStatusText())
           .obj(),
       GetResponseHeaders(env).obj(),
       request->response_info().was_cached ? JNI_TRUE : JNI_FALSE,
       ConvertUTF8ToJavaString(env,
                               request->response_info().alpn_negotiated_protocol)
           .obj(),
-      ConvertUTF8ToJavaString(env,
-                              request->response_info().proxy_server.ToString())
-          .obj(),
+      ConvertUTF8ToJavaString(env, GetProxy(request->response_info())).obj(),
       request->GetTotalReceivedBytes());
   *defer_redirect = true;
 }
 
 void CronetURLRequestAdapter::OnCertificateRequested(
     net::URLRequest* request,
     net::SSLCertRequestInfo* cert_request_info) {
   DCHECK(context_->IsOnNetworkThread());
   // Cronet does not support client certificates.
   request->ContinueWithCertificate(nullptr, nullptr);
@@ skipping 26 matching lines @@
   JNIEnv* env = base::android::AttachCurrentThread();
   cronet::Java_CronetUrlRequest_onResponseStarted(
       env, owner_.obj(), request->GetResponseCode(),
       ConvertUTF8ToJavaString(env, request->response_headers()->GetStatusText())
           .obj(),
       GetResponseHeaders(env).obj(),
       request->response_info().was_cached ? JNI_TRUE : JNI_FALSE,
       ConvertUTF8ToJavaString(env,
                               request->response_info().alpn_negotiated_protocol)
           .obj(),
-      ConvertUTF8ToJavaString(env,
-                              request->response_info().proxy_server.ToString())
-          .obj());
+      ConvertUTF8ToJavaString(env, GetProxy(request->response_info())).obj());
 }
 
 void CronetURLRequestAdapter::OnReadCompleted(net::URLRequest* request,
                                               int bytes_read) {
   DCHECK(context_->IsOnNetworkThread());
 
   if (bytes_read < 0) {
     ReportError(request, bytes_read);
     return;
   }
@@ skipping 140 matching lines @@
       ConvertTime(base::TimeTicks::Now(), start_ticks, start_time),
       metrics.socket_reused, url_request_->GetTotalSentBytes(),
       url_request_->GetTotalReceivedBytes());
 }
 
 net::URLRequest* CronetURLRequestAdapter::GetURLRequestForTesting() {
   return url_request_.get();
 }
 
 }  // namespace cronet