Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(191)

Unified Diff: net/http2/decoder/decode_http2_structures.cc

Issue 2293613002: Add new HTTP/2 and HPACK decoder in net/http2/. (Closed)
Patch Set: Replace LOG(INFO) by VLOG(2) in DecodeBufferTest.SlowDecodeTestStruct so that trybots do not fail. Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/http2/decoder/decode_http2_structures.h ('k') | net/http2/decoder/decode_http2_structures_test.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/http2/decoder/decode_http2_structures.cc
diff --git a/net/http2/decoder/decode_http2_structures.cc b/net/http2/decoder/decode_http2_structures.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cd419e38bfbf1d41a42dfadaed2cd022739c7279
--- /dev/null
+++ b/net/http2/decoder/decode_http2_structures.cc
@@ -0,0 +1,355 @@
+// Copyright 2016 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/http2/decoder/decode_http2_structures.h"
+
+#include <string.h>
+
+#include "base/logging.h"
+#include "net/http2/decoder/decode_buffer.h"
+#include "net/http2/http2_constants.h"
+
+namespace net {
+
+// Http2FrameHeader decoding:
+
+void DoDecode(Http2FrameHeader* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_LE(Http2FrameHeader::EncodedSize(), b->Remaining());
+ out->payload_length = b->DecodeUInt24();
+ out->type = static_cast<Http2FrameType>(b->DecodeUInt8());
+ out->flags = static_cast<Http2FrameFlag>(b->DecodeUInt8());
+ out->stream_id = b->DecodeUInt31();
+}
+
+bool MaybeDecode(Http2FrameHeader* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ if (b->Remaining() >= Http2FrameHeader::EncodedSize()) {
+ DoDecode(out, b);
+ return true;
+ }
+ return false;
+}
+
+bool SlowDecode(Http2FrameHeader* out, DecodeBuffer* b, uint32_t* offset) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_NE(nullptr, offset);
+ DCHECK_GT(Http2FrameHeader::EncodedSize(), *offset);
+ if (b->SlowDecodeUInt24(0 /* field_offset */, offset, &out->payload_length) &&
+ b->SlowDecodeEnum(1 /* field_size */, 3 /* field_offset */, offset,
+ &out->type) &&
+ b->SlowDecodeEnum(1 /* field_size */, 4 /* field_offset */, offset,
+ &out->flags) &&
+ b->SlowDecodeUInt31(5 /* field_offset */, offset, &out->stream_id)) {
+ DCHECK_EQ(Http2FrameHeader::EncodedSize(), *offset);
+ return true;
+ }
+ DCHECK_GT(Http2FrameHeader::EncodedSize(), *offset);
+ return false;
+}
+
+// Http2PriorityFields decoding:
+
+void DoDecode(Http2PriorityFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_LE(Http2PriorityFields::EncodedSize(), b->Remaining());
+ uint32_t stream_id_and_flag = b->DecodeUInt32();
+ out->stream_dependency = stream_id_and_flag & StreamIdMask();
+ if (out->stream_dependency == stream_id_and_flag) {
+ out->is_exclusive = false;
+ } else {
+ out->is_exclusive = true;
+ }
+ // Note that chars are automatically promoted to ints during arithmetic,
+ // so 255 + 1 doesn't end up as zero.
+ out->weight = b->DecodeUInt8() + 1;
+}
+
+bool MaybeDecode(Http2PriorityFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ if (b->Remaining() >= Http2PriorityFields::EncodedSize()) {
+ DoDecode(out, b);
+ return true;
+ }
+ return false;
+}
+
+bool SlowDecode(Http2PriorityFields* out, DecodeBuffer* b, uint32_t* offset) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_NE(nullptr, offset);
+ DCHECK_GT(Http2PriorityFields::EncodedSize(), *offset);
+ const uint32_t start_offset = *offset;
+ if (b->SlowDecodeUInt32(0 /* field_offset */, offset,
+ &out->stream_dependency) &&
+ b->SlowDecodeUnsignedInt(1, // field_size
+ 4, // field_offset
+ offset, &out->weight)) {
+ DCHECK_EQ(Http2PriorityFields::EncodedSize(), *offset);
+ if (start_offset < *offset) {
+ // First time here. Extract is_exclusive from stream_dependency.
+ const uint32_t stream_id_only = out->stream_dependency & StreamIdMask();
+ if (out->stream_dependency != stream_id_only) {
+ out->stream_dependency = stream_id_only;
+ out->is_exclusive = true;
+ } else {
+ out->is_exclusive = false;
+ }
+ // Need to add one to the weight field because the encoding is 0-255, but
+ // interpreted as 1-256.
+ ++(out->weight);
+ }
+ return true;
+ }
+ DCHECK_GT(Http2PriorityFields::EncodedSize(), *offset);
+ return false;
+}
+
+// Http2RstStreamFields decoding:
+
+void DoDecode(Http2RstStreamFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_LE(Http2RstStreamFields::EncodedSize(), b->Remaining());
+ out->error_code = static_cast<Http2ErrorCode>(b->DecodeUInt32());
+}
+
+bool MaybeDecode(Http2RstStreamFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ if (b->Remaining() >= Http2RstStreamFields::EncodedSize()) {
+ DoDecode(out, b);
+ return true;
+ }
+ return false;
+}
+
+bool SlowDecode(Http2RstStreamFields* out, DecodeBuffer* b, uint32_t* offset) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_NE(nullptr, offset);
+ DCHECK_GT(Http2RstStreamFields::EncodedSize(), *offset);
+
+ if (b->SlowDecodeEnum(4 /* field_size */, 0 /* field_offset */, offset,
+ &out->error_code)) {
+ DCHECK_EQ(Http2RstStreamFields::EncodedSize(), *offset);
+ return true;
+ }
+ DCHECK_GT(Http2RstStreamFields::EncodedSize(), *offset);
+ return false;
+}
+
+// Http2SettingFields decoding:
+
+void DoDecode(Http2SettingFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_LE(Http2SettingFields::EncodedSize(), b->Remaining());
+ out->parameter = static_cast<Http2SettingsParameter>(b->DecodeUInt16());
+ out->value = b->DecodeUInt32();
+}
+
+bool MaybeDecode(Http2SettingFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ if (b->Remaining() >= Http2SettingFields::EncodedSize()) {
+ DoDecode(out, b);
+ return true;
+ }
+ return false;
+}
+
+bool SlowDecode(Http2SettingFields* out, DecodeBuffer* b, uint32_t* offset) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_NE(nullptr, offset);
+ DCHECK_LT(*offset, Http2SettingFields::EncodedSize());
+
+ if (b->SlowDecodeEnum(2 /* field_size */, 0 /* field_offset */, offset,
+ &out->parameter) &&
+ b->SlowDecodeUInt32(2 /* field_offset */, offset, &out->value)) {
+ DCHECK_EQ(Http2SettingFields::EncodedSize(), *offset);
+ return true;
+ }
+ DCHECK_LT(*offset, Http2SettingFields::EncodedSize());
+ return false;
+}
+
+// Http2PushPromiseFields decoding:
+
+void DoDecode(Http2PushPromiseFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_LE(Http2PushPromiseFields::EncodedSize(), b->Remaining());
+ out->promised_stream_id = b->DecodeUInt31();
+}
+
+bool MaybeDecode(Http2PushPromiseFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ if (b->Remaining() >= Http2PushPromiseFields::EncodedSize()) {
+ DoDecode(out, b);
+ return true;
+ }
+ return false;
+}
+
+bool SlowDecode(Http2PushPromiseFields* out,
+ DecodeBuffer* b,
+ uint32_t* offset) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_NE(nullptr, offset);
+ DCHECK_LT(*offset, Http2PushPromiseFields::EncodedSize());
+ if (b->SlowDecodeUInt31(0 /* field_offset */, offset,
+ &out->promised_stream_id)) {
+ DCHECK_EQ(Http2PushPromiseFields::EncodedSize(), *offset);
+ return true;
+ }
+ DCHECK_LT(*offset, Http2PushPromiseFields::EncodedSize());
+ return false;
+}
+
+// Http2PingFields decoding:
+
+void DoDecode(Http2PingFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_LE(Http2PingFields::EncodedSize(), b->Remaining());
+ memcpy(out->opaque_data, b->cursor(), Http2PingFields::EncodedSize());
+ b->AdvanceCursor(Http2PingFields::EncodedSize());
+}
+
+bool MaybeDecode(Http2PingFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ if (b->Remaining() >= Http2PingFields::EncodedSize()) {
+ DoDecode(out, b);
+ return true;
+ }
+ return false;
+}
+
+bool SlowDecode(Http2PingFields* out, DecodeBuffer* b, uint32_t* offset) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_NE(nullptr, offset);
+ DCHECK_LT(*offset, Http2PingFields::EncodedSize());
+ while (*offset < Http2PingFields::EncodedSize()) {
+ if (b->Empty()) {
+ return false;
+ }
+ out->opaque_data[(*offset)++] = b->DecodeUInt8();
+ }
+ return true;
+}
+
+// Http2GoAwayFields decoding:
+
+void DoDecode(Http2GoAwayFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_LE(Http2GoAwayFields::EncodedSize(), b->Remaining());
+ out->last_stream_id = b->DecodeUInt31();
+ out->error_code = static_cast<Http2ErrorCode>(b->DecodeUInt32());
+}
+
+bool MaybeDecode(Http2GoAwayFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ if (b->Remaining() >= Http2GoAwayFields::EncodedSize()) {
+ DoDecode(out, b);
+ return true;
+ }
+ return false;
+}
+
+bool SlowDecode(Http2GoAwayFields* out, DecodeBuffer* b, uint32_t* offset) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_NE(nullptr, offset);
+ DCHECK_LT(*offset, Http2GoAwayFields::EncodedSize());
+ if (b->SlowDecodeUInt31(0 /* field_offset */, offset, &out->last_stream_id) &&
+ b->SlowDecodeEnum(4 /* field_size */, 4 /* field_offset */, offset,
+ &out->error_code)) {
+ DCHECK_EQ(Http2GoAwayFields::EncodedSize(), *offset);
+ return true;
+ }
+ DCHECK_LT(*offset, Http2GoAwayFields::EncodedSize());
+ return false;
+}
+
+// Http2WindowUpdateFields decoding:
+
+void DoDecode(Http2WindowUpdateFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_LE(Http2WindowUpdateFields::EncodedSize(), b->Remaining());
+ out->window_size_increment = b->DecodeUInt31();
+}
+
+bool MaybeDecode(Http2WindowUpdateFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ if (b->Remaining() >= Http2WindowUpdateFields::EncodedSize()) {
+ DoDecode(out, b);
+ return true;
+ }
+ return false;
+}
+
+bool SlowDecode(Http2WindowUpdateFields* out,
+ DecodeBuffer* b,
+ uint32_t* offset) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_NE(nullptr, offset);
+ DCHECK_LT(*offset, Http2WindowUpdateFields::EncodedSize());
+ if (b->SlowDecodeUInt31(0 /* field_offset */, offset,
+ &out->window_size_increment)) {
+ DCHECK_EQ(Http2WindowUpdateFields::EncodedSize(), *offset);
+ return true;
+ }
+ DCHECK_LT(*offset, Http2WindowUpdateFields::EncodedSize());
+ return false;
+}
+
+// Http2AltSvcFields decoding:
+
+void DoDecode(Http2AltSvcFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_LE(Http2AltSvcFields::EncodedSize(), b->Remaining());
+ out->origin_length = b->DecodeUInt16();
+}
+
+bool MaybeDecode(Http2AltSvcFields* out, DecodeBuffer* b) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ if (b->Remaining() >= Http2AltSvcFields::EncodedSize()) {
+ DoDecode(out, b);
+ return true;
+ }
+ return false;
+}
+
+bool SlowDecode(Http2AltSvcFields* out, DecodeBuffer* b, uint32_t* offset) {
+ DCHECK_NE(nullptr, out);
+ DCHECK_NE(nullptr, b);
+ DCHECK_NE(nullptr, offset);
+ DCHECK_LT(*offset, Http2AltSvcFields::EncodedSize());
+ if (b->SlowDecodeUInt16(0 /* field_offset */, offset, &out->origin_length)) {
+ DCHECK_EQ(Http2AltSvcFields::EncodedSize(), *offset);
+ return true;
+ }
+ DCHECK_LT(*offset, Http2AltSvcFields::EncodedSize());
+ return false;
+}
+
+} // namespace net
« no previous file with comments | « net/http2/decoder/decode_http2_structures.h ('k') | net/http2/decoder/decode_http2_structures_test.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698