SPDY - integration of spdy/3 code.

net/spdy/spdy_protocol_test.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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_protocol.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "net/spdy/spdy_bitmasks.h"
 #include "net/spdy/spdy_framer.h"
 #include "testing/platform_test.h"
 
 using spdy::CONTROL_FLAG_FIN;
 using spdy::CONTROL_FLAG_NONE;
+using spdy::FlagsAndLength;
 using spdy::GOAWAY;
 using spdy::HEADERS;
 using spdy::NOOP;
 using spdy::NUM_CONTROL_FRAME_TYPES;
 using spdy::PING;
 using spdy::RST_STREAM;
 using spdy::SETTINGS;
 using spdy::SYN_REPLY;
 using spdy::SYN_STREAM;
-using spdy::WINDOW_UPDATE;
-using spdy::FlagsAndLength;
+using spdy::SettingsFlagsAndId;
 using spdy::SpdyControlFrame;
 using spdy::SpdyControlType;
 using spdy::SpdyDataFrame;
 using spdy::SpdyFrame;
 using spdy::SpdyFramer;
+using spdy::SpdyGoAwayControlFrame;
 using spdy::SpdyHeaderBlock;
 using spdy::SpdyHeadersControlFrame;
-using spdy::SpdyGoAwayControlFrame;
-using spdy::SpdyNoOpControlFrame;
 using spdy::SpdyPingControlFrame;
 using spdy::SpdyRstStreamControlFrame;
 using spdy::SpdySettings;
 using spdy::SpdySettingsControlFrame;
 using spdy::SpdyStatusCodes;
 using spdy::SpdySynReplyControlFrame;
 using spdy::SpdySynStreamControlFrame;
 using spdy::SpdyWindowUpdateControlFrame;
-using spdy::SettingsFlagsAndId;
+using spdy::WINDOW_UPDATE;
 using spdy::kLengthMask;
