Deprecates --spdy_framer_use_new_methods4.

net/spdy/spdy_framer.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/spdy_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
+#include <cctype>
 #include <ios>
 #include <iterator>
 #include <list>
 #include <memory>
 #include <new>
 #include <string>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/strings/string_util.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/spdy_bitmasks.h"
 #include "net/spdy/spdy_bug_tracker.h"
 #include "net/spdy/spdy_flags.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_frame_reader.h"
 #include "net/spdy/spdy_framer_decoder_adapter.h"
 #include "net/spdy/spdy_headers_block_parser.h"
 #include "third_party/zlib/zlib.h"
@@ skipping 1365 matching lines @@
 // manner that resists the length of the compressed data from compromising
 // cookie data.
 void SpdyFramer::WriteHeaderBlockToZ(const SpdyHeaderBlock* headers,
                                      z_stream* z) const {
   const size_t length_length = 4;
   WriteLengthZ(headers->size(), length_length, kZStandardData, z);
 
   SpdyHeaderBlock::const_iterator it;
   for (it = headers->begin(); it != headers->end(); ++it) {
     WriteLengthZ(it->first.size(), length_length, kZStandardData, z);
-    WriteZ(it->first, kZStandardData, z);
 
-    if (it->first == "cookie") {
+    std::string lowercase_key = base::ToLowerASCII(it->first);
+    WriteZ(lowercase_key, kZStandardData, z);
+
+    if (lowercase_key == "cookie") {
       // We require the cookie values (save for the last) to end with a
       // semicolon and (save for the first) to start with a space. This is
       // typically the format that we are given them in but we reserialize them
       // to be sure.
 
       std::vector<base::StringPiece> cookie_values;
       size_t cookie_length = 0;
       base::StringPiece cookie_data(it->second);
 
       for (;;) {
@@ skipping 37 matching lines @@
           cookie = cookie_values[i].as_string();
         } else if (i == 0) {
           cookie = cookie_values[i].as_string() + ";";
         } else if (i < cookie_values.size() - 1) {
           cookie = " " + cookie_values[i].as_string() + ";";
         } else {
           cookie = " " + cookie_values[i].as_string();
         }
         WriteZ(cookie, kZCookieData, z);
       }
-    } else if (it->first == "accept" ||
-               it->first == "accept-charset" ||
-               it->first == "accept-encoding" ||
-               it->first == "accept-language" ||
-               it->first == "host" ||
-               it->first == "version" ||
-               it->first == "method" ||
-               it->first == "scheme" ||
-               it->first == ":host" ||
-               it->first == ":version" ||
-               it->first == ":method" ||
-               it->first == ":scheme" ||
-               it->first == "user-agent") {
+    } else if (lowercase_key == "accept" ||
+               lowercase_key == "accept-charset" ||
+               lowercase_key == "accept-encoding" ||
+               lowercase_key == "accept-language" ||
+               lowercase_key == "host" ||
+               lowercase_key == "version" ||
+               lowercase_key == "method" ||
+               lowercase_key == "scheme" ||
+               lowercase_key == ":host" ||
+               lowercase_key == ":version" ||
+               lowercase_key == ":method" ||
+               lowercase_key == ":scheme" ||
+               lowercase_key == "user-agent") {
       WriteLengthZ(it->second.size(), length_length, kZStandardData, z);
       WriteZ(it->second, kZStandardData, z);
     } else {
       // Non-whitelisted headers are Huffman compressed in their own block, but
       // don't match against the window.
       WriteLengthZ(it->second.size(), length_length, kZStandardData, z);
       WriteZ(it->second, kZHuffmanOnlyData, z);
     }
   }
 
@@ skipping 199 matching lines @@
         break;
       default:
 #ifndef NDEBUG
         LOG(FATAL) << "Invalid control frame type: " << current_frame_type_;
 #else
         set_error(SPDY_INVALID_CONTROL_FRAME);
         return original_len - len;
 #endif
     }
 
