// services/network/public/mojom/sri_message_signature.mojom.cc is auto generated by mojom_bindings_generator.py, do not edit

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

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif

#include "services/network/public/mojom/sri_message_signature.mojom.h"
#include <stdint.h>
#include <utility>
#include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "services/network/public/mojom/sri_message_signature.mojom-params-data.h"
#include "services/network/public/mojom/sri_message_signature.mojom-shared-message-ids.h"

#include "services/network/public/mojom/sri_message_signature.mojom-import-headers.h"
#include "services/network/public/mojom/sri_message_signature.mojom-test-utils.h"


namespace network::mojom {
SRIMessageSignatureComponentParameter::SRIMessageSignatureComponentParameter()
    : type(),
      value() {}

SRIMessageSignatureComponentParameter::SRIMessageSignatureComponentParameter(
    SRIMessageSignatureComponentParameter::Type type_in,
    const std::optional<std::string>& value_in)
    : type(std::move(type_in)),
      value(std::move(value_in)) {}

SRIMessageSignatureComponentParameter::~SRIMessageSignatureComponentParameter() = default;

void SRIMessageSignatureComponentParameter::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "type"), this->type,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type SRIMessageSignatureComponentParameter::Type>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool SRIMessageSignatureComponentParameter::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
SRIMessageSignatureComponent::SRIMessageSignatureComponent()
    : name(),
      params() {}

SRIMessageSignatureComponent::SRIMessageSignatureComponent(
    const std::string& name_in,
    std::vector<SRIMessageSignatureComponentParameterPtr> params_in)
    : name(std::move(name_in)),
      params(std::move(params_in)) {}

SRIMessageSignatureComponent::~SRIMessageSignatureComponent() = default;

void SRIMessageSignatureComponent::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "name"), this->name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "params"), this->params,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::vector<SRIMessageSignatureComponentParameterPtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool SRIMessageSignatureComponent::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
SRIMessageSignature::SRIMessageSignature()
    : label(),
      signature(),
      components(),
      created(),
      expires(),
      keyid(),
      nonce(),
      tag(),
      serialized_signature_params() {}

SRIMessageSignature::SRIMessageSignature(
    const std::string& label_in,
    std::vector<uint8_t> signature_in,
    std::vector<SRIMessageSignatureComponentPtr> components_in,
    std::optional<int64_t> created_in,
    std::optional<int64_t> expires_in,
    std::optional<std::vector<uint8_t>> keyid_in,
    const std::optional<std::string>& nonce_in,
    const std::optional<std::string>& tag_in,
    const std::string& serialized_signature_params_in)
    : label(std::move(label_in)),
      signature(std::move(signature_in)),
      components(std::move(components_in)),
      created(std::move(created_in)),
      expires(std::move(expires_in)),
      keyid(std::move(keyid_in)),
      nonce(std::move(nonce_in)),
      tag(std::move(tag_in)),
      serialized_signature_params(std::move(serialized_signature_params_in)) {}

SRIMessageSignature::~SRIMessageSignature() = default;

void SRIMessageSignature::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "label"), this->label,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "signature"), this->signature,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::vector<uint8_t>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "components"), this->components,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::vector<SRIMessageSignatureComponentPtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "created"), this->created,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<int64_t>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "expires"), this->expires,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<int64_t>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "keyid"), this->keyid,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::vector<uint8_t>>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "nonce"), this->nonce,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "tag"), this->tag,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "serialized_signature_params"), this->serialized_signature_params,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool SRIMessageSignature::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
SRIMessageSignatureIssue::SRIMessageSignatureIssue()
    : error(),
      signature_base(),
      integrity_assertions() {}

SRIMessageSignatureIssue::SRIMessageSignatureIssue(
    SRIMessageSignatureError error_in,
    const std::optional<std::string>& signature_base_in,
    std::optional<std::vector<std::string>> integrity_assertions_in)
    : error(std::move(error_in)),
      signature_base(std::move(signature_base_in)),
      integrity_assertions(std::move(integrity_assertions_in)) {}

SRIMessageSignatureIssue::~SRIMessageSignatureIssue() = default;

void SRIMessageSignatureIssue::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "error"), this->error,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type SRIMessageSignatureError>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "signature_base"), this->signature_base,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::string>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "integrity_assertions"), this->integrity_assertions,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<std::vector<std::string>>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool SRIMessageSignatureIssue::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
SRIMessageSignatures::SRIMessageSignatures()
    : signatures(),
      issues() {}

