Update from chromium https://crrev.com/302282

net/http/http_proxy_client_socket_pool_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 "net/http/http_proxy_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 45 matching lines @@
 
 typedef ::testing::TestWithParam<HttpProxyType> TestWithHttpParam;
 
 const char kHttpProxyHost[] = "httpproxy.example.com";
 const char kHttpsProxyHost[] = "httpsproxy.example.com";
 
 class TestProxyDelegate : public ProxyDelegate {
  public:
   TestProxyDelegate()
       : on_before_tunnel_request_called_(false),
+        on_tunnel_request_completed_called_(false),
         on_tunnel_headers_received_called_(false) {
   }
 
   ~TestProxyDelegate() override {}
 
   bool on_before_tunnel_request_called() const {
     return on_before_tunnel_request_called_;
   }
 
+  bool on_tunnel_request_completed_called() const {
+    return on_tunnel_request_completed_called_;
+  }
+
   bool on_tunnel_headers_received_called() const {
     return on_tunnel_headers_received_called_;
   }
 
+  void VerifyOnTunnelRequestCompleted(const std::string& endpoint,
+                                      const std::string& proxy_server) const {
+    EXPECT_TRUE(on_tunnel_request_completed_called_);
+    EXPECT_TRUE(HostPortPair::FromString(endpoint).Equals(
+        on_tunnel_request_completed_endpoint_));
+    EXPECT_TRUE(HostPortPair::FromString(proxy_server).Equals(
+        on_tunnel_request_completed_proxy_server_));
+  }
+
   void VerifyOnTunnelHeadersReceived(const std::string& origin,
                                      const std::string& proxy_server,
                                      const std::string& status_line) const {
     EXPECT_TRUE(on_tunnel_headers_received_called_);
     EXPECT_TRUE(HostPortPair::FromString(origin).Equals(
                     on_tunnel_headers_received_origin_));
     EXPECT_TRUE(HostPortPair::FromString(proxy_server).Equals(
                     on_tunnel_headers_received_proxy_server_));
     EXPECT_EQ(status_line, on_tunnel_headers_received_status_line_);
   }
 
   // ProxyDelegate:
   void OnResolveProxy(const GURL& url,
                       int load_flags,
                       const ProxyService& proxy_service,
                       ProxyInfo* result) override {}
 
+  void OnTunnelConnectCompleted(const HostPortPair& endpoint,
+                                const HostPortPair& proxy_server,
+                                int net_error) override {
+    on_tunnel_request_completed_called_ = true;
+    on_tunnel_request_completed_endpoint_ = endpoint;
+    on_tunnel_request_completed_proxy_server_ = proxy_server;
+  }
+
   void OnFallback(const ProxyServer& bad_proxy, int net_error) override {}
 
   void OnBeforeSendHeaders(URLRequest* request,
                            const ProxyInfo& proxy_info,
                            HttpRequestHeaders* headers) override {}
 
   void OnBeforeTunnelRequest(const net::HostPortPair& proxy_server,
                              net::HttpRequestHeaders* extra_headers) override {
     on_before_tunnel_request_called_ = true;
     if (extra_headers) {
       extra_headers->SetHeader("Foo", proxy_server.ToString());
     }
   }
 
   void OnTunnelHeadersReceived(
       const net::HostPortPair& origin,
       const net::HostPortPair& proxy_server,
       const net::HttpResponseHeaders& response_headers) override {
     on_tunnel_headers_received_called_ = true;
     on_tunnel_headers_received_origin_ = origin;
     on_tunnel_headers_received_proxy_server_ = proxy_server;
     on_tunnel_headers_received_status_line_ = response_headers.GetStatusLine();
   }
 
  private:
   bool on_before_tunnel_request_called_;
+  bool on_tunnel_request_completed_called_;
   bool on_tunnel_headers_received_called_;
+  HostPortPair on_tunnel_request_completed_endpoint_;
+  HostPortPair on_tunnel_request_completed_proxy_server_;
   HostPortPair on_tunnel_headers_received_origin_;
   HostPortPair on_tunnel_headers_received_proxy_server_;
   std::string on_tunnel_headers_received_status_line_;
 };
 
 
 class HttpProxyClientSocketPoolTest
     : public ::testing::TestWithParam<HttpProxyClientSocketPoolTestParams> {
  protected:
   HttpProxyClientSocketPoolTest()
@@ skipping 204 matching lines @@
   int rv = handle_.Init("a", CreateNoTunnelParams(proxy_delegate.get()), LOW,
                         CompletionCallback(), &pool_, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   HttpProxyClientSocket* tunnel_socket =
           static_cast<HttpProxyClientSocket*>(handle_.socket());
   EXPECT_TRUE(tunnel_socket->IsConnected());
   EXPECT_FALSE(proxy_delegate->on_before_tunnel_request_called());
   EXPECT_FALSE(proxy_delegate->on_tunnel_headers_received_called());
+  EXPECT_TRUE(proxy_delegate->on_tunnel_request_completed_called());
 }
 
 // Make sure that HttpProxyConnectJob passes on its priority to its
 // (non-SSL) socket request on Init.
 TEST_P(HttpProxyClientSocketPoolTest, SetSocketRequestPriorityOnInit) {
   Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0);
   EXPECT_EQ(OK,
             handle_.Init("a", CreateNoTunnelParams(NULL), HIGHEST,
                          CompletionCallback(), &pool_, BoundNetLog()));
   EXPECT_EQ(HIGHEST, GetLastTransportRequestPriority());
@@ skipping 90 matching lines @@
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   HttpProxyClientSocket* tunnel_socket =
           static_cast<HttpProxyClientSocket*>(handle_.socket());
   EXPECT_TRUE(tunnel_socket->IsConnected());
   proxy_delegate->VerifyOnTunnelHeadersReceived(
       "www.google.com:443",
       proxy_host_port.c_str(),
       "HTTP/1.1 200 Connection Established");
+  proxy_delegate->VerifyOnTunnelRequestCompleted(
+      "www.google.com:443",
+      proxy_host_port.c_str());
 }
 
 TEST_P(HttpProxyClientSocketPoolTest, AsyncHaveAuth) {
+  std::string proxy_host_port =
+      GetParam().proxy_type == HTTP ?
+          (kHttpProxyHost + std::string(":80")) :
+          (kHttpsProxyHost + std::string(":443"));
+  std::string request =
+      "CONNECT www.google.com:443 HTTP/1.1\r\n"
+      "Host: www.google.com\r\n"
+      "Proxy-Connection: keep-alive\r\n"
+      "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n"
+      "Foo: " + proxy_host_port + "\r\n\r\n";
   MockWrite writes[] = {
-    MockWrite(ASYNC, 0, "CONNECT www.google.com:443 HTTP/1.1\r\n"
-              "Host: www.google.com\r\n"
-              "Proxy-Connection: keep-alive\r\n"
-              "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
+    MockWrite(ASYNC, 0, request.c_str()),
   };
   MockRead reads[] = {
     MockRead(ASYNC, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW));
   MockWrite spdy_writes[] = {
     CreateMockWrite(*req, 0, ASYNC)
   };
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
     MockRead(ASYNC, 0, 2)
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes),
              spdy_reads, arraysize(spdy_reads), spdy_writes,
              arraysize(spdy_writes));
   AddAuthToCache();
 
