Convert FrameParts to a class.

As the TODO in frame_parts.h, Convert FrameParts to a class,
hide the member variables, add getters/setters for them.

BUG=
Signed-off-by: Zhuoyu Qian <zhuoyu.qian@samsung.com>
Change-Id: I897045b887842647e79cf9e8ff301b7faf8dcd90
Reviewed-on: https://chromium-review.googlesource.com/844499Reviewed-by: Bence Béky <bnc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#526925}

net/http2/decoder/http2_frame_decoder_test.cc

@@ -196,7 +196,7 @@ class Http2FrameDecoderTest : public RandomDecoderTest {
   template <size_t N>
   AssertionResult DecodePayloadExpectingFrameSizeError(const char (&buf)[N],
                                                        FrameParts expected) {
-    expected.has_frame_size_error = true;
+    expected.SetHasFrameSizeError(true);
     VERIFY_AND_RETURN_SUCCESS(DecodePayloadExpectingError(buf, expected));
   }
 
@@ -260,7 +260,7 @@ TEST_F(Http2FrameDecoderTest, Priority) {
   };
   Http2FrameHeader header(5, Http2FrameType::PRIORITY, 0, 2);
   FrameParts expected(header);
-  expected.opt_priority = Http2PriorityFields(1, 17, true);
+  expected.SetOptPriority(Http2PriorityFields(1, 17, true));
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
@@ -274,7 +274,7 @@ TEST_F(Http2FrameDecoderTest, RstStream) {
   };
   Http2FrameHeader header(4, Http2FrameType::RST_STREAM, 0, 1);
   FrameParts expected(header);
-  expected.opt_rst_stream_error_code = Http2ErrorCode::PROTOCOL_ERROR;
+  expected.SetOptRstStreamErrorCode(Http2ErrorCode::PROTOCOL_ERROR);
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
@@ -312,7 +312,7 @@ TEST_F(Http2FrameDecoderTest, PushPromiseMinimal) {
   Http2FrameHeader header(4, Http2FrameType::PUSH_PROMISE,
                           Http2FrameFlag::END_HEADERS, 2);
   FrameParts expected(header, "");
-  expected.opt_push_promise = Http2PushPromiseFields{1};
+  expected.SetOptPushPromise(Http2PushPromiseFields{1});
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
@@ -327,7 +327,8 @@ TEST_F(Http2FrameDecoderTest, Ping) {
   };
   Http2FrameHeader header(8, Http2FrameType::PING, 0, 0);
   FrameParts expected(header);
-  expected.opt_ping = Http2PingFields{{'s', 'o', 'm', 'e', 'd', 'a', 't', 'a'}};
+  expected.SetOptPing(
+      Http2PingFields{{'s', 'o', 'm', 'e', 'd', 'a', 't', 'a'}});
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
@@ -342,7 +343,8 @@ TEST_F(Http2FrameDecoderTest, PingAck) {
   };
   Http2FrameHeader header(8, Http2FrameType::PING, Http2FrameFlag::ACK, 0);
   FrameParts expected(header);
-  expected.opt_ping = Http2PingFields{{'s', 'o', 'm', 'e', 'd', 'a', 't', 'a'}};
+  expected.SetOptPing(
+      Http2PingFields{{'s', 'o', 'm', 'e', 'd', 'a', 't', 'a'}});
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
@@ -357,8 +359,8 @@ TEST_F(Http2FrameDecoderTest, GoAwayMinimal) {
   };
   Http2FrameHeader header(8, Http2FrameType::GOAWAY, 0, 1);
   FrameParts expected(header);
-  expected.opt_goaway =
-      Http2GoAwayFields(255, Http2ErrorCode::COMPRESSION_ERROR);
+  expected.SetOptGoaway(
+      Http2GoAwayFields(255, Http2ErrorCode::COMPRESSION_ERROR));
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
@@ -372,7 +374,7 @@ TEST_F(Http2FrameDecoderTest, WindowUpdate) {
   };
   Http2FrameHeader header(4, Http2FrameType::WINDOW_UPDATE, 0, 1);
   FrameParts expected(header);
-  expected.opt_window_update_increment = 1024;
+  expected.SetOptWindowUpdateIncrement(1024);
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
@@ -398,8 +400,8 @@ TEST_F(Http2FrameDecoderTest, AltSvcMinimal) {
   };
   Http2FrameHeader header(2, Http2FrameType::ALTSVC, 0, 0);
   FrameParts expected(header);
-  expected.opt_altsvc_origin_length = 0;
-  expected.opt_altsvc_value_length = 0;
+  expected.SetOptAltsvcOriginLength(0);
+  expected.SetOptAltsvcValueLength(0);
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
@@ -458,7 +460,7 @@ TEST_F(Http2FrameDecoderTest, HeadersPriority) {
   Http2FrameHeader header(5, Http2FrameType::HEADERS, Http2FrameFlag::PRIORITY,
                           2);
   FrameParts expected(header);
-  expected.opt_priority = Http2PriorityFields(1, 256, false);
+  expected.SetOptPriority(Http2PriorityFields(1, 256, false));
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
@@ -475,9 +477,9 @@ TEST_F(Http2FrameDecoderTest, Settings) {
   };
   Http2FrameHeader header(12, Http2FrameType::SETTINGS, 0, 0);
   FrameParts expected(header);
-  expected.settings.push_back(Http2SettingFields(
+  expected.AppendSetting(Http2SettingFields(
       Http2SettingsParameter::INITIAL_WINDOW_SIZE, 168496141));
-  expected.settings.push_back(
+  expected.AppendSetting(
       Http2SettingFields(Http2SettingsParameter::ENABLE_PUSH, 3));
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
@@ -494,7 +496,7 @@ TEST_F(Http2FrameDecoderTest, PushPromisePayload) {
   Http2FrameHeader header(7, Http2FrameType::PUSH_PROMISE,
                           Http2FrameFlag::END_HEADERS, 255);
   FrameParts expected(header, "abc");
-  expected.opt_push_promise = Http2PushPromiseFields{256};
+  expected.SetOptPushPromise(Http2PushPromiseFields{256});
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
@@ -510,8 +512,8 @@ TEST_F(Http2FrameDecoderTest, GoAwayOpaqueData) {
   };
   Http2FrameHeader header(14, Http2FrameType::GOAWAY, 0, 0);
   FrameParts expected(header, "opaque");
-  expected.opt_goaway =
-      Http2GoAwayFields(256, Http2ErrorCode::FLOW_CONTROL_ERROR);
+  expected.SetOptGoaway(
+      Http2GoAwayFields(256, Http2ErrorCode::FLOW_CONTROL_ERROR));
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
@@ -615,7 +617,7 @@ TEST_F(Http2FrameDecoderTest, HeadersPayloadPriorityAndPadding) {
                           2);
   size_t total_pad_length = 4;  // Including the Pad Length field.
   FrameParts expected(header, "abc", total_pad_length);
-  expected.opt_priority = Http2PriorityFields(1, 17, true);
+  expected.SetOptPriority(Http2PriorityFields(1, 17, true));
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
@@ -635,7 +637,7 @@ TEST_F(Http2FrameDecoderTest, PushPromisePayloadAndPadding) {
                           1);
   size_t total_pad_length = 4;  // Including the Pad Length field.
   FrameParts expected(header, "abc", total_pad_length);
-  expected.opt_push_promise = Http2PushPromiseFields{2};
+  expected.SetOptPushPromise(Http2PushPromiseFields{2});
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(kFrameData, expected));
 }
 
@@ -651,7 +653,7 @@ TEST_F(Http2FrameDecoderTest, DataMissingPadLengthField) {
   };
   Http2FrameHeader header(0, Http2FrameType::DATA, Http2FrameFlag::PADDED, 1);
   FrameParts expected(header);
-  expected.opt_missing_length = 1;
+  expected.SetOptMissingLength(1);
   EXPECT_TRUE(DecodePayloadExpectingError(kFrameData, expected));
 }
 
@@ -667,7 +669,7 @@ TEST_F(Http2FrameDecoderTest, HeaderPaddingTooLong) {
   Http2FrameHeader header(2, Http2FrameType::HEADERS, Http2FrameFlag::PADDED,
                           65536);
   FrameParts expected(header);
-  expected.opt_missing_length = 254;
+  expected.SetOptMissingLength(254);
   EXPECT_TRUE(DecodePayloadExpectingError(kFrameData, expected));
 }
 
@@ -723,7 +725,7 @@ TEST_F(Http2FrameDecoderTest, SettingsWrongSize) {
   };
   Http2FrameHeader header(9, Http2FrameType::SETTINGS, 0, 0);
   FrameParts expected(header);
-  expected.settings.push_back(
+  expected.AppendSetting(
       Http2SettingFields(Http2SettingsParameter::ENABLE_PUSH, 3));
   EXPECT_TRUE(DecodePayloadExpectingFrameSizeError(kFrameData, expected));
 }
@@ -835,7 +837,7 @@ TEST_F(Http2FrameDecoderTest, BeyondMaximum) {
                           Http2FrameFlag::END_STREAM | Http2FrameFlag::PADDED,
                           2);
   FrameParts expected(header);
-  expected.has_frame_size_error = true;
+  expected.SetHasFrameSizeError(true);
   auto validator = [&expected, this](const DecodeBuffer& input,
                                      DecodeStatus status) -> AssertionResult {
     VERIFY_EQ(status, DecodeStatus::kDecodeError);

net/http2/decoder/payload_decoders/goaway_payload_decoder_test.cc

@@ -98,7 +98,7 @@ TEST_P(GoAwayOpaqueDataLengthTests, ValidLength) {
                           RandStreamId());
   set_frame_header(header);
   FrameParts expected(header, opaque_data);
-  expected.opt_goaway = goaway;
+  expected.SetOptGoaway(goaway);
   ASSERT_TRUE(DecodePayloadAndValidateSeveralWays(fb.buffer(), expected));
 }
 

net/http2/decoder/payload_decoders/headers_payload_decoder_test.cc

@@ -126,7 +126,7 @@ TEST_P(HeadersPayloadDecoderTest, VariousHpackPayloadSizes) {
       ScrubFlagsOfHeader(&frame_header);
       FrameParts expected(frame_header, hpack_payload, total_pad_length_);
       if (has_priority) {
-        expected.opt_priority = priority;
+        expected.SetOptPriority(priority);
       }
       EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(frame_builder_.buffer(),
                                                       expected));

net/http2/decoder/payload_decoders/payload_decoder_base_test_util.h

@@ -232,11 +232,11 @@ class AbstractPayloadDecoderTest : public PayloadDecoderBaseTest {
       VERIFY_FALSE(listener_.IsInProgress());
       VERIFY_EQ(1u, listener_.size());
       const FrameParts* frame = listener_.frame(0);
-      VERIFY_EQ(header, frame->frame_header);
-      VERIFY_TRUE(frame->has_frame_size_error);
+      VERIFY_EQ(header, frame->GetFrameHeader());
+      VERIFY_TRUE(frame->GetHasFrameSizeError());
       // Verify did not get OnPaddingTooLong, as we should only ever produce
       // one of these two errors for a single frame.
-      VERIFY_FALSE(frame->opt_missing_length);
+      VERIFY_FALSE(frame->GetOptMissingLength());
       return validator(input, status);
     };
     VERIFY_AND_RETURN_SUCCESS(
@@ -403,11 +403,11 @@ class AbstractPaddablePayloadDecoderTest
       VERIFY_FALSE(listener.IsInProgress());
       VERIFY_EQ(1u, listener.size());
       const FrameParts* frame = listener.frame(0);
-      VERIFY_EQ(header, frame->frame_header);
-      VERIFY_TRUE(frame->opt_missing_length);
-      VERIFY_EQ(expected_missing_length, frame->opt_missing_length.value());
+      VERIFY_EQ(header, frame->GetFrameHeader());
+      VERIFY_TRUE(frame->GetOptMissingLength());
+      VERIFY_EQ(expected_missing_length, frame->GetOptMissingLength().value());
       // Verify did not get OnFrameSizeError.
-      VERIFY_FALSE(frame->has_frame_size_error);
+      VERIFY_FALSE(frame->GetHasFrameSizeError());
       return ::testing::AssertionSuccess();
     };
     VERIFY_AND_RETURN_SUCCESS(

net/http2/decoder/payload_decoders/ping_payload_decoder_test.cc

@@ -85,7 +85,7 @@ TEST_F(PingPayloadDecoderTest, Ping) {
                             RandFlags() & ~Http2FrameFlag::ACK, RandStreamId());
     set_frame_header(header);
     FrameParts expected(header);
-    expected.opt_ping = fields;
+    expected.SetOptPing(fields);
     EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(fb.buffer(), expected));
   }
 }
@@ -100,7 +100,7 @@ TEST_F(PingPayloadDecoderTest, PingAck) {
                             RandFlags() | Http2FrameFlag::ACK, RandStreamId());
     set_frame_header(header);
     FrameParts expected(header);
-    expected.opt_ping = fields;
+    expected.SetOptPing(fields);
     EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(fb.buffer(), expected));
   }
 }

