// components/browser_apis/bookmarks/bookmarks_api.mojom-shared.cc is auto generated by mojom_bindings_generator.py, do not edit

// 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 "components/browser_apis/bookmarks/bookmarks_api.mojom-shared.h"
#include <ostream>
#include <utility>
#include "base/strings/stringprintf.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/lib/validation_util.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "components/browser_apis/bookmarks/bookmarks_api.mojom-params-data.h"
namespace bookmarks_api {
namespace mojom {

NOINLINE static const char* PermanentFolderTypeToStringHelper(PermanentFolderType value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case PermanentFolderType::kUnknown:
      return "kUnknown";
    case PermanentFolderType::kBookmarkBar:
      return "kBookmarkBar";
    case PermanentFolderType::kOther:
      return "kOther";
    case PermanentFolderType::kMobile:
      return "kMobile";
    case PermanentFolderType::kManaged:
      return "kManaged";
    default:
      return nullptr;
  }
}

std::string PermanentFolderTypeToString(PermanentFolderType value) {
  const char *str = PermanentFolderTypeToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown PermanentFolderType value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, PermanentFolderType value) {
  return os << PermanentFolderTypeToString(value);
}

namespace internal {
// static
bool BookmarkNode_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const BookmarkNode_Data* object = static_cast<const BookmarkNode_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case BookmarkNode_Tag::kUrl: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_url, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_url, validation_context))
        return false;
      return true;
    }
    case BookmarkNode_Tag::kFolder: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_folder, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_folder, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in BookmarkNode");
      return false;
    }
  }
}
// static
bool BookmarksEvent_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const BookmarksEvent_Data* object = static_cast<const BookmarksEvent_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case BookmarksEvent_Tag::kAdded: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_added, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_added, validation_context))
        return false;
      return true;
    }
    case BookmarksEvent_Tag::kRemoved: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_removed, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_removed, validation_context))
        return false;
      return true;
    }
    case BookmarksEvent_Tag::kMoved: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_moved, 3, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_moved, validation_context))
        return false;
      return true;
    }
    case BookmarksEvent_Tag::kChanged: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_changed, 4, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_changed, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in BookmarksEvent");
      return false;
    }
  }
}
// static
bool BookmarksService_GetBookmarks_ResponseParam_Result_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const BookmarksService_GetBookmarks_ResponseParam_Result_Data* object = static_cast<const BookmarksService_GetBookmarks_ResponseParam_Result_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case BookmarksService_GetBookmarks_ResponseParam_Result_Tag::kSuccess: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_success, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_success, validation_context))
        return false;
      return true;
    }
    case BookmarksService_GetBookmarks_ResponseParam_Result_Tag::kFailure: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_failure, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_failure, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in BookmarksService_GetBookmarks_ResponseParam_Result");
      return false;
    }
  }
}
// static
bool BookmarksService_GetBookmark_ResponseParam_Result_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const BookmarksService_GetBookmark_ResponseParam_Result_Data* object = static_cast<const BookmarksService_GetBookmark_ResponseParam_Result_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case BookmarksService_GetBookmark_ResponseParam_Result_Tag::kSuccess: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_success, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateNonInlinedUnion(object->data.f_success,
                                                   validation_context))
        return false;
      return true;
    }
    case BookmarksService_GetBookmark_ResponseParam_Result_Tag::kFailure: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_failure, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_failure, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in BookmarksService_GetBookmark_ResponseParam_Result");
      return false;
    }
  }
}
// static
bool BookmarksService_CreateBookmarkNode_ResponseParam_Result_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const BookmarksService_CreateBookmarkNode_ResponseParam_Result_Data* object = static_cast<const BookmarksService_CreateBookmarkNode_ResponseParam_Result_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case BookmarksService_CreateBookmarkNode_ResponseParam_Result_Tag::kSuccess: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_success, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateNonInlinedUnion(object->data.f_success,
                                                   validation_context))
        return false;
      return true;
    }
    case BookmarksService_CreateBookmarkNode_ResponseParam_Result_Tag::kFailure: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_failure, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_failure, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in BookmarksService_CreateBookmarkNode_ResponseParam_Result");
      return false;
    }
  }
}
// static
bool BookmarksService_UpdateBookmarkNode_ResponseParam_Result_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const BookmarksService_UpdateBookmarkNode_ResponseParam_Result_Data* object = static_cast<const BookmarksService_UpdateBookmarkNode_ResponseParam_Result_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case BookmarksService_UpdateBookmarkNode_ResponseParam_Result_Tag::kSuccess: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_success, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateNonInlinedUnion(object->data.f_success,
                                                   validation_context))
        return false;
      return true;
    }
    case BookmarksService_UpdateBookmarkNode_ResponseParam_Result_Tag::kFailure: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_failure, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_failure, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in BookmarksService_UpdateBookmarkNode_ResponseParam_Result");
      return false;
    }
  }
}
// static
bool BookmarksService_MoveBookmarkNode_ResponseParam_Result_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const BookmarksService_MoveBookmarkNode_ResponseParam_Result_Data* object = static_cast<const BookmarksService_MoveBookmarkNode_ResponseParam_Result_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case BookmarksService_MoveBookmarkNode_ResponseParam_Result_Tag::kSuccess: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_success, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_success, validation_context))
        return false;
      return true;
    }
    case BookmarksService_MoveBookmarkNode_ResponseParam_Result_Tag::kFailure: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_failure, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_failure, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in BookmarksService_MoveBookmarkNode_ResponseParam_Result");
      return false;
    }
  }
}
// static
bool BookmarksService_DeleteBookmarkNodes_ResponseParam_Result_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const BookmarksService_DeleteBookmarkNodes_ResponseParam_Result_Data* object = static_cast<const BookmarksService_DeleteBookmarkNodes_ResponseParam_Result_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case BookmarksService_DeleteBookmarkNodes_ResponseParam_Result_Tag::kSuccess: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_success, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_success, validation_context))
        return false;
      return true;
    }
    case BookmarksService_DeleteBookmarkNodes_ResponseParam_Result_Tag::kFailure: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_failure, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_failure, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in BookmarksService_DeleteBookmarkNodes_ResponseParam_Result");
      return false;
    }
  }
}


