Added new callbacks to SpdyHeadersHandlerInterface.

Callbacks notify when the parser starts, and finishes handling
a SPDY headers block. No other changes (new methods not in use).

This lands server change 59261835 by ygi.

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

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

3 files changed, 39 insertions, 16 deletions

diff --git a/net/spdy/spdy_headers_block_parser.cc b/net/spdy/spdy_headers_block_parser.cc
index 30bc00c..4ba6374 100644
--- a/net/spdy/spdy_headers_block_parser.cc
+++ b/net/spdy/spdy_headers_block_parser.cc
@@ -64,10 +64,9 @@ std::vector<char> SpdyHeadersBlockParserReader::Remainder() {
   return remainder;
 }
 
-SpdyHeadersBlockParser::SpdyHeadersBlockParser(KeyValueHandler* handler) :
-    state_(READING_HEADER_BLOCK_LEN),
-    remaining_key_value_pairs_for_frame_(0),
-    next_field_len_(0),
+SpdyHeadersBlockParser::SpdyHeadersBlockParser(
+    SpdyHeadersHandlerInterface* handler) : state_(READING_HEADER_BLOCK_LEN),
+    remaining_key_value_pairs_for_frame_(0), next_field_len_(0),
     handler_(handler) {
 }
 
@@ -112,6 +111,7 @@ void SpdyHeadersBlockParser::HandleControlFrameHeadersData(
   // headers block, try to do it now (succeeds if we received enough bytes).
   if (state_ == READING_HEADER_BLOCK_LEN) {
     if (ParseUInt32(&reader, &remaining_key_value_pairs_for_frame_)) {
+      handler_->OnHeaderBlock(remaining_key_value_pairs_for_frame_);
       state_ = READING_KEY_LEN;
     } else {
       headers_block_prefix_ = reader.Remainder();
@@ -174,6 +174,7 @@ void SpdyHeadersBlockParser::HandleControlFrameHeadersData(
 
   // Did we finish handling the current block?
   if (remaining_key_value_pairs_for_frame_ == 0) {
+    handler_->OnHeaderBlockEnd();
     Reset();
   }
 }
diff --git a/net/spdy/spdy_headers_block_parser.h b/net/spdy/spdy_headers_block_parser.h
index 9b8ec8c..3162ebe 100644
--- a/net/spdy/spdy_headers_block_parser.h
+++ b/net/spdy/spdy_headers_block_parser.h
@@ -15,12 +15,21 @@
 
 namespace net {
 
-// A handler class for SPDY headers block key/value pairs.
-// TODO(ygi) Modify this stub handler to pass the key-value pair
-// through the spdy logic.
-class KeyValueHandler {
+// A handler class for SPDY headers.
+class SpdyHeadersHandlerInterface {
  public:
-  virtual ~KeyValueHandler() {}
+  virtual ~SpdyHeadersHandlerInterface() {}
+
+  // A callback method which notifies when the parser starts handling a new
+  // SPDY headers block, this method also notifies on the number of headers in
+  // the block.
+  virtual void OnHeaderBlock(uint32_t num_of_headers) = 0;
+
+  // A callback method which notifies when the parser finishes handling a SPDY
+  // headers block.
+  virtual void OnHeaderBlockEnd() = 0;
+
+  // A callback method which notifies on a SPDY header key value pair.
   virtual void OnKeyValuePair(const base::StringPiece& key,
                               const base::StringPiece& value) = 0;
 };
@@ -57,7 +66,7 @@ class NET_EXPORT_PRIVATE SpdyHeadersBlockParser {
  public:
   // Costructor. The handler's OnKeyValuePair will be called for every key
   // value pair that we parsed from the headers block.
-  explicit SpdyHeadersBlockParser(KeyValueHandler* handler);
+  explicit SpdyHeadersBlockParser(SpdyHeadersHandlerInterface* handler);
 
   virtual ~SpdyHeadersBlockParser();
 
@@ -102,7 +111,7 @@ class NET_EXPORT_PRIVATE SpdyHeadersBlockParser {
   std::vector<char> headers_block_prefix_;
 
   // Handles key-value pairs as we parse them.
-  KeyValueHandler* handler_;
+  SpdyHeadersHandlerInterface* handler_;
 
   // Points to the current key.
   scoped_ptr<char[]> current_key;
diff --git a/net/spdy/spdy_headers_block_parser_test.cc b/net/spdy/spdy_headers_block_parser_test.cc
index 326cb05..34464ef 100644
--- a/net/spdy/spdy_headers_block_parser_test.cc
+++ b/net/spdy/spdy_headers_block_parser_test.cc
@@ -19,10 +19,12 @@ using std::string;
 using testing::ElementsAre;
 using testing::ElementsAreArray;
 
-class MockKeyValueHandler : public KeyValueHandler {
+// A mock the handler class to check that we parse out the correct headers
+// and call the callback methods when we should.
+class MockSpdyHeadersHandler : public SpdyHeadersHandlerInterface {
  public:
-  // A mock the handler method to make sure we parse out (and call it with)
-  // the correct parameters.
+  MOCK_METHOD1(OnHeaderBlock, void(uint32_t num_of_headers));
+  MOCK_METHOD0(OnHeaderBlockEnd, void());
   MOCK_METHOD2(OnKeyValuePair, void(const StringPiece&, const StringPiece&));
 };
 
@@ -36,7 +38,7 @@ class SpdyHeadersBlockParserTest : public testing::Test {
     parser_.reset(new SpdyHeadersBlockParser(&handler_));
   }
 
-  MockKeyValueHandler handler_;
+  MockSpdyHeadersHandler handler_;
   scoped_ptr<SpdyHeadersBlockParser> parser_;
 
   // Create a header block with a specified number of headers.
@@ -97,11 +99,16 @@ const char* SpdyHeadersBlockParserTest::base_value = "test_value";
 
 TEST_F(SpdyHeadersBlockParserTest, Basic) {
   // Sanity test, verify that we parse out correctly a block with
-  // a single key-value pair.
+  // a single key-value pair and that we notify when we start and finish
+  // handling a headers block.
+  EXPECT_CALL(handler_, OnHeaderBlock(1)).Times(1);
+
   std::string expect_key = base_key + IntToString(0);
   std::string expect_value = base_value + IntToString(0);
   EXPECT_CALL(handler_, OnKeyValuePair(StringPiece(expect_key),
                                        StringPiece(expect_value))).Times(1);
+  EXPECT_CALL(handler_, OnHeaderBlockEnd()).Times(1);
+
   string headers(CreateHeaders(1, false));
   parser_->HandleControlFrameHeadersData(headers.c_str(), headers.length());
 }
@@ -109,10 +116,14 @@ TEST_F(SpdyHeadersBlockParserTest, Basic) {
 TEST_F(SpdyHeadersBlockParserTest, NullsSupported) {
   // Sanity test, verify that we parse out correctly a block with
   // a single key-value pair when the key and value contain null charecters.
+  EXPECT_CALL(handler_, OnHeaderBlock(1)).Times(1);
+
   std::string expect_key = base_key + string("\0", 1) + IntToString(0);
   std::string expect_value = base_value + string("\0", 1) + IntToString(0);
   EXPECT_CALL(handler_, OnKeyValuePair(StringPiece(expect_key),
                                        StringPiece(expect_value))).Times(1);
+  EXPECT_CALL(handler_, OnHeaderBlockEnd()).Times(1);
+
   string headers(CreateHeaders(1, true));
   parser_->HandleControlFrameHeadersData(headers.c_str(), headers.length());
 }
@@ -128,11 +139,13 @@ TEST_F(SpdyHeadersBlockParserTest, MultipleBlocksMultipleHeadersPerBlock) {
   }
   // For each block we expect to parse out the headers in order.
   for (int i = 0; i < kNumHeaderBlocks; i++) {
+    EXPECT_CALL(handler_, OnHeaderBlock(kNumHeadersInBlock)).Times(1);
     for (int j = 0; j < kNumHeadersInBlock; j++) {
       EXPECT_CALL(handler_, OnKeyValuePair(
           StringPiece(retained_arguments[2 * j]),
           StringPiece(retained_arguments[2 * j + 1]))).Times(1);
     }
+    EXPECT_CALL(handler_, OnHeaderBlockEnd()).Times(1);
   }
   // Parse the blocks, breaking them into multiple reads at various points.
   for (int i = 0; i < kNumHeaderBlocks; i++) {