SRIMessageSignatures::SRIMessageSignatures(
    std::vector<SRIMessageSignaturePtr> signatures_in,
    std::vector<SRIMessageSignatureIssuePtr> issues_in)
    : signatures(std::move(signatures_in)),
      issues(std::move(issues_in)) {}

SRIMessageSignatures::~SRIMessageSignatures() = default;

void SRIMessageSignatures::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "signatures"), this->signatures,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::vector<SRIMessageSignaturePtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "issues"), this->issues,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::vector<SRIMessageSignatureIssuePtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool SRIMessageSignatures::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}


}  // network::mojom


namespace mojo {


// static
bool StructTraits<::network::mojom::SRIMessageSignatureComponentParameter::DataView, ::network::mojom::SRIMessageSignatureComponentParameterPtr>::Read(
    ::network::mojom::SRIMessageSignatureComponentParameter::DataView input,
    ::network::mojom::SRIMessageSignatureComponentParameterPtr* output) {
  bool success = true;
  ::network::mojom::SRIMessageSignatureComponentParameterPtr result(::network::mojom::SRIMessageSignatureComponentParameter::New());
  
      if (success && !input.ReadType(&result->type))
        success = false;
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::SRIMessageSignatureComponent::DataView, ::network::mojom::SRIMessageSignatureComponentPtr>::Read(
    ::network::mojom::SRIMessageSignatureComponent::DataView input,
    ::network::mojom::SRIMessageSignatureComponentPtr* output) {
  bool success = true;
  ::network::mojom::SRIMessageSignatureComponentPtr result(::network::mojom::SRIMessageSignatureComponent::New());
  
      if (success && !input.ReadName(&result->name))
        success = false;
      if (success && !input.ReadParams(&result->params))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::SRIMessageSignature::DataView, ::network::mojom::SRIMessageSignaturePtr>::Read(
    ::network::mojom::SRIMessageSignature::DataView input,
    ::network::mojom::SRIMessageSignaturePtr* output) {
  bool success = true;
  ::network::mojom::SRIMessageSignaturePtr result(::network::mojom::SRIMessageSignature::New());
  
      if (success && !input.ReadLabel(&result->label))
        success = false;
      if (success && !input.ReadSignature(&result->signature))
        success = false;
      if (success && !input.ReadComponents(&result->components))
        success = false;
      if (success) {
        result->created = input.created();
      }
      if (success) {
        result->expires = input.expires();
      }
      if (success && !input.ReadKeyid(&result->keyid))
        success = false;
      if (success && !input.ReadNonce(&result->nonce))
        success = false;
      if (success && !input.ReadTag(&result->tag))
        success = false;
      if (success && !input.ReadSerializedSignatureParams(&result->serialized_signature_params))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::SRIMessageSignatureIssue::DataView, ::network::mojom::SRIMessageSignatureIssuePtr>::Read(
    ::network::mojom::SRIMessageSignatureIssue::DataView input,
    ::network::mojom::SRIMessageSignatureIssuePtr* output) {
  bool success = true;
  ::network::mojom::SRIMessageSignatureIssuePtr result(::network::mojom::SRIMessageSignatureIssue::New());
  
      if (success && !input.ReadError(&result->error))
        success = false;
      if (success && !input.ReadSignatureBase(&result->signature_base))
        success = false;
      if (success && !input.ReadIntegrityAssertions(&result->integrity_assertions))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::SRIMessageSignatures::DataView, ::network::mojom::SRIMessageSignaturesPtr>::Read(
    ::network::mojom::SRIMessageSignatures::DataView input,
    ::network::mojom::SRIMessageSignaturesPtr* output) {
  bool success = true;
  ::network::mojom::SRIMessageSignaturesPtr result(::network::mojom::SRIMessageSignatures::New());
  
      if (success && !input.ReadSignatures(&result->signatures))
        success = false;
      if (success && !input.ReadIssues(&result->issues))
        success = false;
  *output = std::move(result);
  return success;
}

}  // namespace mojo


// Symbols declared in the -test-utils.h header are defined here instead of a
// separate .cc file to save compile time.


namespace network::mojom {




}  // network::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif