Store net::ProxyServer in HttpResponseInfo object

net/url_request/url_request_unittest.cc

 // Copyright (c) 2012 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 <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
@@ skipping 65 matching lines @@
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_source.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/log/test_net_log_util.h"
 #include "net/nqe/external_estimate_provider.h"
+#include "net/proxy/proxy_server.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/ssl/ssl_server_config.h"
 #include "net/ssl/token_binding.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
@@ skipping 2057 matching lines @@
   TestDelegate d;
   std::unique_ptr<URLRequest> req(
       context.CreateRequest(GURL("http://example.com"), DEFAULT_PRIORITY, &d));
   req->set_method("GET");
 
   req->Start();
   base::RunLoop().Run();
 
   // Check we see a failed request.
   // The proxy server is not set before failure.
-  EXPECT_TRUE(req->proxy_server().IsEmpty());
+  EXPECT_FALSE(req->proxy_server().is_valid());
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, d.request_status());
 
   EXPECT_EQ(1, network_delegate.error_count());
   EXPECT_THAT(network_delegate.last_error(),
               IsError(ERR_PROXY_CONNECTION_FAILED));
   EXPECT_EQ(1, network_delegate.completed_requests());
 }
 
 // Make sure that NetworkDelegate::NotifyCompleted is called if
 // content is empty.
@@ skipping 1423 matching lines @@
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(context.CreateRequest(
         GURL("https://www.redirect.com/"), DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     // The proxy server is not set before failure.
-    EXPECT_TRUE(r->proxy_server().IsEmpty());
+    EXPECT_FALSE(r->proxy_server().is_valid());
     EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, d.request_status());
     EXPECT_EQ(1, d.response_started_count());
     // We should not have followed the redirect.
     EXPECT_EQ(0, d.received_redirect_count());
   }
 }
 
 // This is the same as the previous test, but checks that the network delegate
 // registers the error.
 TEST_F(URLRequestTestHTTP, NetworkDelegateTunnelConnectionFailed) {
   ASSERT_TRUE(http_test_server()->Start());
 
   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
   TestURLRequestContextWithProxy context(
       http_test_server()->host_port_pair().ToString(), &network_delegate);
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(context.CreateRequest(
         GURL("https://www.redirect.com/"), DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     // The proxy server is not set before failure.
-    EXPECT_TRUE(r->proxy_server().IsEmpty());
+    EXPECT_FALSE(r->proxy_server().is_valid());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, d.request_status());
     // We should not have followed the redirect.
     EXPECT_EQ(0, d.received_redirect_count());
 
     EXPECT_EQ(1, network_delegate.error_count());
     EXPECT_THAT(network_delegate.last_error(),
                 IsError(ERR_TUNNEL_CONNECTION_FAILED));
   }
 }
