Extend SpdyFramerDebugVisitorInterface interface.

In chrome we need more detailed data on compression/decompression.

I've renamed methods and added stream_id, frame type and frame prefix length
parameters.

I've changed the scope of reporting - one message per frame.
This helped to fix bug with compressed size reporting: previously we reported
compressed size several times for one block. For example, in test we see that
sum of compressed lengths for frame is 3x of real compressed length.

This lands server change 47952359.

BUG=
R=rch@chromium.org

Review URL: https://codereview.chromium.org/16843013

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@206453 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 89 insertions, 45 deletions

diff --git a/net/spdy/spdy_framer.cc b/net/spdy/spdy_framer.cc
index 5cab815..f74fb02 100644
--- a/net/spdy/spdy_framer.cc
+++ b/net/spdy/spdy_framer.cc
@@ -822,6 +822,13 @@ void SpdyFramer::ProcessControlFrameHeader(uint16 control_frame_type_field) {
               static_cast<int32>(current_frame_buffer_length_));
     remaining_control_header_ = frame_size_without_variable_data -
         current_frame_buffer_length_;
+
+    if (debug_visitor_) {
+      debug_visitor_->OnReceiveCompressedFrame(current_frame_stream_id_,
+                                               current_frame_type_,
+                                               current_frame_length_);
+    }
+
     CHANGE_STATE(SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK);
     return;
   }
@@ -1579,6 +1586,15 @@ SpdySerializedFrame* SpdyFramer::SerializeSynStream(
   if (visitor_)
     visitor_->OnSynStreamCompressed(size, builder.length());
 
+  if (debug_visitor_) {
+    const size_t payload_len = GetSerializedLength(
+        protocol_version(), &(syn_stream.name_value_block()));
+    debug_visitor_->OnSendCompressedFrame(syn_stream.stream_id(),
+                                          SYN_STREAM,
+                                          payload_len,
+                                          builder.length());
+  }
+
   return builder.take();
 }
 
@@ -1626,6 +1642,15 @@ SpdySerializedFrame* SpdyFramer::SerializeSynReply(
   DCHECK_EQ(GetSynReplyMinimumSize(), builder.length());
   SerializeNameValueBlock(&builder, syn_reply);
 
+  if (debug_visitor_) {
+    const size_t payload_len = GetSerializedLength(
+        protocol_version(), &(syn_reply.name_value_block()));
+    debug_visitor_->OnSendCompressedFrame(syn_reply.stream_id(),
+                                          SYN_REPLY,
+                                          payload_len,
+                                          builder.length());
+  }
+
   return builder.take();
 }
 
@@ -1798,6 +1823,15 @@ SpdySerializedFrame* SpdyFramer::SerializeHeaders(
 
   SerializeNameValueBlock(&builder, headers);
 
+  if (debug_visitor_) {
+    const size_t payload_len = GetSerializedLength(
+        protocol_version(), &(headers.name_value_block()));
+    debug_visitor_->OnSendCompressedFrame(headers.stream_id(),
+                                          HEADERS,
+                                          payload_len,
+                                          builder.length());
+  }
+
   return builder.take();
 }
 
@@ -2037,9 +2071,6 @@ bool SpdyFramer::IncrementallyDecompressControlFrameHeaderData(
     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 (debug_visitor_ != NULL) {
-        debug_visitor_->OnDecompressedHeaderBlock(decompressed_len, len);
-      }
       if (decompressed_len > 0) {
         processed_successfully = visitor_->OnControlFrameHeaderData(
             stream_id, buffer, decompressed_len);
@@ -2167,10 +2198,6 @@ void SpdyFramer::SerializeNameValueBlock(
   post_compress_bytes.Add(compressed_size);
 
   compressed_frames.Increment();
-
-  if (debug_visitor_ != NULL) {
-    debug_visitor_->OnCompressedHeaderBlock(uncompressed_len, compressed_size);
-  }
 }
 
 }  // namespace net
diff --git a/net/spdy/spdy_framer.h b/net/spdy/spdy_framer.h
index cdd8f43..f9d6830 100644
--- a/net/spdy/spdy_framer.h
+++ b/net/spdy/spdy_framer.h
@@ -241,20 +241,21 @@ class SpdyFramerDebugVisitorInterface {
  public:
   virtual ~SpdyFramerDebugVisitorInterface() {}
 
-  // Called after compressing header blocks.
-  // Provides uncompressed and compressed sizes.
-  virtual void OnCompressedHeaderBlock(size_t uncompressed_len,
-                                       size_t compressed_len) {}
-
-  // Called when decompressing header blocks.
-  // Provides uncompressed and compressed sizes.
-  // Called once per incremental decompression. That is to say, if a header
-  // block is decompressed in four chunks, this will result in four calls to
-  // OnDecompressedHeaderBlock() interleaved with four calls to
-  // OnControlFrameHeaderData(). Note that uncompressed_len may be 0 in some
-  // valid cases, even though compressed_len is nonzero.
-  virtual void OnDecompressedHeaderBlock(size_t uncompressed_len,
-                                         size_t compressed_len) {}
+  // Called after compressing a frame with a payload of
+  // a list of name-value pairs.
+  // |payload_len| is the uncompressed payload size.
+  // |frame_len| is the compressed frame size.
+  virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
+                                     SpdyFrameType type,
+                                     size_t payload_len,
+                                     size_t frame_len) {}
+
+  // Called when a frame containing a compressed payload of
+  // name-value pairs is received.
+  // |frame_len| is the compressed frame size.
+  virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
+                                        SpdyFrameType type,
+                                        size_t frame_len) {}
 };
 
 class NET_EXPORT_PRIVATE SpdyFramer {
diff --git a/net/spdy/spdy_framer_test.cc b/net/spdy/spdy_framer_test.cc
index 6a6ca84..d75dadb 100644
--- a/net/spdy/spdy_framer_test.cc
+++ b/net/spdy/spdy_framer_test.cc
@@ -282,8 +282,8 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface,
       control_frame_header_data_count_(0),
       zero_length_control_frame_header_data_count_(0),
       data_frame_count_(0),
-      last_uncompressed_size_(0),
-      last_compressed_size_(0),
+      last_payload_len_(0),
+      last_frame_len_(0),
       header_buffer_(new char[kDefaultHeaderBufferSize]),
       header_buffer_length_(0),
       header_buffer_size_(kDefaultHeaderBufferSize),
@@ -431,16 +431,18 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface,
     return true;
   }
 
