| 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 |
|---|
Chromium Code Reviews
Issue 2554683003:
Revert of Add new HTTP/2 and HPACK decoder in net/http2/. (Closed)