net/http2/decoder/payload_decoders/priority_payload_decoder_test.cc

@@ -80,7 +80,7 @@ TEST_F(PriorityPayloadDecoderTest, VariousPayloads) {
                             RandStreamId());
     set_frame_header(header);
     FrameParts expected(header);
-    expected.opt_priority = fields;
+    expected.SetOptPriority(fields);
     EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(fb.buffer(), expected));
   }
 }

net/http2/decoder/payload_decoders/push_promise_payload_decoder_test.cc

@@ -108,7 +108,7 @@ TEST_P(PushPromisePayloadDecoderTest, VariousHpackPayloadSizes) {
                                   RandStreamId());
     set_frame_header(frame_header);
     FrameParts expected(frame_header, hpack_payload, total_pad_length_);
-    expected.opt_push_promise = push_promise;
+    expected.SetOptPushPromise(push_promise);
     EXPECT_TRUE(
         DecodePayloadAndValidateSeveralWays(frame_builder_.buffer(), expected));
   }

net/http2/decoder/payload_decoders/rst_stream_payload_decoder_test.cc

@@ -82,7 +82,7 @@ TEST_F(RstStreamPayloadDecoderTest, AllErrors) {
                             RandStreamId());
     set_frame_header(header);
     FrameParts expected(header);
