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 {
 
@@ skipping 155 matching lines @@
                             base::Unretained(this), jsend_on_canceled));
 }
 
 void CronetURLRequestAdapter::OnReceivedRedirect(
     net::URLRequest* request,
     const net::RedirectInfo& redirect_info,
     bool* defer_redirect) {
   DCHECK(context_->IsOnNetworkThread());
   DCHECK(request->status().is_success());
   JNIEnv* env = base::android::AttachCurrentThread();
+
+  const net::HostPortPair host_port_pair =
+      !request->response_info().proxy_server.is_valid() ||
+              request->response_info().proxy_server.is_direct()
+          ? net::HostPortPair()
+          : request->response_info().proxy_server.host_port_pair();

[Not at Google. Contact bengr, 2016/09/14 21:54:09]

Is this test required? If proxy server is invalid or direct, isnt its
HostPortPair the default "net::HostPortPair()" anyways?

Same for other occurances in this file.

[tbansal1, 2016/09/14 22:04:16]

No. In fact, there is a DCHECK in ProxyServer::host_port_pair() method:
https://cs.chromium.org/chromium/src/net/proxy/proxy_server.cc?rcl=1473866283...
Adding the check here avoids tripping on those DCHECKs.
I can remove the checks here but then we are making an assumption that
ResponseInfo will contain a ProxyServer only when it is a valid non-direct Proxy
Server. I am not sure if we should be making that assumption (it holds
currently, but may not in future).

   cronet::Java_CronetUrlRequest_onRedirectReceived(
       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().npn_negotiated_protocol)
           .obj(),
-      ConvertUTF8ToJavaString(env,
-                              request->response_info().proxy_server.ToString())
-          .obj(),
+      ConvertUTF8ToJavaString(env, host_port_pair.ToString()).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 12 matching lines @@
       net::QUIC_NO_ERROR,
       ConvertUTF8ToJavaString(env, net::ErrorToString(net_error)).obj(),
       request->GetTotalReceivedBytes());
 }
 
 void CronetURLRequestAdapter::OnResponseStarted(net::URLRequest* request) {
   DCHECK(context_->IsOnNetworkThread());
   if (MaybeReportError(request))
     return;
   JNIEnv* env = base::android::AttachCurrentThread();
+  const net::HostPortPair host_port_pair =
+      !request->response_info().proxy_server.is_valid() ||
+              request->response_info().proxy_server.is_direct()
+          ? net::HostPortPair()
+          : request->response_info().proxy_server.host_port_pair();
   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().npn_negotiated_protocol)
           .obj(),
-      ConvertUTF8ToJavaString(env,
-                              request->response_info().proxy_server.ToString())
-          .obj());
+      ConvertUTF8ToJavaString(env, host_port_pair.ToString()).obj());
 }
 
 void CronetURLRequestAdapter::OnReadCompleted(net::URLRequest* request,
                                               int bytes_read) {
   DCHECK(context_->IsOnNetworkThread());
   if (MaybeReportError(request))
     return;
   if (bytes_read != 0) {
     JNIEnv* env = base::android::AttachCurrentThread();
     cronet::Java_CronetUrlRequest_onReadCompleted(
@@ skipping 110 matching lines @@
       ConvertUTF8ToJavaString(env, net::ErrorToString(net_error)).obj(),
       request->GetTotalReceivedBytes());
   return true;
 }
 
 net::URLRequest* CronetURLRequestAdapter::GetURLRequestForTesting() {
   return url_request_.get();
 }
 
 }  // namespace cronet