Add SpdyFramerDebugVisitorInterface for later usage in stats collecting

net/spdy/spdy_framer.h

 // 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.
 
 #ifndef NET_SPDY_SPDY_FRAMER_H_
 #define NET_SPDY_SPDY_FRAMER_H_
 
 #include <list>
 #include <map>
 #include <string>
@@ skipping 196 matching lines @@
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
                               int delta_window_size) = 0;
 
   // Called after a control frame has been compressed to allow the visitor
   // to record compression statistics.
   virtual void OnControlFrameCompressed(
       const SpdyControlFrame& uncompressed_frame,
       const SpdyControlFrame& compressed_frame) = 0;
 };
 
+// Optionally, and in addition to SpdyFramerVisitorInterface, a class supporting
+// SpdyFramerDebugVisitorInterface may be used in conjunction with SpdyFramer in
+// order to extract debug/internal information about the SpdyFramer as it
+// operates.
+//
+// Most SPDY implementations need not bother with this interface at all.
+class SpdyFramerDebugVisitorInterface {
+ public:
+  virtual ~SpdyFramerDebugVisitorInterface() {}
+
+  // Called after compressing header blocks.
+  // Provides decompressed and compressed sizes.
+  virtual void OnCompressedHeaderBlock(size_t decompressed_len,
+                                       size_t compressed_len) {}
+};
+
 class NET_EXPORT_PRIVATE SpdyFramer {
  public:
   // SPDY states.
   // TODO(mbelshe): Can we move these into the implementation
   //                and avoid exposing through the header.  (Needed for test)
   enum SpdyState {
     SPDY_ERROR,
     SPDY_DONE,
     SPDY_RESET,
     SPDY_AUTO_RESET,
@@ skipping 50 matching lines @@
   virtual ~SpdyFramer();
 
   // Set callbacks to be called from the framer.  A visitor must be set, or
   // else the framer will likely crash.  It is acceptable for the visitor
   // to do nothing.  If this is called multiple times, only the last visitor
   // will be used.
   void set_visitor(SpdyFramerVisitorInterface* visitor) {
     visitor_ = visitor;
   }
 
+  // Set debug callbacks to be called from the framer. The debug visitor is
+  // completely optional and need not be set in order for normal operation.
+  // If this is called multiple times, only the last visitor will be used.
+  void set_debug_visitor(SpdyFramerDebugVisitorInterface* debug_visitor) {
+    debug_visitor_ = debug_visitor;
+  }
+
   // Pass data into the framer for parsing.
   // Returns the number of bytes consumed. It is safe to pass more bytes in
   // than may be consumed.
   size_t ProcessInput(const char* data, size_t len);
 
   // Resets the framer state after a frame has been successfully decoded.
   // TODO(mbelshe): can we make this private?
   void Reset();
 
   // Check the state of the framer.
@@ skipping 275 matching lines @@
   // TODO(hkhalil): Unify memory for this scratch space with
   // current_frame_buffer_.
   SpdySettingsScratch settings_scratch_;
 
   bool enable_compression_;  // Controls all compression
   // SPDY header compressors.
   scoped_ptr<z_stream> header_compressor_;
   scoped_ptr<z_stream> header_decompressor_;
 
   SpdyFramerVisitorInterface* visitor_;
+  SpdyFramerDebugVisitorInterface* debug_visitor_;
 
   std::string display_protocol_;
 
   // The SPDY version to be spoken/understood by this framer. We support only
   // integer versions here, as major version numbers indicate framer-layer
   // incompatibility and minor version numbers indicate application-layer
   // incompatibility.
   const int spdy_version_;
 
   // Tracks if we've ever gotten far enough in framing to see a control frame of
   // type SYN_STREAM or SYN_REPLY.
   //
   // If we ever get something which looks like a data frame before we've had a
   // SYN, we explicitly check to see if it looks like we got an HTTP response to
   // a SPDY request.  This boolean lets us do that.
   bool syn_frame_processed_;
 
   // If we ever get a data frame before a SYN frame, we check to see if it
   // starts with HTTP.  If it does, we likely have an HTTP response.   This
   // isn't guaranteed though: we could have gotten a settings frame and then
   // corrupt data that just looks like HTTP, but deterministic checking requires
   // a lot more state.
   bool probable_http_response_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_FRAMER_H_