Remove //net (except for Android test stuff) and sdch

net/tools/flip_server/spdy_interface_test.cc

Index: net/tools/flip_server/spdy_interface_test.cc
diff --git a/net/tools/flip_server/spdy_interface_test.cc b/net/tools/flip_server/spdy_interface_test.cc
deleted file mode 100644
index d84543826253ae0c2ae8cb57270b1de9e43657f4..0000000000000000000000000000000000000000
--- a/net/tools/flip_server/spdy_interface_test.cc
+++ /dev/null
@@ -1,606 +0,0 @@
-// Copyright 2013 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/tools/flip_server/spdy_interface.h"
-
-#include <list>
-
-#include "base/memory/scoped_ptr.h"
-#include "base/strings/string_piece.h"
-#include "net/spdy/buffered_spdy_framer.h"
-#include "net/tools/balsa/balsa_enums.h"
-#include "net/tools/balsa/balsa_headers.h"
-#include "net/tools/flip_server/flip_config.h"
-#include "net/tools/flip_server/flip_test_utils.h"
-#include "net/tools/flip_server/mem_cache.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace net {
-
-using ::base::StringPiece;
-using ::testing::_;
-using ::testing::InSequence;
-using ::testing::InvokeWithoutArgs;
-using ::testing::Return;
-using ::testing::SaveArg;
-using ::testing::Values;
-
-namespace {
-
-struct StringSaver {
- public:
-  StringSaver() : data(NULL), size(0) {}
-  void Save() { string = std::string(data, size); }
-
-  const char* data;
-  size_t size;
-  std::string string;
-};
-
-class SpdyFramerVisitor : public BufferedSpdyFramerVisitorInterface {
- public:
-  virtual ~SpdyFramerVisitor() {}
-  MOCK_METHOD1(OnError, void(SpdyFramer::SpdyError));
-  MOCK_METHOD2(OnStreamError, void(SpdyStreamId, const std::string&));
-  MOCK_METHOD6(OnSynStream,
-               void(SpdyStreamId,
-                    SpdyStreamId,
-                    SpdyPriority,
-                    bool,
-                    bool,
-                    const SpdyHeaderBlock&));
-  MOCK_METHOD3(OnSynReply, void(SpdyStreamId, bool, const SpdyHeaderBlock&));
-  MOCK_METHOD5(OnHeaders,
-               void(SpdyStreamId,
-                    bool,
-                    SpdyPriority,
-                    bool,
-                    const SpdyHeaderBlock&));
-  MOCK_METHOD3(OnDataFrameHeader, void(SpdyStreamId, size_t, bool));
-  MOCK_METHOD4(OnStreamFrameData, void(SpdyStreamId,
-                                       const char*,
-                                       size_t,
-                                       bool));
-  MOCK_METHOD1(OnSettings, void(bool clear_persisted));
-  MOCK_METHOD3(OnSetting, void(SpdySettingsIds, uint8, uint32));
-  MOCK_METHOD2(OnPing, void(SpdyPingId unique_id, bool is_ack));
-  MOCK_METHOD2(OnRstStream, void(SpdyStreamId, SpdyRstStreamStatus));
-  MOCK_METHOD2(OnGoAway, void(SpdyStreamId, SpdyGoAwayStatus));
-  MOCK_METHOD2(OnWindowUpdate, void(SpdyStreamId, uint32));
-  MOCK_METHOD3(OnPushPromise,
-               void(SpdyStreamId, SpdyStreamId, const SpdyHeaderBlock&));
-  MOCK_METHOD2(OnUnknownFrame, bool(SpdyStreamId stream_id, int frame_type));
-};
-
-class FakeSMConnection : public SMConnection {
- public:
-  FakeSMConnection(EpollServer* epoll_server,
-                   SSLState* ssl_state,
-                   MemoryCache* memory_cache,
-                   FlipAcceptor* acceptor,
-                   std::string log_prefix)
-      : SMConnection(epoll_server,
-                     ssl_state,
-                     memory_cache,
-                     acceptor,
-                     log_prefix) {}
-
-  MOCK_METHOD0(Cleanup, void());
-  MOCK_METHOD8(InitSMConnection,
-               void(SMConnectionPoolInterface*,
-                    SMInterface*,
-                    EpollServer*,
-                    int,
-                    std::string,
-                    std::string,
-                    std::string,
-                    bool));
-};
-
-// This class is almost SpdySM, except one function.
-// This class is the test target of tests in this file.
-class TestSpdySM : public SpdySM {
- public:
-  virtual ~TestSpdySM() {}
-  TestSpdySM(SMConnection* connection,
-             SMInterface* sm_http_interface,
-             EpollServer* epoll_server,
-             MemoryCache* memory_cache,
-             FlipAcceptor* acceptor,
-             SpdyMajorVersion version)
-      : SpdySM(connection,
-               sm_http_interface,
-               epoll_server,
-               memory_cache,
-               acceptor,
-               version) {}
-
-  MOCK_METHOD2(FindOrMakeNewSMConnectionInterface,
-               SMInterface*(const std::string&, const std::string&));
-};
-
-class SpdySMTestBase : public ::testing::TestWithParam<SpdyMajorVersion> {
- public:
-  explicit SpdySMTestBase(FlipHandlerType type) {
-    SSLState* ssl_state = NULL;
-    mock_another_interface_.reset(new MockSMInterface);
-    memory_cache_.reset(new MemoryCache);
-    acceptor_.reset(new FlipAcceptor(type,
-                                     "127.0.0.1",
-                                     "8941",
-                                     "ssl_cert_filename",
-                                     "ssl_key_filename",
-                                     "127.0.0.1",
-                                     "8942",
-                                     "127.0.0.1",
-                                     "8943",
-                                     1,
-                                     0,
-                                     true,
-                                     1,
-                                     false,
-                                     true,
-                                     NULL));
-    epoll_server_.reset(new EpollServer);
-    connection_.reset(new FakeSMConnection(epoll_server_.get(),
-                                           ssl_state,
-                                           memory_cache_.get(),
-                                           acceptor_.get(),
-                                           "log_prefix"));
-
-    interface_.reset(new TestSpdySM(connection_.get(),
-                                    mock_another_interface_.get(),
-                                    epoll_server_.get(),
-                                    memory_cache_.get(),
-                                    acceptor_.get(),
-                                    GetParam()));
-
-    spdy_framer_.reset(new BufferedSpdyFramer(GetParam(), true));
-    spdy_framer_visitor_.reset(new SpdyFramerVisitor);
-    spdy_framer_->set_visitor(spdy_framer_visitor_.get());
-  }
-
-  virtual ~SpdySMTestBase() {
-    if (acceptor_->listen_fd_ >= 0) {
-      epoll_server_->UnregisterFD(acceptor_->listen_fd_);
-      close(acceptor_->listen_fd_);
-      acceptor_->listen_fd_ = -1;
-    }
-    OutputList& output_list = *connection_->output_list();
-    for (OutputList::const_iterator i = output_list.begin();
-         i != output_list.end();
-         ++i) {
-      delete *i;
-    }
-    output_list.clear();
-  }
-
-  bool HasStream(uint32 stream_id) {
-    return interface_->output_ordering().ExistsInPriorityMaps(stream_id);
-  }
-
- protected:
-  scoped_ptr<MockSMInterface> mock_another_interface_;
-  scoped_ptr<MemoryCache> memory_cache_;
-  scoped_ptr<FlipAcceptor> acceptor_;
-  scoped_ptr<EpollServer> epoll_server_;
-  scoped_ptr<FakeSMConnection> connection_;
-  scoped_ptr<TestSpdySM> interface_;
-  scoped_ptr<BufferedSpdyFramer> spdy_framer_;
-  scoped_ptr<SpdyFramerVisitor> spdy_framer_visitor_;
-};
-
-class SpdySMProxyTest : public SpdySMTestBase {
- public:
-  SpdySMProxyTest() : SpdySMTestBase(FLIP_HANDLER_PROXY) {}
-  virtual ~SpdySMProxyTest() {}
-};
-
-class SpdySMServerTest : public SpdySMTestBase {
- public:
-  SpdySMServerTest() : SpdySMTestBase(FLIP_HANDLER_SPDY_SERVER) {}
-  virtual ~SpdySMServerTest() {}
-};
-
-INSTANTIATE_TEST_CASE_P(SpdySMProxyTest,
-                        SpdySMProxyTest,
-                        Values(SPDY3, SPDY4));
-INSTANTIATE_TEST_CASE_P(SpdySMServerTest, SpdySMServerTest, Values(SPDY4));
-
-TEST_P(SpdySMProxyTest, InitSMConnection) {
-  {
-    InSequence s;
-    EXPECT_CALL(*connection_, InitSMConnection(_, _, _, _, _, _, _, _));
-  }
-  interface_->InitSMConnection(
-      NULL, NULL, epoll_server_.get(), -1, "", "", "", false);
-}
-
-TEST_P(SpdySMProxyTest, OnStreamFrameData) {
-  BufferedSpdyFramerVisitorInterface* visitor = interface_.get();
-  scoped_ptr<MockSMInterface> mock_interface(new MockSMInterface);
-  uint32 stream_id = 92;
-  uint32 associated_id = 43;
-  SpdyHeaderBlock block;
-  testing::MockFunction<void(int)> checkpoint;  // NOLINT
-
-  scoped_ptr<SpdyFrame> frame(spdy_framer_->CreatePingFrame(12, false));
-  block[":method"] = "GET";
-  block[":host"] = "www.example.com";
-  block[":path"] = "/path";
-  block[":scheme"] = "http";
-  block["foo"] = "bar";
-  {
-    InSequence s;
-    EXPECT_CALL(*interface_,
-                FindOrMakeNewSMConnectionInterface(_, _))
-        .WillOnce(Return(mock_interface.get()));
-    EXPECT_CALL(*mock_interface, SetStreamID(stream_id));
-    EXPECT_CALL(*mock_interface, ProcessWriteInput(_, _)).Times(1);
-    EXPECT_CALL(checkpoint, Call(0));
-    EXPECT_CALL(*mock_interface,
-                ProcessWriteInput(frame->data(), frame->size())).Times(1);
-  }
-
-  visitor->OnSynStream(stream_id, associated_id, 0, false, false, block);
-  checkpoint.Call(0);
-  visitor->OnStreamFrameData(stream_id, frame->data(), frame->size(), true);
-}
-
-TEST_P(SpdySMProxyTest, OnRstStream) {
-  BufferedSpdyFramerVisitorInterface* visitor = interface_.get();
-  uint32 stream_id = 82;
-  MemCacheIter mci;
-  mci.stream_id = stream_id;
-
-  {
-    BalsaHeaders headers;
-    std::string filename = "foobar";
-    memory_cache_->InsertFile(&headers, filename, "");
-    mci.file_data = memory_cache_->GetFileData(filename);
-  }
-
-  interface_->AddToOutputOrder(mci);
-  ASSERT_TRUE(HasStream(stream_id));
-  visitor->OnRstStream(stream_id, RST_STREAM_INVALID);
-  ASSERT_FALSE(HasStream(stream_id));
-}
-
-TEST_P(SpdySMProxyTest, ProcessReadInput) {
-  ASSERT_EQ(SpdyFramer::SPDY_RESET, interface_->spdy_framer()->state());
-  interface_->ProcessReadInput("", 1);
-  ASSERT_EQ(SpdyFramer::SPDY_READING_COMMON_HEADER,
-            interface_->spdy_framer()->state());
-}
-
-TEST_P(SpdySMProxyTest, ResetForNewConnection) {
-  uint32 stream_id = 13;
-  MemCacheIter mci;
-  mci.stream_id = stream_id;
-  // incomplete input
-  const char input[] = {'\0', '\0', '\0'};
-
-  {
-    BalsaHeaders headers;
-    std::string filename = "foobar";
-    memory_cache_->InsertFile(&headers, filename, "");
-    mci.file_data = memory_cache_->GetFileData(filename);
-  }
-
-  interface_->AddToOutputOrder(mci);
-  ASSERT_TRUE(HasStream(stream_id));
-  interface_->ProcessReadInput(input, sizeof(input));
-  ASSERT_NE(SpdyFramer::SPDY_RESET, interface_->spdy_framer()->state());
-
-  interface_->ResetForNewConnection();
-  ASSERT_FALSE(HasStream(stream_id));
-  ASSERT_TRUE(interface_->spdy_framer() == NULL);
-}
-
-TEST_P(SpdySMProxyTest, CreateFramer) {
-  interface_->ResetForNewConnection();
-  interface_->CreateFramer(SPDY3);
-  ASSERT_TRUE(interface_->spdy_framer() != NULL);
-  ASSERT_EQ(interface_->spdy_version(), SPDY3);
-
-  interface_->ResetForNewConnection();
-  interface_->CreateFramer(SPDY4);
-  ASSERT_TRUE(interface_->spdy_framer() != NULL);
-  ASSERT_EQ(interface_->spdy_version(), SPDY4);
-}
-
-TEST_P(SpdySMProxyTest, PostAcceptHook) {
-  interface_->PostAcceptHook();
-
-  ASSERT_EQ(1u, connection_->output_list()->size());
-  std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
-  DataFrame* df = *i++;
-
-  {
-    InSequence s;
-    EXPECT_CALL(*spdy_framer_visitor_, OnSettings(false));
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnSetting(SETTINGS_MAX_CONCURRENT_STREAMS, 0u, 100u));
-  }
-  spdy_framer_->ProcessInput(df->data, df->size);
-}
-
-TEST_P(SpdySMProxyTest, NewStream) {
-  // TODO(yhirano): SpdySM::NewStream leads to crash when
-  // acceptor_->flip_handler_type_ != FLIP_HANDLER_SPDY_SERVER.
-  // It should be fixed though I don't know the solution now.
-}
-
-TEST_P(SpdySMProxyTest, AddToOutputOrder) {
-  uint32 stream_id = 13;
-  MemCacheIter mci;
-  mci.stream_id = stream_id;
-
-  {
-    BalsaHeaders headers;
-    std::string filename = "foobar";
-    memory_cache_->InsertFile(&headers, filename, "");
-    mci.file_data = memory_cache_->GetFileData(filename);
-  }
-
-  interface_->AddToOutputOrder(mci);
-  ASSERT_TRUE(HasStream(stream_id));
-}
-
-TEST_P(SpdySMProxyTest, SendErrorNotFound) {
-  uint32 stream_id = 82;
-  SpdyHeaderBlock actual_header_block;
-  const char* actual_data;
-  size_t actual_size;
-  testing::MockFunction<void(int)> checkpoint;  // NOLINT
-
-  interface_->SendErrorNotFound(stream_id);
-
-  ASSERT_EQ(2u, connection_->output_list()->size());
-
-  {
-    InSequence s;
-    if (GetParam() < SPDY4) {
-      EXPECT_CALL(*spdy_framer_visitor_,
-                  OnSynReply(stream_id, false, _))
-          .WillOnce(SaveArg<2>(&actual_header_block));
-    } else {
-      EXPECT_CALL(*spdy_framer_visitor_,
-                  OnHeaders(stream_id, false, 0, false, _))
-          .WillOnce(SaveArg<4>(&actual_header_block));
-    }
-    EXPECT_CALL(checkpoint, Call(0));
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnDataFrameHeader(stream_id, _, true));
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnStreamFrameData(stream_id, _, _, false)).Times(1)
-        .WillOnce(DoAll(SaveArg<1>(&actual_data),
-                        SaveArg<2>(&actual_size)));
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnStreamFrameData(stream_id, NULL, 0, true)).Times(1);
-  }
-
-  std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
-  DataFrame* df = *i++;
-  spdy_framer_->ProcessInput(df->data, df->size);
-  checkpoint.Call(0);
-  df = *i++;
-  spdy_framer_->ProcessInput(df->data, df->size);
-
-  ASSERT_EQ(2, spdy_framer_->frames_received());
-  ASSERT_EQ(2u, actual_header_block.size());
-  ASSERT_EQ("404 Not Found", actual_header_block[":status"]);
-  ASSERT_EQ("HTTP/1.1", actual_header_block[":version"]);
-  ASSERT_EQ("wtf?", StringPiece(actual_data, actual_size));
-}
-
-TEST_P(SpdySMProxyTest, SendSynStream) {
-  uint32 stream_id = 82;
-  BalsaHeaders headers;
-  SpdyHeaderBlock actual_header_block;
-  headers.AppendHeader("key1", "value1");
-  headers.AppendHeader("Host", "www.example.com");
-  headers.SetRequestFirstlineFromStringPieces("GET", "/path", "HTTP/1.1");
-
-  interface_->SendSynStream(stream_id, headers);
-
-  ASSERT_EQ(1u, connection_->output_list()->size());
-  std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
-  DataFrame* df = *i++;
-
-  {
-    InSequence s;
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnSynStream(stream_id, 0, _, false, false, _))
-        .WillOnce(SaveArg<5>(&actual_header_block));
-  }
-
-  spdy_framer_->ProcessInput(df->data, df->size);
-  ASSERT_EQ(1, spdy_framer_->frames_received());
-  ASSERT_EQ(5u, actual_header_block.size());
-  ASSERT_EQ("GET", actual_header_block[":method"]);
-  ASSERT_EQ("HTTP/1.1", actual_header_block[":version"]);
-  ASSERT_EQ("/path", actual_header_block[":path"]);
-  ASSERT_EQ("www.example.com", actual_header_block[":host"]);
-  ASSERT_EQ("value1", actual_header_block["key1"]);
-}
-
-TEST_P(SpdySMProxyTest, SendSynReply) {
-  uint32 stream_id = 82;
-  BalsaHeaders headers;
-  SpdyHeaderBlock actual_header_block;
-  headers.AppendHeader("key1", "value1");
-  headers.SetResponseFirstlineFromStringPieces("HTTP/1.1", "200", "OK");
-
-  interface_->SendSynReply(stream_id, headers);
-
-  ASSERT_EQ(1u, connection_->output_list()->size());
-  std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
-  DataFrame* df = *i++;
-
-  {
-    InSequence s;
-    if (GetParam() < SPDY4) {
-      EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
-          .WillOnce(SaveArg<2>(&actual_header_block));
-    } else {
-      EXPECT_CALL(*spdy_framer_visitor_,
-                  OnHeaders(stream_id, false, 0, false, _))
-          .WillOnce(SaveArg<4>(&actual_header_block));
-    }
-  }
-
-  spdy_framer_->ProcessInput(df->data, df->size);
-  ASSERT_EQ(1, spdy_framer_->frames_received());
-  ASSERT_EQ(3u, actual_header_block.size());
-  ASSERT_EQ("200 OK", actual_header_block[":status"]);
-  ASSERT_EQ("HTTP/1.1", actual_header_block[":version"]);
-  ASSERT_EQ("value1", actual_header_block["key1"]);
-}
-
-TEST_P(SpdySMProxyTest, SendDataFrame) {
-  uint32 stream_id = 133;
-  SpdyDataFlags flags = DATA_FLAG_NONE;
-  const char* actual_data;
-  size_t actual_size;
-
-  interface_->SendDataFrame(stream_id, "hello", 5, flags, true);
-
-  ASSERT_EQ(1u, connection_->output_list()->size());
-  std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
-  DataFrame* df = *i++;
-
-  {
-    InSequence s;
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnDataFrameHeader(stream_id, _, false));
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnStreamFrameData(stream_id, _, _, false))
-        .WillOnce(DoAll(SaveArg<1>(&actual_data), SaveArg<2>(&actual_size)));
-  }
-
-  spdy_framer_->ProcessInput(df->data, df->size);
-  ASSERT_EQ(1, spdy_framer_->frames_received());
-  ASSERT_EQ("hello", StringPiece(actual_data, actual_size));
-}
-
-TEST_P(SpdySMProxyTest, SendLongDataFrame) {
-  uint32 stream_id = 133;
-  SpdyDataFlags flags = DATA_FLAG_NONE;
-  const char* actual_data;
-  size_t actual_size;
-
-  std::string data = std::string(kSpdySegmentSize, 'a') +
-                     std::string(kSpdySegmentSize, 'b') + "c";
-  interface_->SendDataFrame(stream_id, data.data(), data.size(), flags, true);
-
-  {
-    InSequence s;
-    for (int i = 0; i < 3; ++i) {
-        EXPECT_CALL(*spdy_framer_visitor_,
-                    OnDataFrameHeader(stream_id, _, false));
-        EXPECT_CALL(*spdy_framer_visitor_,
-                    OnStreamFrameData(stream_id, _, _, false))
-            .WillOnce(DoAll(SaveArg<1>(&actual_data),
-                            SaveArg<2>(&actual_size)));
-    }
-  }
-
-  ASSERT_EQ(3u, connection_->output_list()->size());
-  std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
-  DataFrame* df = *i++;
-  spdy_framer_->ProcessInput(df->data, df->size);
-  ASSERT_EQ(std::string(kSpdySegmentSize, 'a'),
-            StringPiece(actual_data, actual_size));
-
-  df = *i++;
-  spdy_framer_->ProcessInput(df->data, df->size);
-  ASSERT_EQ(std::string(kSpdySegmentSize, 'b'),
-            StringPiece(actual_data, actual_size));
-
-  df = *i++;
-  spdy_framer_->ProcessInput(df->data, df->size);
-  ASSERT_EQ("c", StringPiece(actual_data, actual_size));
-}
-
-TEST_P(SpdySMServerTest, OnSynStream) {
-  BufferedSpdyFramerVisitorInterface* visitor = interface_.get();
-  uint32 stream_id = 82;
-  SpdyHeaderBlock spdy_headers;
-  spdy_headers["url"] = "http://www.example.com/path";
-  spdy_headers["method"] = "GET";
-  spdy_headers["scheme"] = "http";
-  spdy_headers["version"] = "HTTP/1.1";
-
-  {
-    BalsaHeaders headers;
-    memory_cache_->InsertFile(&headers, "GET_/path", "");
-  }
-  visitor->OnSynStream(stream_id, 0, 0, true, true, spdy_headers);
-  ASSERT_TRUE(HasStream(stream_id));
-}
-
-TEST_P(SpdySMServerTest, NewStream) {
-  uint32 stream_id = 13;
-  std::string filename = "foobar";
-
-  {
-    BalsaHeaders headers;
-    memory_cache_->InsertFile(&headers, filename, "");
-  }
-
-  interface_->NewStream(stream_id, 0, filename);
-  ASSERT_TRUE(HasStream(stream_id));
-}
-
-TEST_P(SpdySMServerTest, NewStreamError) {
-  uint32 stream_id = 82;
-  SpdyHeaderBlock actual_header_block;
-  const char* actual_data;
-  size_t actual_size;
-  testing::MockFunction<void(int)> checkpoint;  // NOLINT
-
-  interface_->NewStream(stream_id, 0, "nonexistingfile");
-
-  ASSERT_EQ(2u, connection_->output_list()->size());
-
-  {
-    InSequence s;
-    if (GetParam() < SPDY4) {
-      EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
-          .WillOnce(SaveArg<2>(&actual_header_block));
-    } else {
-      EXPECT_CALL(*spdy_framer_visitor_,
-                  OnHeaders(stream_id, false, 0, false, _))
-          .WillOnce(SaveArg<4>(&actual_header_block));
-    }
-    EXPECT_CALL(checkpoint, Call(0));
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnDataFrameHeader(stream_id, _, true));
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnStreamFrameData(stream_id, _, _, false)).Times(1)
-        .WillOnce(DoAll(SaveArg<1>(&actual_data),
-                        SaveArg<2>(&actual_size)));
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnStreamFrameData(stream_id, NULL, 0, true)).Times(1);
-  }
-
-  std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
-  DataFrame* df = *i++;
-  spdy_framer_->ProcessInput(df->data, df->size);
-  checkpoint.Call(0);
-  df = *i++;
-  spdy_framer_->ProcessInput(df->data, df->size);
-
-  ASSERT_EQ(2, spdy_framer_->frames_received());
-  ASSERT_EQ(2u, actual_header_block.size());
-  ASSERT_EQ("404 Not Found", actual_header_block["status"]);
-  ASSERT_EQ("HTTP/1.1", actual_header_block["version"]);
-  ASSERT_EQ("wtf?", StringPiece(actual_data, actual_size));
-}
-
-}  // namespace
-
-}  // namespace net