-  int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW,
+  scoped_ptr<TestProxyDelegate> proxy_delegate(new TestProxyDelegate());
+  int rv = handle_.Init("a", CreateTunnelParams(proxy_delegate.get()), LOW,
                         callback_.callback(), &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   data_->RunFor(2);
   EXPECT_EQ(OK, callback_.WaitForResult());
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   HttpProxyClientSocket* tunnel_socket =
           static_cast<HttpProxyClientSocket*>(handle_.socket());
   EXPECT_TRUE(tunnel_socket->IsConnected());
+  proxy_delegate->VerifyOnTunnelRequestCompleted(
+      "www.google.com:443",
+      proxy_host_port.c_str());
 }
 
 // Make sure that HttpProxyConnectJob passes on its priority to its
 // SPDY session's socket request on Init (if applicable).
 TEST_P(HttpProxyClientSocketPoolTest,
        SetSpdySessionSocketRequestPriorityOnInit) {
   if (GetParam().proxy_type != SPDY)
     return;
 
   scoped_ptr<SpdyFrame> req(
@@ skipping 295 matching lines @@
     EXPECT_TRUE(headers->IsRedirect(&location));
     EXPECT_EQ(location, redirectTarget);
   }
 }
 
 // It would be nice to also test the timeouts in HttpProxyClientSocketPool.
 
 }  // namespace
 
 }  // namespace net