-    expected.opt_rst_stream_error_code = error_code;
+    expected.SetOptRstStreamErrorCode(error_code);
     EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(fb.buffer(), expected));
   }
 }

net/http2/decoder/payload_decoders/settings_payload_decoder_test.cc

@@ -129,7 +129,7 @@ TEST_F(SettingsPayloadDecoderTest, OneRealSetting) {
                               RandStreamId());
       set_frame_header(header);
       FrameParts expected(header);
-      expected.settings.push_back(fields);
+      expected.AppendSetting(fields);
       EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(fb.buffer(), expected));
     }
   }
@@ -149,7 +149,7 @@ TEST_F(SettingsPayloadDecoderTest, ManySettings) {
     Http2SettingFields fields(static_cast<Http2SettingsParameter>(n),
                               Random().Rand32());
     fb.Append(fields);
-    expected.settings.push_back(fields);
+    expected.AppendSetting(fields);
   }
   ASSERT_EQ(size, fb.size());
   EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(fb.buffer(), expected));

net/http2/decoder/payload_decoders/window_update_payload_decoder_test.cc

@@ -86,7 +86,7 @@ TEST_F(WindowUpdatePayloadDecoderTest, VariousPayloads) {
                             RandFlags(), stream_id);
     set_frame_header(header);
     FrameParts expected(header);
-    expected.opt_window_update_increment = fields.window_size_increment;
+    expected.SetOptWindowUpdateIncrement(fields.window_size_increment);
     EXPECT_TRUE(DecodePayloadAndValidateSeveralWays(fb.buffer(), expected));
   }
 }

net/http2/test_tools/frame_parts.cc

@@ -46,15 +46,15 @@ AssertionResult VerifyOptionalEq(const T& opt_a, const T& opt_b) {
 
 }  // namespace
 
-FrameParts::FrameParts(const Http2FrameHeader& header) : frame_header(header) {
-  VLOG(1) << "FrameParts, header: " << frame_header;
+FrameParts::FrameParts(const Http2FrameHeader& header) : frame_header_(header) {
+  VLOG(1) << "FrameParts, header: " << frame_header_;
 }
 
 FrameParts::FrameParts(const Http2FrameHeader& header, Http2StringPiece payload)
     : FrameParts(header) {
   VLOG(1) << "FrameParts with payload.size() = " << payload.size();
-  this->payload.append(payload.data(), payload.size());
-  opt_payload_length = payload.size();
+  this->payload_.append(payload.data(), payload.size());
+  opt_payload_length_ = payload.size();
 }
 FrameParts::FrameParts(const Http2FrameHeader& header,
                        Http2StringPiece payload,
@@ -71,26 +71,26 @@ FrameParts::~FrameParts() = default;
 AssertionResult FrameParts::VerifyEquals(const FrameParts& that) const {
 #define COMMON_MESSAGE "\n  this: " << *this << "\n  that: " << that
 
-  VERIFY_EQ(frame_header, that.frame_header) << COMMON_MESSAGE;
-  VERIFY_EQ(payload, that.payload) << COMMON_MESSAGE;
-  VERIFY_EQ(padding, that.padding) << COMMON_MESSAGE;
-  VERIFY_EQ(altsvc_origin, that.altsvc_origin) << COMMON_MESSAGE;
-  VERIFY_EQ(altsvc_value, that.altsvc_value) << COMMON_MESSAGE;
-  VERIFY_EQ(settings, that.settings) << COMMON_MESSAGE;
+  VERIFY_EQ(frame_header_, that.frame_header_) << COMMON_MESSAGE;
+  VERIFY_EQ(payload_, that.payload_) << COMMON_MESSAGE;
+  VERIFY_EQ(padding_, that.padding_) << COMMON_MESSAGE;
+  VERIFY_EQ(altsvc_origin_, that.altsvc_origin_) << COMMON_MESSAGE;
+  VERIFY_EQ(altsvc_value_, that.altsvc_value_) << COMMON_MESSAGE;
+  VERIFY_EQ(settings_, that.settings_) << COMMON_MESSAGE;
 
 #define VERIFY_OPTIONAL_FIELD(field_name) \
   VERIFY_SUCCESS(VerifyOptionalEq(field_name, that.field_name))
 
-  VERIFY_OPTIONAL_FIELD(opt_altsvc_origin_length) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_altsvc_value_length) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_goaway) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_missing_length) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_pad_length) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_ping) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_priority) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_push_promise) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_rst_stream_error_code) << COMMON_MESSAGE;
-  VERIFY_OPTIONAL_FIELD(opt_window_update_increment) << COMMON_MESSAGE;
+  VERIFY_OPTIONAL_FIELD(opt_altsvc_origin_length_) << COMMON_MESSAGE;
+  VERIFY_OPTIONAL_FIELD(opt_altsvc_value_length_) << COMMON_MESSAGE;
+  VERIFY_OPTIONAL_FIELD(opt_goaway_) << COMMON_MESSAGE;
+  VERIFY_OPTIONAL_FIELD(opt_missing_length_) << COMMON_MESSAGE;
+  VERIFY_OPTIONAL_FIELD(opt_pad_length_) << COMMON_MESSAGE;
+  VERIFY_OPTIONAL_FIELD(opt_ping_) << COMMON_MESSAGE;
+  VERIFY_OPTIONAL_FIELD(opt_priority_) << COMMON_MESSAGE;
+  VERIFY_OPTIONAL_FIELD(opt_push_promise_) << COMMON_MESSAGE;
+  VERIFY_OPTIONAL_FIELD(opt_rst_stream_error_code_) << COMMON_MESSAGE;
+  VERIFY_OPTIONAL_FIELD(opt_window_update_increment_) << COMMON_MESSAGE;
 
 #undef VERIFY_OPTIONAL_FIELD
 