-  virtual void OnCompressedHeaderBlock(size_t uncompressed_size,
-                                       size_t compressed_size) OVERRIDE {
-    last_uncompressed_size_ = uncompressed_size;
-    last_compressed_size_ = compressed_size;
+  virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
+                                     SpdyFrameType type,
+                                     size_t payload_len,
+                                     size_t frame_len) OVERRIDE {
+    last_payload_len_ = payload_len;
+    last_frame_len_ = frame_len;
   }
 
-  virtual void OnDecompressedHeaderBlock(size_t decompressed_size,
-                                         size_t compressed_size) OVERRIDE {
-    last_uncompressed_size_ = decompressed_size;
-    last_compressed_size_ = compressed_size;
+  virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
+                                        SpdyFrameType type,
+                                        size_t frame_len) OVERRIDE {
+    last_frame_len_ = frame_len;
   }
 
   // Convenience function which runs a framer simulation with particular input.
@@ -505,8 +507,8 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface,
   // 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_uncompressed_size_;
-  size_t last_compressed_size_;
+  size_t last_payload_len_;
+  size_t last_frame_len_;
 
   // Header block streaming state:
   scoped_ptr<char[]> header_buffer_;
@@ -942,19 +944,22 @@ TEST_P(SpdyFramerTest, BasicCompression) {
                              CONTROL_FLAG_NONE,
                              true,  // compress
                              &headers));
+  size_t uncompressed_size1 = visitor->last_payload_len_;
+  size_t compressed_size1 =
+      visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
   if (IsSpdy2()) {
-    EXPECT_EQ(139u, visitor->last_uncompressed_size_);
+    EXPECT_EQ(139u, uncompressed_size1);
 #if defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(155u, visitor->last_compressed_size_);
+    EXPECT_EQ(155u, compressed_size1);
 #else  // !defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(135u, visitor->last_compressed_size_);
+    EXPECT_EQ(135u, compressed_size1);
 #endif  // !defined(USE_SYSTEM_ZLIB)
   } else {
-    EXPECT_EQ(165u, visitor->last_uncompressed_size_);
+    EXPECT_EQ(165u, uncompressed_size1);
 #if defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(181u, visitor->last_compressed_size_);
+    EXPECT_EQ(181u, compressed_size1);
 #else  // !defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(117u, visitor->last_compressed_size_);
+    EXPECT_EQ(117u, compressed_size1);
 #endif  // !defined(USE_SYSTEM_ZLIB)
   }
   scoped_ptr<SpdyFrame> frame2(
@@ -965,6 +970,9 @@ TEST_P(SpdyFramerTest, BasicCompression) {
                              CONTROL_FLAG_NONE,
                              true,  // compress
                              &headers));
+  size_t uncompressed_size2 = visitor->last_payload_len_;
+  size_t compressed_size2 =
+      visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
 
   // Expect the second frame to be more compact than the first.
   EXPECT_LE(frame2->size(), frame1->size());
@@ -978,22 +986,30 @@ TEST_P(SpdyFramerTest, BasicCompression) {
   framer.set_debug_visitor(visitor.get());
   scoped_ptr<SpdyFrame> frame4(SpdyFramerTestUtil::DecompressFrame(
       &framer, *frame2.get()));
+  size_t uncompressed_size4 =
+      frame4->size() - framer.GetSynStreamMinimumSize();
+  size_t compressed_size4 =
+      visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
   if (IsSpdy2()) {
-    EXPECT_EQ(139u, visitor->last_uncompressed_size_);
+    EXPECT_EQ(139u, uncompressed_size4);
 #if defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(149u, visitor->last_compressed_size_);
+    EXPECT_EQ(149u, compressed_size4);
 #else  // !defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(101u, visitor->last_compressed_size_);
+    EXPECT_EQ(101u, compressed_size4);
 #endif  // !defined(USE_SYSTEM_ZLIB)
   } else {
-    EXPECT_EQ(165u, visitor->last_uncompressed_size_);
+    EXPECT_EQ(165u, uncompressed_size4);
 #if defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(175u, visitor->last_compressed_size_);
+    EXPECT_EQ(175u, compressed_size4);
 #else  // !defined(USE_SYSTEM_ZLIB)
-    EXPECT_EQ(102u, visitor->last_compressed_size_);
+    EXPECT_EQ(102u, compressed_size4);
 #endif  // !defined(USE_SYSTEM_ZLIB)
   }
 
+  EXPECT_EQ(uncompressed_size1, uncompressed_size2);
+  EXPECT_EQ(uncompressed_size1, uncompressed_size4);
+  EXPECT_EQ(compressed_size2, compressed_size4);
+
   // Expect frames 3 & 4 to be the same.
   CompareFrames("Uncompressed SYN_STREAM", *frame3, *frame4);