Update from https://crrev.com/304121

net/tools/flip_server/spdy_interface_test.cc

 // Copyright 2013 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 "net/tools/flip_server/spdy_interface.h"
 
 #include <list>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
@@ skipping 34 matching lines @@
   MOCK_METHOD1(OnError, void(SpdyFramer::SpdyError));
   MOCK_METHOD2(OnStreamError, void(SpdyStreamId, const std::string&));
   MOCK_METHOD6(OnSynStream,
                void(SpdyStreamId,
                     SpdyStreamId,
                     SpdyPriority,
                     bool,
                     bool,
                     const SpdyHeaderBlock&));
   MOCK_METHOD3(OnSynReply, void(SpdyStreamId, bool, const SpdyHeaderBlock&));
-  MOCK_METHOD3(OnHeaders, void(SpdyStreamId, bool, const SpdyHeaderBlock&));
+  MOCK_METHOD5(OnHeaders,
+               void(SpdyStreamId,
+                    bool,
+                    SpdyPriority,
+                    bool,
+                    const SpdyHeaderBlock&));
   MOCK_METHOD3(OnDataFrameHeader, void(SpdyStreamId, size_t, bool));
   MOCK_METHOD4(OnStreamFrameData, void(SpdyStreamId,
                                        const char*,
                                        size_t,
                                        bool));
   MOCK_METHOD1(OnSettings, void(bool clear_persisted));
   MOCK_METHOD3(OnSetting, void(SpdySettingsIds, uint8, uint32));
   MOCK_METHOD2(OnPing, void(SpdyPingId unique_id, bool is_ack));
   MOCK_METHOD2(OnRstStream, void(SpdyStreamId, SpdyRstStreamStatus));
   MOCK_METHOD2(OnGoAway, void(SpdyStreamId, SpdyGoAwayStatus));
@@ skipping 398 matching lines @@
   interface_->SendErrorNotFound(stream_id);
 
   ASSERT_EQ(2u, connection_->output_list()->size());
 
   {
     InSequence s;
     if (GetParam() < SPDY4) {
       EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
           .WillOnce(SaveArg<2>(&actual_header_block));
     } else {
-      EXPECT_CALL(*spdy_framer_visitor_, OnHeaders(stream_id, false, _))
-          .WillOnce(SaveArg<2>(&actual_header_block));
+      EXPECT_CALL(*spdy_framer_visitor_,
+                  OnHeaders(stream_id, false, 0, false, _))
+          .WillOnce(SaveArg<4>(&actual_header_block));
     }
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnDataFrameHeader(stream_id, _, true));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnStreamFrameData(stream_id, _, _, false)).Times(1)
         .WillOnce(DoAll(SaveArg<1>(&actual_data),
                         SaveArg<2>(&actual_size)));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnStreamFrameData(stream_id, NULL, 0, true)).Times(1);
@@ skipping 29 matching lines @@
   ASSERT_EQ(2u, connection_->output_list()->size());
 
   {
     InSequence s;
     if (GetParam() < SPDY4) {
       EXPECT_CALL(*spdy_framer_visitor_,
                   OnSynReply(stream_id, false, _))
           .WillOnce(SaveArg<2>(&actual_header_block));
     } else {
       EXPECT_CALL(*spdy_framer_visitor_,
-                  OnHeaders(stream_id, false, _))
-          .WillOnce(SaveArg<2>(&actual_header_block));
+                  OnHeaders(stream_id, false, 0, false, _))
+          .WillOnce(SaveArg<4>(&actual_header_block));
     }
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnDataFrameHeader(stream_id, _, true));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnStreamFrameData(stream_id, _, _, false)).Times(1)
         .WillOnce(DoAll(SaveArg<1>(&actual_data),
                         SaveArg<2>(&actual_size)));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnStreamFrameData(stream_id, NULL, 0, true)).Times(1);