// static
bool LegacyFields_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const LegacyFields_Data* object =
      static_cast<const LegacyFields_Data*>(data);

  return true;
}

LegacyFields_Data::LegacyFields_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool RootNode_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const RootNode_Data* object =
      static_cast<const RootNode_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->id, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->id, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->children, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& children_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->children, validation_context,
                                         &children_validate_params)) {
    return false;
  }

  return true;
}

RootNode_Data::RootNode_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool Url_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 56, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const Url_Data* object =
      static_cast<const Url_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->id, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->legacy, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->title, 3, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& title_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->title, validation_context,
                                         &title_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->url, 4, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->url, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->favicon_url, validation_context))
    return false;

  return true;
}

Url_Data::Url_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool Folder_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 48, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const Folder_Data* object =
      static_cast<const Folder_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->id, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->legacy, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->title, 3, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& title_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->title, validation_context,
                                         &title_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->children, 4, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& children_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->children, validation_context,
                                         &children_validate_params)) {
    return false;
  }


  if (!::bookmarks_api::mojom::internal::PermanentFolderType_Data
        ::Validate(object->permanent_folder_type_$value, validation_context))
    return false;

  return true;
}

Folder_Data::Folder_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksSnapshot_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksSnapshot_Data* object =
      static_cast<const BookmarksSnapshot_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->root, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->root, validation_context))
    return false;

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->stream, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->stream,
                                                 validation_context)) {
    return false;
  }

  return true;
}

BookmarksSnapshot_Data::BookmarksSnapshot_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarkNodeCreated_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 40, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarkNodeCreated_Data* object =
      static_cast<const BookmarkNodeCreated_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->parent_id, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->parent_id, validation_context))
    return false;

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->node, 3, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->node, validation_context))
    return false;

  return true;
}

BookmarkNodeCreated_Data::BookmarkNodeCreated_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarkNodeRemoved_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarkNodeRemoved_Data* object =
      static_cast<const BookmarkNodeRemoved_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->id, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->id, validation_context))
    return false;

  return true;
}

BookmarkNodeRemoved_Data::BookmarkNodeRemoved_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarkNodeMoved_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarkNodeMoved_Data* object =
      static_cast<const BookmarkNodeMoved_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->old_parent_id, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->old_parent_id, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->new_parent_id, 3, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->new_parent_id, validation_context))
    return false;

  return true;
}

BookmarkNodeMoved_Data::BookmarkNodeMoved_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarkNodeChanged_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarkNodeChanged_Data* object =
      static_cast<const BookmarkNodeChanged_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->node, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->node, validation_context))
    return false;

  return true;
}

BookmarkNodeChanged_Data::BookmarkNodeChanged_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksObserver_OnBookmarksEvents_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksObserver_OnBookmarksEvents_Params_Data* object =
      static_cast<const BookmarksObserver_OnBookmarksEvents_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->events, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& events_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->events, validation_context,
                                         &events_validate_params)) {
    return false;
  }

  return true;
}