@@ -98,18 +98,18 @@ AssertionResult FrameParts::VerifyEquals(const FrameParts& that) const {
 }
 
 void FrameParts::SetTotalPadLength(size_t total_pad_length) {
-  opt_pad_length.reset();
-  padding.clear();
+  opt_pad_length_.reset();
+  padding_.clear();
   if (total_pad_length > 0) {
     ASSERT_LE(total_pad_length, 256u);
-    ASSERT_TRUE(frame_header.IsPadded());
-    opt_pad_length = total_pad_length - 1;
+    ASSERT_TRUE(frame_header_.IsPadded());
+    opt_pad_length_ = total_pad_length - 1;
     char zero = 0;
-    padding.append(opt_pad_length.value(), zero);
+    padding_.append(opt_pad_length_.value(), zero);
   }
 
-  if (opt_pad_length) {
-    VLOG(1) << "SetTotalPadLength: pad_length=" << opt_pad_length.value();
+  if (opt_pad_length_) {
+    VLOG(1) << "SetTotalPadLength: pad_length=" << opt_pad_length_.value();
   } else {
     VLOG(1) << "SetTotalPadLength: has no pad length";
   }
@@ -117,10 +117,10 @@ void FrameParts::SetTotalPadLength(size_t total_pad_length) {
 
 void FrameParts::SetAltSvcExpected(Http2StringPiece origin,
                                    Http2StringPiece value) {
-  altsvc_origin.append(origin.data(), origin.size());
-  altsvc_value.append(value.data(), value.size());
-  opt_altsvc_origin_length = origin.size();
-  opt_altsvc_value_length = value.size();
+  altsvc_origin_.append(origin.data(), origin.size());
+  altsvc_value_.append(value.data(), value.size());
+  opt_altsvc_origin_length_ = origin.size();
+  opt_altsvc_value_length_ = value.size();
 }
 
 bool FrameParts::OnFrameHeader(const Http2FrameHeader& header) {
@@ -131,50 +131,51 @@ bool FrameParts::OnFrameHeader(const Http2FrameHeader& header) {
 void FrameParts::OnDataStart(const Http2FrameHeader& header) {
   VLOG(1) << "OnDataStart: " << header;
   ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::DATA)) << *this;
-  opt_payload_length = header.payload_length;
+  opt_payload_length_ = header.payload_length;
 }
 
 void FrameParts::OnDataPayload(const char* data, size_t len) {
-  VLOG(1) << "OnDataPayload: len=" << len << "; frame_header: " << frame_header;
+  VLOG(1) << "OnDataPayload: len=" << len
+          << "; frame_header_: " << frame_header_;
   ASSERT_TRUE(InFrameOfType(Http2FrameType::DATA)) << *this;
-  ASSERT_TRUE(
-      AppendString(Http2StringPiece(data, len), &payload, &opt_payload_length));
+  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &payload_,
+                           &opt_payload_length_));
 }
 
 void FrameParts::OnDataEnd() {
-  VLOG(1) << "OnDataEnd; frame_header: " << frame_header;
+  VLOG(1) << "OnDataEnd; frame_header_: " << frame_header_;
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::DATA)) << *this;
 }
 
 void FrameParts::OnHeadersStart(const Http2FrameHeader& header) {
   VLOG(1) << "OnHeadersStart: " << header;
   ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::HEADERS)) << *this;
-  opt_payload_length = header.payload_length;
+  opt_payload_length_ = header.payload_length;
 }
 
 void FrameParts::OnHeadersPriority(const Http2PriorityFields& priority) {
   VLOG(1) << "OnHeadersPriority: priority: " << priority
-          << "; frame_header: " << frame_header;
+          << "; frame_header_: " << frame_header_;
   ASSERT_TRUE(InFrameOfType(Http2FrameType::HEADERS)) << *this;
-  ASSERT_FALSE(opt_priority);
-  opt_priority = priority;
-  ASSERT_TRUE(opt_payload_length);
-  opt_payload_length =
-      opt_payload_length.value() - Http2PriorityFields::EncodedSize();
+  ASSERT_FALSE(opt_priority_);
+  opt_priority_ = priority;
+  ASSERT_TRUE(opt_payload_length_);
+  opt_payload_length_ =
+      opt_payload_length_.value() - Http2PriorityFields::EncodedSize();
 }
 
 void FrameParts::OnHpackFragment(const char* data, size_t len) {
   VLOG(1) << "OnHpackFragment: len=" << len
-          << "; frame_header: " << frame_header;
-  ASSERT_TRUE(got_start_callback);
-  ASSERT_FALSE(got_end_callback);
-  ASSERT_TRUE(FrameCanHaveHpackPayload(frame_header)) << *this;
-  ASSERT_TRUE(
-      AppendString(Http2StringPiece(data, len), &payload, &opt_payload_length));
+          << "; frame_header_: " << frame_header_;
+  ASSERT_TRUE(got_start_callback_);
+  ASSERT_FALSE(got_end_callback_);
+  ASSERT_TRUE(FrameCanHaveHpackPayload(frame_header_)) << *this;
+  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &payload_,
+                           &opt_payload_length_));
 }
 
 void FrameParts::OnHeadersEnd() {
-  VLOG(1) << "OnHeadersEnd; frame_header: " << frame_header;
+  VLOG(1) << "OnHeadersEnd; frame_header_: " << frame_header_;
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::HEADERS)) << *this;
 }
 
@@ -182,72 +183,72 @@ void FrameParts::OnPriorityFrame(const Http2FrameHeader& header,
                                  const Http2PriorityFields& priority) {
   VLOG(1) << "OnPriorityFrame: " << header << "; priority: " << priority;
   ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::PRIORITY)) << *this;
-  ASSERT_FALSE(opt_priority);
-  opt_priority = priority;
+  ASSERT_FALSE(opt_priority_);
+  opt_priority_ = priority;
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::PRIORITY)) << *this;
 }
 
 void FrameParts::OnContinuationStart(const Http2FrameHeader& header) {
   VLOG(1) << "OnContinuationStart: " << header;
   ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::CONTINUATION)) << *this;
