Landing recent QUIC changes until Sun Mar 5 09:18:09 2017 +0000

net/quic/core/quic_spdy_session.cc

 // Copyright (c) 2015 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/core/quic_spdy_session.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <string>
 #include <utility>
@@ skipping 106 matching lines @@
       header_list_.Clear();
     }
   }
 
   void OnStreamFrameData(SpdyStreamId stream_id,
                          const char* data,
                          size_t len) override {
     if (session_->OnStreamFrameData(stream_id, data, len)) {
       return;
     }
-    CloseConnection("SPDY DATA frame received.");
+    CloseConnection("SPDY DATA frame received.",
+                    QUIC_INVALID_HEADERS_STREAM_DATA);
   }
 
   void OnStreamEnd(SpdyStreamId stream_id) override {
     // The framer invokes OnStreamEnd after processing a frame that had the fin
     // bit set.
   }
 
   void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {
-    CloseConnection("SPDY frame padding received.");
+    CloseConnection("SPDY frame padding received.",
+                    QUIC_INVALID_HEADERS_STREAM_DATA);
   }
 
   void OnError(SpdyFramer* framer) override {
-    CloseConnection(QuicStrCat(
-        "SPDY framing error: ",
-        SpdyFramer::SpdyFramerErrorToString(framer->spdy_framer_error())));
+    QuicErrorCode code = QUIC_INVALID_HEADERS_STREAM_DATA;
+    SpdyFramer::SpdyFramerError error = framer->spdy_framer_error();
+    switch (error) {
+      case SpdyFramer::SpdyFramerError::SPDY_DECOMPRESS_FAILURE:
+        code = QUIC_HEADERS_STREAM_DATA_DECOMPRESS_FAILURE;
+        break;
+      default:
+        break;
+    }
+    CloseConnection(QuicStrCat("SPDY framing error: ",
+                               SpdyFramer::SpdyFramerErrorToString(error)),
+                    code);
   }
 
   void OnDataFrameHeader(SpdyStreamId stream_id,
                          size_t length,
                          bool fin) override {
     if (session_->OnDataFrameHeader(stream_id, length, fin)) {
       return;
     }
-    CloseConnection("SPDY DATA frame received.");
+    CloseConnection("SPDY DATA frame received.",
+                    QUIC_INVALID_HEADERS_STREAM_DATA);
   }
 
   void OnRstStream(SpdyStreamId stream_id, SpdyErrorCode error_code) override {
-    CloseConnection("SPDY RST_STREAM frame received.");
+    CloseConnection("SPDY RST_STREAM frame received.",
+                    QUIC_INVALID_HEADERS_STREAM_DATA);
   }
 
   void OnSetting(SpdySettingsIds id, uint32_t value) override {
     if (!FLAGS_quic_reloadable_flag_quic_respect_http2_settings_frame) {
-      CloseConnection("SPDY SETTINGS frame received.");
+      CloseConnection("SPDY SETTINGS frame received.",
+                      QUIC_INVALID_HEADERS_STREAM_DATA);
       return;
     }
     switch (id) {
       case SETTINGS_HEADER_TABLE_SIZE:
         session_->UpdateHeaderEncoderTableSize(value);
         break;
       case SETTINGS_ENABLE_PUSH:
         if (FLAGS_quic_reloadable_flag_quic_enable_server_push_by_default &&
             session_->perspective() == Perspective::IS_SERVER) {
           // See rfc7540, Section 6.5.2.
           if (value > 1) {
             CloseConnection(
-                QuicStrCat("Invalid value for SETTINGS_ENABLE_PUSH: ", value));
+                QuicStrCat("Invalid value for SETTINGS_ENABLE_PUSH: ", value),
+                QUIC_INVALID_HEADERS_STREAM_DATA);
             return;
           }
           session_->UpdateEnableServerPush(value > 0);
           break;
         } else {
           CloseConnection(
-              QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ", id));
+              QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ", id),
+              QUIC_INVALID_HEADERS_STREAM_DATA);
         }
         break;
       // TODO(fayang): Need to support SETTINGS_MAX_HEADER_LIST_SIZE when
       // clients are actually sending it.
       case SETTINGS_MAX_HEADER_LIST_SIZE:
         if (FLAGS_quic_reloadable_flag_quic_send_max_header_list_size) {
           break;
         }
       default:
         CloseConnection(
-            QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ", id));
+            QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ", id),
+            QUIC_INVALID_HEADERS_STREAM_DATA);
     }
   }
 
   void OnSettingsAck() override {
     if (!FLAGS_quic_reloadable_flag_quic_respect_http2_settings_frame) {
-      CloseConnection("SPDY SETTINGS frame received.");
+      CloseConnection("SPDY SETTINGS frame received.",
+                      QUIC_INVALID_HEADERS_STREAM_DATA);
     }
   }
 
   void OnSettingsEnd() override {
     if (!FLAGS_quic_reloadable_flag_quic_respect_http2_settings_frame) {
-      CloseConnection("SPDY SETTINGS frame received.");
+      CloseConnection("SPDY SETTINGS frame received.",
+                      QUIC_INVALID_HEADERS_STREAM_DATA);
     }
   }
 
   void OnPing(SpdyPingId unique_id, bool is_ack) override {
-    CloseConnection("SPDY PING frame received.");
+    CloseConnection("SPDY PING frame received.",
+                    QUIC_INVALID_HEADERS_STREAM_DATA);
   }
 
   void OnGoAway(SpdyStreamId last_accepted_stream_id,
                 SpdyErrorCode error_code) override {
-    CloseConnection("SPDY GOAWAY frame received.");
+    CloseConnection("SPDY GOAWAY frame received.",
+                    QUIC_INVALID_HEADERS_STREAM_DATA);
   }
 
   void OnHeaders(SpdyStreamId stream_id,
                  bool has_priority,
                  int weight,
                  SpdyStreamId /*parent_stream_id*/,
                  bool /*exclusive*/,
                  bool fin,
                  bool end) override {
     if (!session_->IsConnected()) {
       return;
     }
 
     // TODO(mpw): avoid down-conversion and plumb SpdyStreamPrecedence through
     // QuicHeadersStream.
     SpdyPriority priority =
         has_priority ? Http2WeightToSpdy3Priority(weight) : 0;
     session_->OnHeaders(stream_id, has_priority, priority, fin);
   }
 
   void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) override {
-    CloseConnection("SPDY WINDOW_UPDATE frame received.");
+    CloseConnection("SPDY WINDOW_UPDATE frame received.",
+                    QUIC_INVALID_HEADERS_STREAM_DATA);
   }
 
   void OnPushPromise(SpdyStreamId stream_id,
                      SpdyStreamId promised_stream_id,
                      bool end) override {
     if (!session_->supports_push_promise()) {
-      CloseConnection("PUSH_PROMISE not supported.");
+      CloseConnection("PUSH_PROMISE not supported.",
+                      QUIC_INVALID_HEADERS_STREAM_DATA);
       return;
     }
     if (!session_->IsConnected()) {
       return;
     }
     session_->OnPushPromise(stream_id, promised_stream_id, end);
   }
 
   void OnContinuation(SpdyStreamId stream_id, bool end) override {}
 
   void OnPriority(SpdyStreamId stream_id,
                   SpdyStreamId parent_id,
                   int weight,
                   bool exclusive) override {
-    CloseConnection("SPDY PRIORITY frame received.");
+    CloseConnection("SPDY PRIORITY frame received.",
+                    QUIC_INVALID_HEADERS_STREAM_DATA);
   }
 
   bool OnUnknownFrame(SpdyStreamId stream_id, uint8_t frame_type) override {
-    CloseConnection("Unknown frame type received.");
+    CloseConnection("Unknown frame type received.",
+                    QUIC_INVALID_HEADERS_STREAM_DATA);
     return false;
   }
 
   // SpdyFramerDebugVisitorInterface implementation
   void OnSendCompressedFrame(SpdyStreamId stream_id,
                              SpdyFrameType type,
                              size_t payload_len,
                              size_t frame_len) override {
     if (payload_len == 0) {
       QUIC_BUG << "Zero payload length.";
@@ skipping 11 matching lines @@
     }
   }
 
   void set_max_uncompressed_header_bytes(
       size_t set_max_uncompressed_header_bytes) {
     header_list_.set_max_uncompressed_header_bytes(
         set_max_uncompressed_header_bytes);
   }
 
  private:
-  void CloseConnection(const string& details) {
+  void CloseConnection(const string& details, QuicErrorCode code) {
     if (session_->IsConnected()) {
-      session_->CloseConnectionWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
-                                           details);
+      session_->CloseConnectionWithDetails(code, details);
     }
   }
 
  private:
   QuicSpdySession* session_;
   QuicHeaderList header_list_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyFramerVisitor);
 };
 
@@ skipping 438 matching lines @@
       set_max_uncompressed_header_bytes);
 }
 
 void QuicSpdySession::CloseConnectionWithDetails(QuicErrorCode error,
                                                  const string& details) {
   connection()->CloseConnection(
       error, details, ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
 }
 
 }  // namespace net