1614 lines
56 KiB
C++
Executable File
1614 lines
56 KiB
C++
Executable File
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: probe_message.proto
|
|
|
|
#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
|
|
#include "probe_message.pb.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include <google/protobuf/stubs/common.h>
|
|
#include <google/protobuf/stubs/port.h>
|
|
#include <google/protobuf/stubs/once.h>
|
|
#include <google/protobuf/io/coded_stream.h>
|
|
#include <google/protobuf/wire_format_lite_inl.h>
|
|
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
|
|
// @@protoc_insertion_point(includes)
|
|
|
|
namespace chrome_browser_net {
|
|
class ProbePacket_HeaderDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<ProbePacket_Header> {
|
|
} _ProbePacket_Header_default_instance_;
|
|
class ProbePacket_TokenDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<ProbePacket_Token> {
|
|
} _ProbePacket_Token_default_instance_;
|
|
class ProbePacketDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<ProbePacket> {
|
|
} _ProbePacket_default_instance_;
|
|
|
|
namespace protobuf_probe_5fmessage_2eproto {
|
|
|
|
PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTableField
|
|
const TableStruct::entries[] = {
|
|
{0, 0, 0, ::google::protobuf::internal::kInvalidMask, 0, 0},
|
|
};
|
|
|
|
PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::AuxillaryParseTableField
|
|
const TableStruct::aux[] = {
|
|
::google::protobuf::internal::AuxillaryParseTableField(),
|
|
};
|
|
PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTable const
|
|
TableStruct::schema[] = {
|
|
{ NULL, NULL, 0, -1, -1, false },
|
|
{ NULL, NULL, 0, -1, -1, false },
|
|
{ NULL, NULL, 0, -1, -1, false },
|
|
};
|
|
|
|
|
|
void TableStruct::Shutdown() {
|
|
_ProbePacket_Header_default_instance_.Shutdown();
|
|
_ProbePacket_Token_default_instance_.Shutdown();
|
|
_ProbePacket_default_instance_.Shutdown();
|
|
}
|
|
|
|
void TableStruct::InitDefaultsImpl() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
::google::protobuf::internal::InitProtobufDefaults();
|
|
_ProbePacket_Header_default_instance_.DefaultConstruct();
|
|
_ProbePacket_Token_default_instance_.DefaultConstruct();
|
|
_ProbePacket_default_instance_.DefaultConstruct();
|
|
_ProbePacket_default_instance_.get_mutable()->header_ = const_cast< ::chrome_browser_net::ProbePacket_Header*>(
|
|
::chrome_browser_net::ProbePacket_Header::internal_default_instance());
|
|
_ProbePacket_default_instance_.get_mutable()->token_ = const_cast< ::chrome_browser_net::ProbePacket_Token*>(
|
|
::chrome_browser_net::ProbePacket_Token::internal_default_instance());
|
|
}
|
|
|
|
void InitDefaults() {
|
|
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
|
|
::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
|
|
}
|
|
void AddDescriptorsImpl() {
|
|
InitDefaults();
|
|
::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);
|
|
}
|
|
|
|
void AddDescriptors() {
|
|
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
|
|
::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
|
|
}
|
|
|
|
} // namespace protobuf_probe_5fmessage_2eproto
|
|
|
|
bool ProbePacket_Type_IsValid(int value) {
|
|
switch (value) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#if !defined(_MSC_VER) || _MSC_VER >= 1900
|
|
const ProbePacket_Type ProbePacket::UNKNOWN;
|
|
const ProbePacket_Type ProbePacket::HELLO_REQUEST;
|
|
const ProbePacket_Type ProbePacket::HELLO_REPLY;
|
|
const ProbePacket_Type ProbePacket::PROBE_REQUEST;
|
|
const ProbePacket_Type ProbePacket::PROBE_REPLY;
|
|
const ProbePacket_Type ProbePacket::Type_MIN;
|
|
const ProbePacket_Type ProbePacket::Type_MAX;
|
|
const int ProbePacket::Type_ARRAYSIZE;
|
|
#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
|
|
|
|
// ===================================================================
|
|
|
|
#if !defined(_MSC_VER) || _MSC_VER >= 1900
|
|
const int ProbePacket_Header::kVersionFieldNumber;
|
|
const int ProbePacket_Header::kChecksumFieldNumber;
|
|
const int ProbePacket_Header::kTypeFieldNumber;
|
|
#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
|
|
|
|
ProbePacket_Header::ProbePacket_Header()
|
|
: ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
|
|
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
|
|
protobuf_probe_5fmessage_2eproto::InitDefaults();
|
|
}
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:chrome_browser_net.ProbePacket.Header)
|
|
}
|
|
ProbePacket_Header::ProbePacket_Header(const ProbePacket_Header& from)
|
|
: ::google::protobuf::MessageLite(),
|
|
_internal_metadata_(NULL),
|
|
_has_bits_(from._has_bits_),
|
|
_cached_size_(0) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::memcpy(&version_, &from.version_,
|
|
static_cast<size_t>(reinterpret_cast<char*>(&type_) -
|
|
reinterpret_cast<char*>(&version_)) + sizeof(type_));
|
|
// @@protoc_insertion_point(copy_constructor:chrome_browser_net.ProbePacket.Header)
|
|
}
|
|
|
|
void ProbePacket_Header::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
::memset(&version_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&type_) -
|
|
reinterpret_cast<char*>(&version_)) + sizeof(type_));
|
|
}
|
|
|
|
ProbePacket_Header::~ProbePacket_Header() {
|
|
// @@protoc_insertion_point(destructor:chrome_browser_net.ProbePacket.Header)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ProbePacket_Header::SharedDtor() {
|
|
}
|
|
|
|
void ProbePacket_Header::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ProbePacket_Header& ProbePacket_Header::default_instance() {
|
|
protobuf_probe_5fmessage_2eproto::InitDefaults();
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
ProbePacket_Header* ProbePacket_Header::New(::google::protobuf::Arena* arena) const {
|
|
ProbePacket_Header* n = new ProbePacket_Header;
|
|
if (arena != NULL) {
|
|
arena->Own(n);
|
|
}
|
|
return n;
|
|
}
|
|
|
|
void ProbePacket_Header::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:chrome_browser_net.ProbePacket.Header)
|
|
if (_has_bits_[0 / 32] & 7u) {
|
|
::memset(&version_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&type_) -
|
|
reinterpret_cast<char*>(&version_)) + sizeof(type_));
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
bool ProbePacket_Header::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
|
|
::google::protobuf::uint32 tag;
|
|
::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
|
|
::google::protobuf::NewPermanentCallback(&_internal_metadata_,
|
|
&::google::protobuf::internal::InternalMetadataWithArenaLite::
|
|
mutable_unknown_fields));
|
|
::google::protobuf::io::CodedOutputStream unknown_fields_stream(
|
|
&unknown_fields_string, false);
|
|
// @@protoc_insertion_point(parse_start:chrome_browser_net.ProbePacket.Header)
|
|
for (;;) {
|
|
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
|
|
tag = p.first;
|
|
if (!p.second) goto handle_unusual;
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required uint32 version = 1;
|
|
case 1: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(8u)) {
|
|
set_has_version();
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &version_)));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// optional uint32 checksum = 2;
|
|
case 2: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(16u)) {
|
|
set_has_checksum();
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &checksum_)));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// optional .chrome_browser_net.ProbePacket.Type type = 3;
|
|
case 3: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(24u)) {
|
|
int value;
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
|
|
input, &value)));
|
|
if (::chrome_browser_net::ProbePacket_Type_IsValid(value)) {
|
|
set_type(static_cast< ::chrome_browser_net::ProbePacket_Type >(value));
|
|
} else {
|
|
unknown_fields_stream.WriteVarint32(24u);
|
|
unknown_fields_stream.WriteVarint32(
|
|
static_cast< ::google::protobuf::uint32>(value));
|
|
}
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_unusual:
|
|
if (tag == 0 ||
|
|
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
goto success;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormatLite::SkipField(
|
|
input, tag, &unknown_fields_stream));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
success:
|
|
// @@protoc_insertion_point(parse_success:chrome_browser_net.ProbePacket.Header)
|
|
return true;
|
|
failure:
|
|
// @@protoc_insertion_point(parse_failure:chrome_browser_net.ProbePacket.Header)
|
|
return false;
|
|
#undef DO_
|
|
}
|
|
|
|
void ProbePacket_Header::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// @@protoc_insertion_point(serialize_start:chrome_browser_net.ProbePacket.Header)
|
|
::google::protobuf::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// required uint32 version = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->version(), output);
|
|
}
|
|
|
|
// optional uint32 checksum = 2;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->checksum(), output);
|
|
}
|
|
|
|
// optional .chrome_browser_net.ProbePacket.Type type = 3;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteEnum(
|
|
3, this->type(), output);
|
|
}
|
|
|
|
output->WriteRaw(unknown_fields().data(),
|
|
static_cast<int>(unknown_fields().size()));
|
|
// @@protoc_insertion_point(serialize_end:chrome_browser_net.ProbePacket.Header)
|
|
}
|
|
|
|
size_t ProbePacket_Header::ByteSizeLong() const {
|
|
// @@protoc_insertion_point(message_byte_size_start:chrome_browser_net.ProbePacket.Header)
|
|
size_t total_size = 0;
|
|
|
|
total_size += unknown_fields().size();
|
|
|
|
// required uint32 version = 1;
|
|
if (has_version()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->version());
|
|
}
|
|
if (_has_bits_[0 / 32] & 6u) {
|
|
// optional uint32 checksum = 2;
|
|
if (has_checksum()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->checksum());
|
|
}
|
|
|
|
// optional .chrome_browser_net.ProbePacket.Type type = 3;
|
|
if (has_type()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
|
|
}
|
|
|
|
}
|
|
int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = cached_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void ProbePacket_Header::CheckTypeAndMergeFrom(
|
|
const ::google::protobuf::MessageLite& from) {
|
|
MergeFrom(*::google::protobuf::down_cast<const ProbePacket_Header*>(&from));
|
|
}
|
|
|
|
void ProbePacket_Header::MergeFrom(const ProbePacket_Header& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:chrome_browser_net.ProbePacket.Header)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::google::protobuf::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 7u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
version_ = from.version_;
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
checksum_ = from.checksum_;
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
type_ = from.type_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
}
|
|
|
|
void ProbePacket_Header::CopyFrom(const ProbePacket_Header& from) {
|
|
// @@protoc_insertion_point(class_specific_copy_from_start:chrome_browser_net.ProbePacket.Header)
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool ProbePacket_Header::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
|
|
return true;
|
|
}
|
|
|
|
void ProbePacket_Header::Swap(ProbePacket_Header* other) {
|
|
if (other == this) return;
|
|
InternalSwap(other);
|
|
}
|
|
void ProbePacket_Header::InternalSwap(ProbePacket_Header* other) {
|
|
std::swap(version_, other->version_);
|
|
std::swap(checksum_, other->checksum_);
|
|
std::swap(type_, other->type_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
|
|
::std::string ProbePacket_Header::GetTypeName() const {
|
|
return "chrome_browser_net.ProbePacket.Header";
|
|
}
|
|
|
|
#if PROTOBUF_INLINE_NOT_IN_HEADERS
|
|
// ProbePacket_Header
|
|
|
|
// required uint32 version = 1;
|
|
bool ProbePacket_Header::has_version() const {
|
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
|
}
|
|
void ProbePacket_Header::set_has_version() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
}
|
|
void ProbePacket_Header::clear_has_version() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
void ProbePacket_Header::clear_version() {
|
|
version_ = 0u;
|
|
clear_has_version();
|
|
}
|
|
::google::protobuf::uint32 ProbePacket_Header::version() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.Header.version)
|
|
return version_;
|
|
}
|
|
void ProbePacket_Header::set_version(::google::protobuf::uint32 value) {
|
|
set_has_version();
|
|
version_ = value;
|
|
// @@protoc_insertion_point(field_set:chrome_browser_net.ProbePacket.Header.version)
|
|
}
|
|
|
|
// optional uint32 checksum = 2;
|
|
bool ProbePacket_Header::has_checksum() const {
|
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
|
}
|
|
void ProbePacket_Header::set_has_checksum() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
}
|
|
void ProbePacket_Header::clear_has_checksum() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
void ProbePacket_Header::clear_checksum() {
|
|
checksum_ = 0u;
|
|
clear_has_checksum();
|
|
}
|
|
::google::protobuf::uint32 ProbePacket_Header::checksum() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.Header.checksum)
|
|
return checksum_;
|
|
}
|
|
void ProbePacket_Header::set_checksum(::google::protobuf::uint32 value) {
|
|
set_has_checksum();
|
|
checksum_ = value;
|
|
// @@protoc_insertion_point(field_set:chrome_browser_net.ProbePacket.Header.checksum)
|
|
}
|
|
|
|
// optional .chrome_browser_net.ProbePacket.Type type = 3;
|
|
bool ProbePacket_Header::has_type() const {
|
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
|
}
|
|
void ProbePacket_Header::set_has_type() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
}
|
|
void ProbePacket_Header::clear_has_type() {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
void ProbePacket_Header::clear_type() {
|
|
type_ = 0;
|
|
clear_has_type();
|
|
}
|
|
::chrome_browser_net::ProbePacket_Type ProbePacket_Header::type() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.Header.type)
|
|
return static_cast< ::chrome_browser_net::ProbePacket_Type >(type_);
|
|
}
|
|
void ProbePacket_Header::set_type(::chrome_browser_net::ProbePacket_Type value) {
|
|
assert(::chrome_browser_net::ProbePacket_Type_IsValid(value));
|
|
set_has_type();
|
|
type_ = value;
|
|
// @@protoc_insertion_point(field_set:chrome_browser_net.ProbePacket.Header.type)
|
|
}
|
|
|
|
#endif // PROTOBUF_INLINE_NOT_IN_HEADERS
|
|
|
|
// ===================================================================
|
|
|
|
#if !defined(_MSC_VER) || _MSC_VER >= 1900
|
|
const int ProbePacket_Token::kTimestampMicrosFieldNumber;
|
|
const int ProbePacket_Token::kHashFieldNumber;
|
|
#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
|
|
|
|
ProbePacket_Token::ProbePacket_Token()
|
|
: ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
|
|
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
|
|
protobuf_probe_5fmessage_2eproto::InitDefaults();
|
|
}
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:chrome_browser_net.ProbePacket.Token)
|
|
}
|
|
ProbePacket_Token::ProbePacket_Token(const ProbePacket_Token& from)
|
|
: ::google::protobuf::MessageLite(),
|
|
_internal_metadata_(NULL),
|
|
_has_bits_(from._has_bits_),
|
|
_cached_size_(0) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
hash_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
if (from.has_hash()) {
|
|
hash_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.hash_);
|
|
}
|
|
timestamp_micros_ = from.timestamp_micros_;
|
|
// @@protoc_insertion_point(copy_constructor:chrome_browser_net.ProbePacket.Token)
|
|
}
|
|
|
|
void ProbePacket_Token::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
hash_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
timestamp_micros_ = GOOGLE_ULONGLONG(0);
|
|
}
|
|
|
|
ProbePacket_Token::~ProbePacket_Token() {
|
|
// @@protoc_insertion_point(destructor:chrome_browser_net.ProbePacket.Token)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ProbePacket_Token::SharedDtor() {
|
|
hash_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
void ProbePacket_Token::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ProbePacket_Token& ProbePacket_Token::default_instance() {
|
|
protobuf_probe_5fmessage_2eproto::InitDefaults();
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
ProbePacket_Token* ProbePacket_Token::New(::google::protobuf::Arena* arena) const {
|
|
ProbePacket_Token* n = new ProbePacket_Token;
|
|
if (arena != NULL) {
|
|
arena->Own(n);
|
|
}
|
|
return n;
|
|
}
|
|
|
|
void ProbePacket_Token::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:chrome_browser_net.ProbePacket.Token)
|
|
if (has_hash()) {
|
|
GOOGLE_DCHECK(!hash_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
|
|
(*hash_.UnsafeRawStringPointer())->clear();
|
|
}
|
|
timestamp_micros_ = GOOGLE_ULONGLONG(0);
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
bool ProbePacket_Token::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
|
|
::google::protobuf::uint32 tag;
|
|
::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
|
|
::google::protobuf::NewPermanentCallback(&_internal_metadata_,
|
|
&::google::protobuf::internal::InternalMetadataWithArenaLite::
|
|
mutable_unknown_fields));
|
|
::google::protobuf::io::CodedOutputStream unknown_fields_stream(
|
|
&unknown_fields_string, false);
|
|
// @@protoc_insertion_point(parse_start:chrome_browser_net.ProbePacket.Token)
|
|
for (;;) {
|
|
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
|
|
tag = p.first;
|
|
if (!p.second) goto handle_unusual;
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required uint64 timestamp_micros = 1;
|
|
case 1: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(8u)) {
|
|
set_has_timestamp_micros();
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
|
|
input, ×tamp_micros_)));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// required bytes hash = 2;
|
|
case 2: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(18u)) {
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
|
|
input, this->mutable_hash()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_unusual:
|
|
if (tag == 0 ||
|
|
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
goto success;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormatLite::SkipField(
|
|
input, tag, &unknown_fields_stream));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
success:
|
|
// @@protoc_insertion_point(parse_success:chrome_browser_net.ProbePacket.Token)
|
|
return true;
|
|
failure:
|
|
// @@protoc_insertion_point(parse_failure:chrome_browser_net.ProbePacket.Token)
|
|
return false;
|
|
#undef DO_
|
|
}
|
|
|
|
void ProbePacket_Token::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// @@protoc_insertion_point(serialize_start:chrome_browser_net.ProbePacket.Token)
|
|
::google::protobuf::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// required uint64 timestamp_micros = 1;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->timestamp_micros(), output);
|
|
}
|
|
|
|
// required bytes hash = 2;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
|
|
2, this->hash(), output);
|
|
}
|
|
|
|
output->WriteRaw(unknown_fields().data(),
|
|
static_cast<int>(unknown_fields().size()));
|
|
// @@protoc_insertion_point(serialize_end:chrome_browser_net.ProbePacket.Token)
|
|
}
|
|
|
|
size_t ProbePacket_Token::RequiredFieldsByteSizeFallback() const {
|
|
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:chrome_browser_net.ProbePacket.Token)
|
|
size_t total_size = 0;
|
|
|
|
if (has_hash()) {
|
|
// required bytes hash = 2;
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::BytesSize(
|
|
this->hash());
|
|
}
|
|
|
|
if (has_timestamp_micros()) {
|
|
// required uint64 timestamp_micros = 1;
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt64Size(
|
|
this->timestamp_micros());
|
|
}
|
|
|
|
return total_size;
|
|
}
|
|
size_t ProbePacket_Token::ByteSizeLong() const {
|
|
// @@protoc_insertion_point(message_byte_size_start:chrome_browser_net.ProbePacket.Token)
|
|
size_t total_size = 0;
|
|
|
|
total_size += unknown_fields().size();
|
|
|
|
if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) { // All required fields are present.
|
|
// required bytes hash = 2;
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::BytesSize(
|
|
this->hash());
|
|
|
|
// required uint64 timestamp_micros = 1;
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt64Size(
|
|
this->timestamp_micros());
|
|
|
|
} else {
|
|
total_size += RequiredFieldsByteSizeFallback();
|
|
}
|
|
int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = cached_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void ProbePacket_Token::CheckTypeAndMergeFrom(
|
|
const ::google::protobuf::MessageLite& from) {
|
|
MergeFrom(*::google::protobuf::down_cast<const ProbePacket_Token*>(&from));
|
|
}
|
|
|
|
void ProbePacket_Token::MergeFrom(const ProbePacket_Token& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:chrome_browser_net.ProbePacket.Token)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::google::protobuf::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 3u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
set_has_hash();
|
|
hash_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.hash_);
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
timestamp_micros_ = from.timestamp_micros_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
}
|
|
|
|
void ProbePacket_Token::CopyFrom(const ProbePacket_Token& from) {
|
|
// @@protoc_insertion_point(class_specific_copy_from_start:chrome_browser_net.ProbePacket.Token)
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool ProbePacket_Token::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
|
|
return true;
|
|
}
|
|
|
|
void ProbePacket_Token::Swap(ProbePacket_Token* other) {
|
|
if (other == this) return;
|
|
InternalSwap(other);
|
|
}
|
|
void ProbePacket_Token::InternalSwap(ProbePacket_Token* other) {
|
|
hash_.Swap(&other->hash_);
|
|
std::swap(timestamp_micros_, other->timestamp_micros_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
|
|
::std::string ProbePacket_Token::GetTypeName() const {
|
|
return "chrome_browser_net.ProbePacket.Token";
|
|
}
|
|
|
|
#if PROTOBUF_INLINE_NOT_IN_HEADERS
|
|
// ProbePacket_Token
|
|
|
|
// required uint64 timestamp_micros = 1;
|
|
bool ProbePacket_Token::has_timestamp_micros() const {
|
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
|
}
|
|
void ProbePacket_Token::set_has_timestamp_micros() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
}
|
|
void ProbePacket_Token::clear_has_timestamp_micros() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
void ProbePacket_Token::clear_timestamp_micros() {
|
|
timestamp_micros_ = GOOGLE_ULONGLONG(0);
|
|
clear_has_timestamp_micros();
|
|
}
|
|
::google::protobuf::uint64 ProbePacket_Token::timestamp_micros() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.Token.timestamp_micros)
|
|
return timestamp_micros_;
|
|
}
|
|
void ProbePacket_Token::set_timestamp_micros(::google::protobuf::uint64 value) {
|
|
set_has_timestamp_micros();
|
|
timestamp_micros_ = value;
|
|
// @@protoc_insertion_point(field_set:chrome_browser_net.ProbePacket.Token.timestamp_micros)
|
|
}
|
|
|
|
// required bytes hash = 2;
|
|
bool ProbePacket_Token::has_hash() const {
|
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
|
}
|
|
void ProbePacket_Token::set_has_hash() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
}
|
|
void ProbePacket_Token::clear_has_hash() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
void ProbePacket_Token::clear_hash() {
|
|
hash_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
clear_has_hash();
|
|
}
|
|
const ::std::string& ProbePacket_Token::hash() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.Token.hash)
|
|
return hash_.GetNoArena();
|
|
}
|
|
void ProbePacket_Token::set_hash(const ::std::string& value) {
|
|
set_has_hash();
|
|
hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set:chrome_browser_net.ProbePacket.Token.hash)
|
|
}
|
|
#if LANG_CXX11
|
|
void ProbePacket_Token::set_hash(::std::string&& value) {
|
|
set_has_hash();
|
|
hash_.SetNoArena(
|
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
|
// @@protoc_insertion_point(field_set_rvalue:chrome_browser_net.ProbePacket.Token.hash)
|
|
}
|
|
#endif
|
|
void ProbePacket_Token::set_hash(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
set_has_hash();
|
|
hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
|
// @@protoc_insertion_point(field_set_char:chrome_browser_net.ProbePacket.Token.hash)
|
|
}
|
|
void ProbePacket_Token::set_hash(const void* value, size_t size) {
|
|
set_has_hash();
|
|
hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
::std::string(reinterpret_cast<const char*>(value), size));
|
|
// @@protoc_insertion_point(field_set_pointer:chrome_browser_net.ProbePacket.Token.hash)
|
|
}
|
|
::std::string* ProbePacket_Token::mutable_hash() {
|
|
set_has_hash();
|
|
// @@protoc_insertion_point(field_mutable:chrome_browser_net.ProbePacket.Token.hash)
|
|
return hash_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
::std::string* ProbePacket_Token::release_hash() {
|
|
// @@protoc_insertion_point(field_release:chrome_browser_net.ProbePacket.Token.hash)
|
|
clear_has_hash();
|
|
return hash_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
void ProbePacket_Token::set_allocated_hash(::std::string* hash) {
|
|
if (hash != NULL) {
|
|
set_has_hash();
|
|
} else {
|
|
clear_has_hash();
|
|
}
|
|
hash_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), hash);
|
|
// @@protoc_insertion_point(field_set_allocated:chrome_browser_net.ProbePacket.Token.hash)
|
|
}
|
|
|
|
#endif // PROTOBUF_INLINE_NOT_IN_HEADERS
|
|
|
|
// ===================================================================
|
|
|
|
#if !defined(_MSC_VER) || _MSC_VER >= 1900
|
|
const int ProbePacket::kHeaderFieldNumber;
|
|
const int ProbePacket::kTokenFieldNumber;
|
|
const int ProbePacket::kGroupIdFieldNumber;
|
|
const int ProbePacket::kPacketIndexFieldNumber;
|
|
const int ProbePacket::kProbeSizeBytesFieldNumber;
|
|
const int ProbePacket::kPacingIntervalMicrosFieldNumber;
|
|
const int ProbePacket::kNumberProbePacketsFieldNumber;
|
|
const int ProbePacket::kServerProcessingMicrosFieldNumber;
|
|
const int ProbePacket::kPaddingFieldNumber;
|
|
#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
|
|
|
|
ProbePacket::ProbePacket()
|
|
: ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
|
|
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
|
|
protobuf_probe_5fmessage_2eproto::InitDefaults();
|
|
}
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:chrome_browser_net.ProbePacket)
|
|
}
|
|
ProbePacket::ProbePacket(const ProbePacket& from)
|
|
: ::google::protobuf::MessageLite(),
|
|
_internal_metadata_(NULL),
|
|
_has_bits_(from._has_bits_),
|
|
_cached_size_(0) {
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
padding_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
if (from.has_padding()) {
|
|
padding_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.padding_);
|
|
}
|
|
if (from.has_header()) {
|
|
header_ = new ::chrome_browser_net::ProbePacket_Header(*from.header_);
|
|
} else {
|
|
header_ = NULL;
|
|
}
|
|
if (from.has_token()) {
|
|
token_ = new ::chrome_browser_net::ProbePacket_Token(*from.token_);
|
|
} else {
|
|
token_ = NULL;
|
|
}
|
|
::memcpy(&group_id_, &from.group_id_,
|
|
static_cast<size_t>(reinterpret_cast<char*>(&number_probe_packets_) -
|
|
reinterpret_cast<char*>(&group_id_)) + sizeof(number_probe_packets_));
|
|
// @@protoc_insertion_point(copy_constructor:chrome_browser_net.ProbePacket)
|
|
}
|
|
|
|
void ProbePacket::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
padding_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
::memset(&header_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&number_probe_packets_) -
|
|
reinterpret_cast<char*>(&header_)) + sizeof(number_probe_packets_));
|
|
}
|
|
|
|
ProbePacket::~ProbePacket() {
|
|
// @@protoc_insertion_point(destructor:chrome_browser_net.ProbePacket)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ProbePacket::SharedDtor() {
|
|
padding_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
if (this != internal_default_instance()) {
|
|
delete header_;
|
|
}
|
|
if (this != internal_default_instance()) {
|
|
delete token_;
|
|
}
|
|
}
|
|
|
|
void ProbePacket::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ProbePacket& ProbePacket::default_instance() {
|
|
protobuf_probe_5fmessage_2eproto::InitDefaults();
|
|
return *internal_default_instance();
|
|
}
|
|
|
|
ProbePacket* ProbePacket::New(::google::protobuf::Arena* arena) const {
|
|
ProbePacket* n = new ProbePacket;
|
|
if (arena != NULL) {
|
|
arena->Own(n);
|
|
}
|
|
return n;
|
|
}
|
|
|
|
void ProbePacket::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:chrome_browser_net.ProbePacket)
|
|
if (_has_bits_[0 / 32] & 7u) {
|
|
if (has_padding()) {
|
|
GOOGLE_DCHECK(!padding_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
|
|
(*padding_.UnsafeRawStringPointer())->clear();
|
|
}
|
|
if (has_header()) {
|
|
GOOGLE_DCHECK(header_ != NULL);
|
|
header_->::chrome_browser_net::ProbePacket_Header::Clear();
|
|
}
|
|
if (has_token()) {
|
|
GOOGLE_DCHECK(token_ != NULL);
|
|
token_->::chrome_browser_net::ProbePacket_Token::Clear();
|
|
}
|
|
}
|
|
if (_has_bits_[0 / 32] & 248u) {
|
|
::memset(&group_id_, 0, static_cast<size_t>(
|
|
reinterpret_cast<char*>(&server_processing_micros_) -
|
|
reinterpret_cast<char*>(&group_id_)) + sizeof(server_processing_micros_));
|
|
}
|
|
number_probe_packets_ = 0u;
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear();
|
|
}
|
|
|
|
bool ProbePacket::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
|
|
::google::protobuf::uint32 tag;
|
|
::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
|
|
::google::protobuf::NewPermanentCallback(&_internal_metadata_,
|
|
&::google::protobuf::internal::InternalMetadataWithArenaLite::
|
|
mutable_unknown_fields));
|
|
::google::protobuf::io::CodedOutputStream unknown_fields_stream(
|
|
&unknown_fields_string, false);
|
|
// @@protoc_insertion_point(parse_start:chrome_browser_net.ProbePacket)
|
|
for (;;) {
|
|
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
|
|
tag = p.first;
|
|
if (!p.second) goto handle_unusual;
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// optional .chrome_browser_net.ProbePacket.Header header = 1;
|
|
case 1: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(10u)) {
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_header()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// optional .chrome_browser_net.ProbePacket.Token token = 2;
|
|
case 2: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(18u)) {
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_token()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// optional uint32 group_id = 3;
|
|
case 3: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(24u)) {
|
|
set_has_group_id();
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &group_id_)));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// optional uint32 packet_index = 4;
|
|
case 4: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(32u)) {
|
|
set_has_packet_index();
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &packet_index_)));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// optional uint32 probe_size_bytes = 5;
|
|
case 5: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(40u)) {
|
|
set_has_probe_size_bytes();
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &probe_size_bytes_)));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// optional uint32 pacing_interval_micros = 6;
|
|
case 6: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(48u)) {
|
|
set_has_pacing_interval_micros();
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &pacing_interval_micros_)));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// optional uint32 number_probe_packets = 7;
|
|
case 7: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(56u)) {
|
|
set_has_number_probe_packets();
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &number_probe_packets_)));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// optional bytes padding = 8;
|
|
case 8: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(66u)) {
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
|
|
input, this->mutable_padding()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// optional int64 server_processing_micros = 9;
|
|
case 9: {
|
|
if (static_cast< ::google::protobuf::uint8>(tag) ==
|
|
static_cast< ::google::protobuf::uint8>(72u)) {
|
|
set_has_server_processing_micros();
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
|
|
input, &server_processing_micros_)));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_unusual:
|
|
if (tag == 0 ||
|
|
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
goto success;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormatLite::SkipField(
|
|
input, tag, &unknown_fields_stream));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
success:
|
|
// @@protoc_insertion_point(parse_success:chrome_browser_net.ProbePacket)
|
|
return true;
|
|
failure:
|
|
// @@protoc_insertion_point(parse_failure:chrome_browser_net.ProbePacket)
|
|
return false;
|
|
#undef DO_
|
|
}
|
|
|
|
void ProbePacket::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// @@protoc_insertion_point(serialize_start:chrome_browser_net.ProbePacket)
|
|
::google::protobuf::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .chrome_browser_net.ProbePacket.Header header = 1;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessage(
|
|
1, *this->header_, output);
|
|
}
|
|
|
|
// optional .chrome_browser_net.ProbePacket.Token token = 2;
|
|
if (cached_has_bits & 0x00000004u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessage(
|
|
2, *this->token_, output);
|
|
}
|
|
|
|
// optional uint32 group_id = 3;
|
|
if (cached_has_bits & 0x00000008u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->group_id(), output);
|
|
}
|
|
|
|
// optional uint32 packet_index = 4;
|
|
if (cached_has_bits & 0x00000010u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->packet_index(), output);
|
|
}
|
|
|
|
// optional uint32 probe_size_bytes = 5;
|
|
if (cached_has_bits & 0x00000020u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->probe_size_bytes(), output);
|
|
}
|
|
|
|
// optional uint32 pacing_interval_micros = 6;
|
|
if (cached_has_bits & 0x00000040u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->pacing_interval_micros(), output);
|
|
}
|
|
|
|
// optional uint32 number_probe_packets = 7;
|
|
if (cached_has_bits & 0x00000100u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->number_probe_packets(), output);
|
|
}
|
|
|
|
// optional bytes padding = 8;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
|
|
8, this->padding(), output);
|
|
}
|
|
|
|
// optional int64 server_processing_micros = 9;
|
|
if (cached_has_bits & 0x00000080u) {
|
|
::google::protobuf::internal::WireFormatLite::WriteInt64(9, this->server_processing_micros(), output);
|
|
}
|
|
|
|
output->WriteRaw(unknown_fields().data(),
|
|
static_cast<int>(unknown_fields().size()));
|
|
// @@protoc_insertion_point(serialize_end:chrome_browser_net.ProbePacket)
|
|
}
|
|
|
|
size_t ProbePacket::ByteSizeLong() const {
|
|
// @@protoc_insertion_point(message_byte_size_start:chrome_browser_net.ProbePacket)
|
|
size_t total_size = 0;
|
|
|
|
total_size += unknown_fields().size();
|
|
|
|
if (_has_bits_[0 / 32] & 255u) {
|
|
// optional bytes padding = 8;
|
|
if (has_padding()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::BytesSize(
|
|
this->padding());
|
|
}
|
|
|
|
// optional .chrome_browser_net.ProbePacket.Header header = 1;
|
|
if (has_header()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
*this->header_);
|
|
}
|
|
|
|
// optional .chrome_browser_net.ProbePacket.Token token = 2;
|
|
if (has_token()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
*this->token_);
|
|
}
|
|
|
|
// optional uint32 group_id = 3;
|
|
if (has_group_id()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->group_id());
|
|
}
|
|
|
|
// optional uint32 packet_index = 4;
|
|
if (has_packet_index()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->packet_index());
|
|
}
|
|
|
|
// optional uint32 probe_size_bytes = 5;
|
|
if (has_probe_size_bytes()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->probe_size_bytes());
|
|
}
|
|
|
|
// optional uint32 pacing_interval_micros = 6;
|
|
if (has_pacing_interval_micros()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->pacing_interval_micros());
|
|
}
|
|
|
|
// optional int64 server_processing_micros = 9;
|
|
if (has_server_processing_micros()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::Int64Size(
|
|
this->server_processing_micros());
|
|
}
|
|
|
|
}
|
|
// optional uint32 number_probe_packets = 7;
|
|
if (has_number_probe_packets()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->number_probe_packets());
|
|
}
|
|
|
|
int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = cached_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void ProbePacket::CheckTypeAndMergeFrom(
|
|
const ::google::protobuf::MessageLite& from) {
|
|
MergeFrom(*::google::protobuf::down_cast<const ProbePacket*>(&from));
|
|
}
|
|
|
|
void ProbePacket::MergeFrom(const ProbePacket& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:chrome_browser_net.ProbePacket)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
_internal_metadata_.MergeFrom(from._internal_metadata_);
|
|
::google::protobuf::uint32 cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = from._has_bits_[0];
|
|
if (cached_has_bits & 255u) {
|
|
if (cached_has_bits & 0x00000001u) {
|
|
set_has_padding();
|
|
padding_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.padding_);
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
mutable_header()->::chrome_browser_net::ProbePacket_Header::MergeFrom(from.header());
|
|
}
|
|
if (cached_has_bits & 0x00000004u) {
|
|
mutable_token()->::chrome_browser_net::ProbePacket_Token::MergeFrom(from.token());
|
|
}
|
|
if (cached_has_bits & 0x00000008u) {
|
|
group_id_ = from.group_id_;
|
|
}
|
|
if (cached_has_bits & 0x00000010u) {
|
|
packet_index_ = from.packet_index_;
|
|
}
|
|
if (cached_has_bits & 0x00000020u) {
|
|
probe_size_bytes_ = from.probe_size_bytes_;
|
|
}
|
|
if (cached_has_bits & 0x00000040u) {
|
|
pacing_interval_micros_ = from.pacing_interval_micros_;
|
|
}
|
|
if (cached_has_bits & 0x00000080u) {
|
|
server_processing_micros_ = from.server_processing_micros_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
if (cached_has_bits & 0x00000100u) {
|
|
set_number_probe_packets(from.number_probe_packets());
|
|
}
|
|
}
|
|
|
|
void ProbePacket::CopyFrom(const ProbePacket& from) {
|
|
// @@protoc_insertion_point(class_specific_copy_from_start:chrome_browser_net.ProbePacket)
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool ProbePacket::IsInitialized() const {
|
|
if (has_header()) {
|
|
if (!this->header_->IsInitialized()) return false;
|
|
}
|
|
if (has_token()) {
|
|
if (!this->token_->IsInitialized()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void ProbePacket::Swap(ProbePacket* other) {
|
|
if (other == this) return;
|
|
InternalSwap(other);
|
|
}
|
|
void ProbePacket::InternalSwap(ProbePacket* other) {
|
|
padding_.Swap(&other->padding_);
|
|
std::swap(header_, other->header_);
|
|
std::swap(token_, other->token_);
|
|
std::swap(group_id_, other->group_id_);
|
|
std::swap(packet_index_, other->packet_index_);
|
|
std::swap(probe_size_bytes_, other->probe_size_bytes_);
|
|
std::swap(pacing_interval_micros_, other->pacing_interval_micros_);
|
|
std::swap(server_processing_micros_, other->server_processing_micros_);
|
|
std::swap(number_probe_packets_, other->number_probe_packets_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_internal_metadata_.Swap(&other->_internal_metadata_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
|
|
::std::string ProbePacket::GetTypeName() const {
|
|
return "chrome_browser_net.ProbePacket";
|
|
}
|
|
|
|
#if PROTOBUF_INLINE_NOT_IN_HEADERS
|
|
// ProbePacket
|
|
|
|
// optional .chrome_browser_net.ProbePacket.Header header = 1;
|
|
bool ProbePacket::has_header() const {
|
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
|
}
|
|
void ProbePacket::set_has_header() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
}
|
|
void ProbePacket::clear_has_header() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
void ProbePacket::clear_header() {
|
|
if (header_ != NULL) header_->::chrome_browser_net::ProbePacket_Header::Clear();
|
|
clear_has_header();
|
|
}
|
|
const ::chrome_browser_net::ProbePacket_Header& ProbePacket::header() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.header)
|
|
return header_ != NULL ? *header_
|
|
: *::chrome_browser_net::ProbePacket_Header::internal_default_instance();
|
|
}
|
|
::chrome_browser_net::ProbePacket_Header* ProbePacket::mutable_header() {
|
|
set_has_header();
|
|
if (header_ == NULL) {
|
|
header_ = new ::chrome_browser_net::ProbePacket_Header;
|
|
}
|
|
// @@protoc_insertion_point(field_mutable:chrome_browser_net.ProbePacket.header)
|
|
return header_;
|
|
}
|
|
::chrome_browser_net::ProbePacket_Header* ProbePacket::release_header() {
|
|
// @@protoc_insertion_point(field_release:chrome_browser_net.ProbePacket.header)
|
|
clear_has_header();
|
|
::chrome_browser_net::ProbePacket_Header* temp = header_;
|
|
header_ = NULL;
|
|
return temp;
|
|
}
|
|
void ProbePacket::set_allocated_header(::chrome_browser_net::ProbePacket_Header* header) {
|
|
delete header_;
|
|
header_ = header;
|
|
if (header) {
|
|
set_has_header();
|
|
} else {
|
|
clear_has_header();
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:chrome_browser_net.ProbePacket.header)
|
|
}
|
|
|
|
// optional .chrome_browser_net.ProbePacket.Token token = 2;
|
|
bool ProbePacket::has_token() const {
|
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
|
}
|
|
void ProbePacket::set_has_token() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
}
|
|
void ProbePacket::clear_has_token() {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
void ProbePacket::clear_token() {
|
|
if (token_ != NULL) token_->::chrome_browser_net::ProbePacket_Token::Clear();
|
|
clear_has_token();
|
|
}
|
|
const ::chrome_browser_net::ProbePacket_Token& ProbePacket::token() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.token)
|
|
return token_ != NULL ? *token_
|
|
: *::chrome_browser_net::ProbePacket_Token::internal_default_instance();
|
|
}
|
|
::chrome_browser_net::ProbePacket_Token* ProbePacket::mutable_token() {
|
|
set_has_token();
|
|
if (token_ == NULL) {
|
|
token_ = new ::chrome_browser_net::ProbePacket_Token;
|
|
}
|
|
// @@protoc_insertion_point(field_mutable:chrome_browser_net.ProbePacket.token)
|
|
return token_;
|
|
}
|
|
::chrome_browser_net::ProbePacket_Token* ProbePacket::release_token() {
|
|
// @@protoc_insertion_point(field_release:chrome_browser_net.ProbePacket.token)
|
|
clear_has_token();
|
|
::chrome_browser_net::ProbePacket_Token* temp = token_;
|
|
token_ = NULL;
|
|
return temp;
|
|
}
|
|
void ProbePacket::set_allocated_token(::chrome_browser_net::ProbePacket_Token* token) {
|
|
delete token_;
|
|
token_ = token;
|
|
if (token) {
|
|
set_has_token();
|
|
} else {
|
|
clear_has_token();
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:chrome_browser_net.ProbePacket.token)
|
|
}
|
|
|
|
// optional uint32 group_id = 3;
|
|
bool ProbePacket::has_group_id() const {
|
|
return (_has_bits_[0] & 0x00000008u) != 0;
|
|
}
|
|
void ProbePacket::set_has_group_id() {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
}
|
|
void ProbePacket::clear_has_group_id() {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
void ProbePacket::clear_group_id() {
|
|
group_id_ = 0u;
|
|
clear_has_group_id();
|
|
}
|
|
::google::protobuf::uint32 ProbePacket::group_id() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.group_id)
|
|
return group_id_;
|
|
}
|
|
void ProbePacket::set_group_id(::google::protobuf::uint32 value) {
|
|
set_has_group_id();
|
|
group_id_ = value;
|
|
// @@protoc_insertion_point(field_set:chrome_browser_net.ProbePacket.group_id)
|
|
}
|
|
|
|
// optional uint32 packet_index = 4;
|
|
bool ProbePacket::has_packet_index() const {
|
|
return (_has_bits_[0] & 0x00000010u) != 0;
|
|
}
|
|
void ProbePacket::set_has_packet_index() {
|
|
_has_bits_[0] |= 0x00000010u;
|
|
}
|
|
void ProbePacket::clear_has_packet_index() {
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
void ProbePacket::clear_packet_index() {
|
|
packet_index_ = 0u;
|
|
clear_has_packet_index();
|
|
}
|
|
::google::protobuf::uint32 ProbePacket::packet_index() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.packet_index)
|
|
return packet_index_;
|
|
}
|
|
void ProbePacket::set_packet_index(::google::protobuf::uint32 value) {
|
|
set_has_packet_index();
|
|
packet_index_ = value;
|
|
// @@protoc_insertion_point(field_set:chrome_browser_net.ProbePacket.packet_index)
|
|
}
|
|
|
|
// optional uint32 probe_size_bytes = 5;
|
|
bool ProbePacket::has_probe_size_bytes() const {
|
|
return (_has_bits_[0] & 0x00000020u) != 0;
|
|
}
|
|
void ProbePacket::set_has_probe_size_bytes() {
|
|
_has_bits_[0] |= 0x00000020u;
|
|
}
|
|
void ProbePacket::clear_has_probe_size_bytes() {
|
|
_has_bits_[0] &= ~0x00000020u;
|
|
}
|
|
void ProbePacket::clear_probe_size_bytes() {
|
|
probe_size_bytes_ = 0u;
|
|
clear_has_probe_size_bytes();
|
|
}
|
|
::google::protobuf::uint32 ProbePacket::probe_size_bytes() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.probe_size_bytes)
|
|
return probe_size_bytes_;
|
|
}
|
|
void ProbePacket::set_probe_size_bytes(::google::protobuf::uint32 value) {
|
|
set_has_probe_size_bytes();
|
|
probe_size_bytes_ = value;
|
|
// @@protoc_insertion_point(field_set:chrome_browser_net.ProbePacket.probe_size_bytes)
|
|
}
|
|
|
|
// optional uint32 pacing_interval_micros = 6;
|
|
bool ProbePacket::has_pacing_interval_micros() const {
|
|
return (_has_bits_[0] & 0x00000040u) != 0;
|
|
}
|
|
void ProbePacket::set_has_pacing_interval_micros() {
|
|
_has_bits_[0] |= 0x00000040u;
|
|
}
|
|
void ProbePacket::clear_has_pacing_interval_micros() {
|
|
_has_bits_[0] &= ~0x00000040u;
|
|
}
|
|
void ProbePacket::clear_pacing_interval_micros() {
|
|
pacing_interval_micros_ = 0u;
|
|
clear_has_pacing_interval_micros();
|
|
}
|
|
::google::protobuf::uint32 ProbePacket::pacing_interval_micros() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.pacing_interval_micros)
|
|
return pacing_interval_micros_;
|
|
}
|
|
void ProbePacket::set_pacing_interval_micros(::google::protobuf::uint32 value) {
|
|
set_has_pacing_interval_micros();
|
|
pacing_interval_micros_ = value;
|
|
// @@protoc_insertion_point(field_set:chrome_browser_net.ProbePacket.pacing_interval_micros)
|
|
}
|
|
|
|
// optional uint32 number_probe_packets = 7;
|
|
bool ProbePacket::has_number_probe_packets() const {
|
|
return (_has_bits_[0] & 0x00000100u) != 0;
|
|
}
|
|
void ProbePacket::set_has_number_probe_packets() {
|
|
_has_bits_[0] |= 0x00000100u;
|
|
}
|
|
void ProbePacket::clear_has_number_probe_packets() {
|
|
_has_bits_[0] &= ~0x00000100u;
|
|
}
|
|
void ProbePacket::clear_number_probe_packets() {
|
|
number_probe_packets_ = 0u;
|
|
clear_has_number_probe_packets();
|
|
}
|
|
::google::protobuf::uint32 ProbePacket::number_probe_packets() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.number_probe_packets)
|
|
return number_probe_packets_;
|
|
}
|
|
void ProbePacket::set_number_probe_packets(::google::protobuf::uint32 value) {
|
|
set_has_number_probe_packets();
|
|
number_probe_packets_ = value;
|
|
// @@protoc_insertion_point(field_set:chrome_browser_net.ProbePacket.number_probe_packets)
|
|
}
|
|
|
|
// optional int64 server_processing_micros = 9;
|
|
bool ProbePacket::has_server_processing_micros() const {
|
|
return (_has_bits_[0] & 0x00000080u) != 0;
|
|
}
|
|
void ProbePacket::set_has_server_processing_micros() {
|
|
_has_bits_[0] |= 0x00000080u;
|
|
}
|
|
void ProbePacket::clear_has_server_processing_micros() {
|
|
_has_bits_[0] &= ~0x00000080u;
|
|
}
|
|
void ProbePacket::clear_server_processing_micros() {
|
|
server_processing_micros_ = GOOGLE_LONGLONG(0);
|
|
clear_has_server_processing_micros();
|
|
}
|
|
::google::protobuf::int64 ProbePacket::server_processing_micros() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.server_processing_micros)
|
|
return server_processing_micros_;
|
|
}
|
|
void ProbePacket::set_server_processing_micros(::google::protobuf::int64 value) {
|
|
set_has_server_processing_micros();
|
|
server_processing_micros_ = value;
|
|
// @@protoc_insertion_point(field_set:chrome_browser_net.ProbePacket.server_processing_micros)
|
|
}
|
|
|
|
// optional bytes padding = 8;
|
|
bool ProbePacket::has_padding() const {
|
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
|
}
|
|
void ProbePacket::set_has_padding() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
}
|
|
void ProbePacket::clear_has_padding() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
void ProbePacket::clear_padding() {
|
|
padding_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
clear_has_padding();
|
|
}
|
|
const ::std::string& ProbePacket::padding() const {
|
|
// @@protoc_insertion_point(field_get:chrome_browser_net.ProbePacket.padding)
|
|
return padding_.GetNoArena();
|
|
}
|
|
void ProbePacket::set_padding(const ::std::string& value) {
|
|
set_has_padding();
|
|
padding_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
|
// @@protoc_insertion_point(field_set:chrome_browser_net.ProbePacket.padding)
|
|
}
|
|
#if LANG_CXX11
|
|
void ProbePacket::set_padding(::std::string&& value) {
|
|
set_has_padding();
|
|
padding_.SetNoArena(
|
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
|
// @@protoc_insertion_point(field_set_rvalue:chrome_browser_net.ProbePacket.padding)
|
|
}
|
|
#endif
|
|
void ProbePacket::set_padding(const char* value) {
|
|
GOOGLE_DCHECK(value != NULL);
|
|
set_has_padding();
|
|
padding_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
|
// @@protoc_insertion_point(field_set_char:chrome_browser_net.ProbePacket.padding)
|
|
}
|
|
void ProbePacket::set_padding(const void* value, size_t size) {
|
|
set_has_padding();
|
|
padding_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
|
::std::string(reinterpret_cast<const char*>(value), size));
|
|
// @@protoc_insertion_point(field_set_pointer:chrome_browser_net.ProbePacket.padding)
|
|
}
|
|
::std::string* ProbePacket::mutable_padding() {
|
|
set_has_padding();
|
|
// @@protoc_insertion_point(field_mutable:chrome_browser_net.ProbePacket.padding)
|
|
return padding_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
::std::string* ProbePacket::release_padding() {
|
|
// @@protoc_insertion_point(field_release:chrome_browser_net.ProbePacket.padding)
|
|
clear_has_padding();
|
|
return padding_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
void ProbePacket::set_allocated_padding(::std::string* padding) {
|
|
if (padding != NULL) {
|
|
set_has_padding();
|
|
} else {
|
|
clear_has_padding();
|
|
}
|
|
padding_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), padding);
|
|
// @@protoc_insertion_point(field_set_allocated:chrome_browser_net.ProbePacket.padding)
|
|
}
|
|
|
|
#endif // PROTOBUF_INLINE_NOT_IN_HEADERS
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
} // namespace chrome_browser_net
|
|
|
|
// @@protoc_insertion_point(global_scope)
|