logging/rtc_event_log/events/rtc_event_field_encoding_parser.cc - src - Git at Google


 /*
  *  Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */

 #include "logging/rtc_event_log/events/rtc_event_field_encoding_parser.h"

 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "logging/rtc_event_log/encoder/var_int.h"
 #include "logging/rtc_event_log/events/rtc_event_field_encoding.h"
 #include "rtc_base/bitstream_reader.h"
 #include "rtc_base/checks.h"

 namespace {
 absl::optional<webrtc::FieldType> ConvertFieldType(uint64_t value) {
   switch (value) {
     case static_cast<uint64_t>(webrtc::FieldType::kFixed8):
       return webrtc::FieldType::kFixed8;
     case static_cast<uint64_t>(webrtc::FieldType::kFixed32):
       return webrtc::FieldType::kFixed32;
     case static_cast<uint64_t>(webrtc::FieldType::kFixed64):
       return webrtc::FieldType::kFixed64;
     case static_cast<uint64_t>(webrtc::FieldType::kVarInt):
       return webrtc::FieldType::kVarInt;
     case static_cast<uint64_t>(webrtc::FieldType::kString):
       return webrtc::FieldType::kString;
     default:
       return absl::nullopt;
   }
 }
 }  // namespace

 namespace webrtc {

 uint64_t EventParser::ReadLittleEndian(uint8_t bytes) {
   RTC_DCHECK_LE(bytes, sizeof(uint64_t));
   RTC_DCHECK_GE(bytes, 1);

   uint64_t value = 0;

   if (bytes > pending_data_.length()) {
     SetError();
     return value;
   }

   const uint8_t* p = reinterpret_cast<const uint8_t*>(pending_data_.data());
   unsigned int shift = 0;
   uint8_t remaining = bytes;
   while (remaining > 0) {
     value += (static_cast<uint64_t>(*p) << shift);
     shift += 8;
     ++p;
     --remaining;
   }

   pending_data_ = pending_data_.substr(bytes);
   return value;
 }

 uint64_t EventParser::ReadVarInt() {
   uint64_t output = 0;
   bool success;
   std::tie(success, pending_data_) = DecodeVarInt(pending_data_, &output);
   if (!success) {
     SetError();
   }
   return output;
 }

 uint64_t EventParser::ReadOptionalValuePositions() {
   RTC_DCHECK(positions_.empty());
   size_t bits_to_read = NumEventsInBatch();
   positions_.reserve(bits_to_read);
   if (pending_data_.size() * 8 < bits_to_read) {
     SetError();
     return 0;
   }

   BitstreamReader reader(pending_data_);
   for (size_t i = 0; i < bits_to_read; i++) {
     positions_.push_back(reader.ReadBit());
   }
   if (!reader.Ok()) {
     SetError();
     return 0;
   }

   size_t num_existing_values =
       std::count(positions_.begin(), positions_.end(), 1);
   pending_data_ = pending_data_.substr((bits_to_read + 7) / 8);
   return num_existing_values;
 }

 uint64_t EventParser::ReadSingleValue(FieldType field_type) {
   switch (field_type) {
     case FieldType::kFixed8:
       return ReadLittleEndian(/*bytes=*/1);
     case FieldType::kFixed32:
       return ReadLittleEndian(/*bytes=*/4);
     case FieldType::kFixed64:
       return ReadLittleEndian(/*bytes=*/8);
     case FieldType::kVarInt:
       return ReadVarInt();
     case FieldType::kString:
       RTC_DCHECK_NOTREACHED();
       SetError();
       return 0;
   }
   RTC_DCHECK_NOTREACHED();
   SetError();
   return 0;
 }

 void EventParser::ReadDeltasAndPopulateValues(
     FixedLengthEncodingParametersV3 params,
     uint64_t num_deltas,
     uint64_t base) {
   RTC_DCHECK(values_.empty());
   values_.reserve(num_deltas + 1);
   values_.push_back(base);

   if (pending_data_.size() * 8 < num_deltas * params.delta_bit_width()) {
     SetError();
     return;
   }

   BitstreamReader reader(pending_data_);
   const uint64_t top_bit = static_cast<uint64_t>(1)
                            << (params.delta_bit_width() - 1);

   uint64_t value = base;
   for (uint64_t i = 0; i < num_deltas; ++i) {
     uint64_t delta = reader.ReadBits(params.delta_bit_width());
     RTC_DCHECK_LE(value, webrtc_event_logging::MaxUnsignedValueOfBitWidth(
                              params.value_bit_width()));
     RTC_DCHECK_LE(delta, webrtc_event_logging::MaxUnsignedValueOfBitWidth(
                              params.delta_bit_width()));
     bool negative_delta = params.signed_deltas() && ((delta & top_bit) != 0);
     if (negative_delta) {
       uint64_t delta_abs = (~delta & params.delta_mask()) + 1;
       value = (value - delta_abs) & params.value_mask();
     } else {
       value = (value + delta) & params.value_mask();
     }
     values_.push_back(value);
   }

   if (!reader.Ok()) {
     SetError();
     return;
   }

   pending_data_ =
       pending_data_.substr((num_deltas * params.delta_bit_width() + 7) / 8);
 }

 RtcEventLogParseStatus EventParser::Initialize(absl::string_view s,
                                                bool batched) {
   pending_data_ = s;
   num_events_ = 1;

   if (batched) {
     num_events_ = ReadVarInt();
     if (!Ok()) {
       return RtcEventLogParseStatus::Error(
           "Failed to read number of events in batch.", __FILE__, __LINE__);
     }
   }
   return RtcEventLogParseStatus::Success();
 }

 RtcEventLogParseStatus EventParser::ParseNumericFieldInternal(
     uint64_t value_bit_width,
     FieldType field_type) {
   RTC_DCHECK(values_.empty());
   RTC_DCHECK(positions_.empty());

   if (num_events_ == 1) {
     // Just a single value in the batch.
     uint64_t base = ReadSingleValue(field_type);
     if (!Ok()) {
       return RtcEventLogParseStatus::Error("Failed to read value", __FILE__,
                                            __LINE__);
     }
     positions_.push_back(true);
     values_.push_back(base);
   } else {
     // Delta compressed batch.
     // Read delta header.
     uint64_t header_value = ReadVarInt();
     if (!Ok())
       return RtcEventLogParseStatus::Error("Failed to read delta header",
                                            __FILE__, __LINE__);
     // NB: value_bit_width may be incorrect for the field, if this isn't the
     // field we are looking for.
     absl::optional<FixedLengthEncodingParametersV3> delta_header =
         FixedLengthEncodingParametersV3::ParseDeltaHeader(header_value,
                                                           value_bit_width);
     if (!delta_header.has_value()) {
       return RtcEventLogParseStatus::Error("Failed to parse delta header",
                                            __FILE__, __LINE__);
     }

     uint64_t num_existing_deltas = NumEventsInBatch() - 1;
     if (delta_header->values_optional()) {
       size_t num_nonempty_values = ReadOptionalValuePositions();
       if (!Ok()) {
         return RtcEventLogParseStatus::Error(
             "Failed to read positions of optional values", __FILE__, __LINE__);
       }
       if (num_nonempty_values < 1 || NumEventsInBatch() < num_nonempty_values) {
         return RtcEventLogParseStatus::Error(
             "Expected at least one non_empty value", __FILE__, __LINE__);
       }
       num_existing_deltas = num_nonempty_values - 1;
     } else {
       // All elements in the batch have values.
       positions_.assign(NumEventsInBatch(), 1u);
     }

     // Read base.
     uint64_t base = ReadSingleValue(field_type);
     if (!Ok()) {
       return RtcEventLogParseStatus::Error("Failed to read value", __FILE__,
                                            __LINE__);
     }

     if (delta_header->values_equal()) {
       // Duplicate the base value num_existing_deltas times.
       values_.assign(num_existing_deltas + 1, base);
     } else {
       // Read deltas; ceil(num_existing_deltas*delta_width/8) bits
       ReadDeltasAndPopulateValues(delta_header.value(), num_existing_deltas,
                                   base);
       if (!Ok()) {
         return RtcEventLogParseStatus::Error("Failed to decode deltas",
                                              __FILE__, __LINE__);
       }
     }
   }
   return RtcEventLogParseStatus::Success();
 }

 RtcEventLogParseStatus EventParser::ParseStringFieldInternal() {
   RTC_DCHECK(strings_.empty());
   if (num_events_ > 1) {
     // String encoding params reserved for future use.
     uint64_t encoding_params = ReadVarInt();
     if (!Ok()) {
       return RtcEventLogParseStatus::Error("Failed to read string encoding",
                                            __FILE__, __LINE__);
     }
     if (encoding_params != 0) {
       return RtcEventLogParseStatus::Error(
           "Unrecognized string encoding parameters", __FILE__, __LINE__);
     }
   }
   strings_.reserve(num_events_);
   for (uint64_t i = 0; i < num_events_; ++i) {
     // Just a single value in the batch.
     uint64_t size = ReadVarInt();
     if (!Ok()) {
       return RtcEventLogParseStatus::Error("Failed to read string size",
                                            __FILE__, __LINE__);
     }
     if (size > pending_data_.size()) {
       return RtcEventLogParseStatus::Error("String size exceeds remaining data",
                                            __FILE__, __LINE__);
     }
     strings_.push_back(pending_data_.substr(0, size));
     pending_data_ = pending_data_.substr(size);
   }
   return RtcEventLogParseStatus::Success();
 }

 RtcEventLogParseStatus EventParser::ParseField(const FieldParameters& params) {
   // Verify that the event parses fields in increasing order.
   if (params.field_id == FieldParameters::kTimestampField) {
     RTC_DCHECK_EQ(last_field_id_, FieldParameters::kTimestampField);
   } else {
     RTC_DCHECK_GT(params.field_id, last_field_id_);
   }
   last_field_id_ = params.field_id;

   // Initialization for positional fields that don't encode field ID and type.
   uint64_t field_id = params.field_id;
   FieldType field_type = params.field_type;

   // Fields are encoded in increasing field_id order.
   // Skip unknown fields with field_id < params.field_id until we either
   // find params.field_id or a field with higher id, in which case we know that
   // params.field_id doesn't exist.
   while (!pending_data_.empty()) {
     absl::string_view field_start = pending_data_;
     ClearTemporaries();

     // Read tag for non-positional fields.
     if (params.field_id != FieldParameters::kTimestampField) {
       uint64_t field_tag = ReadVarInt();
       if (!Ok())
         return RtcEventLogParseStatus::Error("Failed to read field tag",
                                              __FILE__, __LINE__);
       // Split tag into field ID and field type.
       field_id = field_tag >> 3;
       absl::optional<FieldType> conversion = ConvertFieldType(field_tag & 7u);
       if (!conversion.has_value())
         return RtcEventLogParseStatus::Error("Failed to parse field type",
                                              __FILE__, __LINE__);
       field_type = conversion.value();
     }

     if (field_id > params.field_id) {
       // We've passed all fields with ids less than or equal to what we are
       // looking for. Reset pending_data_ to first field with id higher than
       // params.field_id, since we didn't find the field we were looking for.
       pending_data_ = field_start;
       return RtcEventLogParseStatus::Success();
     }

     if (field_type == FieldType::kString) {
       auto status = ParseStringFieldInternal();
       if (!status.ok()) {
         return status;
       }
     } else {
       auto status = ParseNumericFieldInternal(params.value_width, field_type);
       if (!status.ok()) {
         return status;
       }
     }

     if (field_id == params.field_id) {
       // The field we're looking for has been found and values populated.
       return RtcEventLogParseStatus::Success();
     }
   }

   // Field not found because the event ended.
   ClearTemporaries();
   return RtcEventLogParseStatus::Success();
 }

 RtcEventLogParseStatusOr<rtc::ArrayView<absl::string_view>>
 EventParser::ParseStringField(const FieldParameters& params,
                               bool required_field) {
   using StatusOr = RtcEventLogParseStatusOr<rtc::ArrayView<absl::string_view>>;
   RTC_DCHECK_EQ(params.field_type, FieldType::kString);
   auto status = ParseField(params);
   if (!status.ok())
     return StatusOr(status);
   rtc::ArrayView<absl::string_view> strings = GetStrings();
   if (required_field && strings.size() != NumEventsInBatch()) {
     return StatusOr::Error("Required string field not found", __FILE__,
                            __LINE__);
   }
   return StatusOr(strings);
 }

 RtcEventLogParseStatusOr<rtc::ArrayView<uint64_t>>
 EventParser::ParseNumericField(const FieldParameters& params,
                                bool required_field) {
   using StatusOr = RtcEventLogParseStatusOr<rtc::ArrayView<uint64_t>>;
   RTC_DCHECK_NE(params.field_type, FieldType::kString);
   auto status = ParseField(params);
   if (!status.ok())
     return StatusOr(status);
   rtc::ArrayView<uint64_t> values = GetValues();
   if (required_field && values.size() != NumEventsInBatch()) {
     return StatusOr::Error("Required numerical field not found", __FILE__,
                            __LINE__);
   }
   return StatusOr(values);
 }

 RtcEventLogParseStatusOr<EventParser::ValueAndPostionView>
 EventParser::ParseOptionalNumericField(const FieldParameters& params,
                                        bool required_field) {
   using StatusOr = RtcEventLogParseStatusOr<ValueAndPostionView>;
   RTC_DCHECK_NE(params.field_type, FieldType::kString);
   auto status = ParseField(params);
   if (!status.ok())
     return StatusOr(status);
   ValueAndPostionView view{GetValues(), GetPositions()};
   if (required_field && view.positions.size() != NumEventsInBatch()) {
     return StatusOr::Error("Required numerical field not found", __FILE__,
                            __LINE__);
   }
   return StatusOr(view);
 }

 }  // namespace webrtc

	/*
	* Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
	*
	* Use of this source code is governed by a BSD-style license
	* that can be found in the LICENSE file in the root of the source
	* tree. An additional intellectual property rights grant can be found
	* in the file PATENTS. All contributing project authors may
	* be found in the AUTHORS file in the root of the source tree.
	*/

	#include "logging/rtc_event_log/events/rtc_event_field_encoding_parser.h"

	#include "absl/strings/string_view.h"
	#include "absl/types/optional.h"
	#include "logging/rtc_event_log/encoder/var_int.h"
	#include "logging/rtc_event_log/events/rtc_event_field_encoding.h"
	#include "rtc_base/bitstream_reader.h"
	#include "rtc_base/checks.h"

	namespace {
	absl::optional<webrtc::FieldType> ConvertFieldType(uint64_t value) {
	switch (value) {
	case static_cast<uint64_t>(webrtc::FieldType::kFixed8):
	return webrtc::FieldType::kFixed8;
	case static_cast<uint64_t>(webrtc::FieldType::kFixed32):
	return webrtc::FieldType::kFixed32;
	case static_cast<uint64_t>(webrtc::FieldType::kFixed64):
	return webrtc::FieldType::kFixed64;
	case static_cast<uint64_t>(webrtc::FieldType::kVarInt):
	return webrtc::FieldType::kVarInt;
	case static_cast<uint64_t>(webrtc::FieldType::kString):
	return webrtc::FieldType::kString;
	default:
	return absl::nullopt;
	}
	}
	} // namespace

	namespace webrtc {

	uint64_t EventParser::ReadLittleEndian(uint8_t bytes) {
	RTC_DCHECK_LE(bytes, sizeof(uint64_t));
	RTC_DCHECK_GE(bytes, 1);

	uint64_t value = 0;

	if (bytes > pending_data_.length()) {
	SetError();
	return value;
	}

	const uint8_t* p = reinterpret_cast<const uint8_t*>(pending_data_.data());
	unsigned int shift = 0;
	uint8_t remaining = bytes;
	while (remaining > 0) {
	value += (static_cast<uint64_t>(*p) << shift);
	shift += 8;
	++p;
	--remaining;
	}

	pending_data_ = pending_data_.substr(bytes);
	return value;
	}

	uint64_t EventParser::ReadVarInt() {
	uint64_t output = 0;
	bool success;
	std::tie(success, pending_data_) = DecodeVarInt(pending_data_, &output);
	if (!success) {
	SetError();
	}
	return output;
	}

	uint64_t EventParser::ReadOptionalValuePositions() {
	RTC_DCHECK(positions_.empty());
	size_t bits_to_read = NumEventsInBatch();
	positions_.reserve(bits_to_read);
	if (pending_data_.size() * 8 < bits_to_read) {
	SetError();
	return 0;
	}

	BitstreamReader reader(pending_data_);
	for (size_t i = 0; i < bits_to_read; i++) {
	positions_.push_back(reader.ReadBit());
	}
	if (!reader.Ok()) {
	SetError();
	return 0;
	}

	size_t num_existing_values =
	std::count(positions_.begin(), positions_.end(), 1);
	pending_data_ = pending_data_.substr((bits_to_read + 7) / 8);
	return num_existing_values;
	}

	uint64_t EventParser::ReadSingleValue(FieldType field_type) {
	switch (field_type) {
	case FieldType::kFixed8:
	return ReadLittleEndian(/bytes=/1);
	case FieldType::kFixed32:
	return ReadLittleEndian(/bytes=/4);
	case FieldType::kFixed64:
	return ReadLittleEndian(/bytes=/8);
	case FieldType::kVarInt:
	return ReadVarInt();
	case FieldType::kString:
	RTC_DCHECK_NOTREACHED();
	SetError();
	return 0;
	}
	RTC_DCHECK_NOTREACHED();
	SetError();
	return 0;
	}

	void EventParser::ReadDeltasAndPopulateValues(
	FixedLengthEncodingParametersV3 params,
	uint64_t num_deltas,
	uint64_t base) {
	RTC_DCHECK(values_.empty());
	values_.reserve(num_deltas + 1);
	values_.push_back(base);

	if (pending_data_.size() * 8 < num_deltas * params.delta_bit_width()) {
	SetError();
	return;
	}

	BitstreamReader reader(pending_data_);
	const uint64_t top_bit = static_cast<uint64_t>(1)
	<< (params.delta_bit_width() - 1);

	uint64_t value = base;
	for (uint64_t i = 0; i < num_deltas; ++i) {
	uint64_t delta = reader.ReadBits(params.delta_bit_width());
	RTC_DCHECK_LE(value, webrtc_event_logging::MaxUnsignedValueOfBitWidth(
	params.value_bit_width()));
	RTC_DCHECK_LE(delta, webrtc_event_logging::MaxUnsignedValueOfBitWidth(
	params.delta_bit_width()));
	bool negative_delta = params.signed_deltas() && ((delta & top_bit) != 0);
	if (negative_delta) {
	uint64_t delta_abs = (~delta & params.delta_mask()) + 1;
	value = (value - delta_abs) & params.value_mask();
	} else {
	value = (value + delta) & params.value_mask();
	}
	values_.push_back(value);
	}

	if (!reader.Ok()) {
	SetError();
	return;
	}

	pending_data_ =
	pending_data_.substr((num_deltas * params.delta_bit_width() + 7) / 8);
	}

	RtcEventLogParseStatus EventParser::Initialize(absl::string_view s,
	bool batched) {
	pending_data_ = s;
	num_events_ = 1;

	if (batched) {
	num_events_ = ReadVarInt();
	if (!Ok()) {
	return RtcEventLogParseStatus::Error(
	"Failed to read number of events in batch.", __FILE__, __LINE__);
	}
	}
	return RtcEventLogParseStatus::Success();
	}

	RtcEventLogParseStatus EventParser::ParseNumericFieldInternal(
	uint64_t value_bit_width,
	FieldType field_type) {
	RTC_DCHECK(values_.empty());
	RTC_DCHECK(positions_.empty());

	if (num_events_ == 1) {
	// Just a single value in the batch.
	uint64_t base = ReadSingleValue(field_type);
	if (!Ok()) {
	return RtcEventLogParseStatus::Error("Failed to read value", __FILE__,
	__LINE__);
	}
	positions_.push_back(true);
	values_.push_back(base);
	} else {
	// Delta compressed batch.
	// Read delta header.
	uint64_t header_value = ReadVarInt();
	if (!Ok())
	return RtcEventLogParseStatus::Error("Failed to read delta header",
	__FILE__, __LINE__);
	// NB: value_bit_width may be incorrect for the field, if this isn't the
	// field we are looking for.
	absl::optional<FixedLengthEncodingParametersV3> delta_header =
	FixedLengthEncodingParametersV3::ParseDeltaHeader(header_value,
	value_bit_width);
	if (!delta_header.has_value()) {
	return RtcEventLogParseStatus::Error("Failed to parse delta header",
	__FILE__, __LINE__);
	}

	uint64_t num_existing_deltas = NumEventsInBatch() - 1;
	if (delta_header->values_optional()) {
	size_t num_nonempty_values = ReadOptionalValuePositions();
	if (!Ok()) {
	return RtcEventLogParseStatus::Error(
	"Failed to read positions of optional values", __FILE__, __LINE__);
	}
	if (num_nonempty_values < 1 \|\| NumEventsInBatch() < num_nonempty_values) {
	return RtcEventLogParseStatus::Error(
	"Expected at least one non_empty value", __FILE__, __LINE__);
	}
	num_existing_deltas = num_nonempty_values - 1;
	} else {
	// All elements in the batch have values.
	positions_.assign(NumEventsInBatch(), 1u);
	}

	// Read base.
	uint64_t base = ReadSingleValue(field_type);
	if (!Ok()) {
	return RtcEventLogParseStatus::Error("Failed to read value", __FILE__,
	__LINE__);
	}

	if (delta_header->values_equal()) {
	// Duplicate the base value num_existing_deltas times.
	values_.assign(num_existing_deltas + 1, base);
	} else {
	// Read deltas; ceil(num_existing_deltas*delta_width/8) bits
	ReadDeltasAndPopulateValues(delta_header.value(), num_existing_deltas,
	base);
	if (!Ok()) {
	return RtcEventLogParseStatus::Error("Failed to decode deltas",
	__FILE__, __LINE__);
	}
	}
	}
	return RtcEventLogParseStatus::Success();
	}

	RtcEventLogParseStatus EventParser::ParseStringFieldInternal() {
	RTC_DCHECK(strings_.empty());
	if (num_events_ > 1) {
	// String encoding params reserved for future use.
	uint64_t encoding_params = ReadVarInt();
	if (!Ok()) {
	return RtcEventLogParseStatus::Error("Failed to read string encoding",
	__FILE__, __LINE__);
	}
	if (encoding_params != 0) {
	return RtcEventLogParseStatus::Error(
	"Unrecognized string encoding parameters", __FILE__, __LINE__);
	}
	}
	strings_.reserve(num_events_);
	for (uint64_t i = 0; i < num_events_; ++i) {
	// Just a single value in the batch.
	uint64_t size = ReadVarInt();
	if (!Ok()) {
	return RtcEventLogParseStatus::Error("Failed to read string size",
	__FILE__, __LINE__);
	}
	if (size > pending_data_.size()) {
	return RtcEventLogParseStatus::Error("String size exceeds remaining data",
	__FILE__, __LINE__);
	}
	strings_.push_back(pending_data_.substr(0, size));
	pending_data_ = pending_data_.substr(size);
	}
	return RtcEventLogParseStatus::Success();
	}

	RtcEventLogParseStatus EventParser::ParseField(const FieldParameters& params) {
	// Verify that the event parses fields in increasing order.
	if (params.field_id == FieldParameters::kTimestampField) {
	RTC_DCHECK_EQ(last_field_id_, FieldParameters::kTimestampField);
	} else {
	RTC_DCHECK_GT(params.field_id, last_field_id_);
	}
	last_field_id_ = params.field_id;

	// Initialization for positional fields that don't encode field ID and type.
	uint64_t field_id = params.field_id;
	FieldType field_type = params.field_type;

	// Fields are encoded in increasing field_id order.
	// Skip unknown fields with field_id < params.field_id until we either
	// find params.field_id or a field with higher id, in which case we know that
	// params.field_id doesn't exist.
	while (!pending_data_.empty()) {
	absl::string_view field_start = pending_data_;
	ClearTemporaries();

	// Read tag for non-positional fields.
	if (params.field_id != FieldParameters::kTimestampField) {
	uint64_t field_tag = ReadVarInt();
	if (!Ok())
	return RtcEventLogParseStatus::Error("Failed to read field tag",
	__FILE__, __LINE__);
	// Split tag into field ID and field type.
	field_id = field_tag >> 3;
	absl::optional<FieldType> conversion = ConvertFieldType(field_tag & 7u);
	if (!conversion.has_value())
	return RtcEventLogParseStatus::Error("Failed to parse field type",
	__FILE__, __LINE__);
	field_type = conversion.value();
	}

	if (field_id > params.field_id) {
	// We've passed all fields with ids less than or equal to what we are
	// looking for. Reset pending_data_ to first field with id higher than
	// params.field_id, since we didn't find the field we were looking for.
	pending_data_ = field_start;
	return RtcEventLogParseStatus::Success();
	}

	if (field_type == FieldType::kString) {
	auto status = ParseStringFieldInternal();
	if (!status.ok()) {
	return status;
	}
	} else {
	auto status = ParseNumericFieldInternal(params.value_width, field_type);
	if (!status.ok()) {
	return status;
	}
	}

	if (field_id == params.field_id) {
	// The field we're looking for has been found and values populated.
	return RtcEventLogParseStatus::Success();
	}
	}

	// Field not found because the event ended.
	ClearTemporaries();
	return RtcEventLogParseStatus::Success();
	}

	RtcEventLogParseStatusOr<rtc::ArrayView<absl::string_view>>
	EventParser::ParseStringField(const FieldParameters& params,
	bool required_field) {
	using StatusOr = RtcEventLogParseStatusOr<rtc::ArrayView<absl::string_view>>;
	RTC_DCHECK_EQ(params.field_type, FieldType::kString);
	auto status = ParseField(params);
	if (!status.ok())
	return StatusOr(status);
	rtc::ArrayView<absl::string_view> strings = GetStrings();
	if (required_field && strings.size() != NumEventsInBatch()) {
	return StatusOr::Error("Required string field not found", __FILE__,
	__LINE__);
	}
	return StatusOr(strings);
	}

	RtcEventLogParseStatusOr<rtc::ArrayView<uint64_t>>
	EventParser::ParseNumericField(const FieldParameters& params,
	bool required_field) {
	using StatusOr = RtcEventLogParseStatusOr<rtc::ArrayView<uint64_t>>;
	RTC_DCHECK_NE(params.field_type, FieldType::kString);
	auto status = ParseField(params);
	if (!status.ok())
	return StatusOr(status);
	rtc::ArrayView<uint64_t> values = GetValues();
	if (required_field && values.size() != NumEventsInBatch()) {
	return StatusOr::Error("Required numerical field not found", __FILE__,
	__LINE__);
	}
	return StatusOr(values);
	}

	RtcEventLogParseStatusOr<EventParser::ValueAndPostionView>
	EventParser::ParseOptionalNumericField(const FieldParameters& params,
	bool required_field) {
	using StatusOr = RtcEventLogParseStatusOr<ValueAndPostionView>;
	RTC_DCHECK_NE(params.field_type, FieldType::kString);
	auto status = ParseField(params);
	if (!status.ok())
	return StatusOr(status);
	ValueAndPostionView view{GetValues(), GetPositions()};
	if (required_field && view.positions.size() != NumEventsInBatch()) {
	return StatusOr::Error("Required numerical field not found", __FILE__,
	__LINE__);
	}
	return StatusOr(view);
	}

	} // namespace webrtc