Update HTTP/2 ALTSVC wireformat from draft-04 to draft-06.

net/spdy/spdy_framer_test.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 <algorithm>
 #include <iostream>
 #include <limits>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 3406 matching lines @@
 }
 
 TEST_P(SpdyFramerTest, CreateAltSvc) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
 
   const char kDescription[] = "ALTSVC frame";
-  const unsigned char kType = static_cast<unsigned char>(
+  const char kType = static_cast<unsigned char>(
       SpdyConstants::SerializeFrameType(spdy_version_, ALTSVC));
   const unsigned char kFrameData[] = {
-    0x00, 0x00, 0x17, kType, 0x00,
-    0x00, 0x00, 0x00, 0x03,
-    0x00, 0x00, 0x00, 0x05,
-    0x01, 0xbb, 0x00, 0x04,  // Port = 443
-    'p',  'i',  'd',  '1',   // Protocol-ID
-    0x04, 'h',  'o',  's',
-    't',  'o',  'r',  'i',
-    'g',  'i',  'n',
+      0x00, 0x00, 0x1d, kType, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00,
+      0x06, 'o',  'r',  'i',   'g',  'i',  'n',  'p',  'i',  'd',
+      '1',  '=',  '"',  'h',   'o',  's',  't',  ':',  '4',  '4',
+      '3',  '"',  ';',  ' ',   'm',  'a',  '=',  '5',
   };
   SpdyAltSvcIR altsvc_ir(3);
   altsvc_ir.set_max_age(5);
   altsvc_ir.set_port(443);
   altsvc_ir.set_protocol_id("pid1");
   altsvc_ir.set_host("host");
   altsvc_ir.set_origin("origin");
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
   CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
 }
@@ skipping 1253 matching lines @@
     EXPECT_EQ(14u, framer.GetSynStreamMinimumSize());
     EXPECT_EQ(9u, framer.GetSynReplyMinimumSize());
     EXPECT_EQ(13u, framer.GetRstStreamMinimumSize());
     EXPECT_EQ(9u, framer.GetSettingsMinimumSize());
     EXPECT_EQ(17u, framer.GetPingSize());
     EXPECT_EQ(17u, framer.GetGoAwayMinimumSize());
     EXPECT_EQ(9u, framer.GetHeadersMinimumSize());
     EXPECT_EQ(13u, framer.GetWindowUpdateSize());
     EXPECT_EQ(9u, framer.GetBlockedSize());
     EXPECT_EQ(13u, framer.GetPushPromiseMinimumSize());
-    EXPECT_EQ(18u, framer.GetAltSvcMinimumSize());
+    EXPECT_EQ(11u, framer.GetAltSvcMinimumSize());
     EXPECT_EQ(9u, framer.GetFrameMinimumSize());
     EXPECT_EQ(16393u, framer.GetFrameMaximumSize());
     EXPECT_EQ(16384u, framer.GetDataFrameMaximumPayload());
   } else {
     EXPECT_EQ(8u, framer.GetDataFrameMinimumSize());
     EXPECT_EQ(8u, framer.GetControlFrameHeaderSize());
     EXPECT_EQ(18u, framer.GetSynStreamMinimumSize());
     EXPECT_EQ(IsSpdy2() ? 14u : 12u, framer.GetSynReplyMinimumSize());
     EXPECT_EQ(16u, framer.GetRstStreamMinimumSize());
     EXPECT_EQ(12u, framer.GetSettingsMinimumSize());
@@ skipping 983 matching lines @@
                                 StringPiece("h1"),
                                 StringPiece("o1")));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.set_max_age(10);
   altsvc_ir.set_port(443);
   altsvc_ir.set_protocol_id("pid");
   altsvc_ir.set_host("h1");
   altsvc_ir.set_origin("o1");
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
-  framer.ProcessInput(frame->data(), framer.GetAltSvcMinimumSize() +
-                      altsvc_ir.protocol_id().length() +
-                      altsvc_ir.host().length() +
-                      altsvc_ir.origin().length());
+  framer.ProcessInput(frame->data(), frame->size());
 
   EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, OnAltSvcNoOrigin) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   const SpdyStreamId kStreamId = 1;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
-  EXPECT_CALL(visitor, OnAltSvc(kStreamId,
-                                10,
-                                443,
-                                StringPiece("pid"),
-                                StringPiece("h1"),
-                                StringPiece("")));
+  EXPECT_CALL(visitor,
+              OnAltSvc(kStreamId, 10, 443, StringPiece("p\"=i:d"),
+                       StringPiece("h_\\o\"st"), StringPiece("o_r|g!n")));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.set_max_age(10);
   altsvc_ir.set_port(443);
-  altsvc_ir.set_protocol_id("pid");
-  altsvc_ir.set_host("h1");
+  altsvc_ir.set_protocol_id("p\"=i:d");
+  altsvc_ir.set_host("h_\\o\"st");
+  altsvc_ir.set_origin("o_r|g!n");
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
-  framer.ProcessInput(frame->data(), framer.GetAltSvcMinimumSize() +
-                      altsvc_ir.protocol_id().length() +
-                      altsvc_ir.host().length());
+  framer.ProcessInput(frame->data(), frame->size());
 
   EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, OnAltSvcEmptyProtocolId) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.set_max_age(10);
   altsvc_ir.set_port(443);
   altsvc_ir.set_host("h1");
   altsvc_ir.set_origin("o1");
   scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
