Process HTTP/2 ALTSVC frames.

net/spdy/buffered_spdy_framer_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 "net/spdy/buffered_spdy_framer.h"
 
 #include "base/logging.h"
 #include "net/spdy/spdy_test_util_common.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 namespace {
 
 class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
  public:
   explicit TestBufferedSpdyVisitor(SpdyMajorVersion spdy_version)
       : buffered_spdy_framer_(spdy_version),
         error_count_(0),
         setting_count_(0),
         syn_frame_count_(0),
         syn_reply_frame_count_(0),
         headers_frame_count_(0),
         push_promise_frame_count_(0),
         goaway_count_(0),
+        altsvc_count_(0),
         header_stream_id_(static_cast<SpdyStreamId>(-1)),
         promised_stream_id_(static_cast<SpdyStreamId>(-1)) {}
 
   void OnError(SpdyFramer::SpdyError error_code) override {
     VLOG(1) << "SpdyFramer Error: " << error_code;
     error_count_++;
   }
 
   void OnStreamError(SpdyStreamId stream_id,
                      const std::string& description) override {
@@ skipping 89 matching lines @@
                      SpdyStreamId promised_stream_id,
                      const SpdyHeaderBlock& headers) override {
     header_stream_id_ = stream_id;
     EXPECT_NE(header_stream_id_, SpdyFramer::kInvalidStream);
     push_promise_frame_count_++;
     promised_stream_id_ = promised_stream_id;
     EXPECT_NE(promised_stream_id_, SpdyFramer::kInvalidStream);
     headers_ = headers;
   }
 
+  void OnAltSvc(SpdyStreamId stream_id,
+                base::StringPiece origin,
+                const SpdyAltSvcWireFormat::AlternativeServiceVector&
+                    altsvc_vector) override {
+    altsvc_count_++;
+    altsvc_stream_id_ = stream_id;
+    origin.CopyToString(&altsvc_origin_);
+    altsvc_vector_ = altsvc_vector;
+  }
+
   bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
     return true;
   }
 
   // Convenience function which runs a framer simulation with particular input.
   void SimulateInFramer(const unsigned char* input, size_t size) {
     buffered_spdy_framer_.set_visitor(this);
     size_t input_remaining = size;
     const char* input_ptr = reinterpret_cast<const char*>(input);
     while (input_remaining > 0 &&
@@ skipping 14 matching lines @@
   BufferedSpdyFramer buffered_spdy_framer_;
 
   // Counters from the visitor callbacks.
   int error_count_;
   int setting_count_;
   int syn_frame_count_;
   int syn_reply_frame_count_;
   int headers_frame_count_;
   int push_promise_frame_count_;
   int goaway_count_;
+  int altsvc_count_;
 
   // Header block streaming state:
   SpdyStreamId header_stream_id_;
   SpdyStreamId promised_stream_id_;
 
   // Headers from OnSyn, OnSynReply, OnHeaders and OnPushPromise for
   // verification.
   SpdyHeaderBlock headers_;
 
   // OnGoAway parameters.
   SpdyStreamId goaway_last_accepted_stream_id_;
   SpdyGoAwayStatus goaway_status_;
   std::string goaway_debug_data_;
+
+  // OnAltSvc parameters.
+  SpdyStreamId altsvc_stream_id_;
+  std::string altsvc_origin_;
+  SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector_;
 };
 
 }  // namespace
 
 class BufferedSpdyFramerTest
     : public PlatformTest,
       public ::testing::WithParamInterface<NextProto> {
  protected:
   SpdyMajorVersion spdy_version() {
     return NextProtoToSpdyMajorVersion(GetParam());
@@ skipping 139 matching lines @@
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(goaway_frame.get()->data()),
       goaway_frame.get()->size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.goaway_count_);
   EXPECT_EQ(2u, visitor.goaway_last_accepted_stream_id_);
   EXPECT_EQ(GOAWAY_FRAME_SIZE_ERROR, visitor.goaway_status_);
   EXPECT_EQ("foo", visitor.goaway_debug_data_);
 }
 
+TEST_P(BufferedSpdyFramerTest, OnAltSvc) {
+  if (spdy_version() < HTTP2)
+    return;
+
+  const SpdyStreamId altsvc_stream_id(1);
+  const char altsvc_origin[] = "https://www.example.org";
+  SpdyAltSvcIR altsvc_ir(altsvc_stream_id);
+  SpdyAltSvcWireFormat::AlternativeService alternative_service(
+      "quic", "alternative.example.org", 443, 86400,
+      SpdyAltSvcWireFormat::VersionVector());
+  altsvc_ir.add_altsvc(alternative_service);
+  altsvc_ir.set_origin(altsvc_origin);
+  BufferedSpdyFramer framer(spdy_version());
+  SpdySerializedFrame altsvc_frame(framer.SerializeFrame(altsvc_ir));
+
+  TestBufferedSpdyVisitor visitor(spdy_version());
+  visitor.SimulateInFramer(
+      reinterpret_cast<unsigned char*>(altsvc_frame.data()),
+      altsvc_frame.size());
+  EXPECT_EQ(0, visitor.error_count_);
+  EXPECT_EQ(1, visitor.altsvc_count_);
+  EXPECT_EQ(altsvc_stream_id, visitor.altsvc_stream_id_);
+  EXPECT_EQ(altsvc_origin, visitor.altsvc_origin_);
+  ASSERT_EQ(1u, visitor.altsvc_vector_.size());
+  EXPECT_EQ(alternative_service, visitor.altsvc_vector_[0]);
+}
+
 }  // namespace net