chromium/out/Default/gen/third_party/blink/renderer/core/inspector/protocol/protocol.cc

// This file is generated by Protocol_cpp.template.

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "third_party/blink/renderer/core/inspector/protocol/protocol.h"

#include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>


// This file is generated by Values_cpp.template.

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

//#include "Values.h"

#include "third_party/inspector_protocol/crdtp/cbor.h"

namespace blink {
namespace protocol {

namespace {
Status;
ParserHandler;
span;
namespace cbor {
ParseCBOR;
EncodeBinary;
EncodeDouble;
EncodeFalse;
EncodeFromLatin1;
EncodeFromUTF16;
EncodeIndefiniteLengthArrayStart;
EncodeIndefiniteLengthMapStart;
EncodeInt32;
EncodeNull;
EncodeStop;
EncodeString8;
EncodeTrue;
EnvelopeEncoder;
}  // namespace cbor

// Uses the parsing events received from driver of |ParserHandler|
// (e.g. cbor::ParseCBOR) into a protocol::Value instance.
class ValueParserHandler : public ParserHandler { … };
} // anonymous namespace

// static
std::unique_ptr<Value> Value::parseBinary(const uint8_t* data, size_t size) { … }

bool Value::asBoolean(bool*) const
{ … }

bool Value::asDouble(double*) const
{ … }

bool Value::asInteger(int*) const
{ … }

bool Value::asString(String*) const
{ … }

bool Value::asBinary(Binary*) const
{ … }

void Value::AppendSerialized(std::vector<uint8_t>* bytes) const { … }

std::unique_ptr<Value> Value::clone() const
{ … }

bool FundamentalValue::asBoolean(bool* output) const
{ … }

bool FundamentalValue::asDouble(double* output) const
{ … }

bool FundamentalValue::asInteger(int* output) const
{ … }

void FundamentalValue::AppendSerialized(std::vector<uint8_t>* bytes) const { … }

std::unique_ptr<Value> FundamentalValue::clone() const
{ … }

bool StringValue::asString(String* output) const
{ … }

namespace {
// This routine distinguishes between the current encoding for a given
// string |s|, and calls encoding routines that will
// - Ensure that all ASCII strings end up being encoded as UTF8 in
//   the wire format - e.g., EncodeFromUTF16 will detect ASCII and
//   do the (trivial) transcode to STRING8 on the wire, but if it's
//   not ASCII it'll do STRING16.
// - Select a format that's cheap to convert to. E.g., we don't
//   have LATIN1 on the wire, so we call EncodeFromLatin1 which
//   transcodes to UTF8 if needed.
void EncodeString(const String& s, std::vector<uint8_t>* out) { … }
}  // namespace
void StringValue::AppendSerialized(std::vector<uint8_t>* bytes) const { … }

std::unique_ptr<Value> StringValue::clone() const
{ … }

bool BinaryValue::asBinary(Binary* output) const
{ … }

void BinaryValue::AppendSerialized(std::vector<uint8_t>* bytes) const { … }

std::unique_ptr<Value> BinaryValue::clone() const
{ … }


DictionaryValue::~DictionaryValue()
{ … }

void DictionaryValue::setBoolean(const String& name, bool value)
{ … }

void DictionaryValue::setInteger(const String& name, int value)
{ … }

void DictionaryValue::setDouble(const String& name, double value)
{ … }

void DictionaryValue::setString(const String& name, const String& value)
{ … }

void DictionaryValue::setValue(const String& name, std::unique_ptr<Value> value)
{ … }

void DictionaryValue::setObject(const String& name, std::unique_ptr<DictionaryValue> value)
{ … }

void DictionaryValue::setArray(const String& name, std::unique_ptr<ListValue> value)
{ … }

bool DictionaryValue::getBoolean(const String& name, bool* output) const
{ … }

bool DictionaryValue::getInteger(const String& name, int* output) const
{ … }

bool DictionaryValue::getDouble(const String& name, double* output) const
{ … }

bool DictionaryValue::getString(const String& name, String* output) const
{ … }

DictionaryValue* DictionaryValue::getObject(const String& name) const
{ … }

protocol::ListValue* DictionaryValue::getArray(const String& name) const
{ … }

protocol::Value* DictionaryValue::get(const String& name) const
{ … }

DictionaryValue::Entry DictionaryValue::at(size_t index) const
{ … }

bool DictionaryValue::booleanProperty(const String& name, bool defaultValue) const
{ … }

int DictionaryValue::integerProperty(const String& name, int defaultValue) const
{ … }

double DictionaryValue::doubleProperty(const String& name, double defaultValue) const
{ … }

void DictionaryValue::remove(const String& name)
{ … }

void DictionaryValue::AppendSerialized(std::vector<uint8_t>* bytes) const { … }

std::unique_ptr<Value> DictionaryValue::clone() const
{ … }

DictionaryValue::DictionaryValue()
    : … { … }

ListValue::~ListValue()
{ … }

void ListValue::AppendSerialized(std::vector<uint8_t>* bytes) const { … }

std::unique_ptr<Value> ListValue::clone() const
{ … }

ListValue::ListValue()
    : … { … }

void ListValue::pushValue(std::unique_ptr<protocol::Value> value)
{ … }

protocol::Value* ListValue::at(size_t index)
{ … }

} // namespace blink
} // namespace protocol


// This file is generated by Object_cpp.template.

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

//#include "Object.h"

namespace blink {
namespace protocol {

std::unique_ptr<Object> Object::fromValue(protocol::Value* value, ErrorSupport* errors)
{ … }

// Implements Serializable.
void Object::AppendSerialized(std::vector<uint8_t>* out) const { … }

std::unique_ptr<protocol::DictionaryValue> Object::toValue() const
{ … }

std::unique_ptr<Object> Object::clone() const
{ … }

Object::Object(std::unique_ptr<protocol::DictionaryValue> object) : … { … }

Object::~Object() { … }

} // namespace blink
} // namespace protocol


// This file is generated by ValueConversions_cpp.template.

// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "third_party/blink/renderer/core/inspector/protocol/protocol.h"

#include <algorithm>
#include <climits>
#include <string>

//#include "ValueConversions.h"
//#include "Values.h"

namespace blink {
namespace protocol {

}  // namespace
}  // namespace


namespace crdtp {

namespace {

Binary;
Object;
Value;
String;
DictionaryValue;
FundamentalValue;
StringValue;
StringUtil;
//using blink::protocol::EncodeString;

std::unique_ptr<Value> ReadValue(DeserializerState* state) { … }

}  // namespace

// static
bool ProtocolTypeTraits<std::unique_ptr<Value>>::Deserialize(
    DeserializerState* state, std::unique_ptr<Value>* value) { … }

// static
void ProtocolTypeTraits<std::unique_ptr<Value>>::Serialize(
    const std::unique_ptr<Value>& value, std::vector<uint8_t>* bytes) { … }

// static
bool ProtocolTypeTraits<std::unique_ptr<DictionaryValue>>::Deserialize(
    DeserializerState* state, std::unique_ptr<DictionaryValue>* value) { … }

// static
void ProtocolTypeTraits<std::unique_ptr<DictionaryValue>>::Serialize(
    const std::unique_ptr<DictionaryValue>& value, std::vector<uint8_t>* bytes) { … }

// static
bool ProtocolTypeTraits<std::unique_ptr<Object>>::Deserialize(DeserializerState* state, std::unique_ptr<Object>* value) { … }

void ProtocolTypeTraits<std::unique_ptr<Object>>::Serialize(const std::unique_ptr<Object>& value, std::vector<uint8_t>* bytes) { … }

}  // namespace crdtp