-  opt_payload_length = header.payload_length;
+  opt_payload_length_ = header.payload_length;
 }
 
 void FrameParts::OnContinuationEnd() {
-  VLOG(1) << "OnContinuationEnd; frame_header: " << frame_header;
+  VLOG(1) << "OnContinuationEnd; frame_header_: " << frame_header_;
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::CONTINUATION)) << *this;
 }
 
 void FrameParts::OnPadLength(size_t trailing_length) {
   VLOG(1) << "OnPadLength: trailing_length=" << trailing_length;
   ASSERT_TRUE(InPaddedFrame()) << *this;
-  ASSERT_FALSE(opt_pad_length);
-  ASSERT_TRUE(opt_payload_length);
+  ASSERT_FALSE(opt_pad_length_);
+  ASSERT_TRUE(opt_payload_length_);
   size_t total_padding_length = trailing_length + 1;
-  ASSERT_GE(opt_payload_length.value(), total_padding_length);
-  opt_payload_length = opt_payload_length.value() - total_padding_length;
-  opt_pad_length = trailing_length;
+  ASSERT_GE(opt_payload_length_.value(), total_padding_length);
+  opt_payload_length_ = opt_payload_length_.value() - total_padding_length;
+  opt_pad_length_ = trailing_length;
 }
 
 void FrameParts::OnPadding(const char* pad, size_t skipped_length) {
   VLOG(1) << "OnPadding: skipped_length=" << skipped_length;
   ASSERT_TRUE(InPaddedFrame()) << *this;
-  ASSERT_TRUE(opt_pad_length);
-  ASSERT_TRUE(AppendString(Http2StringPiece(pad, skipped_length), &padding,
-                           &opt_pad_length));
+  ASSERT_TRUE(opt_pad_length_);
+  ASSERT_TRUE(AppendString(Http2StringPiece(pad, skipped_length), &padding_,
+                           &opt_pad_length_));
 }
 
 void FrameParts::OnRstStream(const Http2FrameHeader& header,
                              Http2ErrorCode error_code) {
   VLOG(1) << "OnRstStream: " << header << "; code=" << error_code;
   ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::RST_STREAM)) << *this;
-  ASSERT_FALSE(opt_rst_stream_error_code);
-  opt_rst_stream_error_code = error_code;
+  ASSERT_FALSE(opt_rst_stream_error_code_);
+  opt_rst_stream_error_code_ = error_code;
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::RST_STREAM)) << *this;
 }
 
 void FrameParts::OnSettingsStart(const Http2FrameHeader& header) {
   VLOG(1) << "OnSettingsStart: " << header;
   ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::SETTINGS)) << *this;
-  ASSERT_EQ(0u, settings.size());
+  ASSERT_EQ(0u, settings_.size());
   ASSERT_FALSE(header.IsAck()) << header;
 }
 
 void FrameParts::OnSetting(const Http2SettingFields& setting_fields) {
   VLOG(1) << "OnSetting: " << setting_fields;
   ASSERT_TRUE(InFrameOfType(Http2FrameType::SETTINGS)) << *this;
-  settings.push_back(setting_fields);
+  settings_.push_back(setting_fields);
 }
 
 void FrameParts::OnSettingsEnd() {
-  VLOG(1) << "OnSettingsEnd; frame_header: " << frame_header;
+  VLOG(1) << "OnSettingsEnd; frame_header_: " << frame_header_;
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::SETTINGS)) << *this;
 }
 
 void FrameParts::OnSettingsAck(const Http2FrameHeader& header) {
   VLOG(1) << "OnSettingsAck: " << header;
   ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::SETTINGS)) << *this;
-  ASSERT_EQ(0u, settings.size());
+  ASSERT_EQ(0u, settings_.size());
   ASSERT_TRUE(header.IsAck());
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::SETTINGS)) << *this;
 }
@@ -259,12 +260,12 @@ void FrameParts::OnPushPromiseStart(const Http2FrameHeader& header,
           << "; total_padding_length: " << total_padding_length;
   ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::PUSH_PROMISE)) << *this;
   ASSERT_GE(header.payload_length, Http2PushPromiseFields::EncodedSize());
-  opt_payload_length =
+  opt_payload_length_ =
       header.payload_length - Http2PushPromiseFields::EncodedSize();
-  ASSERT_FALSE(opt_push_promise);
-  opt_push_promise = promise;
+  ASSERT_FALSE(opt_push_promise_);
+  opt_push_promise_ = promise;
   if (total_padding_length > 0) {
-    ASSERT_GE(opt_payload_length.value(), total_padding_length);
+    ASSERT_GE(opt_payload_length_.value(), total_padding_length);
     OnPadLength(total_padding_length - 1);
   } else {
     ASSERT_FALSE(header.IsPadded());
@@ -272,7 +273,7 @@ void FrameParts::OnPushPromiseStart(const Http2FrameHeader& header,
 }
 
 void FrameParts::OnPushPromiseEnd() {
-  VLOG(1) << "OnPushPromiseEnd; frame_header: " << frame_header;
+  VLOG(1) << "OnPushPromiseEnd; frame_header_: " << frame_header_;
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::PUSH_PROMISE)) << *this;
 }
 
@@ -281,8 +282,8 @@ void FrameParts::OnPing(const Http2FrameHeader& header,
   VLOG(1) << "OnPing header: " << header << "   ping: " << ping;
   ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::PING)) << *this;
   ASSERT_FALSE(header.IsAck());
-  ASSERT_FALSE(opt_ping);
-  opt_ping = ping;
+  ASSERT_FALSE(opt_ping_);
+  opt_ping_ = ping;
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::PING)) << *this;
 }
 
@@ -291,8 +292,8 @@ void FrameParts::OnPingAck(const Http2FrameHeader& header,
   VLOG(1) << "OnPingAck header: " << header << "   ping: " << ping;
   ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::PING)) << *this;
   ASSERT_TRUE(header.IsAck());
-  ASSERT_FALSE(opt_ping);
-  opt_ping = ping;
+  ASSERT_FALSE(opt_ping_);
+  opt_ping_ = ping;
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::PING)) << *this;
 }
 
@@ -300,20 +301,21 @@ void FrameParts::OnGoAwayStart(const Http2FrameHeader& header,
                                const Http2GoAwayFields& goaway) {
   VLOG(1) << "OnGoAwayStart: " << goaway;
   ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::GOAWAY)) << *this;
-  ASSERT_FALSE(opt_goaway);
-  opt_goaway = goaway;
-  opt_payload_length = header.payload_length - Http2GoAwayFields::EncodedSize();
+  ASSERT_FALSE(opt_goaway_);
+  opt_goaway_ = goaway;
+  opt_payload_length_ =
+      header.payload_length - Http2GoAwayFields::EncodedSize();
 }
 
 void FrameParts::OnGoAwayOpaqueData(const char* data, size_t len) {
   VLOG(1) << "OnGoAwayOpaqueData: len=" << len;
   ASSERT_TRUE(InFrameOfType(Http2FrameType::GOAWAY)) << *this;
-  ASSERT_TRUE(
-      AppendString(Http2StringPiece(data, len), &payload, &opt_payload_length));
+  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &payload_,
+                           &opt_payload_length_));
 }
 
 void FrameParts::OnGoAwayEnd() {
-  VLOG(1) << "OnGoAwayEnd; frame_header: " << frame_header;
+  VLOG(1) << "OnGoAwayEnd; frame_header_: " << frame_header_;
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::GOAWAY)) << *this;
 }
 
@@ -322,8 +324,8 @@ void FrameParts::OnWindowUpdate(const Http2FrameHeader& header,
   VLOG(1) << "OnWindowUpdate header: " << header
           << "     increment=" << increment;
   ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::WINDOW_UPDATE)) << *this;