BookmarksObserver_OnBookmarksEvents_Params_Data::BookmarksObserver_OnBookmarksEvents_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksService_GetBookmarks_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksService_GetBookmarks_Params_Data* object =
      static_cast<const BookmarksService_GetBookmarks_Params_Data*>(data);

  return true;
}

BookmarksService_GetBookmarks_Params_Data::BookmarksService_GetBookmarks_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksService_GetBookmarks_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksService_GetBookmarks_ResponseParams_Data* object =
      static_cast<const BookmarksService_GetBookmarks_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

BookmarksService_GetBookmarks_ResponseParams_Data::BookmarksService_GetBookmarks_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksService_GetBookmark_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksService_GetBookmark_Params_Data* object =
      static_cast<const BookmarksService_GetBookmark_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->id, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->id, validation_context))
    return false;

  return true;
}

BookmarksService_GetBookmark_Params_Data::BookmarksService_GetBookmark_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksService_GetBookmark_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksService_GetBookmark_ResponseParams_Data* object =
      static_cast<const BookmarksService_GetBookmark_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

BookmarksService_GetBookmark_ResponseParams_Data::BookmarksService_GetBookmark_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksService_CreateBookmarkNode_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 40, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksService_CreateBookmarkNode_Params_Data* object =
      static_cast<const BookmarksService_CreateBookmarkNode_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->parent_id, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->parent_id, validation_context))
    return false;

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->node, 4, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->node, validation_context))
    return false;

  return true;
}

BookmarksService_CreateBookmarkNode_Params_Data::BookmarksService_CreateBookmarkNode_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksService_CreateBookmarkNode_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksService_CreateBookmarkNode_ResponseParams_Data* object =
      static_cast<const BookmarksService_CreateBookmarkNode_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

BookmarksService_CreateBookmarkNode_ResponseParams_Data::BookmarksService_CreateBookmarkNode_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksService_UpdateBookmarkNode_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksService_UpdateBookmarkNode_Params_Data* object =
      static_cast<const BookmarksService_UpdateBookmarkNode_Params_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->node, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->node, validation_context))
    return false;

  return true;
}

BookmarksService_UpdateBookmarkNode_Params_Data::BookmarksService_UpdateBookmarkNode_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksService_UpdateBookmarkNode_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksService_UpdateBookmarkNode_ResponseParams_Data* object =
      static_cast<const BookmarksService_UpdateBookmarkNode_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

BookmarksService_UpdateBookmarkNode_ResponseParams_Data::BookmarksService_UpdateBookmarkNode_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksService_MoveBookmarkNode_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksService_MoveBookmarkNode_Params_Data* object =
      static_cast<const BookmarksService_MoveBookmarkNode_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->id, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->id, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->new_parent_id, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->new_parent_id, validation_context))
    return false;

  return true;
}

BookmarksService_MoveBookmarkNode_Params_Data::BookmarksService_MoveBookmarkNode_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksService_MoveBookmarkNode_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksService_MoveBookmarkNode_ResponseParams_Data* object =
      static_cast<const BookmarksService_MoveBookmarkNode_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

BookmarksService_MoveBookmarkNode_ResponseParams_Data::BookmarksService_MoveBookmarkNode_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksService_DeleteBookmarkNodes_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksService_DeleteBookmarkNodes_Params_Data* object =
      static_cast<const BookmarksService_DeleteBookmarkNodes_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->ids, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& ids_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->ids, validation_context,
                                         &ids_validate_params)) {
    return false;
  }

  return true;
}

BookmarksService_DeleteBookmarkNodes_Params_Data::BookmarksService_DeleteBookmarkNodes_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool BookmarksService_DeleteBookmarkNodes_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const BookmarksService_DeleteBookmarkNodes_ResponseParams_Data* object =
      static_cast<const BookmarksService_DeleteBookmarkNodes_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

BookmarksService_DeleteBookmarkNodes_ResponseParams_Data::BookmarksService_DeleteBookmarkNodes_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}

}  // namespace internal
}  // namespace mojom
}  // namespace bookmarks_api

namespace perfetto {

// static
void TraceFormatTraits<::bookmarks_api::mojom::PermanentFolderType>::WriteIntoTrace(
   perfetto::TracedValue context, ::bookmarks_api::mojom::PermanentFolderType value) {
  return std::move(context).WriteString(::bookmarks_api::mojom::PermanentFolderTypeToString(value));
}

} // namespace perfetto