-    if (use_new_methods_ && current_frame_type_ != CONTINUATION) {
+    if (current_frame_type_ != CONTINUATION) {
       header_handler_ = visitor_->OnHeaderFrameStart(current_frame_stream_id_);
       if (header_handler_ == nullptr) {
         SPDY_BUG << "visitor_->OnHeaderFrameStart returned nullptr";
         set_error(SPDY_INTERNAL_FRAMER_ERROR);
         return original_len - len;
       }
       if (protocol_version() == SPDY3) {
         header_parser_.reset(
             new SpdyHeadersBlockParser(protocol_version(), header_handler_));
       } else {
@@ skipping 49 matching lines @@
   remaining_data_length_ -= process_bytes;
 
   // Handle the case that there is no futher data in this frame.
   if (remaining_data_length_ == remaining_padding_payload_length_ &&
       processed_successfully) {
     if (expect_continuation_ == 0) {
       if (is_hpack_header_block) {
         size_t compressed_len = 0;
         if (GetHpackDecoder()->HandleControlFrameHeadersComplete(
                 &compressed_len)) {
-          if (use_new_methods_) {
-            visitor_->OnHeaderFrameEnd(current_frame_stream_id_, true);
-            if (state_ == SPDY_ERROR) {
-              return data_len;
-            }
-          } else {
-            // TODO(jgraettinger): To be removed with migration to
-            // SpdyHeadersHandlerInterface. Serializes the HPACK block as a
-            // SPDY3 block, delivered via reentrant call to
-            // ProcessControlFrameHeaderBlock().
-            DeliverHpackBlockAsSpdy3Block(compressed_len);
-            return process_bytes;
+          visitor_->OnHeaderFrameEnd(current_frame_stream_id_, true);
+          if (state_ == SPDY_ERROR) {
+            return data_len;
           }
         } else {
           set_error(SPDY_DECOMPRESS_FAILURE);
           processed_successfully = false;
         }
       } else {
-        if (use_new_methods_) {
-          visitor_->OnHeaderFrameEnd(current_frame_stream_id_, true);
-          if (state_ == SPDY_ERROR) {
-            return data_len;
-          }
-        } else {
-          // The complete header block has been delivered. We send a zero-length
-          // OnControlFrameHeaderData() to indicated this.
-          visitor_->OnControlFrameHeaderData(current_frame_stream_id_, nullptr,
-                                             0);
+        visitor_->OnHeaderFrameEnd(current_frame_stream_id_, true);
+        if (state_ == SPDY_ERROR) {
+          return data_len;
         }
       }
     }
     if (processed_successfully) {
       CHANGE_STATE(SPDY_CONSUME_PADDING);
     }
   }
 
   // Handle error.
   if (!processed_successfully) {
@@ skipping 546 matching lines @@
   // Read each header.
   for (uint32_t index = 0; index < num_headers; ++index) {
     base::StringPiece temp;
 
     // Read header name.
     if (!reader.ReadStringPiece32(&temp)) {
       DVLOG(1) << "Unable to read header name (" << index + 1 << " of "
                << num_headers << ").";
       return false;
     }
+    const char* begin = temp.data();
+    const char* end = begin;
+    std::advance(end, temp.size());
+    if (protocol_version_ == HTTP2 && std::any_of(begin, end, isupper)) {
+      DVLOG(1) << "Malformed header: Header name " << temp
+               << " contains upper-case characters.";
+      return false;
+    }
     std::string name = temp.as_string();
 
     // Read header value.
     if (!reader.ReadStringPiece32(&temp)) {
       DVLOG(1) << "Unable to read header value (" << index + 1 << " of "
                << num_headers << ").";
       return false;
     }
     std::string value = temp.as_string();
 
@@ skipping 921 matching lines @@
     }
 
     // Inflate will generate a Z_BUF_ERROR if it runs out of input
     // without producing any output.  The input is consumed and
     // buffered internally by zlib so we can detect this condition by
     // checking if avail_in is 0 after the call to inflate.
     bool input_exhausted = ((rv == Z_BUF_ERROR) && (decomp->avail_in == 0));
     if ((rv == Z_OK) || input_exhausted) {
       size_t decompressed_len = arraysize(buffer) - decomp->avail_out;
       if (decompressed_len > 0) {
-        if (use_new_methods_) {
-          processed_successfully =
-              header_parser_->HandleControlFrameHeadersData(stream_id, buffer,
-                                                            decompressed_len);
-          if (header_parser_->get_error() ==
-              SpdyHeadersBlockParser::NEED_MORE_DATA) {
-            processed_successfully = true;
-          }
-        } else {
-          processed_successfully = visitor_->OnControlFrameHeaderData(
-              stream_id, buffer, decompressed_len);
+        processed_successfully = header_parser_->HandleControlFrameHeadersData(
+            stream_id, buffer, decompressed_len);
+        if (header_parser_->get_error() ==
+            SpdyHeadersBlockParser::NEED_MORE_DATA) {
+          processed_successfully = true;
         }
       }
       if (!processed_successfully) {
         // Assume that the problem was the header block was too large for the
         // visitor.
         set_error(SPDY_CONTROL_PAYLOAD_TOO_LARGE);
       }
     } else {
       DLOG(WARNING) << "inflate failure: " << rv << " " << len;
       set_error(SPDY_DECOMPRESS_FAILURE);
       processed_successfully = false;
     }
   }
   return processed_successfully;
 }
 
 bool SpdyFramer::IncrementallyDeliverControlFrameHeaderData(
     SpdyStreamId stream_id, const char* data, size_t len) {
   bool read_successfully = true;
   while (read_successfully && len > 0) {
     size_t bytes_to_deliver = std::min(len, kHeaderDataChunkMaxSize);
-    if (use_new_methods_) {
-      read_successfully = header_parser_->HandleControlFrameHeadersData(
-          stream_id, data, bytes_to_deliver);
-      if (header_parser_->get_error() ==
-          SpdyHeadersBlockParser::NEED_MORE_DATA) {
-        read_successfully = true;
-      }
-    } else {
-      read_successfully =
-          visitor_->OnControlFrameHeaderData(stream_id, data, bytes_to_deliver);
+    read_successfully = header_parser_->HandleControlFrameHeadersData(
+        stream_id, data, bytes_to_deliver);
+    if (header_parser_->get_error() == SpdyHeadersBlockParser::NEED_MORE_DATA) {
+      read_successfully = true;
     }
     data += bytes_to_deliver;
     len -= bytes_to_deliver;
     if (!read_successfully) {
       // Assume that the problem was the header block was too large for the
       // visitor.
       set_error(SPDY_CONTROL_PAYLOAD_TOO_LARGE);
     }
   }
   return read_successfully;
@@ skipping 30 matching lines @@
 }
 
 void SpdyFramer::SerializeHeaderBlockWithoutCompression(
     SpdyFrameBuilder* builder,
     const SpdyHeaderBlock& header_block) const {
   // Serialize number of headers.
   builder->WriteUInt32(header_block.size());
 
   // Serialize each header.
   for (const auto& header : header_block) {
-    builder->WriteStringPiece32(header.first);
+    builder->WriteStringPiece32(base::ToLowerASCII(header.first));
     builder->WriteStringPiece32(header.second);
   }
 }
 
 void SpdyFramer::SerializeHeaderBlock(SpdyFrameBuilder* builder,
                                       const SpdyFrameWithHeaderBlockIR& frame) {
   if (!enable_compression_) {
     return SerializeHeaderBlockWithoutCompression(builder,
                                                   frame.header_block());
   }
@@ skipping 43 matching lines @@
 #else
   WriteHeaderBlockToZ(&frame.header_block(), compressor);
 #endif  // defined(USE_SYSTEM_ZLIB)
 
   int compressed_size = compressed_max_size - compressor->avail_out;
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 }
 
 }  // namespace net