[SPDY] Refactor tests in preparation for a fix for a session flow control bug

net/spdy/spdy_stream_spdy2_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/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_log_unittest.h"
 #include "net/spdy/buffered_spdy_framer.h"
 #include "net/spdy/spdy_stream.h"
@@ skipping 22 matching lines @@
   0,
   ConvertRequestPriorityToSpdyPriority(LOWEST, 2),
   CONTROL_FLAG_NONE,
   false,
   RST_STREAM_INVALID,
   NULL,
   0,
   DATA_FLAG_NONE
 };
 
-const char* const kGetHeaders[] = {
-  "method",
-  "GET",
-  "scheme",
-  "http",
-  "host",
-  "www.google.com",
-  "url",
-  "/",
-  "version",
-  "HTTP/1.1",
-};
-
-scoped_ptr<SpdyFrame> ConstructSpdyGetRequest() {
+// TODO(akalin): Merge with ConstructSpdyGet(). (The sticking point is
+// CONTROL_FLAG_NONE vs. CONTROL_FLAG_FIN.)
+scoped_ptr<SpdyFrame> ConstructSpdyGetRequest(const char* url) {
   return scoped_ptr<SpdyFrame>(
-      ConstructSpdyPacket(
-          kSynStartHeader, NULL, 0, kGetHeaders, arraysize(kGetHeaders) / 2));
-}
-
-scoped_ptr<SpdyHeaderBlock> ConstructSpdyGetHeaderBlock() {
-  scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
-  for (size_t i = 0; i < arraysize(kGetHeaders) / 2; ++i) {
-    (*headers)[kGetHeaders[2*i]] = kGetHeaders[2*i+1];
-  }
-  return headers.Pass();
+      ConstructSpdyPacket(kSynStartHeader, ConstructHeaderBlock(url)));
 }
 
 scoped_ptr<SpdyFrame> ConstructSpdyBodyFrame(const char* data, int length) {
   BufferedSpdyFramer framer(kSpdyVersion2, false);
   return scoped_ptr<SpdyFrame>(
       framer.CreateDataFrame(1, data, length, DATA_FLAG_NONE));
 }
 
 class SpdyStreamSpdy2Test : public testing::Test {
  protected:
@@ skipping 25 matching lines @@
   virtual void TearDown() {
     MessageLoop::current()->RunUntilIdle();
   }
 
   HostPortPair host_port_pair_;
   SpdySessionDependencies session_deps_;
   scoped_refptr<HttpNetworkSession> session_;
 };
 
 TEST_F(SpdyStreamSpdy2Test, SendDataAfterOpen) {
+  const char kStreamUrl[] = "http://www.google.com/";
+  GURL url(kStreamUrl);
+
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 
-  scoped_ptr<SpdyFrame> req = ConstructSpdyGetRequest();
+  scoped_ptr<SpdyFrame> req = ConstructSpdyGetRequest(kStreamUrl);
   scoped_ptr<SpdyFrame> msg = ConstructSpdyBodyFrame("\0hello!\xff", 8);
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*msg),
   };
   writes[0].sequence_number = 0;
   writes[1].sequence_number = 2;
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> echo(
       ConstructSpdyBodyFrame("\0hello!\xff", 8));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*echo),
     MockRead(ASYNC, 0, 0), // EOF
   };
   reads[0].sequence_number = 1;
   reads[1].sequence_number = 3;
   reads[2].sequence_number = 4;
 
   OrderedSocketData data(reads, arraysize(reads),
                          writes, arraysize(writes));
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   scoped_refptr<SpdySession> session(CreateSpdySession());
-  const char kStreamUrl[] = "http://www.google.com/";
-  GURL url(kStreamUrl);
 
   InitializeSpdySession(session, host_port_pair_);
 
   scoped_refptr<SpdyStream> stream =
       CreateStreamSynchronously(session, url, LOWEST, BoundNetLog());
   ASSERT_TRUE(stream.get() != NULL);
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(8));
   memcpy(buf->data(), "\0hello!\xff", 8);
 
   StreamDelegateSendImmediate delegate(
       stream.get(), scoped_ptr<SpdyHeaderBlock>(), buf.get());
   stream->SetDelegate(&delegate);
 
   EXPECT_FALSE(stream->HasUrl());
 
-  stream->set_spdy_headers(ConstructSpdyGetHeaderBlock());
+  stream->set_spdy_headers(ConstructHeaderBlock(kStreamUrl));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(true));
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 
   EXPECT_TRUE(delegate.send_headers_completed());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue("status"));
   EXPECT_EQ("HTTP/1.1", delegate.GetResponseHeaderValue("version"));
@@ skipping 119 matching lines @@
   response["version"] = "OK";
   stream->OnHeaders(headers);
 
   stream->set_response_received();
   EXPECT_TRUE(stream->response_received());
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 }
 
 TEST_F(SpdyStreamSpdy2Test, StreamError) {
+  const char kStreamUrl[] = "http://www.google.com/";
+  GURL url(kStreamUrl);
+
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 
-  scoped_ptr<SpdyFrame> req = ConstructSpdyGetRequest();
+  scoped_ptr<SpdyFrame> req = ConstructSpdyGetRequest(kStreamUrl);
   scoped_ptr<SpdyFrame> msg(
       ConstructSpdyBodyFrame("\0hello!\xff", 8));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*msg),
   };
   writes[0].sequence_number = 0;
   writes[1].sequence_number = 2;
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
@@ skipping 11 matching lines @@
   CapturingBoundNetLog log;
 
   OrderedSocketData data(reads, arraysize(reads),
                          writes, arraysize(writes));
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   scoped_refptr<SpdySession> session(CreateSpdySession());
-  const char kStreamUrl[] = "http://www.google.com/";
-  GURL url(kStreamUrl);
 
   InitializeSpdySession(session, host_port_pair_);
 
   scoped_refptr<SpdyStream> stream =
       CreateStreamSynchronously(session, url, LOWEST, log.bound());
   ASSERT_TRUE(stream.get() != NULL);
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(8));
   memcpy(buf->data(), "\0hello!\xff", 8);
 
   StreamDelegateSendImmediate delegate(
       stream.get(), scoped_ptr<SpdyHeaderBlock>(), buf.get());
   stream->SetDelegate(&delegate);
 
   EXPECT_FALSE(stream->HasUrl());
 
-  stream->set_spdy_headers(ConstructSpdyGetHeaderBlock());
+  stream->set_spdy_headers(ConstructHeaderBlock(kStreamUrl));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(true));
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 
   const SpdyStreamId stream_id = stream->stream_id();
 
   EXPECT_TRUE(delegate.send_headers_completed());
@@ skipping 16 matching lines @@
   int stream_id2;
   ASSERT_TRUE(entries[pos].GetIntegerValue("stream_id", &stream_id2));
   EXPECT_EQ(static_cast<int>(stream_id), stream_id2);
 }
 
 }  // namespace
 
 }  // namespace test
 
 }  // namespace net