-using spdy::kSpdyProtocolVersion;
 using spdy::kStreamIdMask;
 
 namespace {
 
 // Test our protocol constants
 TEST(SpdyProtocolTest, ProtocolConstants) {
   EXPECT_EQ(8u, SpdyFrame::kHeaderSize);
   EXPECT_EQ(8u, SpdyDataFrame::size());
   EXPECT_EQ(8u, SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(18u, SpdySynStreamControlFrame::size());
-  EXPECT_EQ(14u, SpdySynReplyControlFrame::size());
+  EXPECT_EQ(12u, SpdySynReplyControlFrame::size());

[Ryan Hamilton, 2012/03/09 19:09:58]

Why is this changing?  Just want to make sure we're not regressing spdy/2
support in some way.

[ramant (doing other things), 2012/03/10 01:14:09]

Added separate tests for SPDY/2 and SPDY/3.

Done.

   EXPECT_EQ(16u, SpdyRstStreamControlFrame::size());
   EXPECT_EQ(12u, SpdySettingsControlFrame::size());
-  EXPECT_EQ(8u, SpdyNoOpControlFrame::size());
   EXPECT_EQ(12u, SpdyPingControlFrame::size());
   EXPECT_EQ(12u, SpdyGoAwayControlFrame::size());
-  EXPECT_EQ(14u, SpdyHeadersControlFrame::size());
+  EXPECT_EQ(12u, SpdyHeadersControlFrame::size());
   EXPECT_EQ(16u, SpdyWindowUpdateControlFrame::size());
   EXPECT_EQ(4u, sizeof(FlagsAndLength));
   EXPECT_EQ(1, SYN_STREAM);
   EXPECT_EQ(2, SYN_REPLY);
   EXPECT_EQ(3, RST_STREAM);
   EXPECT_EQ(4, SETTINGS);
   EXPECT_EQ(5, NOOP);
   EXPECT_EQ(6, PING);
   EXPECT_EQ(7, GOAWAY);
   EXPECT_EQ(8, HEADERS);
@@ skipping 16 matching lines @@
   EXPECT_FALSE(frame.is_control_frame());
 }
 
 TEST(SpdyProtocolTest, DataFrameStructs) {
   SpdyDataFrame data_frame;
   data_frame.set_stream_id(12345);
   EXPECT_EQ(12345u, data_frame.stream_id());
 }
 
 TEST(SpdyProtocolTest, ControlFrameStructs) {
-  SpdyFramer framer;
+  SpdyFramer framer(SPDY_VERSION_FOR_TESTS);

[Ryan Hamilton, 2012/03/09 19:09:58]

Where is this defined?  We want to make sure we're testing both / all spdy
versions.  Is that happening?

[ramant (doing other things), 2012/03/10 01:14:09]

Forked this test for spdy/2 and spdy/3.

Done.

   SpdyHeaderBlock headers;
 
   scoped_ptr<SpdySynStreamControlFrame> syn_frame(
       framer.CreateSynStream(123, 456, 2, CONTROL_FLAG_FIN, false, &headers));
-  EXPECT_EQ(kSpdyProtocolVersion, syn_frame->version());
+  EXPECT_EQ(framer.protocol_version(), syn_frame->version());
   EXPECT_TRUE(syn_frame->is_control_frame());
   EXPECT_EQ(SYN_STREAM, syn_frame->type());
   EXPECT_EQ(123u, syn_frame->stream_id());
   EXPECT_EQ(456u, syn_frame->associated_stream_id());
   EXPECT_EQ(2u, syn_frame->priority());
-  EXPECT_EQ(2, syn_frame->header_block_len());
+  EXPECT_EQ((SPDY_VERSION_FOR_TESTS < 3) ? 2 : 4,
+            syn_frame->header_block_len());
   EXPECT_EQ(1u, syn_frame->flags());
   syn_frame->set_associated_stream_id(999u);
   EXPECT_EQ(123u, syn_frame->stream_id());
   EXPECT_EQ(999u, syn_frame->associated_stream_id());
 
   scoped_ptr<SpdySynReplyControlFrame> syn_reply(
       framer.CreateSynReply(123, CONTROL_FLAG_NONE, false, &headers));
-  EXPECT_EQ(kSpdyProtocolVersion, syn_reply->version());
+  EXPECT_EQ(framer.protocol_version(), syn_reply->version());
   EXPECT_TRUE(syn_reply->is_control_frame());
   EXPECT_EQ(SYN_REPLY, syn_reply->type());
   EXPECT_EQ(123u, syn_reply->stream_id());
-  EXPECT_EQ(2, syn_reply->header_block_len());
+  EXPECT_EQ((SPDY_VERSION_FOR_TESTS < 3) ? 2 : 4,
+            syn_reply->header_block_len());
   EXPECT_EQ(0, syn_reply->flags());
 
   scoped_ptr<SpdyRstStreamControlFrame> rst_frame(
       framer.CreateRstStream(123, spdy::PROTOCOL_ERROR));
-  EXPECT_EQ(kSpdyProtocolVersion, rst_frame->version());
+  EXPECT_EQ(framer.protocol_version(), rst_frame->version());
   EXPECT_TRUE(rst_frame->is_control_frame());
   EXPECT_EQ(RST_STREAM, rst_frame->type());
   EXPECT_EQ(123u, rst_frame->stream_id());
   EXPECT_EQ(spdy::PROTOCOL_ERROR, rst_frame->status());
   rst_frame->set_status(spdy::INVALID_STREAM);
   EXPECT_EQ(spdy::INVALID_STREAM, rst_frame->status());
   EXPECT_EQ(0, rst_frame->flags());
 
-  scoped_ptr<SpdyNoOpControlFrame> noop_frame(
-      framer.CreateNopFrame());
-  EXPECT_EQ(kSpdyProtocolVersion, noop_frame->version());
-  EXPECT_TRUE(noop_frame->is_control_frame());
-  EXPECT_EQ(NOOP, noop_frame->type());
-  EXPECT_EQ(0, noop_frame->flags());
-
   const uint32 kUniqueId = 1234567u;
   const uint32 kUniqueId2 = 31415926u;
   scoped_ptr<SpdyPingControlFrame> ping_frame(
       framer.CreatePingFrame(kUniqueId));
-  EXPECT_EQ(kSpdyProtocolVersion, ping_frame->version());
+  EXPECT_EQ(framer.protocol_version(), ping_frame->version());
   EXPECT_TRUE(ping_frame->is_control_frame());
   EXPECT_EQ(PING, ping_frame->type());
   EXPECT_EQ(kUniqueId, ping_frame->unique_id());
   ping_frame->set_unique_id(kUniqueId2);
   EXPECT_EQ(kUniqueId2, ping_frame->unique_id());
 
   scoped_ptr<SpdyGoAwayControlFrame> goaway_frame(
       framer.CreateGoAway(123));
-  EXPECT_EQ(kSpdyProtocolVersion, goaway_frame->version());
+  EXPECT_EQ(framer.protocol_version(), goaway_frame->version());
   EXPECT_TRUE(goaway_frame->is_control_frame());
   EXPECT_EQ(GOAWAY, goaway_frame->type());
   EXPECT_EQ(123u, goaway_frame->last_accepted_stream_id());
 
   scoped_ptr<SpdyHeadersControlFrame> headers_frame(
       framer.CreateHeaders(123, CONTROL_FLAG_NONE, false, &headers));
-  EXPECT_EQ(kSpdyProtocolVersion, headers_frame->version());
+  EXPECT_EQ(framer.protocol_version(), headers_frame->version());
   EXPECT_TRUE(headers_frame->is_control_frame());
   EXPECT_EQ(HEADERS, headers_frame->type());
   EXPECT_EQ(123u, headers_frame->stream_id());
-  EXPECT_EQ(2, headers_frame->header_block_len());
+  EXPECT_EQ((SPDY_VERSION_FOR_TESTS < 3) ? 2 : 4,
+            headers_frame->header_block_len());
   EXPECT_EQ(0, headers_frame->flags());
 
   scoped_ptr<SpdyWindowUpdateControlFrame> window_update_frame(
       framer.CreateWindowUpdate(123, 456));
-  EXPECT_EQ(kSpdyProtocolVersion, window_update_frame->version());
+  EXPECT_EQ(framer.protocol_version(), window_update_frame->version());
   EXPECT_TRUE(window_update_frame->is_control_frame());
   EXPECT_EQ(WINDOW_UPDATE, window_update_frame->type());
   EXPECT_EQ(123u, window_update_frame->stream_id());
   EXPECT_EQ(456u, window_update_frame->delta_window_size());
 }
 
 TEST(SpdyProtocolTest, TestDataFrame) {
   SpdyDataFrame frame;
 
   // Set the stream ID to various values.
@@ skipping 30 matching lines @@
   flags = frame.flags();
   EXPECT_EQ(all_flags, flags);
   EXPECT_EQ(length, frame.length());
   frame.set_flags(5u);
   EXPECT_EQ(5u, frame.flags());
   EXPECT_EQ(length, frame.length());
 }
 
 // Test various types of SETTINGS frames.
 TEST(SpdyProtocolTest, TestSpdySettingsFrame) {
-  SpdyFramer framer;
+  SpdyFramer framer(SPDY_VERSION_FOR_TESTS);
 
   // Create a settings frame with no settings.
   SpdySettings settings;
   scoped_ptr<SpdySettingsControlFrame> settings_frame(
       framer.CreateSettings(settings));
-  EXPECT_EQ(kSpdyProtocolVersion, settings_frame->version());
+  EXPECT_EQ(framer.protocol_version(), settings_frame->version());
   EXPECT_TRUE(settings_frame->is_control_frame());
   EXPECT_EQ(SETTINGS, settings_frame->type());
   EXPECT_EQ(0u, settings_frame->num_entries());
 
   // We'll add several different ID/Flag combinations and then verify
   // that they encode and decode properly.
   SettingsFlagsAndId ids[] = {
-    0x00000000,
-    0xffffffff,
-    0xff000001,
-    0x01000002,
+    SettingsFlagsAndId::FromWireFormat(SPDY_VERSION_FOR_TESTS, 0x00000000),
+    SettingsFlagsAndId::FromWireFormat(SPDY_VERSION_FOR_TESTS, 0xffffffff),
+    SettingsFlagsAndId::FromWireFormat(SPDY_VERSION_FOR_TESTS, 0xff000001),
+    SettingsFlagsAndId::FromWireFormat(SPDY_VERSION_FOR_TESTS, 0xffffffff),
+    SettingsFlagsAndId::FromWireFormat(SPDY_VERSION_FOR_TESTS, 0x01000002),
+    SettingsFlagsAndId(3, 1)
   };
 
   for (size_t index = 0; index < arraysize(ids); ++index) {
     settings.insert(settings.end(), std::make_pair(ids[index], index));
     settings_frame.reset(framer.CreateSettings(settings));
-    EXPECT_EQ(kSpdyProtocolVersion, settings_frame->version());
+    EXPECT_EQ(framer.protocol_version(), settings_frame->version());
     EXPECT_TRUE(settings_frame->is_control_frame());
     EXPECT_EQ(SETTINGS, settings_frame->type());
     EXPECT_EQ(index + 1, settings_frame->num_entries());
 
     SpdySettings parsed_settings;
     EXPECT_TRUE(framer.ParseSettings(settings_frame.get(), &parsed_settings));
-    EXPECT_EQ(parsed_settings.size(), settings.size());
+    EXPECT_EQ(settings.size(), parsed_settings.size());
     SpdySettings::const_iterator it = parsed_settings.begin();
     int pos = 0;
     while (it != parsed_settings.end()) {
       SettingsFlagsAndId parsed = it->first;
       uint32 value = it->second;
-      EXPECT_EQ(parsed.flags(), ids[pos].flags());
-      EXPECT_EQ(parsed.id(), ids[pos].id());
-      EXPECT_EQ(value, static_cast<uint32>(pos));
+      EXPECT_EQ(ids[pos].flags(), parsed.flags());
+      EXPECT_EQ(ids[pos].id(), parsed.id());
+      EXPECT_EQ(static_cast<uint32>(pos), value);
       ++it;
       ++pos;
     }
   }
 }
 
 TEST(SpdyProtocolTest, HasHeaderBlock) {
   SpdyControlFrame frame(SpdyControlFrame::kHeaderSize);
   for (SpdyControlType type = SYN_STREAM;
       type < NUM_CONTROL_FRAME_TYPES;
@@ skipping 73 matching lines @@
 
 TEST(SpdyProtocolDeathTest, TestSpdyControlFrameType) {
   SpdyControlFrame frame(SpdyControlFrame::kHeaderSize);
   memset(frame.data(), 255, SpdyControlFrame::kHeaderSize);
 
   // type() should be out of bounds.
   EXPECT_FALSE(frame.AppearsToBeAValidControlFrame());
 
   uint16 version = frame.version();
 
-  for (int i = SYN_STREAM; i <= spdy::NOOP; ++i) {
+  for (int i = SYN_STREAM; i <= spdy::WINDOW_UPDATE; ++i) {
     frame.set_type(static_cast<SpdyControlType>(i));
     EXPECT_EQ(i, static_cast<int>(frame.type()));
-    EXPECT_TRUE(frame.AppearsToBeAValidControlFrame());
+    if (i == spdy::NOOP) {
+      // NOOP frames aren't 'valid'.

[Ryan Hamilton, 2012/03/09 19:09:58]

NOOP is valid in spdy/2 right?

[ramant (doing other things), 2012/03/10 01:14:09]

Checked in SPDY/2 tests and kept the as above for spdy/3.

Done.

+      EXPECT_FALSE(frame.AppearsToBeAValidControlFrame());
+    } else {
+      EXPECT_TRUE(frame.AppearsToBeAValidControlFrame());
+    }
     // Make sure setting type does not alter the version block.
     EXPECT_EQ(version, frame.version());
     EXPECT_TRUE(frame.is_control_frame());
   }
 }
 
 TEST(SpdyProtocolDeathTest, TestRstStreamStatusBounds) {
-  SpdyFramer framer;
+  SpdyFramer framer(SPDY_VERSION_FOR_TESTS);
   scoped_ptr<SpdyRstStreamControlFrame> rst_frame;
 
   rst_frame.reset(framer.CreateRstStream(123, spdy::PROTOCOL_ERROR));
   EXPECT_EQ(spdy::PROTOCOL_ERROR, rst_frame->status());
 
   rst_frame->set_status(spdy::INVALID);
   EXPECT_EQ(spdy::INVALID, rst_frame->status());
 
   rst_frame->set_status(
       static_cast<spdy::SpdyStatusCodes>(spdy::INVALID - 1));
   EXPECT_EQ(spdy::INVALID, rst_frame->status());
 
   rst_frame->set_status(spdy::NUM_STATUS_CODES);
   EXPECT_EQ(spdy::INVALID, rst_frame->status());
 }
 
 }  // namespace