OLD | NEW |
| (Empty) |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #ifndef NET_HTTP2_DECODER_FRAME_PARTS_H_ | |
6 #define NET_HTTP2_DECODER_FRAME_PARTS_H_ | |
7 | |
8 // FrameParts implements Http2FrameDecoderListener, recording the callbacks | |
9 // during the decoding of a single frame. It is also used for comparing the | |
10 // info that a test expects to be recorded during the decoding of a frame | |
11 // with the actual recorded value (i.e. by providing a comparator). | |
12 | |
13 // TODO(jamessynge): Convert FrameParts to a class, hide the members, add | |
14 // getters/setters. | |
15 | |
16 #include <stddef.h> | |
17 | |
18 #include <string> | |
19 #include <vector> | |
20 | |
21 #include "base/logging.h" | |
22 #include "base/optional.h" | |
23 #include "base/strings/string_piece.h" | |
24 #include "net/http2/decoder/http2_frame_decoder_listener.h" | |
25 #include "net/http2/http2_constants.h" | |
26 #include "net/http2/http2_structures.h" | |
27 #include "testing/gtest/include/gtest/gtest.h" | |
28 | |
29 namespace net { | |
30 namespace test { | |
31 | |
32 struct FrameParts; | |
33 | |
34 std::ostream& operator<<(std::ostream& out, const FrameParts& v); | |
35 | |
36 struct FrameParts : public Http2FrameDecoderListener { | |
37 // The first callback for every type of frame includes the frame header; this | |
38 // is the only constructor used during decoding of a frame. | |
39 explicit FrameParts(const Http2FrameHeader& header); | |
40 | |
41 // For use in tests where the expected frame has a variable size payload. | |
42 FrameParts(const Http2FrameHeader& header, base::StringPiece payload); | |
43 | |
44 // For use in tests where the expected frame has a variable size payload | |
45 // and may be padded. | |
46 FrameParts(const Http2FrameHeader& header, | |
47 base::StringPiece payload, | |
48 size_t total_pad_length); | |
49 | |
50 FrameParts(const FrameParts& other); | |
51 | |
52 ~FrameParts() override; | |
53 | |
54 // Returns AssertionSuccess() if they're equal, else AssertionFailure() | |
55 // with info about the difference. | |
56 ::testing::AssertionResult VerifyEquals(const FrameParts& other) const; | |
57 | |
58 // Format this FrameParts object. | |
59 void OutputTo(std::ostream& out) const; | |
60 | |
61 // Set the total padding length (0 to 256). | |
62 void SetTotalPadLength(size_t total_pad_length); | |
63 | |
64 // Set the origin and value expected in an ALTSVC frame. | |
65 void SetAltSvcExpected(base::StringPiece origin, base::StringPiece value); | |
66 | |
67 // Http2FrameDecoderListener methods: | |
68 bool OnFrameHeader(const Http2FrameHeader& header) override; | |
69 void OnDataStart(const Http2FrameHeader& header) override; | |
70 void OnDataPayload(const char* data, size_t len) override; | |
71 void OnDataEnd() override; | |
72 void OnHeadersStart(const Http2FrameHeader& header) override; | |
73 void OnHeadersPriority(const Http2PriorityFields& priority) override; | |
74 void OnHpackFragment(const char* data, size_t len) override; | |
75 void OnHeadersEnd() override; | |
76 void OnPriorityFrame(const Http2FrameHeader& header, | |
77 const Http2PriorityFields& priority) override; | |
78 void OnContinuationStart(const Http2FrameHeader& header) override; | |
79 void OnContinuationEnd() override; | |
80 void OnPadLength(size_t trailing_length) override; | |
81 void OnPadding(const char* pad, size_t skipped_length) override; | |
82 void OnRstStream(const Http2FrameHeader& header, | |
83 Http2ErrorCode error_code) override; | |
84 void OnSettingsStart(const Http2FrameHeader& header) override; | |
85 void OnSetting(const Http2SettingFields& setting_fields) override; | |
86 void OnSettingsEnd() override; | |
87 void OnSettingsAck(const Http2FrameHeader& header) override; | |
88 void OnPushPromiseStart(const Http2FrameHeader& header, | |
89 const Http2PushPromiseFields& promise, | |
90 size_t total_padding_length) override; | |
91 void OnPushPromiseEnd() override; | |
92 void OnPing(const Http2FrameHeader& header, | |
93 const Http2PingFields& ping) override; | |
94 void OnPingAck(const Http2FrameHeader& header, | |
95 const Http2PingFields& ping) override; | |
96 void OnGoAwayStart(const Http2FrameHeader& header, | |
97 const Http2GoAwayFields& goaway) override; | |
98 void OnGoAwayOpaqueData(const char* data, size_t len) override; | |
99 void OnGoAwayEnd() override; | |
100 void OnWindowUpdate(const Http2FrameHeader& header, | |
101 uint32_t increment) override; | |
102 void OnAltSvcStart(const Http2FrameHeader& header, | |
103 size_t origin_length, | |
104 size_t value_length) override; | |
105 void OnAltSvcOriginData(const char* data, size_t len) override; | |
106 void OnAltSvcValueData(const char* data, size_t len) override; | |
107 void OnAltSvcEnd() override; | |
108 void OnUnknownStart(const Http2FrameHeader& header) override; | |
109 void OnUnknownPayload(const char* data, size_t len) override; | |
110 void OnUnknownEnd() override; | |
111 void OnPaddingTooLong(const Http2FrameHeader& header, | |
112 size_t missing_length) override; | |
113 void OnFrameSizeError(const Http2FrameHeader& header) override; | |
114 | |
115 // The fields are public for access by tests. | |
116 | |
117 const Http2FrameHeader frame_header; | |
118 | |
119 std::string payload; | |
120 std::string padding; | |
121 std::string altsvc_origin; | |
122 std::string altsvc_value; | |
123 | |
124 base::Optional<Http2PriorityFields> opt_priority; | |
125 base::Optional<Http2ErrorCode> opt_rst_stream_error_code; | |
126 base::Optional<Http2PushPromiseFields> opt_push_promise; | |
127 base::Optional<Http2PingFields> opt_ping; | |
128 base::Optional<Http2GoAwayFields> opt_goaway; | |
129 | |
130 base::Optional<int> opt_pad_length; | |
131 base::Optional<int> opt_payload_length; | |
132 base::Optional<int> opt_missing_length; | |
133 base::Optional<int> opt_altsvc_origin_length; | |
134 base::Optional<int> opt_altsvc_value_length; | |
135 | |
136 base::Optional<size_t> opt_window_update_increment; | |
137 | |
138 bool has_frame_size_error = false; | |
139 | |
140 std::vector<Http2SettingFields> settings; | |
141 | |
142 // These booleans are not checked by CompareCollectedFrames. | |
143 bool got_start_callback = false; | |
144 bool got_end_callback = false; | |
145 | |
146 private: | |
147 // ASSERT during an On* method that we're handling a frame of type | |
148 // expected_frame_type, and have not already received other On* methods | |
149 // (i.e. got_start_callback is false). | |
150 ::testing::AssertionResult StartFrameOfType( | |
151 const Http2FrameHeader& header, | |
152 Http2FrameType expected_frame_type); | |
153 | |
154 // ASSERT that StartFrameOfType has already been called with | |
155 // expected_frame_type (i.e. got_start_callback has been called), and that | |
156 // EndFrameOfType has not yet been called (i.e. got_end_callback is false). | |
157 ::testing::AssertionResult InFrameOfType(Http2FrameType expected_frame_type); | |
158 | |
159 // ASSERT that we're InFrameOfType, and then sets got_end_callback=true. | |
160 ::testing::AssertionResult EndFrameOfType(Http2FrameType expected_frame_type); | |
161 | |
162 // ASSERT that we're in the middle of processing a frame that is padded. | |
163 ::testing::AssertionResult InPaddedFrame(); | |
164 | |
165 // Append source to target. If opt_length is not nullptr, then verifies that | |
166 // the optional has a value (i.e. that the necessary On*Start method has been | |
167 // called), and that target is not longer than opt_length->value(). | |
168 ::testing::AssertionResult AppendString(base::StringPiece source, | |
169 std::string* target, | |
170 base::Optional<int>* opt_length); | |
171 }; | |
172 | |
173 } // namespace test | |
174 } // namespace net | |
175 | |
176 #endif // NET_HTTP2_DECODER_FRAME_PARTS_H_ | |
OLD | NEW |