-  framer.ProcessInput(frame->data(), framer.GetAltSvcMinimumSize() +
-                      altsvc_ir.protocol_id().length() +
-                      altsvc_ir.host().length());
+  framer.ProcessInput(frame->data(), frame->size());
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, OnAltSvcBadLengths) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
 
-  const unsigned char kType = static_cast<unsigned char>(
-      SpdyConstants::SerializeFrameType(spdy_version_, ALTSVC));
-  {
-    TestSpdyVisitor visitor(spdy_version_);
-    SpdyFramer framer(spdy_version_);
-    framer.set_visitor(&visitor);
+  const SpdyStreamId kStreamId = 1;
 
-    const unsigned char kFrameDataLargePIDLen[] = {
-      0x00, 0x00, 0x17, kType, 0x00,
-      0x00, 0x00, 0x00, 0x03,
-      0x00, 0x00, 0x00, 0x05,
-      0x01, 0xbb, 0x00, 0x05,  // Port = 443
-      'p',  'i',  'd',  '1',   // Protocol-ID
-      0x04, 'h',  'o',  's',
-      't',  'o',  'r',  'i',
-      'g',  'i',  'n',
-    };
+  testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
+  SpdyFramer framer(spdy_version_);
+  framer.set_visitor(&visitor);
 
-    visitor.SimulateInFramer(kFrameDataLargePIDLen,
-                             sizeof(kFrameDataLargePIDLen));
-    EXPECT_EQ(1, visitor.error_count_);
-    EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
-              visitor.framer_.error_code());
-  }
+  EXPECT_CALL(visitor, OnAltSvc(kStreamId, 10, 443, StringPiece("pid"),
+                                StringPiece("h1"), StringPiece("")));
 
-  {
-    TestSpdyVisitor visitor(spdy_version_);
-    SpdyFramer framer(spdy_version_);
-    framer.set_visitor(&visitor);
-    const unsigned char kFrameDataPIDLenLargerThanFrame[] = {
-      0x00, 0x00, 0x17, kType, 0x00,
-      0x00, 0x00, 0x00, 0x03,
-      0x00, 0x00, 0x00, 0x05,
-      0x01, 0xbb, 0x00, 0x99,  // Port = 443
-      'p',  'i',  'd',  '1',   // Protocol-ID
-      0x04, 'h',  'o',  's',
-      't',  'o',  'r',  'i',
-      'g',  'i',  'n',
-    };
+  SpdyAltSvcIR altsvc_ir(1);
+  altsvc_ir.set_max_age(10);
+  altsvc_ir.set_port(443);
+  altsvc_ir.set_protocol_id("pid");
+  altsvc_ir.set_host("h1");
+  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
+  framer.ProcessInput(frame->data(), frame->size());
 
-    visitor.SimulateInFramer(kFrameDataPIDLenLargerThanFrame,
-                             sizeof(kFrameDataPIDLenLargerThanFrame));
-    EXPECT_EQ(1, visitor.error_count_);
-    EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
-              visitor.framer_.error_code());
-  }
-
-  {
-    TestSpdyVisitor visitor(spdy_version_);
-    SpdyFramer framer(spdy_version_);
-    framer.set_visitor(&visitor);
-
-    const unsigned char kFrameDataLargeHostLen[] = {
-      0x00, 0x00, 0x17, kType, 0x00,
-      0x00, 0x00, 0x00, 0x03,
-      0x00, 0x00, 0x00, 0x05,
-      0x01, 0xbb, 0x00, 0x04,  // Port = 443
-      'p',  'i',  'd',  '1',   // Protocol-ID
-      0x0f, 'h',  'o',  's',
-      't',  'o',  'r',  'i',
-      'g',  'i',  'n',
-    };
-
-    visitor.SimulateInFramer(kFrameDataLargeHostLen,
-                             sizeof(kFrameDataLargeHostLen));
-    EXPECT_EQ(1, visitor.error_count_);
-    EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
-              visitor.framer_.error_code());
-  }
-
-  {
-    TestSpdyVisitor visitor(spdy_version_);
-    SpdyFramer framer(spdy_version_);
-    framer.set_visitor(&visitor);
-    const unsigned char kFrameDataSmallPIDLen[] = {
-      0x00, 0x00, 0x17, kType, 0x00,
-      0x00, 0x00, 0x00, 0x03,
-      0x00, 0x00, 0x00, 0x05,
-      0x01, 0xbb, 0x00, 0x01,  // Port = 443
-      'p',  'i',  'd',  '1',   // Protocol-ID
-      0x04, 'h',  'o',  's',
-      't',  'o',  'r',  'i',
-      'g',  'i',  'n',
-    };
-
-    visitor.SimulateInFramer(kFrameDataSmallPIDLen,
-                             sizeof(kFrameDataSmallPIDLen));
-    EXPECT_EQ(1, visitor.error_count_);
-    EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
-              visitor.framer_.error_code());
-  }
+  EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
+  EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
+      << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Tests handling of ALTSVC frames delivered in small chunks.
 TEST_P(SpdyFramerTest, ReadChunkedAltSvcFrame) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
+
   SpdyFramer framer(spdy_version_);
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.set_max_age(20);
   altsvc_ir.set_port(443);
   altsvc_ir.set_protocol_id("protocolid");
   altsvc_ir.set_host("hostname");
 
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeAltSvc(altsvc_ir));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
@@ skipping 86 matching lines @@
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 }  // namespace net