Stop using SpdySynStreamIR for SPDY 4.

net/spdy/spdy_proxy_client_socket_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/spdy/spdy_proxy_client_socket.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/address_list.h"
@@ skipping 53 matching lines @@
     : public PlatformTest,
       public testing::WithParamInterface<NextProto> {
  public:
   SpdyProxyClientSocketTest();
 
   virtual void TearDown();
 
  protected:
   void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes,
                   size_t writes_count);
-  void PopulateConnectRequestIR(SpdySynStreamIR* syn_ir);
+  void PopulateConnectRequestIR(SpdyHeaderBlock* syn_ir);
   void PopulateConnectReplyIR(SpdyHeaderBlock* block, const char* status);
   SpdyFrame* ConstructConnectRequestFrame();
   SpdyFrame* ConstructConnectAuthRequestFrame();
   SpdyFrame* ConstructConnectReplyFrame();
   SpdyFrame* ConstructConnectAuthReplyFrame();
   SpdyFrame* ConstructConnectRedirectReplyFrame();
   SpdyFrame* ConstructConnectErrorReplyFrame();
   SpdyFrame* ConstructBodyFrame(const char* data, int length);
   scoped_refptr<IOBufferWithSize> CreateBuffer(const char* data, int size);
   void AssertConnectSucceeds();
@@ skipping 219 matching lines @@
 
   for (int i = 0; i < num_reads; i++) {
     Run(1);
     AssertSyncReadEquals(kMsg2, kLen2);
   }
 
   write_callback_.WaitForResult();
 }
 
 void SpdyProxyClientSocketTest::PopulateConnectRequestIR(
-    SpdySynStreamIR* syn_ir) {
-  spdy_util_.SetPriority(LOWEST, syn_ir);
-  syn_ir->SetHeader(spdy_util_.GetMethodKey(), "CONNECT");
-  syn_ir->SetHeader(spdy_util_.GetPathKey(), kOriginHostPort);
-  syn_ir->SetHeader(spdy_util_.GetHostKey(), kOriginHost);
-  syn_ir->SetHeader("user-agent", kUserAgent);
-  spdy_util_.MaybeAddVersionHeader(syn_ir);
+    SpdyHeaderBlock* block) {
+  (*block)[spdy_util_.GetMethodKey()] = "CONNECT";
+  (*block)[spdy_util_.GetPathKey()] = kOriginHostPort;
+  (*block)[spdy_util_.GetHostKey()] = kOriginHost;
+  (*block)["user-agent"] = kUserAgent;
+  spdy_util_.MaybeAddVersionHeader(block);
 }
 
 void SpdyProxyClientSocketTest::PopulateConnectReplyIR(SpdyHeaderBlock* block,
                                                        const char* status) {
   (*block)[spdy_util_.GetStatusKey()] = status;
   spdy_util_.MaybeAddVersionHeader(block);
 }
 
 // Constructs a standard SPDY SYN_STREAM frame for a CONNECT request.
 SpdyFrame*
 SpdyProxyClientSocketTest::ConstructConnectRequestFrame() {
-  SpdySynStreamIR syn_ir(kStreamId);
-  PopulateConnectRequestIR(&syn_ir);
-  return spdy_util_.CreateFramer(false)->SerializeFrame(syn_ir);
+  SpdyHeaderBlock block;
+  PopulateConnectRequestIR(&block);
+  return spdy_util_.ConstructSpdySyn(kStreamId, block, LOWEST, false, false);
 }
 
 // Constructs a SPDY SYN_STREAM frame for a CONNECT request which includes
 // Proxy-Authorization headers.
 SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectAuthRequestFrame() {
-  SpdySynStreamIR syn_ir(kStreamId);
-  PopulateConnectRequestIR(&syn_ir);
-  syn_ir.SetHeader("proxy-authorization", "Basic Zm9vOmJhcg==");
-  return spdy_util_.CreateFramer(false)->SerializeFrame(syn_ir);
+  SpdyHeaderBlock block;
+  PopulateConnectRequestIR(&block);
+  block["proxy-authorization"] = "Basic Zm9vOmJhcg==";
+  return spdy_util_.ConstructSpdySyn(kStreamId, block, LOWEST, false, false);
 }
 
 // Constructs a standard SPDY SYN_REPLY frame to match the SPDY CONNECT.
 SpdyFrame* SpdyProxyClientSocketTest::ConstructConnectReplyFrame() {
   SpdyHeaderBlock block;
   PopulateConnectReplyIR(&block, "200");
   SpdySynReplyIR reply_ir(kStreamId);
   return spdy_util_.ConstructSpdyReply(kStreamId, block);
 }
 
@@ skipping 1022 matching lines @@
 
   EXPECT_FALSE(sock_.get());
   EXPECT_TRUE(read_callback.have_result());
   EXPECT_FALSE(write_callback_.have_result());
 
   // Let the RST_STREAM write while |rst| is in-scope.
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 }  // namespace net