chromium/net/third_party/quiche/src/quiche/common/http/http_header_block.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/http/http_header_block.h"

#include <string.h>

#include <algorithm>
#include <ios>
#include <string>
#include <utility>

#include "absl/strings/str_cat.h"
#include "quiche/common/platform/api/quiche_logging.h"

namespace quiche {
namespace {

// By default, linked_hash_map's internal map allocates space for 100 map
// buckets on construction, which is larger than necessary.  Standard library
// unordered map implementations use a list of prime numbers to set the bucket
// count for a particular capacity.  |kInitialMapBuckets| is chosen to reduce
// memory usage for small header blocks, at the cost of having to rehash for
// large header blocks.
const size_t kInitialMapBuckets = …;

const char kCookieKey[] = …;
const char kNullSeparator = …;

absl::string_view SeparatorForKey(absl::string_view key) { … }

}  // namespace

HttpHeaderBlock::HeaderValue::HeaderValue(HttpHeaderStorage* storage,
                                          absl::string_view key,
                                          absl::string_view initial_value)
    : … { … }

HttpHeaderBlock::HeaderValue::HeaderValue(HeaderValue&& other)
    : … { … }

HttpHeaderBlock::HeaderValue& HttpHeaderBlock::HeaderValue::operator=(
    HeaderValue&& other) { … }

void HttpHeaderBlock::HeaderValue::set_storage(HttpHeaderStorage* storage) { … }

HttpHeaderBlock::HeaderValue::~HeaderValue() = default;

absl::string_view HttpHeaderBlock::HeaderValue::ConsolidatedValue() const { … }

void HttpHeaderBlock::HeaderValue::Append(absl::string_view fragment) { … }

const std::pair<absl::string_view, absl::string_view>&
HttpHeaderBlock::HeaderValue::as_pair() const { … }

HttpHeaderBlock::iterator::iterator(MapType::const_iterator it) : … { … }

HttpHeaderBlock::iterator::iterator(const iterator& other) = default;

HttpHeaderBlock::iterator::~iterator() = default;

HttpHeaderBlock::ValueProxy::ValueProxy(
    HttpHeaderBlock* block, HttpHeaderBlock::MapType::iterator lookup_result,
    const absl::string_view key, size_t* spdy_header_block_value_size)
    : … { … }

HttpHeaderBlock::ValueProxy::ValueProxy(ValueProxy&& other)
    : … { … }

HttpHeaderBlock::ValueProxy& HttpHeaderBlock::ValueProxy::operator=(
    HttpHeaderBlock::ValueProxy&& other) { … }

HttpHeaderBlock::ValueProxy::~ValueProxy() { … }

HttpHeaderBlock::ValueProxy& HttpHeaderBlock::ValueProxy::operator=(
    absl::string_view value) { … }

bool HttpHeaderBlock::ValueProxy::operator==(absl::string_view value) const { … }

std::string HttpHeaderBlock::ValueProxy::as_string() const { … }

HttpHeaderBlock::HttpHeaderBlock() : … { … }

HttpHeaderBlock::HttpHeaderBlock(HttpHeaderBlock&& other)
    : … { … }

HttpHeaderBlock::~HttpHeaderBlock() = default;

HttpHeaderBlock& HttpHeaderBlock::operator=(HttpHeaderBlock&& other) { … }

HttpHeaderBlock HttpHeaderBlock::Clone() const { … }

bool HttpHeaderBlock::operator==(const HttpHeaderBlock& other) const { … }

bool HttpHeaderBlock::operator!=(const HttpHeaderBlock& other) const { … }

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

void HttpHeaderBlock::erase(absl::string_view key) { … }

void HttpHeaderBlock::clear() { … }

HttpHeaderBlock::InsertResult HttpHeaderBlock::insert(
    const HttpHeaderBlock::value_type& value) { … }

HttpHeaderBlock::ValueProxy HttpHeaderBlock::operator[](
    const absl::string_view key) { … }

void HttpHeaderBlock::AppendValueOrAddHeader(const absl::string_view key,
                                             const absl::string_view value) { … }

void HttpHeaderBlock::AppendHeader(const absl::string_view key,
                                   const absl::string_view value) { … }

absl::string_view HttpHeaderBlock::WriteKey(const absl::string_view key) { … }

size_t HttpHeaderBlock::bytes_allocated() const { … }

}  // namespace quiche