Add SpdyFramerDebugVisitorInterface for later usage in stats collecting

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 283 matching lines @@
   if (identical) return;
   ADD_FAILURE()
       << "Description:\n"
       << description
       << "\n\nExpected:\n"
       << HexDumpWithMarks(expected, expected_len, marks.get(), max_len)
       << "\nActual:\n"
       << HexDumpWithMarks(actual, actual_len, marks.get(), max_len);
 }
 
-class TestSpdyVisitor : public SpdyFramerVisitorInterface  {
+class TestSpdyVisitor : public SpdyFramerVisitorInterface,
+                        public SpdyFramerDebugVisitorInterface {
  public:
   static const size_t kDefaultHeaderBufferSize = 16 * 1024;
   static const size_t kDefaultCredentialBufferSize = 16 * 1024;
 
   explicit TestSpdyVisitor(int version)
     : framer_(version),
       use_compression_(false),
       error_count_(0),
       syn_frame_count_(0),
       syn_reply_frame_count_(0),
       headers_frame_count_(0),
       goaway_count_(0),
       setting_count_(0),
       data_bytes_(0),
       fin_frame_count_(0),
       fin_flag_count_(0),
       zero_length_data_frame_count_(0),
       header_blocks_count_(0),
       control_frame_header_data_count_(0),
       zero_length_control_frame_header_data_count_(0),
       data_frame_count_(0),
+      last_decompressed_size_(0),
+      last_compressed_size_(0),
       header_buffer_(new char[kDefaultHeaderBufferSize]),
       header_buffer_length_(0),
       header_buffer_size_(kDefaultHeaderBufferSize),
       header_stream_id_(-1),
       header_control_type_(NUM_CONTROL_FRAME_TYPES),
       header_buffer_valid_(false),
       credential_buffer_(new char[kDefaultCredentialBufferSize]),
       credential_buffer_length_(0),
       credential_buffer_size_(kDefaultCredentialBufferSize) {
   }
 
-  void OnError(SpdyFramer* f) {
+  virtual void OnError(SpdyFramer* f) OVERRIDE {
     LOG(INFO) << "SpdyFramer Error: "
               << SpdyFramer::ErrorCodeToString(f->error_code());
     error_count_++;
   }
 
-  void OnDataFrameHeader(const SpdyDataFrame* frame) {
+  virtual void OnDataFrameHeader(const SpdyDataFrame* frame) OVERRIDE {
     data_frame_count_++;
     header_stream_id_ = frame->stream_id();
   }
 
-  void OnStreamFrameData(SpdyStreamId stream_id,
-                         const char* data,
-                         size_t len,
-                         SpdyDataFlags flags) {
+  virtual void OnStreamFrameData(SpdyStreamId stream_id,
+                                 const char* data,
+                                 size_t len,
+                                 SpdyDataFlags flags) OVERRIDE {
     EXPECT_EQ(header_stream_id_, stream_id);
     if (len == 0)
       ++zero_length_data_frame_count_;
 
     data_bytes_ += len;
     std::cerr << "OnStreamFrameData(" << stream_id << ", \"";
     if (len > 0) {
       for (size_t i = 0 ; i < len; ++i) {
         std::cerr << std::hex << (0xFF & (unsigned int)data[i]) << std::dec;
       }
     }
     std::cerr << "\", " << len << ")\n";
   }
 
   virtual void OnSynStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            uint8 credential_slot,
                            bool fin,
-                           bool unidirectional) {
+                           bool unidirectional) OVERRIDE {
     syn_frame_count_++;
     InitHeaderStreaming(SYN_STREAM, stream_id);
     if (fin) {
       fin_flag_count_++;
     }
   }
 
-  virtual void OnSynReply(SpdyStreamId stream_id, bool fin) {
+  virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
     syn_reply_frame_count_++;
     InitHeaderStreaming(HEADERS, stream_id);
     if (fin) {
       fin_flag_count_++;
     }
   }
 
-  virtual void OnHeaders(SpdyStreamId stream_id, bool fin) {
+  virtual void OnHeaders(SpdyStreamId stream_id, bool fin) OVERRIDE {
     headers_frame_count_++;
     InitHeaderStreaming(SYN_REPLY, stream_id);
     if (fin) {
       fin_flag_count_++;
     }
   }
 
-  virtual void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) {
+  virtual void OnSetting(
+      SpdySettingsIds id, uint8 flags, uint32 value) OVERRIDE {
     setting_count_++;
   }
 
   virtual void OnControlFrameCompressed(
       const SpdyControlFrame& uncompressed_frame,
-      const SpdyControlFrame& compressed_frame) {
+      const SpdyControlFrame& compressed_frame) OVERRIDE {
   }
 
-  virtual void OnPing(uint32 unique_id) {
+  virtual void OnPing(uint32 unique_id) OVERRIDE {
     DLOG(FATAL);
   }
 
-  virtual void OnRstStream(SpdyStreamId stream_id, SpdyStatusCodes status) {
+  virtual void OnRstStream(SpdyStreamId stream_id,
+                           SpdyStatusCodes status) OVERRIDE {
     fin_frame_count_++;
   }
 
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                        SpdyGoAwayStatus status) {
+                        SpdyGoAwayStatus status) OVERRIDE {
     goaway_count_++;
   }
 
-  virtual void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) {
+  virtual void OnWindowUpdate(SpdyStreamId stream_id,
+                              int delta_window_size) OVERRIDE {
     last_window_update_stream_ = stream_id;
     last_window_update_delta_ = delta_window_size;
   }
 
-  bool OnControlFrameHeaderData(SpdyStreamId stream_id,
-                                const char* header_data,
-                                size_t len) {
+  virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
+                                        const char* header_data,
+                                        size_t len) OVERRIDE {
     ++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_);
       size_t parsed_length = framer_.ParseHeaderBlockInBuffer(
           header_buffer_.get(), header_buffer_length_, &headers_);
       DCHECK_EQ(header_buffer_length_, parsed_length);
       return true;
     }
     const size_t available = header_buffer_size_ - header_buffer_length_;
     if (len > available) {
       header_buffer_valid_ = false;
       return false;
     }
     memcpy(header_buffer_.get() + header_buffer_length_, header_data, len);
     header_buffer_length_ += len;
     return true;
   }
 
-  bool OnCredentialFrameData(const char* credential_data,
-                             size_t len) {
+  virtual bool OnCredentialFrameData(const char* credential_data,
+                                     size_t len) OVERRIDE {
     if (len == 0) {
       if (!framer_.ParseCredentialData(credential_buffer_.get(),
                                        credential_buffer_length_,
                                        &credential_)) {
         ++error_count_;
       }
       return true;
     }
     const size_t available =
         credential_buffer_size_ - credential_buffer_length_;
     if (len > available) {
       return false;
     }
     memcpy(credential_buffer_.get() + credential_buffer_length_,
            credential_data, len);
     credential_buffer_length_ += len;
     return true;
   }
 
+  virtual void OnCompressedHeaderBlock(size_t decompressed_size,
+                                       size_t compressed_size) OVERRIDE {
+    last_decompressed_size_ = decompressed_size;
+    last_compressed_size_ = compressed_size;
+  }
+
   // Convenience function which runs a framer simulation with particular input.
   void SimulateInFramer(const unsigned char* input, size_t size) {
     framer_.set_enable_compression(use_compression_);
     framer_.set_visitor(this);
     size_t input_remaining = size;
     const char* input_ptr = reinterpret_cast<const char*>(input);
     while (input_remaining > 0 &&
            framer_.error_code() == SpdyFramer::SPDY_NO_ERROR) {
       // To make the tests more interesting, we feed random (amd small) chunks
       // into the framer.  This simulates getting strange-sized reads from
@@ skipping 47 matching lines @@
   int last_window_update_delta_;
   int data_bytes_;
   int fin_frame_count_;  // The count of RST_STREAM type frames received.
   int fin_flag_count_;  // The count of frames with the FIN flag set.
   int zero_length_data_frame_count_;  // The count of zero-length data frames.
   int header_blocks_count_;
   int control_frame_header_data_count_;  // The count of chunks received.
   // The count of zero-length control frame header data chunks received.
   int zero_length_control_frame_header_data_count_;
   int data_frame_count_;
+  size_t last_decompressed_size_;
+  size_t last_compressed_size_;
 
   // Header block streaming state:
   scoped_array<char> header_buffer_;
   size_t header_buffer_length_;
   size_t header_buffer_size_;
   SpdyStreamId header_stream_id_;
   SpdyControlType header_control_type_;
   bool header_buffer_valid_;
   SpdyHeaderBlock headers_;
 
@@ skipping 341 matching lines @@
 
 TEST_P(SpdyFramerTest, BasicCompression) {
   SpdyHeaderBlock headers;
   headers["server"] = "SpdyServer 1.0";
   headers["date"] = "Mon 12 Jan 2009 12:12:12 PST";
   headers["status"] = "200";
   headers["version"] = "HTTP/1.1";
   headers["content-type"] = "text/html";
   headers["content-length"] = "12";
 
+  TestSpdyVisitor visitor(spdy_version_);
   SpdyFramer framer(spdy_version_);
+  framer.set_debug_visitor(&visitor);
   framer.set_enable_compression(true);
   scoped_ptr<SpdySynStreamControlFrame> frame1(
       framer.CreateSynStream(1,  // stream id
                              0,  // associated stream id
                              1,  // priority
                              0,  // credential slot
                              CONTROL_FLAG_NONE,
                              true,  // compress
                              &headers));
+  if (IsSpdy2()) {
+    EXPECT_EQ(139u, visitor.last_decompressed_size_);
+    EXPECT_EQ(
+#if defined(USE_SYSTEM_ZLIB)
+        93u,

[akalin, 2013/02/06 00:25:07]

I do it this way instead of just copying the line for each block because future
CLs change the variable name, and so I want to avoid the possibility of the
names in the two blocks going out of sync

[akalin, 2013/02/06 00:29:01]

Oh.  looks like only "decompressed" actually changes.  But I still prefer it
this way.

[Ryan Hamilton, 2013/02/06 00:32:30]

Either way is fine with me.

+#else  // !defined(USE_SYSTEM_ZLIB)
+        135u,
+#endif  // !defined(USE_SYSTEM_ZLIB)
+        visitor.last_compressed_size_);
+    EXPECT_EQ(135u, visitor.last_compressed_size_);
+  } else {
+    EXPECT_EQ(165u, visitor.last_decompressed_size_);
+    EXPECT_EQ(
+#if defined(USE_SYSTEM_ZLIB)
+        72u,
+#else  // !defined(USE_SYSTEM_ZLIB)
+        117u,
+#endif  // !defined(USE_SYSTEM_ZLIB)
+        visitor.last_compressed_size_);
+  }
   scoped_ptr<SpdySynStreamControlFrame> frame2(
       framer.CreateSynStream(1,  // stream id
                              0,  // associated stream id
                              1,  // priority
                              0,  // credential slot
                              CONTROL_FLAG_NONE,
                              true,  // compress
                              &headers));
 
   // Expect the second frame to be more compact than the first.
@@ skipping 2287 matching lines @@
   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