chromium/net/third_party/quiche/src/quiche/common/quiche_data_writer.cc

// Copyright (c) 2012 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 "quiche/common/quiche_data_writer.h"

#include <algorithm>
#include <limits>
#include <string>

#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "quiche/common/platform/api/quiche_bug_tracker.h"
#include "quiche/common/quiche_endian.h"

namespace quiche {

QuicheDataWriter::QuicheDataWriter(size_t size, char* buffer)
    : … { … }

QuicheDataWriter::QuicheDataWriter(size_t size, char* buffer,
                                   quiche::Endianness endianness)
    : … { … }

QuicheDataWriter::~QuicheDataWriter() { … }

char* QuicheDataWriter::data() { … }

bool QuicheDataWriter::WriteUInt8(uint8_t value) { … }

bool QuicheDataWriter::WriteUInt16(uint16_t value) { … }

bool QuicheDataWriter::WriteUInt32(uint32_t value) { … }

bool QuicheDataWriter::WriteUInt64(uint64_t value) { … }

bool QuicheDataWriter::WriteBytesToUInt64(size_t num_bytes, uint64_t value) { … }

bool QuicheDataWriter::WriteStringPiece16(absl::string_view val) { … }

bool QuicheDataWriter::WriteStringPiece(absl::string_view val) { … }

char* QuicheDataWriter::BeginWrite(size_t length) { … }

bool QuicheDataWriter::WriteBytes(const void* data, size_t data_len) { … }

bool QuicheDataWriter::WriteRepeatedByte(uint8_t byte, size_t count) { … }

void QuicheDataWriter::WritePadding() { … }

bool QuicheDataWriter::WritePaddingBytes(size_t count) { … }

bool QuicheDataWriter::WriteTag(uint32_t tag) { … }

// Converts a uint64_t into a 62-bit RFC 9000 Variable Length Integer.
//
// Performance notes
//
// Measurements and experiments showed that unrolling the four cases
// like this and dereferencing next_ as we do (*(next_+n)) gains about
// 10% over making a loop and dereferencing it as *(next_++)
//
// Using a register for next didn't help.
//
// Branches are ordered to increase the likelihood of the first being
// taken.
//
// Low-level optimization is useful here because this function will be
// called frequently, leading to outsize benefits.
bool QuicheDataWriter::WriteVarInt62(uint64_t value) { … }

bool QuicheDataWriter::WriteStringPieceVarInt62(
    const absl::string_view& string_piece) { … }

// static
QuicheVariableLengthIntegerLength QuicheDataWriter::GetVarInt62Len(
    uint64_t value) { … }

bool QuicheDataWriter::WriteVarInt62WithForcedLength(
    uint64_t value, QuicheVariableLengthIntegerLength write_length) { … }

bool QuicheDataWriter::Seek(size_t length) { … }

std::string QuicheDataWriter::DebugString() const { … }

}  // namespace quiche