Fix out of order SYN_STEAM frames.

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/memory/scoped_ptr.h"
 #include "net/spdy/spdy_framer.h"
@@ skipping 21 matching lines @@
   MOCK_METHOD3(OnControlFrameHeaderData, bool(SpdyStreamId stream_id,
                                               const char* header_data,
                                               size_t len));
   MOCK_METHOD2(OnCredentialFrameData, bool(const char* header_data,
                                            size_t len));
   MOCK_METHOD1(OnDataFrameHeader, void(const SpdyDataFrame* frame));
   MOCK_METHOD3(OnStreamFrameData, void(SpdyStreamId stream_id,
                                        const char* data,
                                        size_t len));
   MOCK_METHOD3(OnSetting, void(SpdySettingsIds id, uint8 flags, uint32 value));
+  MOCK_METHOD2(OnControlFrameCompressed,
+               void(const SpdyControlFrame& uncompressed_frame,
+                    const SpdyControlFrame& compressed_frame));
 };
 
 class SpdyFramerTestUtil {
  public:
   // Decompress a single frame using the decompression context held by
   // the SpdyFramer.  The implemention is meant for use only in tests
   // and will CHECK fail if the input is anything other than a single,
   // well-formed compressed frame.
   //
   // Returns a new decompressed SpdyFrame.
@@ skipping 73 matching lines @@
       LOG(FATAL) << "Unexpected data frame header";
     }
     virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                    const char* data,
                                    size_t len) {
       LOG(FATAL);
     }
     virtual void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) {
       LOG(FATAL);
     }
+    virtual void OnControlFrameCompressed(
+        const SpdyControlFrame& uncompressed_frame,
+        const SpdyControlFrame& compressed_frame) {
+    }
 
     char* ReleaseBuffer() {
       CHECK(finished_);
       return buffer_.release();
     }
 
     size_t size() const {
       CHECK(finished_);
       return size_;
     }
@@ skipping 170 matching lines @@
         DLOG(FATAL);  // Error!
     }
     if (frame->flags() & CONTROL_FLAG_FIN)
       ++fin_flag_count_;
   }
 
   virtual void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) {
     setting_count_++;
   }
 
+  virtual void OnControlFrameCompressed(
+      const SpdyControlFrame& uncompressed_frame,
+      const SpdyControlFrame& compressed_frame) {
+  }
+
   bool OnControlFrameHeaderData(SpdyStreamId stream_id,
                                 const char* header_data,
                                 size_t len) {
     ++control_frame_header_data_count_;
     CHECK_EQ(header_stream_id_, stream_id);
     if (len == 0) {
       ++zero_length_control_frame_header_data_count_;
       // Indicates end-of-header-block.
       CHECK(header_buffer_valid_);
       bool parsed_headers = framer_.ParseHeaderBlockInBuffer(
@@ skipping 2678 matching lines @@
   }
 }
 
 TEST_P(SpdyFramerTest, EmptySynStream) {
   SpdyHeaderBlock headers;
 
   testing::StrictMock<test::MockVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
+  EXPECT_CALL(visitor, OnControlFrameCompressed(_, _));
   scoped_ptr<SpdySynStreamControlFrame>
       frame(framer.CreateSynStream(1, 0, 1, 0, CONTROL_FLAG_NONE, true,
                                    &headers));
   // Adjust size to remove the name/value block.
   frame->set_length(
       SpdySynStreamControlFrame::size() - SpdyFrame::kHeaderSize);
 
   EXPECT_CALL(visitor, OnControl(_));
   EXPECT_CALL(visitor, OnControlFrameHeaderData(1, NULL, 0));
 
   size_t frame_size = frame->length() + SpdyFrame::kHeaderSize;
   framer.ProcessInput(frame->data(), frame_size);
   EXPECT_EQ(SpdyFramer::SPDY_RESET, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, SettingsFlagsAndId) {
   const uint32 kId = 0x020304;
   const uint32 kFlags = 0x01;
   const uint32 kWireFormat = htonl(IsSpdy2() ? 0x04030201 : 0x01020304);
 
   SettingsFlagsAndId id_and_flags =
       SettingsFlagsAndId::FromWireFormat(spdy_version_, kWireFormat);
   EXPECT_EQ(kId, id_and_flags.id());
   EXPECT_EQ(kFlags, id_and_flags.flags());
   EXPECT_EQ(kWireFormat, id_and_flags.GetWireFormat(spdy_version_));
 }
 
 }  // namespace net