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/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/platform_test.h"
 
 using std::string;
 using std::max;
 using std::min;
@@ skipping 281 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) {
   }
@@ skipping 125 matching lines @@
         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_);
+#if defined(USE_SYSTEM_ZLIB)
+    EXPECT_EQ(93u, visitor.last_compressed_size_);
+#else  // !defined(USE_SYSTEM_ZLIB)
+    EXPECT_EQ(135u, visitor.last_compressed_size_);
+#endif  // !defined(USE_SYSTEM_ZLIB)
+  } else {
+    EXPECT_EQ(165u, visitor.last_decompressed_size_);
+#if defined(USE_SYSTEM_ZLIB)
+    EXPECT_EQ(72u, visitor.last_compressed_size_);
+#else  // !defined(USE_SYSTEM_ZLIB)
+    EXPECT_EQ(117u, visitor.last_compressed_size_);
+#endif  // !defined(USE_SYSTEM_ZLIB)
+  }
   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