Land Recent QUIC changes

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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/test_completion_callback.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/dns/mock_host_resolver.h"
@@ skipping 45 matching lines @@
 
 namespace net {
 namespace test {
 
 class QuicNetworkTransactionTest : public PlatformTest {
  protected:
   QuicNetworkTransactionTest()
       : clock_(new MockClock),
         ssl_config_service_(new SSLConfigServiceDefaults),
         proxy_service_(ProxyService::CreateDirect()),
+        compressor_(new QuicSpdyCompressor()),
         auth_handler_factory_(
             HttpAuthHandlerFactory::CreateDefault(&host_resolver_)) {
   }
 
   virtual void SetUp() {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     MessageLoop::current()->RunUntilIdle();
   }
 
   virtual void TearDown() {
@@ skipping 86 matching lines @@
     headers[":version"] = "HTTP/1.1";
     return SerializeHeaderBlock(headers);
   }
 
   std::string GetResponseString(const std::string& status,
                                 const std::string& body) {
     SpdyHeaderBlock headers;
     headers[":status"] = status;
     headers[":version"] = "HTTP/1.1";
     headers["content-type"] = "text/plain";
-    return SerializeHeaderBlock(headers) + body;
+    return compressor_->CompressHeaders(headers) + body;
   }
 
   std::string SerializeHeaderBlock(const SpdyHeaderBlock& headers) {
     size_t len = SpdyFramer::GetSerializedLength(3, &headers);
     SpdyFrameBuilder builder(len);
     SpdyFramer::WriteHeaderBlock(&builder, 3, &headers);
     scoped_ptr<SpdyFrame> frame(builder.take());
     return std::string(frame->data(), len);
   }
 
@@ skipping 51 matching lines @@
 
   QuicPacketHeader header_;
   scoped_refptr<HttpNetworkSession> session_;
   MockClientSocketFactory socket_factory_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockClock* clock_;  // Owned by QuicStreamFactory after CreateSession.
   MockHostResolver host_resolver_;
   MockCertVerifier cert_verifier_;
   scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
   scoped_ptr<ProxyService> proxy_service_;
+  scoped_ptr<QuicSpdyCompressor> compressor_;
   scoped_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
   MockRandom random_generator_;
   HttpServerPropertiesImpl http_server_properties;
   HttpNetworkSession::Params params_;
 };
 
 TEST_F(QuicNetworkTransactionTest, ForceQuic) {
   params_.origin_port_to_force_quic_on = 80;
 
   HttpRequestInfo request;
@@ skipping 383 matching lines @@
   ASSERT_TRUE(session_->http_server_properties()->HasAlternateProtocol(
       HostPortPair::FromURL(request.url)));
   const PortAlternateProtocolPair alternate =
       session_->http_server_properties()->GetAlternateProtocol(
           HostPortPair::FromURL(request.url));
   EXPECT_EQ(ALTERNATE_PROTOCOL_BROKEN, alternate.protocol);
 }
 
 }  // namespace test
 }  // namespace net