@@ skipping 55 matching lines @@
       http_test_server()->host_port_pair().ToString(), &network_delegate);
 
   {
     std::unique_ptr<URLRequest> r(context.CreateRequest(
         http_test_server()->GetURL("/"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     // The proxy server is not set before cancellation.
-    EXPECT_TRUE(r->proxy_server().IsEmpty());
+    EXPECT_FALSE(r->proxy_server().is_valid());
     EXPECT_EQ(ERR_EMPTY_RESPONSE, d.request_status());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Helper function for NetworkDelegateCancelRequestAsynchronously and
 // NetworkDelegateCancelRequestSynchronously. Sets up a blocking network
 // delegate operating in |block_mode| and a request for |url|. It blocks the
@@ skipping 11 matching lines @@
   context.Init();
 
   {
     std::unique_ptr<URLRequest> r(
         context.CreateRequest(url, DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     // The proxy server is not set before cancellation.
-    EXPECT_TRUE(r->proxy_server().IsEmpty());
+    if (stage == BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST ||
+        stage == BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS) {
+      EXPECT_FALSE(r->proxy_server().is_valid());
+    } else if (stage == BlockingNetworkDelegate::ON_HEADERS_RECEIVED) {
+      EXPECT_TRUE(r->proxy_server().is_direct());
+    } else {
+      NOTREACHED();
+    }
     EXPECT_EQ(ERR_BLOCKED_BY_CLIENT, d.request_status());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // The following 3 tests check that the network delegate can cancel a request
 // synchronously in various stages of the request.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously1) {
@@ skipping 70 matching lines @@
     EXPECT_EQ(307, r->response_headers()->response_code());
     std::string location;
     ASSERT_TRUE(r->response_headers()->EnumerateHeader(NULL, "Location",
                                                        &location));
     EXPECT_EQ(redirect_url, GURL(location));
 
     // Let the request finish.
     r->FollowDeferredRedirect();
     base::RunLoop().Run();
     EXPECT_EQ(OK, d.request_status());
-    EXPECT_TRUE(r->proxy_server().Equals(http_test_server()->host_port_pair()));
+    EXPECT_EQ(ProxyServer(ProxyServer::SCHEME_HTTP,
+                          http_test_server()->host_port_pair()),
+              r->proxy_server());
     // before_send_headers_with_proxy_count only increments for headers sent
     // through an untunneled proxy.
     EXPECT_EQ(1, network_delegate.before_send_headers_with_proxy_count());
     EXPECT_TRUE(network_delegate.last_observed_proxy().Equals(
         http_test_server()->host_port_pair()));
 
     EXPECT_EQ(OK, d.request_status());
     EXPECT_EQ(redirect_url, r->url());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(2U, r->url_chain().size());
@@ skipping 33 matching lines @@
     std::string location;
     ASSERT_TRUE(r->response_headers()->EnumerateHeader(NULL, "Location",
                                                        &location));
     EXPECT_EQ(redirect_url, GURL(location));
 
     // Let the request finish.
     r->FollowDeferredRedirect();
     base::RunLoop().Run();
 
     EXPECT_EQ(OK, d.request_status());
-    EXPECT_TRUE(r->proxy_server().Equals(http_test_server()->host_port_pair()));
+    EXPECT_EQ(ProxyServer(ProxyServer::SCHEME_HTTP,
+                          http_test_server()->host_port_pair()),
+              r->proxy_server());
     // before_send_headers_with_proxy_count only increments for headers sent
     // through an untunneled proxy.
     EXPECT_EQ(1, network_delegate.before_send_headers_with_proxy_count());
     EXPECT_TRUE(network_delegate.last_observed_proxy().Equals(
         http_test_server()->host_port_pair()));
     EXPECT_EQ(OK, d.request_status());
     EXPECT_EQ(redirect_url, r->url());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(2U, r->url_chain().size());
     EXPECT_EQ(1, network_delegate.created_requests());
@@ skipping 76 matching lines @@
 
   {
     GURL original_url(http_test_server()->GetURL("/defaultresponse"));
     std::unique_ptr<URLRequest> r(
         context.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(OK, d.request_status());
-    EXPECT_TRUE(r->proxy_server().Equals(http_test_server()->host_port_pair()));
+    EXPECT_EQ(ProxyServer(ProxyServer::SCHEME_HTTP,
+                          http_test_server()->host_port_pair()),
+              r->proxy_server());
     // before_send_headers_with_proxy_count only increments for headers sent
     // through an untunneled proxy.
     EXPECT_EQ(2, network_delegate.before_send_headers_with_proxy_count());
     EXPECT_TRUE(network_delegate.last_observed_proxy().Equals(
         http_test_server()->host_port_pair()));
 
     EXPECT_EQ(OK, d.request_status());
     EXPECT_EQ(redirect_url, r->url());
     EXPECT_EQ(original_url, r->original_url());
     EXPECT_EQ(2U, r->url_chain().size());
@@ skipping 460 matching lines @@
   {
     std::unique_ptr<URLRequest> r(context.CreateRequest(
         GURL("https://www.server-auth.com/"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     // The proxy server is not set before failure.
-    EXPECT_TRUE(r->proxy_server().IsEmpty());
+    EXPECT_FALSE(r->proxy_server().is_valid());
     EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, d.request_status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, GetTest_NoCache) {
   ASSERT_TRUE(http_test_server()->Start());
 
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
@@ skipping 5736 matching lines @@
   AddTestInterceptor()->set_main_intercept_job(std::move(job));
 
   req->Start();
   req->Cancel();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ERR_ABORTED, d.request_status());
   EXPECT_EQ(0, d.received_redirect_count());
 }
 
 }  // namespace net