Treat QUIC proxy as a valid HTTP proxy.

net/quic/quic_network_transaction_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 <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
@@ skipping 84 matching lines @@
   }
 
  private:
   std::vector<QuicEncryptedPacket*> packets_;
   std::vector<MockWrite> writes_;
   std::vector<MockRead> reads_;
   size_t sequence_number_;
   scoped_ptr<SocketDataProvider> socket_data_;
 };
 
+class ProxyHeadersHandler {
+ public:
+  ProxyHeadersHandler() : was_called_(false) {}
+
+  bool WasCalled() { return was_called_; }

[Ryan Hamilton, 2015/02/05 18:43:12]

nit: according to the style guide, this should be was_called().

[tbansal1, 2015/02/05 20:11:55]

Done.

+
+  void OnBeforeProxyHeadersSent(const ProxyInfo& proxy_info,
+                                HttpRequestHeaders* request_headers) {
+    was_called_ = true;
+  }
+
+ private:
+  bool was_called_;
+};
+
 class QuicNetworkTransactionTest
     : public PlatformTest,
       public ::testing::WithParamInterface<QuicVersion> {
  protected:
   QuicNetworkTransactionTest()
       : clock_(new MockClock),
         maker_(GetParam(), 0, clock_),
         ssl_config_service_(new SSLConfigServiceDefaults),
         proxy_service_(ProxyService::CreateDirect()),
         auth_handler_factory_(
@@ skipping 146 matching lines @@
   }
 
   void SendRequestAndExpectHttpResponse(const std::string& expected) {
     scoped_ptr<HttpNetworkTransaction> trans(
         new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
     RunTransaction(trans.get());
     CheckWasHttpResponse(trans);
     CheckResponseData(trans.get(), expected);
   }
 
-  void SendRequestAndExpectQuicResponse(const std::string& expected) {
+  void SendRequestAndExpectQuicResponse(const std::string& expected,
+                                        bool expect_headers_callback) {

[Ryan Hamilton, 2015/02/05 18:43:12]

nit: I think this parameter should be named something like
"expect_proxy_headers" or even better "used_proxy".

[tbansal1, 2015/02/05 20:11:55]

Done.

     scoped_ptr<HttpNetworkTransaction> trans(
         new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
+    ProxyHeadersHandler proxy_headers_handler;
+    trans->SetBeforeProxyHeadersSentCallback(
+        base::Bind(&ProxyHeadersHandler::OnBeforeProxyHeadersSent,
+                   base::Unretained(&proxy_headers_handler)));
     RunTransaction(trans.get());
     CheckWasQuicResponse(trans);
     CheckResponseData(trans.get(), expected);
+    EXPECT_TRUE(!expect_headers_callback || proxy_headers_handler.WasCalled());
   }
 
   void AddQuicAlternateProtocolMapping(
       MockCryptoClientStream::HandshakeMode handshake_mode) {
     crypto_client_stream_factory_.set_handshake_mode(handshake_mode);
     session_->http_server_properties()->SetAlternateProtocol(
         HostPortPair::FromURL(request_.url), 80, QUIC, 1);
   }
 
   void ExpectBrokenAlternateProtocolMapping() {
@@ skipping 59 matching lines @@
   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
 
-  SendRequestAndExpectQuicResponse("hello!");
+  SendRequestAndExpectQuicResponse("hello!", false);
 
   // Check that the NetLog was filled reasonably.
   net::CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
   EXPECT_LT(0u, entries.size());
 
   // Check that we logged a QUIC_SESSION_PACKET_RECEIVED.
   int pos = net::ExpectLogContainsSomewhere(
       entries, 0,
       net::NetLog::TYPE_QUIC_SESSION_PACKET_RECEIVED,
@@ skipping 40 matching lines @@
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1);
 
   // There is no need to set up an alternate protocol job, because
   // no attempt will be made to speak to the proxy over TCP.
 
   CreateSession();
 
-  SendRequestAndExpectQuicResponse("hello!");
+  SendRequestAndExpectQuicResponse("hello!", true);

[Ryan Hamilton, 2015/02/05 18:43:12]

It's not obvious here what true and false refer to without going back to read
the method description. I recommend one of two approaches:
1) Create two variants of this method, like :
  SendRequestAndExpectQuicResponse("hello!")
  SendRequestAndExpectQuicResponseFromProxy("hello!")
which delegate to a private helper passing in false or true.
2) do something like:
  SendRequestAndExpectQuicResponse("hello!", /*used_proxy=*/true);
  SendRequestAndExpectQuicResponse("hello!", /*used_proxy=*/false);
or
  SendRequestAndExpectQuicResponse("hello!", kUsedProxy);
  SendRequestAndExpectQuicResponse("hello!", !kUsedProxy);

Personally, I'd probably go with #1

[tbansal1, 2015/02/05 20:11:55]

Done.

 }
 
 TEST_P(QuicNetworkTransactionTest, ForceQuicWithErrorConnecting) {
   params_.origin_to_force_quic_on =
       HostPortPair::FromString("www.google.com:80");
 
   MockQuicData mock_quic_data;
   mock_quic_data.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED);
 
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 0);
@@ skipping 57 matching lines @@
 
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSessionWithNextProtos();
 
   SendRequestAndExpectHttpResponse("hello world");
-  SendRequestAndExpectQuicResponse("hello!");
+  SendRequestAndExpectQuicResponse("hello!", false);
 }
 
 TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolProbabilityForQuic) {
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kQuicAlternateProtocol50pctHttpHeader),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
@@ skipping 17 matching lines @@
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   params_.alternate_protocol_probability_threshold = .25;
   CreateSessionWithNextProtos();
 
   SendRequestAndExpectHttpResponse("hello world");
-  SendRequestAndExpectQuicResponse("hello!");
+  SendRequestAndExpectQuicResponse("hello!", false);
 }
 
 TEST_P(QuicNetworkTransactionTest, DontUseAlternateProtocolProbabilityForQuic) {
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kQuicAlternateProtocol50pctHttpHeader),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
@@ skipping 144 matching lines @@
   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
-  SendRequestAndExpectQuicResponse("hello!");
+  SendRequestAndExpectQuicResponse("hello!", false);
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithNoHttpRace) {
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(
       ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
                                     GetRequestHeaders("GET", "http", "/")));
   mock_quic_data.AddRead(
       ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
                                      GetResponseHeaders("200 OK")));
@@ skipping 12 matching lines @@
   AddressList address;
   host_resolver_.Resolve(info,
                          DEFAULT_PRIORITY,
                          &address,
                          CompletionCallback(),
                          nullptr,
                          net_log_.bound());
 
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
-  SendRequestAndExpectQuicResponse("hello!");
+  SendRequestAndExpectQuicResponse("hello!", false);
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithProxy) {
   proxy_service_.reset(
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
 
   // Since we are using a proxy, the QUIC job will not succeed.
   MockWrite http_writes[] = {
     MockWrite(SYNCHRONOUS, 0, "GET http://www.google.com/ HTTP/1.1\r\n"),
     MockWrite(SYNCHRONOUS, 1, "Host: www.google.com\r\n"),
@@ skipping 293 matching lines @@
                          nullptr,
                          net_log_.bound());
 
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 }  // namespace test
 }  // namespace net