@@ skipping 97 matching lines @@
   ASSERT_EQ(1u, connection_->output_list()->size());
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
 
   {
     InSequence s;
     if (GetParam() < SPDY4) {
       EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
           .WillOnce(SaveArg<2>(&actual_header_block));
     } else {
-      EXPECT_CALL(*spdy_framer_visitor_, OnHeaders(stream_id, false, _))
-          .WillOnce(SaveArg<2>(&actual_header_block));
+      EXPECT_CALL(*spdy_framer_visitor_,
+                  OnHeaders(stream_id, false, 0, false, _))
+          .WillOnce(SaveArg<4>(&actual_header_block));
     }
   }
 
   spdy_framer_->ProcessInput(df->data, df->size);
   ASSERT_EQ(1, spdy_framer_->frames_received());
   ASSERT_EQ(3u, actual_header_block.size());
   ASSERT_EQ("200 OK", actual_header_block["status"]);
   ASSERT_EQ("HTTP/1.1", actual_header_block["version"]);
   ASSERT_EQ("value1", actual_header_block["key1"]);
 }
@@ skipping 14 matching lines @@
   ASSERT_EQ(1u, connection_->output_list()->size());
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
 
   {
     InSequence s;
     if (GetParam() < SPDY4) {
       EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
           .WillOnce(SaveArg<2>(&actual_header_block));
     } else {
-      EXPECT_CALL(*spdy_framer_visitor_, OnHeaders(stream_id, false, _))
-          .WillOnce(SaveArg<2>(&actual_header_block));
+      EXPECT_CALL(*spdy_framer_visitor_,
+                  OnHeaders(stream_id, false, 0, false, _))
+          .WillOnce(SaveArg<4>(&actual_header_block));
     }
   }
 
   spdy_framer_->ProcessInput(df->data, df->size);
   ASSERT_EQ(1, spdy_framer_->frames_received());
   ASSERT_EQ(3u, actual_header_block.size());
   ASSERT_EQ("200 OK", actual_header_block[":status"]);
   ASSERT_EQ("HTTP/1.1", actual_header_block[":version"]);
   ASSERT_EQ("value1", actual_header_block["key1"]);
 }
@@ skipping 155 matching lines @@
   interface_->NewStream(stream_id, 0, "nonexistingfile");
 
   ASSERT_EQ(2u, connection_->output_list()->size());
 
   {
     InSequence s;
     if (GetParam() < SPDY4) {
       EXPECT_CALL(*spdy_framer_visitor_, OnSynReply(stream_id, false, _))
           .WillOnce(SaveArg<2>(&actual_header_block));
     } else {
-      EXPECT_CALL(*spdy_framer_visitor_, OnHeaders(stream_id, false, _))
-          .WillOnce(SaveArg<2>(&actual_header_block));
+      EXPECT_CALL(*spdy_framer_visitor_,
+                  OnHeaders(stream_id, false, 0, false, _))
+          .WillOnce(SaveArg<4>(&actual_header_block));
     }
     EXPECT_CALL(checkpoint, Call(0));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnDataFrameHeader(stream_id, _, true));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnStreamFrameData(stream_id, _, _, false)).Times(1)
         .WillOnce(DoAll(SaveArg<1>(&actual_data),
                         SaveArg<2>(&actual_size)));
     EXPECT_CALL(*spdy_framer_visitor_,
                 OnStreamFrameData(stream_id, NULL, 0, true)).Times(1);
   }
 
   std::list<DataFrame*>::const_iterator i = connection_->output_list()->begin();
   DataFrame* df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
   checkpoint.Call(0);
   df = *i++;
   spdy_framer_->ProcessInput(df->data, df->size);
 
   ASSERT_EQ(2, spdy_framer_->frames_received());
   ASSERT_EQ(2u, actual_header_block.size());
   ASSERT_EQ("404 Not Found", actual_header_block["status"]);
   ASSERT_EQ("HTTP/1.1", actual_header_block["version"]);
   ASSERT_EQ("wtf?", StringPiece(actual_data, actual_size));
 }
 
 }  // namespace
 
 }  // namespace net