-  ASSERT_FALSE(opt_window_update_increment);
-  opt_window_update_increment = increment;
+  ASSERT_FALSE(opt_window_update_increment_);
+  opt_window_update_increment_ = increment;
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::WINDOW_UPDATE)) << *this;
 }
 
@@ -334,140 +336,140 @@ void FrameParts::OnAltSvcStart(const Http2FrameHeader& header,
           << "    origin_length: " << origin_length
           << "    value_length: " << value_length;
   ASSERT_TRUE(StartFrameOfType(header, Http2FrameType::ALTSVC)) << *this;
-  ASSERT_FALSE(opt_altsvc_origin_length);
-  opt_altsvc_origin_length = origin_length;
-  ASSERT_FALSE(opt_altsvc_value_length);
-  opt_altsvc_value_length = value_length;
+  ASSERT_FALSE(opt_altsvc_origin_length_);
+  opt_altsvc_origin_length_ = origin_length;
+  ASSERT_FALSE(opt_altsvc_value_length_);
+  opt_altsvc_value_length_ = value_length;
 }
 
 void FrameParts::OnAltSvcOriginData(const char* data, size_t len) {
   VLOG(1) << "OnAltSvcOriginData: len=" << len;
   ASSERT_TRUE(InFrameOfType(Http2FrameType::ALTSVC)) << *this;
-  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &altsvc_origin,
-                           &opt_altsvc_origin_length));
+  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &altsvc_origin_,
+                           &opt_altsvc_origin_length_));
 }
 
 void FrameParts::OnAltSvcValueData(const char* data, size_t len) {
   VLOG(1) << "OnAltSvcValueData: len=" << len;
   ASSERT_TRUE(InFrameOfType(Http2FrameType::ALTSVC)) << *this;
-  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &altsvc_value,
-                           &opt_altsvc_value_length));
+  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &altsvc_value_,
+                           &opt_altsvc_value_length_));
 }
 
 void FrameParts::OnAltSvcEnd() {
-  VLOG(1) << "OnAltSvcEnd; frame_header: " << frame_header;
+  VLOG(1) << "OnAltSvcEnd; frame_header_: " << frame_header_;
   ASSERT_TRUE(EndFrameOfType(Http2FrameType::ALTSVC)) << *this;
 }
 
 void FrameParts::OnUnknownStart(const Http2FrameHeader& header) {
   VLOG(1) << "OnUnknownStart: " << header;
   ASSERT_FALSE(IsSupportedHttp2FrameType(header.type)) << header;
-  ASSERT_FALSE(got_start_callback);
-  ASSERT_EQ(frame_header, header);
-  got_start_callback = true;
-  opt_payload_length = header.payload_length;
+  ASSERT_FALSE(got_start_callback_);
+  ASSERT_EQ(frame_header_, header);
+  got_start_callback_ = true;
+  opt_payload_length_ = header.payload_length;
 }
 
 void FrameParts::OnUnknownPayload(const char* data, size_t len) {
   VLOG(1) << "OnUnknownPayload: len=" << len;
-  ASSERT_FALSE(IsSupportedHttp2FrameType(frame_header.type)) << *this;
-  ASSERT_TRUE(got_start_callback);
-  ASSERT_FALSE(got_end_callback);
-  ASSERT_TRUE(
-      AppendString(Http2StringPiece(data, len), &payload, &opt_payload_length));
+  ASSERT_FALSE(IsSupportedHttp2FrameType(frame_header_.type)) << *this;
+  ASSERT_TRUE(got_start_callback_);
+  ASSERT_FALSE(got_end_callback_);
+  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &payload_,
+                           &opt_payload_length_));
 }
 
 void FrameParts::OnUnknownEnd() {
-  VLOG(1) << "OnUnknownEnd; frame_header: " << frame_header;
-  ASSERT_FALSE(IsSupportedHttp2FrameType(frame_header.type)) << *this;
-  ASSERT_TRUE(got_start_callback);
-  ASSERT_FALSE(got_end_callback);
-  got_end_callback = true;
+  VLOG(1) << "OnUnknownEnd; frame_header_: " << frame_header_;
+  ASSERT_FALSE(IsSupportedHttp2FrameType(frame_header_.type)) << *this;
+  ASSERT_TRUE(got_start_callback_);
+  ASSERT_FALSE(got_end_callback_);
+  got_end_callback_ = true;
 }
 
 void FrameParts::OnPaddingTooLong(const Http2FrameHeader& header,
                                   size_t missing_length) {
   VLOG(1) << "OnPaddingTooLong: " << header
           << "; missing_length: " << missing_length;
-  ASSERT_EQ(frame_header, header);
-  ASSERT_FALSE(got_end_callback);
+  ASSERT_EQ(frame_header_, header);
+  ASSERT_FALSE(got_end_callback_);
   ASSERT_TRUE(FrameIsPadded(header));
-  ASSERT_FALSE(opt_pad_length);
-  ASSERT_FALSE(opt_missing_length);
-  opt_missing_length = missing_length;
-  got_start_callback = true;
-  got_end_callback = true;
+  ASSERT_FALSE(opt_pad_length_);
+  ASSERT_FALSE(opt_missing_length_);
+  opt_missing_length_ = missing_length;
+  got_start_callback_ = true;
+  got_end_callback_ = true;
 }
 
 void FrameParts::OnFrameSizeError(const Http2FrameHeader& header) {
   VLOG(1) << "OnFrameSizeError: " << header;
-  ASSERT_EQ(frame_header, header);
-  ASSERT_FALSE(got_end_callback);
-  ASSERT_FALSE(has_frame_size_error);
-  has_frame_size_error = true;
-  got_end_callback = true;
+  ASSERT_EQ(frame_header_, header);
+  ASSERT_FALSE(got_end_callback_);
+  ASSERT_FALSE(has_frame_size_error_);
+  has_frame_size_error_ = true;
+  got_end_callback_ = true;
 }
 
 void FrameParts::OutputTo(std::ostream& out) const {
-  out << "FrameParts{\n  frame_header: " << frame_header << "\n";
-  if (!payload.empty()) {
-    out << "  payload=\"" << EscapeQueryParamValue(payload, false) << "\"\n";
+  out << "FrameParts{\n  frame_header_: " << frame_header_ << "\n";
+  if (!payload_.empty()) {
+    out << "  payload_=\"" << EscapeQueryParamValue(payload_, false) << "\"\n";
   }
-  if (!padding.empty()) {
-    out << "  padding=\"" << EscapeQueryParamValue(padding, false) << "\"\n";
+  if (!padding_.empty()) {
+    out << "  padding_=\"" << EscapeQueryParamValue(padding_, false) << "\"\n";
   }
-  if (!altsvc_origin.empty()) {
-    out << "  altsvc_origin=\"" << EscapeQueryParamValue(altsvc_origin, false)
+  if (!altsvc_origin_.empty()) {
+    out << "  altsvc_origin_=\"" << EscapeQueryParamValue(altsvc_origin_, false)
         << "\"\n";
   }
-  if (!altsvc_value.empty()) {
-    out << "  altsvc_value=\"" << EscapeQueryParamValue(altsvc_value, false)
+  if (!altsvc_value_.empty()) {
+    out << "  altsvc_value_=\"" << EscapeQueryParamValue(altsvc_value_, false)
         << "\"\n";
   }
-  if (opt_priority) {
-    out << "  priority=" << opt_priority.value() << "\n";
+  if (opt_priority_) {
+    out << "  priority=" << opt_priority_.value() << "\n";
   }
-  if (opt_rst_stream_error_code) {
-    out << "  rst_stream=" << opt_rst_stream_error_code.value() << "\n";
+  if (opt_rst_stream_error_code_) {
+    out << "  rst_stream=" << opt_rst_stream_error_code_.value() << "\n";
   }
-  if (opt_push_promise) {
-    out << "  push_promise=" << opt_push_promise.value() << "\n";
+  if (opt_push_promise_) {
+    out << "  push_promise=" << opt_push_promise_.value() << "\n";
   }
-  if (opt_ping) {
-    out << "  ping=" << opt_ping.value() << "\n";
+  if (opt_ping_) {
+    out << "  ping=" << opt_ping_.value() << "\n";
   }
-  if (opt_goaway) {
-    out << "  goaway=" << opt_goaway.value() << "\n";
+  if (opt_goaway_) {
+    out << "  goaway=" << opt_goaway_.value() << "\n";
   }
-  if (opt_window_update_increment) {
-    out << "  window_update=" << opt_window_update_increment.value() << "\n";
+  if (opt_window_update_increment_) {
+    out << "  window_update=" << opt_window_update_increment_.value() << "\n";
   }
-  if (opt_payload_length) {
-    out << "  payload_length=" << opt_payload_length.value() << "\n";
+  if (opt_payload_length_) {
+    out << "  payload_length=" << opt_payload_length_.value() << "\n";
   }
-  if (opt_pad_length) {
-    out << "  pad_length=" << opt_pad_length.value() << "\n";
+  if (opt_pad_length_) {
+    out << "  pad_length=" << opt_pad_length_.value() << "\n";
   }
-  if (opt_missing_length) {
-    out << "  missing_length=" << opt_missing_length.value() << "\n";
+  if (opt_missing_length_) {
+    out << "  missing_length=" << opt_missing_length_.value() << "\n";
   }
-  if (opt_altsvc_origin_length) {
-    out << "  origin_length=" << opt_altsvc_origin_length.value() << "\n";
+  if (opt_altsvc_origin_length_) {
+    out << "  origin_length=" << opt_altsvc_origin_length_.value() << "\n";
   }
-  if (opt_altsvc_value_length) {
-    out << "  value_length=" << opt_altsvc_value_length.value() << "\n";
+  if (opt_altsvc_value_length_) {
+    out << "  value_length=" << opt_altsvc_value_length_.value() << "\n";
   }
-  if (has_frame_size_error) {
+  if (has_frame_size_error_) {
     out << "  has_frame_size_error\n";
   }
-  if (got_start_callback) {
+  if (got_start_callback_) {
     out << "  got_start_callback\n";
   }
-  if (got_end_callback) {
+  if (got_end_callback_) {
     out << "  got_end_callback\n";
   }
-  for (size_t ndx = 0; ndx < settings.size(); ++ndx) {
-    out << "  setting[" << ndx << "]=" << settings[ndx];
+  for (size_t ndx = 0; ndx < settings_.size(); ++ndx) {
+    out << "  setting[" << ndx << "]=" << settings_[ndx];
   }
   out << "}";
 }
@@ -476,30 +478,30 @@ AssertionResult FrameParts::StartFrameOfType(
     const Http2FrameHeader& header,
     Http2FrameType expected_frame_type) {
   VERIFY_EQ(header.type, expected_frame_type);
-  VERIFY_FALSE(got_start_callback);
-  VERIFY_FALSE(got_end_callback);
-  VERIFY_EQ(frame_header, header);
-  got_start_callback = true;
+  VERIFY_FALSE(got_start_callback_);
+  VERIFY_FALSE(got_end_callback_);
+  VERIFY_EQ(frame_header_, header);
+  got_start_callback_ = true;
   return AssertionSuccess();
 }
 
 AssertionResult FrameParts::InFrameOfType(Http2FrameType expected_frame_type) {
-  VERIFY_TRUE(got_start_callback);
-  VERIFY_FALSE(got_end_callback);
-  VERIFY_EQ(frame_header.type, expected_frame_type);
+  VERIFY_TRUE(got_start_callback_);
+  VERIFY_FALSE(got_end_callback_);
+  VERIFY_EQ(frame_header_.type, expected_frame_type);
   return AssertionSuccess();
 }
 
 AssertionResult FrameParts::EndFrameOfType(Http2FrameType expected_frame_type) {
   VERIFY_SUCCESS(InFrameOfType(expected_frame_type));
-  got_end_callback = true;
+  got_end_callback_ = true;
   return AssertionSuccess();
 }
 
 AssertionResult FrameParts::InPaddedFrame() {
-  VERIFY_TRUE(got_start_callback);
-  VERIFY_FALSE(got_end_callback);
-  VERIFY_TRUE(FrameIsPadded(frame_header));
+  VERIFY_TRUE(got_start_callback_);
+  VERIFY_FALSE(got_end_callback_);
+  VERIFY_TRUE(FrameIsPadded(frame_header_));
   return AssertionSuccess();
 }
 

net/http2/test_tools/frame_parts.h

@@ -10,9 +10,6 @@
 // info that a test expects to be recorded during the decoding of a frame
 // with the actual recorded value (i.e. by providing a comparator).
 
-// TODO(jamessynge): Convert FrameParts to a class, hide the members, add
-// getters/setters.
-
 #include <stddef.h>
 
 #include <vector>
@@ -29,11 +26,8 @@
 namespace net {
 namespace test {
 
-// Forward declarations.
-struct FrameParts;
-std::ostream& operator<<(std::ostream& out, const FrameParts& v);
-
-struct FrameParts : public Http2FrameDecoderListener {
+class FrameParts : public Http2FrameDecoderListener {
+ public:
   // The first callback for every type of frame includes the frame header; this
   // is the only constructor used during decoding of a frame.
   explicit FrameParts(const Http2FrameHeader& header);
@@ -113,36 +107,82 @@ struct FrameParts : public Http2FrameDecoderListener {
                         size_t missing_length) override;
   void OnFrameSizeError(const Http2FrameHeader& header) override;
 
-  // The fields are public for access by tests.
-
-  const Http2FrameHeader frame_header;
-
-  Http2String payload;
-  Http2String padding;
-  Http2String altsvc_origin;
-  Http2String altsvc_value;
-
-  base::Optional<Http2PriorityFields> opt_priority;
-  base::Optional<Http2ErrorCode> opt_rst_stream_error_code;
-  base::Optional<Http2PushPromiseFields> opt_push_promise;
-  base::Optional<Http2PingFields> opt_ping;
-  base::Optional<Http2GoAwayFields> opt_goaway;
-
-  base::Optional<size_t> opt_pad_length;
-  base::Optional<size_t> opt_payload_length;
-  base::Optional<size_t> opt_missing_length;
-  base::Optional<size_t> opt_altsvc_origin_length;
-  base::Optional<size_t> opt_altsvc_value_length;
-
-  base::Optional<size_t> opt_window_update_increment;
-
-  bool has_frame_size_error = false;
-
-  std::vector<Http2SettingFields> settings;
-
-  // These booleans are not checked by CompareCollectedFrames.
-  bool got_start_callback = false;
-  bool got_end_callback = false;
+  void AppendSetting(const Http2SettingFields& setting_fields) {
+    settings_.push_back(setting_fields);
+  }
+
+  const Http2FrameHeader& GetFrameHeader() const { return frame_header_; }
+
+  base::Optional<Http2PriorityFields> GetOptPriority() const {
+    return opt_priority_;
+  }
+  base::Optional<Http2ErrorCode> GetOptRstStreamErrorCode() const {
+    return opt_rst_stream_error_code_;
+  }
+  base::Optional<Http2PushPromiseFields> GetOptPushPromise() const {
+    return opt_push_promise_;
+  }
+  base::Optional<Http2PingFields> GetOptPing() const { return opt_ping_; }
+  base::Optional<Http2GoAwayFields> GetOptGoaway() const { return opt_goaway_; }
+  base::Optional<size_t> GetOptPadLength() const { return opt_pad_length_; }
+  base::Optional<size_t> GetOptPayloadLength() const {
+    return opt_payload_length_;
+  }
+  base::Optional<size_t> GetOptMissingLength() const {
+    return opt_missing_length_;
+  }
+  base::Optional<size_t> GetOptAltsvcOriginLength() const {
+    return opt_altsvc_origin_length_;
+  }
+  base::Optional<size_t> GetOptAltsvcValueLength() const {
+    return opt_altsvc_value_length_;
+  }
+  base::Optional<size_t> GetOptWindowUpdateIncrement() const {
+    return opt_window_update_increment_;
+  }
+  bool GetHasFrameSizeError() const { return has_frame_size_error_; }
+
+  void SetOptPriority(base::Optional<Http2PriorityFields> opt_priority) {
+    opt_priority_ = opt_priority;
+  }
+  void SetOptRstStreamErrorCode(
+      base::Optional<Http2ErrorCode> opt_rst_stream_error_code) {
+    opt_rst_stream_error_code_ = opt_rst_stream_error_code;
+  }
+  void SetOptPushPromise(
+      base::Optional<Http2PushPromiseFields> opt_push_promise) {
+    opt_push_promise_ = opt_push_promise;
+  }
+  void SetOptPing(base::Optional<Http2PingFields> opt_ping) {
+    opt_ping_ = opt_ping;
+  }
+  void SetOptGoaway(base::Optional<Http2GoAwayFields> opt_goaway) {
+    opt_goaway_ = opt_goaway;
+  }
+  void SetOptPadLength(base::Optional<size_t> opt_pad_length) {
+    opt_pad_length_ = opt_pad_length;
+  }
+  void SetOptPayloadLength(base::Optional<size_t> opt_payload_length) {
+    opt_payload_length_ = opt_payload_length;
+  }
+  void SetOptMissingLength(base::Optional<size_t> opt_missing_length) {
+    opt_missing_length_ = opt_missing_length;
+  }
+  void SetOptAltsvcOriginLength(
+      base::Optional<size_t> opt_altsvc_origin_length) {
+    opt_altsvc_origin_length_ = opt_altsvc_origin_length;
+  }
+  void SetOptAltsvcValueLength(base::Optional<size_t> opt_altsvc_value_length) {
+    opt_altsvc_value_length_ = opt_altsvc_value_length;
+  }
+  void SetOptWindowUpdateIncrement(
+      base::Optional<size_t> opt_window_update_increment) {
+    opt_window_update_increment_ = opt_window_update_increment;
+  }
+
+  void SetHasFrameSizeError(bool has_frame_size_error) {
+    has_frame_size_error_ = has_frame_size_error;
+  }
 
  private:
   // ASSERT during an On* method that we're handling a frame of type
@@ -169,8 +209,39 @@ struct FrameParts : public Http2FrameDecoderListener {
   ::testing::AssertionResult AppendString(Http2StringPiece source,
                                           Http2String* target,
                                           base::Optional<size_t>* opt_length);
+
+  const Http2FrameHeader frame_header_;
+
+  Http2String payload_;
+  Http2String padding_;
+  Http2String altsvc_origin_;
+  Http2String altsvc_value_;
+
+  base::Optional<Http2PriorityFields> opt_priority_;
+  base::Optional<Http2ErrorCode> opt_rst_stream_error_code_;
+  base::Optional<Http2PushPromiseFields> opt_push_promise_;
+  base::Optional<Http2PingFields> opt_ping_;
+  base::Optional<Http2GoAwayFields> opt_goaway_;
+
+  base::Optional<size_t> opt_pad_length_;
+  base::Optional<size_t> opt_payload_length_;
+  base::Optional<size_t> opt_missing_length_;
+  base::Optional<size_t> opt_altsvc_origin_length_;
+  base::Optional<size_t> opt_altsvc_value_length_;
+
+  base::Optional<size_t> opt_window_update_increment_;
+
+  bool has_frame_size_error_ = false;
+
+  std::vector<Http2SettingFields> settings_;
+
+  // These booleans are not checked by CompareCollectedFrames.
+  bool got_start_callback_ = false;
+  bool got_end_callback_ = false;
 };
 
+std::ostream& operator<<(std::ostream& out, const FrameParts& v);
+
 }  // namespace test
 }  // namespace net
 

net/http2/test_tools/frame_parts_collector.cc

@@ -101,7 +101,7 @@ Http2FrameDecoderListener* FramePartsCollector::FrameError(
     // frame before detecting the error; for example, the DATA payload decoder
     // calls OnDataStart before it can detect padding errors, hence before it
     // can call OnPaddingTooLong.
-    EXPECT_EQ(header, current_frame_->frame_header);
+    EXPECT_EQ(header, current_frame_->GetFrameHeader());
   }
   Http2FrameDecoderListener* result = current_frame();
   collected_frames_.push_back(std::move(current_frame_));