enterprise_reporting_private.cc | Explore in Territory

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

// GENERATED FROM THE API DEFINITION IN
//   chrome/common/extensions/api/enterprise_reporting_private.idl
// by tools/json_schema_compiler.
// DO NOT EDIT.

#include "chrome/common/extensions/api/enterprise_reporting_private.h"

#include <memory>
#include <optional>
#include <ostream>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

#include "base/check.h"
#include "base/check_op.h"
#include "base/notreached.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "tools/json_schema_compiler/util.h"
#include <string_view>


UTF8ToUTF16;

namespace extensions {
namespace api {
namespace enterprise_reporting_private {
//
// Types
//

const char* ToString(SettingValue enum_param) { … }

SettingValue ParseSettingValue(std::string_view enum_string) { … }

std::u16string GetSettingValueParseError(std::string_view enum_string) { … }


DeviceInfo::DeviceInfo()
: … { … }

DeviceInfo::~DeviceInfo() = default;
DeviceInfo::DeviceInfo(DeviceInfo&& rhs) noexcept = default;
DeviceInfo& DeviceInfo::operator=(DeviceInfo&& rhs) noexcept = default;
DeviceInfo DeviceInfo::Clone() const { … }

// static
bool DeviceInfo::Populate(
    const base::Value::Dict& dict, DeviceInfo& out) { … }

// static
bool DeviceInfo::Populate(
    const base::Value& value, DeviceInfo& out) { … }

// static
std::optional<DeviceInfo> DeviceInfo::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<DeviceInfo> DeviceInfo::FromValue(const base::Value& value) { … }

base::Value::Dict DeviceInfo::ToValue() const { … }


const char* ToString(RealtimeUrlCheckMode enum_param) { … }

RealtimeUrlCheckMode ParseRealtimeUrlCheckMode(std::string_view enum_string) { … }

std::u16string GetRealtimeUrlCheckModeParseError(std::string_view enum_string) { … }


const char* ToString(SafeBrowsingLevel enum_param) { … }

SafeBrowsingLevel ParseSafeBrowsingLevel(std::string_view enum_string) { … }

std::u16string GetSafeBrowsingLevelParseError(std::string_view enum_string) { … }


const char* ToString(PasswordProtectionTrigger enum_param) { … }

PasswordProtectionTrigger ParsePasswordProtectionTrigger(std::string_view enum_string) { … }

std::u16string GetPasswordProtectionTriggerParseError(std::string_view enum_string) { … }


ContextInfo::ContextInfo()
: … { … }

ContextInfo::~ContextInfo() = default;
ContextInfo::ContextInfo(ContextInfo&& rhs) noexcept = default;
ContextInfo& ContextInfo::operator=(ContextInfo&& rhs) noexcept = default;
ContextInfo ContextInfo::Clone() const { … }

// static
bool ContextInfo::Populate(
    const base::Value::Dict& dict, ContextInfo& out) { … }

// static
bool ContextInfo::Populate(
    const base::Value& value, ContextInfo& out) { … }

// static
std::optional<ContextInfo> ContextInfo::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<ContextInfo> ContextInfo::FromValue(const base::Value& value) { … }

base::Value::Dict ContextInfo::ToValue() const { … }


const char* ToString(CertificateStatus enum_param) { … }

CertificateStatus ParseCertificateStatus(std::string_view enum_string) { … }

std::u16string GetCertificateStatusParseError(std::string_view enum_string) { … }


Certificate::Certificate()
: … { … }

Certificate::~Certificate() = default;
Certificate::Certificate(Certificate&& rhs) noexcept = default;
Certificate& Certificate::operator=(Certificate&& rhs) noexcept = default;
Certificate Certificate::Clone() const { … }

// static
bool Certificate::Populate(
    const base::Value::Dict& dict, Certificate& out) { … }

// static
bool Certificate::Populate(
    const base::Value& value, Certificate& out) { … }

// static
std::optional<Certificate> Certificate::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<Certificate> Certificate::FromValue(const base::Value& value) { … }

base::Value::Dict Certificate::ToValue() const { … }


const char* ToString(EventType enum_param) { … }

EventType ParseEventType(std::string_view enum_string) { … }

std::u16string GetEventTypeParseError(std::string_view enum_string) { … }


EnqueueRecordRequest::EnqueueRecordRequest()
: … { … }

EnqueueRecordRequest::~EnqueueRecordRequest() = default;
EnqueueRecordRequest::EnqueueRecordRequest(EnqueueRecordRequest&& rhs) noexcept = default;
EnqueueRecordRequest& EnqueueRecordRequest::operator=(EnqueueRecordRequest&& rhs) noexcept = default;
EnqueueRecordRequest EnqueueRecordRequest::Clone() const { … }

// static
bool EnqueueRecordRequest::Populate(
    const base::Value::Dict& dict, EnqueueRecordRequest& out) { … }

// static
bool EnqueueRecordRequest::Populate(
    const base::Value& value, EnqueueRecordRequest& out) { … }

// static
std::optional<EnqueueRecordRequest> EnqueueRecordRequest::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<EnqueueRecordRequest> EnqueueRecordRequest::FromValue(const base::Value& value) { … }

base::Value::Dict EnqueueRecordRequest::ToValue() const { … }


UserContext::UserContext()
 { … }

UserContext::~UserContext() = default;
UserContext::UserContext(UserContext&& rhs) noexcept = default;
UserContext& UserContext::operator=(UserContext&& rhs) noexcept = default;
UserContext UserContext::Clone() const { … }

// static
bool UserContext::Populate(
    const base::Value::Dict& dict, UserContext& out) { … }

// static
bool UserContext::Populate(
    const base::Value& value, UserContext& out) { … }

// static
std::optional<UserContext> UserContext::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<UserContext> UserContext::FromValue(const base::Value& value) { … }

base::Value::Dict UserContext::ToValue() const { … }


const char* ToString(AntiVirusProductState enum_param) { … }

AntiVirusProductState ParseAntiVirusProductState(std::string_view enum_string) { … }

std::u16string GetAntiVirusProductStateParseError(std::string_view enum_string) { … }


AntiVirusSignal::AntiVirusSignal()
: … { … }

AntiVirusSignal::~AntiVirusSignal() = default;
AntiVirusSignal::AntiVirusSignal(AntiVirusSignal&& rhs) noexcept = default;
AntiVirusSignal& AntiVirusSignal::operator=(AntiVirusSignal&& rhs) noexcept = default;
AntiVirusSignal AntiVirusSignal::Clone() const { … }

// static
bool AntiVirusSignal::Populate(
    const base::Value::Dict& dict, AntiVirusSignal& out) { … }

// static
bool AntiVirusSignal::Populate(
    const base::Value& value, AntiVirusSignal& out) { … }

// static
std::optional<AntiVirusSignal> AntiVirusSignal::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<AntiVirusSignal> AntiVirusSignal::FromValue(const base::Value& value) { … }

base::Value::Dict AntiVirusSignal::ToValue() const { … }


HotfixSignal::HotfixSignal()
 { … }

HotfixSignal::~HotfixSignal() = default;
HotfixSignal::HotfixSignal(HotfixSignal&& rhs) noexcept = default;
HotfixSignal& HotfixSignal::operator=(HotfixSignal&& rhs) noexcept = default;
HotfixSignal HotfixSignal::Clone() const { … }

// static
bool HotfixSignal::Populate(
    const base::Value::Dict& dict, HotfixSignal& out) { … }

// static
bool HotfixSignal::Populate(
    const base::Value& value, HotfixSignal& out) { … }

// static
std::optional<HotfixSignal> HotfixSignal::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<HotfixSignal> HotfixSignal::FromValue(const base::Value& value) { … }

base::Value::Dict HotfixSignal::ToValue() const { … }


const char* ToString(PresenceValue enum_param) { … }

PresenceValue ParsePresenceValue(std::string_view enum_string) { … }

std::u16string GetPresenceValueParseError(std::string_view enum_string) { … }


GetFileSystemInfoOptions::GetFileSystemInfoOptions()
: … { … }

GetFileSystemInfoOptions::~GetFileSystemInfoOptions() = default;
GetFileSystemInfoOptions::GetFileSystemInfoOptions(GetFileSystemInfoOptions&& rhs) noexcept = default;
GetFileSystemInfoOptions& GetFileSystemInfoOptions::operator=(GetFileSystemInfoOptions&& rhs) noexcept = default;
GetFileSystemInfoOptions GetFileSystemInfoOptions::Clone() const { … }

// static
bool GetFileSystemInfoOptions::Populate(
    const base::Value::Dict& dict, GetFileSystemInfoOptions& out) { … }

// static
bool GetFileSystemInfoOptions::Populate(
    const base::Value& value, GetFileSystemInfoOptions& out) { … }

// static
std::optional<GetFileSystemInfoOptions> GetFileSystemInfoOptions::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<GetFileSystemInfoOptions> GetFileSystemInfoOptions::FromValue(const base::Value& value) { … }

base::Value::Dict GetFileSystemInfoOptions::ToValue() const { … }


GetFileSystemInfoRequest::GetFileSystemInfoRequest()
 { … }

GetFileSystemInfoRequest::~GetFileSystemInfoRequest() = default;
GetFileSystemInfoRequest::GetFileSystemInfoRequest(GetFileSystemInfoRequest&& rhs) noexcept = default;
GetFileSystemInfoRequest& GetFileSystemInfoRequest::operator=(GetFileSystemInfoRequest&& rhs) noexcept = default;
GetFileSystemInfoRequest GetFileSystemInfoRequest::Clone() const { … }

// static
bool GetFileSystemInfoRequest::Populate(
    const base::Value::Dict& dict, GetFileSystemInfoRequest& out) { … }

// static
bool GetFileSystemInfoRequest::Populate(
    const base::Value& value, GetFileSystemInfoRequest& out) { … }

// static
std::optional<GetFileSystemInfoRequest> GetFileSystemInfoRequest::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<GetFileSystemInfoRequest> GetFileSystemInfoRequest::FromValue(const base::Value& value) { … }

base::Value::Dict GetFileSystemInfoRequest::ToValue() const { … }


GetFileSystemInfoResponse::GetFileSystemInfoResponse()
: … { … }

GetFileSystemInfoResponse::~GetFileSystemInfoResponse() = default;
GetFileSystemInfoResponse::GetFileSystemInfoResponse(GetFileSystemInfoResponse&& rhs) noexcept = default;
GetFileSystemInfoResponse& GetFileSystemInfoResponse::operator=(GetFileSystemInfoResponse&& rhs) noexcept = default;
GetFileSystemInfoResponse GetFileSystemInfoResponse::Clone() const { … }

// static
bool GetFileSystemInfoResponse::Populate(
    const base::Value::Dict& dict, GetFileSystemInfoResponse& out) { … }

// static
bool GetFileSystemInfoResponse::Populate(
    const base::Value& value, GetFileSystemInfoResponse& out) { … }

// static
std::optional<GetFileSystemInfoResponse> GetFileSystemInfoResponse::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<GetFileSystemInfoResponse> GetFileSystemInfoResponse::FromValue(const base::Value& value) { … }

base::Value::Dict GetFileSystemInfoResponse::ToValue() const { … }


const char* ToString(RegistryHive enum_param) { … }

RegistryHive ParseRegistryHive(std::string_view enum_string) { … }

std::u16string GetRegistryHiveParseError(std::string_view enum_string) { … }


GetSettingsOptions::GetSettingsOptions()
: … { … }

GetSettingsOptions::~GetSettingsOptions() = default;
GetSettingsOptions::GetSettingsOptions(GetSettingsOptions&& rhs) noexcept = default;
GetSettingsOptions& GetSettingsOptions::operator=(GetSettingsOptions&& rhs) noexcept = default;
GetSettingsOptions GetSettingsOptions::Clone() const { … }

// static
bool GetSettingsOptions::Populate(
    const base::Value::Dict& dict, GetSettingsOptions& out) { … }

// static
bool GetSettingsOptions::Populate(
    const base::Value& value, GetSettingsOptions& out) { … }

// static
std::optional<GetSettingsOptions> GetSettingsOptions::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<GetSettingsOptions> GetSettingsOptions::FromValue(const base::Value& value) { … }

base::Value::Dict GetSettingsOptions::ToValue() const { … }


GetSettingsRequest::GetSettingsRequest()
 { … }

GetSettingsRequest::~GetSettingsRequest() = default;
GetSettingsRequest::GetSettingsRequest(GetSettingsRequest&& rhs) noexcept = default;
GetSettingsRequest& GetSettingsRequest::operator=(GetSettingsRequest&& rhs) noexcept = default;
GetSettingsRequest GetSettingsRequest::Clone() const { … }

// static
bool GetSettingsRequest::Populate(
    const base::Value::Dict& dict, GetSettingsRequest& out) { … }

// static
bool GetSettingsRequest::Populate(
    const base::Value& value, GetSettingsRequest& out) { … }

// static
std::optional<GetSettingsRequest> GetSettingsRequest::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<GetSettingsRequest> GetSettingsRequest::FromValue(const base::Value& value) { … }

base::Value::Dict GetSettingsRequest::ToValue() const { … }


GetSettingsResponse::GetSettingsResponse()
: … { … }

GetSettingsResponse::~GetSettingsResponse() = default;
GetSettingsResponse::GetSettingsResponse(GetSettingsResponse&& rhs) noexcept = default;
GetSettingsResponse& GetSettingsResponse::operator=(GetSettingsResponse&& rhs) noexcept = default;
GetSettingsResponse GetSettingsResponse::Clone() const { … }

// static
bool GetSettingsResponse::Populate(
    const base::Value::Dict& dict, GetSettingsResponse& out) { … }

// static
bool GetSettingsResponse::Populate(
    const base::Value& value, GetSettingsResponse& out) { … }

// static
std::optional<GetSettingsResponse> GetSettingsResponse::FromValue(const base::Value::Dict& value) { … }

// static
std::optional<GetSettingsResponse> GetSettingsResponse::FromValue(const base::Value& value) { … }

base::Value::Dict GetSettingsResponse::ToValue() const { … }



//
// Functions
//

namespace GetDeviceId {

base::Value::List Results::Create(const std::string& id) { … }
}  // namespace GetDeviceId

namespace GetPersistentSecret {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::vector<uint8_t>& secret) { … }
}  // namespace GetPersistentSecret

namespace GetDeviceData {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::vector<uint8_t>& data) { … }
}  // namespace GetDeviceData

namespace SetDeviceData {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace SetDeviceData

namespace GetDeviceInfo {

base::Value::List Results::Create(const DeviceInfo& device_info) { … }
}  // namespace GetDeviceInfo

namespace GetContextInfo {

base::Value::List Results::Create(const ContextInfo& context_info) { … }
}  // namespace GetContextInfo

namespace GetCertificate {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const Certificate& certificate) { … }
}  // namespace GetCertificate

namespace EnqueueRecord {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create() { … }
}  // namespace EnqueueRecord

namespace GetFileSystemInfo {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::vector<GetFileSystemInfoResponse>& file_system_signals) { … }
}  // namespace GetFileSystemInfo

namespace GetSettings {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::vector<GetSettingsResponse>& settings) { … }
}  // namespace GetSettings

namespace GetAvInfo {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::vector<AntiVirusSignal>& av_signals) { … }
}  // namespace GetAvInfo

namespace GetHotfixes {

Params::Params() = default;
Params::~Params() = default;
Params::Params(Params&& rhs) noexcept = default;
Params& Params::operator=(Params&& rhs) noexcept = default;

// static
std::optional<Params> Params::Create(const base::Value::List& args) { … }


base::Value::List Results::Create(const std::vector<HotfixSignal>& hotfix_signals) { … }
}  // namespace GetHotfixes

}  // namespace enterprise_reporting_private
}  // namespace api
}  // namespace extensions
chromium/out/Default/gen/chrome/common/extensions/api/enterprise_reporting_private.cc
