SPDY cleanup: remove credential slot.

net/tools/flip_server/spdy_interface_test.cc

 // 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"
@@ skipping 26 matching lines @@
   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_METHOD7(OnSynStream,
+  MOCK_METHOD6(OnSynStream,
                void(SpdyStreamId,
                     SpdyStreamId,
                     SpdyPriority,
-                    uint8,
                     bool,
                     bool,
                     const SpdyHeaderBlock&));
-  MOCK_METHOD3(OnSynStream, void(SpdyStreamId, bool, const SpdyHeaderBlock&));
   MOCK_METHOD3(OnSynReply, void(SpdyStreamId, bool, const SpdyHeaderBlock&));
   MOCK_METHOD3(OnHeaders, void(SpdyStreamId, 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_METHOD1(OnPing, void(uint32 unique_id));
@@ skipping 170 matching lines @@
     InSequence s;
     EXPECT_CALL(*interface_, FindOrMakeNewSMConnectionInterface(_, _))
         .WillOnce(Return(mock_interface.get()));
     EXPECT_CALL(*mock_interface, SetStreamID(stream_id));
     EXPECT_CALL(*mock_interface, ProcessWriteInput(_, _))
         .WillOnce(DoAll(SaveArg<0>(&saver.data),
                         SaveArg<1>(&saver.size),
                         InvokeWithoutArgs(&saver, &StringSaver::Save),
                         Return(0)));
   }
-  visitor->OnSynStream(stream_id, associated_id, 0, 0, false, false, block);
+  visitor->OnSynStream(stream_id, associated_id, 0, false, false, block);
   ASSERT_EQ(expected, saver.string);
 }
 
 TEST_P(SpdySMProxyTest, OnSynStream) {
   if (GetParam() == SPDY2) {
     // This test case is not for SPDY2.
     return;
   }
   BufferedSpdyFramerVisitorInterface* visitor = interface_.get();
   scoped_ptr<MockSMInterface> mock_interface(new MockSMInterface);
@@ skipping 14 matching lines @@
     EXPECT_CALL(*interface_,
                 FindOrMakeNewSMConnectionInterface(_, _))
         .WillOnce(Return(mock_interface.get()));
     EXPECT_CALL(*mock_interface, SetStreamID(stream_id));
     EXPECT_CALL(*mock_interface, ProcessWriteInput(_, _))
         .WillOnce(DoAll(SaveArg<0>(&saver.data),
                         SaveArg<1>(&saver.size),
                         InvokeWithoutArgs(&saver, &StringSaver::Save),
                         Return(0)));
   }
-  visitor->OnSynStream(stream_id, associated_id, 0, 0, false, false, block);
+  visitor->OnSynStream(stream_id, associated_id, 0, false, false, block);
   ASSERT_EQ(expected, saver.string);
 }
 
 TEST_P(SpdySMProxyTest, OnStreamFrameData_SPDY2) {
   if (GetParam() != SPDY2) {
     // This test case is for SPDY2.
     return;
   }
   BufferedSpdyFramerVisitorInterface* visitor = interface_.get();
   scoped_ptr<MockSMInterface> mock_interface(new MockSMInterface);
@@ skipping 11 matching lines @@
     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, 0, false, false, block);
+  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, OnStreamFrameData) {
   if (GetParam() == SPDY2) {
     // This test case is not for SPDY2.
     return;
   }
   BufferedSpdyFramerVisitorInterface* visitor = interface_.get();
@@ skipping 14 matching lines @@
     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, 0, false, false, block);
+  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;
 
@@ skipping 89 matching lines @@
   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;
-    EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
-        .WillOnce(SaveArg<2>(&actual_header_block));
+    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, _))
+          .WillOnce(SaveArg<2>(&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);
   }
@@ skipping 22 matching lines @@
   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;
-    EXPECT_CALL(*spdy_framer_visitor_,
-                OnSynReply(stream_id, false, _))
-        .WillOnce(SaveArg<2>(&actual_header_block));
+    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, _))
+          .WillOnce(SaveArg<2>(&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);
   }
@@ skipping 25 matching lines @@
 
   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<6>(&actual_header_block));
+                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(4u, actual_header_block.size());
   ASSERT_EQ("GET", actual_header_block["method"]);
   ASSERT_EQ("HTTP/1.0", actual_header_block["version"]);
   ASSERT_EQ("/path", actual_header_block["url"]);
   ASSERT_EQ("value1", actual_header_block["key1"]);
 }
@@ skipping 12 matching lines @@
 
   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<6>(&actual_header_block));
+                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"]);
@@ skipping 11 matching lines @@
   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;
-    EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
-        .WillOnce(SaveArg<2>(&actual_header_block));
+    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, _))
+          .WillOnce(SaveArg<2>(&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, SendSynReply) {
   if (GetParam() == SPDY2) {
     // This test is not for SPDY2.
     return;
   }
   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;
-    EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
-        .WillOnce(SaveArg<2>(&actual_header_block));
+    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, _))
+          .WillOnce(SaveArg<2>(&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"]);
 }
 
@@ skipping 120 matching lines @@
   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, 0, true, true, spdy_headers);
+  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;
-    EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
-        .WillOnce(SaveArg<2>(&actual_header_block));
+    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, _))
+          .WillOnce(SaveArg<2>(&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