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 #include "net/http2/decoder/http2_frame_decoder_listener_test_util.h" | |
6 | |
7 #include "base/logging.h" | |
8 #include "testing/gtest/include/gtest/gtest.h" | |
9 | |
10 namespace net { | |
11 | |
12 FailingHttp2FrameDecoderListener::FailingHttp2FrameDecoderListener() {} | |
13 FailingHttp2FrameDecoderListener::~FailingHttp2FrameDecoderListener() {} | |
14 | |
15 bool FailingHttp2FrameDecoderListener::OnFrameHeader( | |
16 const Http2FrameHeader& header) { | |
17 ADD_FAILURE() << "OnFrameHeader: " << header; | |
18 return false; | |
19 } | |
20 | |
21 void FailingHttp2FrameDecoderListener::OnDataStart( | |
22 const Http2FrameHeader& header) { | |
23 FAIL() << "OnDataStart: " << header; | |
24 } | |
25 | |
26 void FailingHttp2FrameDecoderListener::OnDataPayload(const char* data, | |
27 size_t len) { | |
28 FAIL() << "OnDataPayload: len=" << len; | |
29 } | |
30 | |
31 void FailingHttp2FrameDecoderListener::OnDataEnd() { | |
32 FAIL() << "OnDataEnd"; | |
33 } | |
34 | |
35 void FailingHttp2FrameDecoderListener::OnHeadersStart( | |
36 const Http2FrameHeader& header) { | |
37 FAIL() << "OnHeadersStart: " << header; | |
38 } | |
39 | |
40 void FailingHttp2FrameDecoderListener::OnHeadersPriority( | |
41 const Http2PriorityFields& priority) { | |
42 FAIL() << "OnHeadersPriority: " << priority; | |
43 } | |
44 | |
45 void FailingHttp2FrameDecoderListener::OnHpackFragment(const char* data, | |
46 size_t len) { | |
47 FAIL() << "OnHpackFragment: len=" << len; | |
48 } | |
49 | |
50 void FailingHttp2FrameDecoderListener::OnHeadersEnd() { | |
51 FAIL() << "OnHeadersEnd"; | |
52 } | |
53 | |
54 void FailingHttp2FrameDecoderListener::OnPriorityFrame( | |
55 const Http2FrameHeader& header, | |
56 const Http2PriorityFields& priority) { | |
57 FAIL() << "OnPriorityFrame: " << header << "; priority: " << priority; | |
58 } | |
59 | |
60 void FailingHttp2FrameDecoderListener::OnContinuationStart( | |
61 const Http2FrameHeader& header) { | |
62 FAIL() << "OnContinuationStart: " << header; | |
63 } | |
64 | |
65 void FailingHttp2FrameDecoderListener::OnContinuationEnd() { | |
66 FAIL() << "OnContinuationEnd"; | |
67 } | |
68 | |
69 void FailingHttp2FrameDecoderListener::OnPadLength(size_t trailing_length) { | |
70 FAIL() << "OnPadLength: trailing_length=" << trailing_length; | |
71 } | |
72 | |
73 void FailingHttp2FrameDecoderListener::OnPadding(const char* padding, | |
74 size_t skipped_length) { | |
75 FAIL() << "OnPadding: skipped_length=" << skipped_length; | |
76 } | |
77 | |
78 void FailingHttp2FrameDecoderListener::OnRstStream( | |
79 const Http2FrameHeader& header, | |
80 Http2ErrorCode error_code) { | |
81 FAIL() << "OnRstStream: " << header << "; code=" << error_code; | |
82 } | |
83 | |
84 void FailingHttp2FrameDecoderListener::OnSettingsStart( | |
85 const Http2FrameHeader& header) { | |
86 FAIL() << "OnSettingsStart: " << header; | |
87 } | |
88 | |
89 void FailingHttp2FrameDecoderListener::OnSetting( | |
90 const Http2SettingFields& setting_fields) { | |
91 FAIL() << "OnSetting: " << setting_fields; | |
92 } | |
93 | |
94 void FailingHttp2FrameDecoderListener::OnSettingsEnd() { | |
95 FAIL() << "OnSettingsEnd"; | |
96 } | |
97 | |
98 void FailingHttp2FrameDecoderListener::OnSettingsAck( | |
99 const Http2FrameHeader& header) { | |
100 FAIL() << "OnSettingsAck: " << header; | |
101 } | |
102 | |
103 void FailingHttp2FrameDecoderListener::OnPushPromiseStart( | |
104 const Http2FrameHeader& header, | |
105 const Http2PushPromiseFields& promise, | |
106 size_t total_padding_length) { | |
107 FAIL() << "OnPushPromiseStart: " << header << "; promise: " << promise | |
108 << "; total_padding_length: " << total_padding_length; | |
109 } | |
110 | |
111 void FailingHttp2FrameDecoderListener::OnPushPromiseEnd() { | |
112 FAIL() << "OnPushPromiseEnd"; | |
113 } | |
114 | |
115 void FailingHttp2FrameDecoderListener::OnPing(const Http2FrameHeader& header, | |
116 const Http2PingFields& ping) { | |
117 FAIL() << "OnPing: " << header << "; ping: " << ping; | |
118 } | |
119 | |
120 void FailingHttp2FrameDecoderListener::OnPingAck(const Http2FrameHeader& header, | |
121 const Http2PingFields& ping) { | |
122 FAIL() << "OnPingAck: " << header << "; ping: " << ping; | |
123 } | |
124 | |
125 void FailingHttp2FrameDecoderListener::OnGoAwayStart( | |
126 const Http2FrameHeader& header, | |
127 const Http2GoAwayFields& goaway) { | |
128 FAIL() << "OnGoAwayStart: " << header << "; goaway: " << goaway; | |
129 } | |
130 | |
131 void FailingHttp2FrameDecoderListener::OnGoAwayOpaqueData(const char* data, | |
132 size_t len) { | |
133 FAIL() << "OnGoAwayOpaqueData: len=" << len; | |
134 } | |
135 | |
136 void FailingHttp2FrameDecoderListener::OnGoAwayEnd() { | |
137 FAIL() << "OnGoAwayEnd"; | |
138 } | |
139 | |
140 void FailingHttp2FrameDecoderListener::OnWindowUpdate( | |
141 const Http2FrameHeader& header, | |
142 uint32_t increment) { | |
143 FAIL() << "OnWindowUpdate: " << header << "; increment=" << increment; | |
144 } | |
145 | |
146 void FailingHttp2FrameDecoderListener::OnAltSvcStart( | |
147 const Http2FrameHeader& header, | |
148 size_t origin_length, | |
149 size_t value_length) { | |
150 FAIL() << "OnAltSvcStart: " << header << "; origin_length: " << origin_length | |
151 << "; value_length: " << value_length; | |
152 } | |
153 | |
154 void FailingHttp2FrameDecoderListener::OnAltSvcOriginData(const char* data, | |
155 size_t len) { | |
156 FAIL() << "OnAltSvcOriginData: len=" << len; | |
157 } | |
158 | |
159 void FailingHttp2FrameDecoderListener::OnAltSvcValueData(const char* data, | |
160 size_t len) { | |
161 FAIL() << "OnAltSvcValueData: len=" << len; | |
162 } | |
163 | |
164 void FailingHttp2FrameDecoderListener::OnAltSvcEnd() { | |
165 FAIL() << "OnAltSvcEnd"; | |
166 } | |
167 | |
168 void FailingHttp2FrameDecoderListener::OnUnknownStart( | |
169 const Http2FrameHeader& header) { | |
170 FAIL() << "OnUnknownStart: " << header; | |
171 } | |
172 | |
173 void FailingHttp2FrameDecoderListener::OnUnknownPayload(const char* data, | |
174 size_t len) { | |
175 FAIL() << "OnUnknownPayload: len=" << len; | |
176 } | |
177 | |
178 void FailingHttp2FrameDecoderListener::OnUnknownEnd() { | |
179 FAIL() << "OnUnknownEnd"; | |
180 } | |
181 | |
182 void FailingHttp2FrameDecoderListener::OnPaddingTooLong( | |
183 const Http2FrameHeader& header, | |
184 size_t missing_length) { | |
185 FAIL() << "OnPaddingTooLong: " << header | |
186 << "; missing_length: " << missing_length; | |
187 } | |
188 | |
189 void FailingHttp2FrameDecoderListener::OnFrameSizeError( | |
190 const Http2FrameHeader& header) { | |
191 FAIL() << "OnFrameSizeError: " << header; | |
192 } | |
193 | |
194 LoggingHttp2FrameDecoderListener::LoggingHttp2FrameDecoderListener() | |
195 : wrapped_(nullptr) {} | |
196 LoggingHttp2FrameDecoderListener::LoggingHttp2FrameDecoderListener( | |
197 Http2FrameDecoderListener* wrapped) | |
198 : wrapped_(wrapped) {} | |
199 LoggingHttp2FrameDecoderListener::~LoggingHttp2FrameDecoderListener() {} | |
200 | |
201 bool LoggingHttp2FrameDecoderListener::OnFrameHeader( | |
202 const Http2FrameHeader& header) { | |
203 VLOG(1) << "OnFrameHeader: " << header; | |
204 if (wrapped_ != nullptr) { | |
205 return wrapped_->OnFrameHeader(header); | |
206 } | |
207 return true; | |
208 } | |
209 | |
210 void LoggingHttp2FrameDecoderListener::OnDataStart( | |
211 const Http2FrameHeader& header) { | |
212 VLOG(1) << "OnDataStart: " << header; | |
213 if (wrapped_ != nullptr) { | |
214 wrapped_->OnDataStart(header); | |
215 } | |
216 } | |
217 | |
218 void LoggingHttp2FrameDecoderListener::OnDataPayload(const char* data, | |
219 size_t len) { | |
220 VLOG(1) << "OnDataPayload: len=" << len; | |
221 if (wrapped_ != nullptr) { | |
222 wrapped_->OnDataPayload(data, len); | |
223 } | |
224 } | |
225 | |
226 void LoggingHttp2FrameDecoderListener::OnDataEnd() { | |
227 VLOG(1) << "OnDataEnd"; | |
228 if (wrapped_ != nullptr) { | |
229 wrapped_->OnDataEnd(); | |
230 } | |
231 } | |
232 | |
233 void LoggingHttp2FrameDecoderListener::OnHeadersStart( | |
234 const Http2FrameHeader& header) { | |
235 VLOG(1) << "OnHeadersStart: " << header; | |
236 if (wrapped_ != nullptr) { | |
237 wrapped_->OnHeadersStart(header); | |
238 } | |
239 } | |
240 | |
241 void LoggingHttp2FrameDecoderListener::OnHeadersPriority( | |
242 const Http2PriorityFields& priority) { | |
243 VLOG(1) << "OnHeadersPriority: " << priority; | |
244 if (wrapped_ != nullptr) { | |
245 wrapped_->OnHeadersPriority(priority); | |
246 } | |
247 } | |
248 | |
249 void LoggingHttp2FrameDecoderListener::OnHpackFragment(const char* data, | |
250 size_t len) { | |
251 VLOG(1) << "OnHpackFragment: len=" << len; | |
252 if (wrapped_ != nullptr) { | |
253 wrapped_->OnHpackFragment(data, len); | |
254 } | |
255 } | |
256 | |
257 void LoggingHttp2FrameDecoderListener::OnHeadersEnd() { | |
258 VLOG(1) << "OnHeadersEnd"; | |
259 if (wrapped_ != nullptr) { | |
260 wrapped_->OnHeadersEnd(); | |
261 } | |
262 } | |
263 | |
264 void LoggingHttp2FrameDecoderListener::OnPriorityFrame( | |
265 const Http2FrameHeader& header, | |
266 const Http2PriorityFields& priority) { | |
267 VLOG(1) << "OnPriorityFrame: " << header << "; priority: " << priority; | |
268 if (wrapped_ != nullptr) { | |
269 wrapped_->OnPriorityFrame(header, priority); | |
270 } | |
271 } | |
272 | |
273 void LoggingHttp2FrameDecoderListener::OnContinuationStart( | |
274 const Http2FrameHeader& header) { | |
275 VLOG(1) << "OnContinuationStart: " << header; | |
276 if (wrapped_ != nullptr) { | |
277 wrapped_->OnContinuationStart(header); | |
278 } | |
279 } | |
280 | |
281 void LoggingHttp2FrameDecoderListener::OnContinuationEnd() { | |
282 VLOG(1) << "OnContinuationEnd"; | |
283 if (wrapped_ != nullptr) { | |
284 wrapped_->OnContinuationEnd(); | |
285 } | |
286 } | |
287 | |
288 void LoggingHttp2FrameDecoderListener::OnPadLength(size_t trailing_length) { | |
289 VLOG(1) << "OnPadLength: trailing_length=" << trailing_length; | |
290 if (wrapped_ != nullptr) { | |
291 wrapped_->OnPadLength(trailing_length); | |
292 } | |
293 } | |
294 | |
295 void LoggingHttp2FrameDecoderListener::OnPadding(const char* padding, | |
296 size_t skipped_length) { | |
297 VLOG(1) << "OnPadding: skipped_length=" << skipped_length; | |
298 if (wrapped_ != nullptr) { | |
299 wrapped_->OnPadding(padding, skipped_length); | |
300 } | |
301 } | |
302 | |
303 void LoggingHttp2FrameDecoderListener::OnRstStream( | |
304 const Http2FrameHeader& header, | |
305 Http2ErrorCode error_code) { | |
306 VLOG(1) << "OnRstStream: " << header << "; code=" << error_code; | |
307 if (wrapped_ != nullptr) { | |
308 wrapped_->OnRstStream(header, error_code); | |
309 } | |
310 } | |
311 | |
312 void LoggingHttp2FrameDecoderListener::OnSettingsStart( | |
313 const Http2FrameHeader& header) { | |
314 VLOG(1) << "OnSettingsStart: " << header; | |
315 if (wrapped_ != nullptr) { | |
316 wrapped_->OnSettingsStart(header); | |
317 } | |
318 } | |
319 | |
320 void LoggingHttp2FrameDecoderListener::OnSetting( | |
321 const Http2SettingFields& setting_fields) { | |
322 VLOG(1) << "OnSetting: " << setting_fields; | |
323 if (wrapped_ != nullptr) { | |
324 wrapped_->OnSetting(setting_fields); | |
325 } | |
326 } | |
327 | |
328 void LoggingHttp2FrameDecoderListener::OnSettingsEnd() { | |
329 VLOG(1) << "OnSettingsEnd"; | |
330 if (wrapped_ != nullptr) { | |
331 wrapped_->OnSettingsEnd(); | |
332 } | |
333 } | |
334 | |
335 void LoggingHttp2FrameDecoderListener::OnSettingsAck( | |
336 const Http2FrameHeader& header) { | |
337 VLOG(1) << "OnSettingsAck: " << header; | |
338 if (wrapped_ != nullptr) { | |
339 wrapped_->OnSettingsAck(header); | |
340 } | |
341 } | |
342 | |
343 void LoggingHttp2FrameDecoderListener::OnPushPromiseStart( | |
344 const Http2FrameHeader& header, | |
345 const Http2PushPromiseFields& promise, | |
346 size_t total_padding_length) { | |
347 VLOG(1) << "OnPushPromiseStart: " << header << "; promise: " << promise | |
348 << "; total_padding_length: " << total_padding_length; | |
349 if (wrapped_ != nullptr) { | |
350 wrapped_->OnPushPromiseStart(header, promise, total_padding_length); | |
351 } | |
352 } | |
353 | |
354 void LoggingHttp2FrameDecoderListener::OnPushPromiseEnd() { | |
355 VLOG(1) << "OnPushPromiseEnd"; | |
356 if (wrapped_ != nullptr) { | |
357 wrapped_->OnPushPromiseEnd(); | |
358 } | |
359 } | |
360 | |
361 void LoggingHttp2FrameDecoderListener::OnPing(const Http2FrameHeader& header, | |
362 const Http2PingFields& ping) { | |
363 VLOG(1) << "OnPing: " << header << "; ping: " << ping; | |
364 if (wrapped_ != nullptr) { | |
365 wrapped_->OnPing(header, ping); | |
366 } | |
367 } | |
368 | |
369 void LoggingHttp2FrameDecoderListener::OnPingAck(const Http2FrameHeader& header, | |
370 const Http2PingFields& ping) { | |
371 VLOG(1) << "OnPingAck: " << header << "; ping: " << ping; | |
372 if (wrapped_ != nullptr) { | |
373 wrapped_->OnPingAck(header, ping); | |
374 } | |
375 } | |
376 | |
377 void LoggingHttp2FrameDecoderListener::OnGoAwayStart( | |
378 const Http2FrameHeader& header, | |
379 const Http2GoAwayFields& goaway) { | |
380 VLOG(1) << "OnGoAwayStart: " << header << "; goaway: " << goaway; | |
381 if (wrapped_ != nullptr) { | |
382 wrapped_->OnGoAwayStart(header, goaway); | |
383 } | |
384 } | |
385 | |
386 void LoggingHttp2FrameDecoderListener::OnGoAwayOpaqueData(const char* data, | |
387 size_t len) { | |
388 VLOG(1) << "OnGoAwayOpaqueData: len=" << len; | |
389 if (wrapped_ != nullptr) { | |
390 wrapped_->OnGoAwayOpaqueData(data, len); | |
391 } | |
392 } | |
393 | |
394 void LoggingHttp2FrameDecoderListener::OnGoAwayEnd() { | |
395 VLOG(1) << "OnGoAwayEnd"; | |
396 if (wrapped_ != nullptr) { | |
397 wrapped_->OnGoAwayEnd(); | |
398 } | |
399 } | |
400 | |
401 void LoggingHttp2FrameDecoderListener::OnWindowUpdate( | |
402 const Http2FrameHeader& header, | |
403 uint32_t increment) { | |
404 VLOG(1) << "OnWindowUpdate: " << header << "; increment=" << increment; | |
405 if (wrapped_ != nullptr) { | |
406 wrapped_->OnWindowUpdate(header, increment); | |
407 } | |
408 } | |
409 | |
410 void LoggingHttp2FrameDecoderListener::OnAltSvcStart( | |
411 const Http2FrameHeader& header, | |
412 size_t origin_length, | |
413 size_t value_length) { | |
414 VLOG(1) << "OnAltSvcStart: " << header << "; origin_length: " << origin_length | |
415 << "; value_length: " << value_length; | |
416 if (wrapped_ != nullptr) { | |
417 wrapped_->OnAltSvcStart(header, origin_length, value_length); | |
418 } | |
419 } | |
420 | |
421 void LoggingHttp2FrameDecoderListener::OnAltSvcOriginData(const char* data, | |
422 size_t len) { | |
423 VLOG(1) << "OnAltSvcOriginData: len=" << len; | |
424 if (wrapped_ != nullptr) { | |
425 wrapped_->OnAltSvcOriginData(data, len); | |
426 } | |
427 } | |
428 | |
429 void LoggingHttp2FrameDecoderListener::OnAltSvcValueData(const char* data, | |
430 size_t len) { | |
431 VLOG(1) << "OnAltSvcValueData: len=" << len; | |
432 if (wrapped_ != nullptr) { | |
433 wrapped_->OnAltSvcValueData(data, len); | |
434 } | |
435 } | |
436 | |
437 void LoggingHttp2FrameDecoderListener::OnAltSvcEnd() { | |
438 VLOG(1) << "OnAltSvcEnd"; | |
439 if (wrapped_ != nullptr) { | |
440 wrapped_->OnAltSvcEnd(); | |
441 } | |
442 } | |
443 | |
444 void LoggingHttp2FrameDecoderListener::OnUnknownStart( | |
445 const Http2FrameHeader& header) { | |
446 VLOG(1) << "OnUnknownStart: " << header; | |
447 if (wrapped_ != nullptr) { | |
448 wrapped_->OnUnknownStart(header); | |
449 } | |
450 } | |
451 | |
452 void LoggingHttp2FrameDecoderListener::OnUnknownPayload(const char* data, | |
453 size_t len) { | |
454 VLOG(1) << "OnUnknownPayload: len=" << len; | |
455 if (wrapped_ != nullptr) { | |
456 wrapped_->OnUnknownPayload(data, len); | |
457 } | |
458 } | |
459 | |
460 void LoggingHttp2FrameDecoderListener::OnUnknownEnd() { | |
461 VLOG(1) << "OnUnknownEnd"; | |
462 if (wrapped_ != nullptr) { | |
463 wrapped_->OnUnknownEnd(); | |
464 } | |
465 } | |
466 | |
467 void LoggingHttp2FrameDecoderListener::OnPaddingTooLong( | |
468 const Http2FrameHeader& header, | |
469 size_t missing_length) { | |
470 VLOG(1) << "OnPaddingTooLong: " << header | |
471 << "; missing_length: " << missing_length; | |
472 if (wrapped_ != nullptr) { | |
473 wrapped_->OnPaddingTooLong(header, missing_length); | |
474 } | |
475 } | |
476 | |
477 void LoggingHttp2FrameDecoderListener::OnFrameSizeError( | |
478 const Http2FrameHeader& header) { | |
479 VLOG(1) << "OnFrameSizeError: " << header; | |
480 if (wrapped_ != nullptr) { | |
481 wrapped_->OnFrameSizeError(header); | |
482 } | |
483 } | |
484 | |
485 } // namespace net | |
OLD | NEW |