Landing recent QUIC changes until 6/24/2016 14:00 UTC

net/quic/quic_headers_stream_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/quic/quic_headers_stream.h"
 
 #include <string>
 
+#include "base/strings/string_number_conversions.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/spdy_utils.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
 #include "net/spdy/spdy_alt_svc_wire_format.h"
 #include "net/spdy/spdy_flags.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_test_utils.h"
@@ skipping 18 matching lines @@
 class MockHpackDebugVisitor : public QuicHeadersStream::HpackDebugVisitor {
  public:
   explicit MockHpackDebugVisitor() : HpackDebugVisitor() {}
 
   MOCK_METHOD1(OnUseEntry, void(QuicTime::Delta elapsed));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockHpackDebugVisitor);
 };
 
+class QuicHeadersStreamPeer {
+ public:
+  static const SpdyFramer& GetSpdyFramer(QuicHeadersStream* stream) {
+    return stream->spdy_framer_;
+  }
+};
+
 namespace {
 
 // TODO(ckrasic):  this workaround is due to absence of std::initializer_list
 const bool kFins[] = {false, true};
 
 class MockVisitor : public SpdyFramerVisitorInterface {
  public:
   MOCK_METHOD1(OnError, void(SpdyFramer* framer));
   MOCK_METHOD3(OnDataFrameHeader,
                void(SpdyStreamId stream_id, size_t length, bool fin));
@@ skipping 506 matching lines @@
               CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
                               "SPDY RST_STREAM frame received.", _))
       .WillOnce(InvokeWithoutArgs(
           this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
   stream_frame_.data_buffer = frame.data();
   stream_frame_.data_length = frame.size();
   headers_stream_->OnStreamFrame(stream_frame_);
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessSpdySettingsFrame) {
+  FLAGS_quic_respect_http2_settings_frame = false;
   SpdySettingsIR data;
   data.AddSetting(SETTINGS_HEADER_TABLE_SIZE, true, true, 0);
   SpdySerializedFrame frame(framer_->SerializeFrame(data));
   EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
                                             "SPDY SETTINGS frame received.", _))
       .WillOnce(InvokeWithoutArgs(
           this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
   stream_frame_.data_buffer = frame.data();
   stream_frame_.data_length = frame.size();
   headers_stream_->OnStreamFrame(stream_frame_);
 }
 
+TEST_P(QuicHeadersStreamTest, RespectHttp2SettingsFrameSupportedFields) {
+  FLAGS_quic_respect_http2_settings_frame = true;
+  const uint32_t kTestHeaderTableSize = 1000;
+  SpdySettingsIR data;
+  // Respect supported settings frames SETTINGS_HEADER_TABLE_SIZE.
+  data.AddSetting(SETTINGS_HEADER_TABLE_SIZE, true, true, kTestHeaderTableSize);
+  SpdySerializedFrame frame(framer_->SerializeFrame(data));
+  stream_frame_.data_buffer = frame.data();
+  stream_frame_.data_length = frame.size();
+  headers_stream_->OnStreamFrame(stream_frame_);
+  EXPECT_EQ(kTestHeaderTableSize,
+            QuicHeadersStreamPeer::GetSpdyFramer(headers_stream_)
+                .header_encoder_table_size());
+}
+
+TEST_P(QuicHeadersStreamTest, RespectHttp2SettingsFrameUnsupportedFields) {
+  FLAGS_quic_respect_http2_settings_frame = true;
+  SpdySettingsIR data;
+  // Does not support SETTINGS_MAX_HEADER_LIST_SIZE,
+  // SETTINGS_MAX_CONCURRENT_STREAMS, SETTINGS_INITIAL_WINDOW_SIZE,
+  // SETTINGS_ENABLE_PUSH and SETTINGS_MAX_FRAME_SIZE.
+  data.AddSetting(SETTINGS_MAX_HEADER_LIST_SIZE, true, true, 2000);
+  data.AddSetting(SETTINGS_MAX_CONCURRENT_STREAMS, true, true, 100);
+  data.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, true, true, 100);
+  data.AddSetting(SETTINGS_ENABLE_PUSH, true, true, 1);
+  data.AddSetting(SETTINGS_MAX_FRAME_SIZE, true, true, 1250);
+  SpdySerializedFrame frame(framer_->SerializeFrame(data));
+  EXPECT_CALL(
+      *connection_,
+      CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                      "Unsupported field of HTTP/2 SETTINGS frame: " +
+                          base::IntToString(SETTINGS_MAX_HEADER_LIST_SIZE),
+                      _));
+  EXPECT_CALL(
+      *connection_,
+      CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                      "Unsupported field of HTTP/2 SETTINGS frame: " +
+                          base::IntToString(SETTINGS_MAX_CONCURRENT_STREAMS),
+                      _));
+  EXPECT_CALL(
+      *connection_,
+      CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                      "Unsupported field of HTTP/2 SETTINGS frame: " +
+                          base::IntToString(SETTINGS_INITIAL_WINDOW_SIZE),
+                      _));
+  EXPECT_CALL(*connection_,
+              CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                              "Unsupported field of HTTP/2 SETTINGS frame: " +
+                                  base::IntToString(SETTINGS_ENABLE_PUSH),
+                              _));
+  EXPECT_CALL(*connection_,
+              CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                              "Unsupported field of HTTP/2 SETTINGS frame: " +
+                                  base::IntToString(SETTINGS_MAX_FRAME_SIZE),
+                              _));
+  stream_frame_.data_buffer = frame.data();
+  stream_frame_.data_length = frame.size();
+  headers_stream_->OnStreamFrame(stream_frame_);
+}
+
 TEST_P(QuicHeadersStreamTest, ProcessSpdyPingFrame) {
   SpdyPingIR data(1);
   SpdySerializedFrame frame(framer_->SerializeFrame(data));
   EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
                                             "SPDY PING frame received.", _))
       .WillOnce(InvokeWithoutArgs(
           this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
   stream_frame_.data_buffer = frame.data();
   stream_frame_.data_length = frame.size();
   headers_stream_->OnStreamFrame(stream_frame_);
@@ skipping 116 matching lines @@
           connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
         }
       }
     }
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net