// components/browser_apis/bookmarks/bookmarks_api.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 "components/browser_apis/bookmarks/bookmarks_api.mojom.h"
#include <math.h>
#include <stdint.h>
#include <utility>
#include "base/debug/alias.h"
#include "base/notreached.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/typed_macros.h"
#include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h"
#include "mojo/public/cpp/bindings/lib/generated_code_util.h"
#include "mojo/public/cpp/bindings/lib/message_internal.h"
#include "mojo/public/cpp/bindings/lib/proxy_to_responder.h"
#include "mojo/public/cpp/bindings/lib/send_message_helper.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/lib/unserialized_message_context.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 "mojo/public/cpp/bindings/urgent_message_scope.h"
#include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "components/browser_apis/bookmarks/bookmarks_api.mojom-params-data.h"
#include "components/browser_apis/bookmarks/bookmarks_api.mojom-shared-message-ids.h"

#include "components/browser_apis/bookmarks/bookmarks_api.mojom-import-headers.h"
#include "components/browser_apis/bookmarks/bookmarks_api.mojom-test-utils.h"


namespace bookmarks_api::mojom {
LegacyFields::LegacyFields()
    : id() {}

LegacyFields::LegacyFields(
    std::optional<int64_t> id_in)
    : id(std::move(id_in)) {}

LegacyFields::~LegacyFields() = default;

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

bool LegacyFields::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
RootNode::RootNode()
    : id(),
      children() {}

RootNode::RootNode(
    const ::base::Uuid& id_in,
    std::vector<FolderPtr> children_in)
    : id(std::move(id_in)),
      children(std::move(children_in)) {}

RootNode::~RootNode() = default;

void RootNode::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "id"), this->id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::Uuid&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "children"), this->children,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::vector<FolderPtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool RootNode::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
Url::Url()
    : id(),
      legacy(),
      title(),
      url(),
      favicon_url(),
      is_synced() {}

Url::Url(
    const std::optional<::base::Uuid>& id_in,
    LegacyFieldsPtr legacy_in,
    const std::string& title_in,
    const ::GURL& url_in,
    const std::optional<::GURL>& favicon_url_in,
    bool is_synced_in)
    : id(std::move(id_in)),
      legacy(std::move(legacy_in)),
      title(std::move(title_in)),
      url(std::move(url_in)),
      favicon_url(std::move(favicon_url_in)),
      is_synced(std::move(is_synced_in)) {}

Url::~Url() = default;

void Url::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "id"), this->id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::base::Uuid>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "legacy"), this->legacy,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type LegacyFieldsPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "title"), this->title,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "url"), this->url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::GURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "favicon_url"), this->favicon_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::GURL>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_synced"), this->is_synced,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool Url::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
Folder::Folder()
    : id(),
      legacy(),
      title(),
      children(),
      permanent_folder_type(),
      is_synced() {}

Folder::Folder(
    const std::optional<::base::Uuid>& id_in,
    LegacyFieldsPtr legacy_in,
    const std::string& title_in,
    std::vector<BookmarkNodePtr> children_in,
    std::optional<PermanentFolderType> permanent_folder_type_in,
    bool is_synced_in)
    : id(std::move(id_in)),
      legacy(std::move(legacy_in)),
      title(std::move(title_in)),
      children(std::move(children_in)),
      permanent_folder_type(std::move(permanent_folder_type_in)),
      is_synced(std::move(is_synced_in)) {}

Folder::~Folder() = default;

void Folder::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "id"), this->id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::optional<::base::Uuid>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "legacy"), this->legacy,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type LegacyFieldsPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "title"), this->title,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const std::string&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "children"), this->children,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::vector<BookmarkNodePtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "permanent_folder_type"), this->permanent_folder_type,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<PermanentFolderType>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "is_synced"), this->is_synced,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool Folder::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
BookmarksSnapshot::BookmarksSnapshot()
    : root(),
      stream() {}

BookmarksSnapshot::BookmarksSnapshot(
    RootNodePtr root_in,
    ::mojo::PendingAssociatedReceiver<BookmarksObserver> stream_in)
    : root(std::move(root_in)),
      stream(std::move(stream_in)) {}

BookmarksSnapshot::~BookmarksSnapshot() = default;

void BookmarksSnapshot::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "root"), this->root,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type RootNodePtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "stream"), this->stream,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::mojo::PendingAssociatedReceiver<BookmarksObserver>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool BookmarksSnapshot::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
BookmarkNodeCreated::BookmarkNodeCreated()
    : parent_id(),
      index(),
      node() {}

BookmarkNodeCreated::BookmarkNodeCreated(
    const ::base::Uuid& parent_id_in,
    int32_t index_in,
    BookmarkNodePtr node_in)
    : parent_id(std::move(parent_id_in)),
      index(std::move(index_in)),
      node(std::move(node_in)) {}

BookmarkNodeCreated::~BookmarkNodeCreated() = default;

void BookmarkNodeCreated::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "parent_id"), this->parent_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::Uuid&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "index"), this->index,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type int32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "node"), this->node,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type BookmarkNodePtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

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

BookmarkNodeRemoved::BookmarkNodeRemoved(
    const ::base::Uuid& id_in)
    : id(std::move(id_in)) {}

BookmarkNodeRemoved::~BookmarkNodeRemoved() = default;

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

bool BookmarkNodeRemoved::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
BookmarkNodeMoved::BookmarkNodeMoved()
    : old_parent_id(),
      old_index(),
      new_parent_id(),
      new_index() {}

BookmarkNodeMoved::BookmarkNodeMoved(
    const ::base::Uuid& old_parent_id_in,
    int32_t old_index_in,
    const ::base::Uuid& new_parent_id_in,
    int32_t new_index_in)
    : old_parent_id(std::move(old_parent_id_in)),
      old_index(std::move(old_index_in)),
      new_parent_id(std::move(new_parent_id_in)),
      new_index(std::move(new_index_in)) {}

BookmarkNodeMoved::~BookmarkNodeMoved() = default;

void BookmarkNodeMoved::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "old_parent_id"), this->old_parent_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::Uuid&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "old_index"), this->old_index,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type int32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "new_parent_id"), this->new_parent_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::Uuid&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "new_index"), this->new_index,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type int32_t>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

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

BookmarkNodeChanged::BookmarkNodeChanged(
    BookmarkNodePtr node_in)
    : node(std::move(node_in)) {}

BookmarkNodeChanged::~BookmarkNodeChanged() = default;

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

bool BookmarkNodeChanged::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
BookmarkNodePtr
BookmarkNode::NewUrl(
    UrlPtr value) {
  return BookmarkNodePtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kUrl)>,
      std::move(value));
}

BookmarkNodePtr
BookmarkNode::NewFolder(
    FolderPtr value) {
  return BookmarkNodePtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kFolder)>,
      std::move(value));
}

BookmarkNode::BookmarkNode(
    std::in_place_index_t<static_cast<size_t>(Tag::kUrl)>,
    UrlPtr value)
    : tag_(Tag::kUrl),
      data_(std::in_place_index<static_cast<size_t>(Tag::kUrl)>,
            std::move(value)) {}

BookmarkNode::BookmarkNode(
    std::in_place_index_t<static_cast<size_t>(Tag::kFolder)>,
    FolderPtr value)
    : tag_(Tag::kFolder),
      data_(std::in_place_index<static_cast<size_t>(Tag::kFolder)>,
            std::move(value)) {}
BookmarkNode::~BookmarkNode() {
  DestroyActive();
}

void BookmarkNode::set_url(UrlPtr url) {
  if (tag_ == Tag::kUrl) {
    data_.url = std::move(url);
  } else {
    DestroyActive();
    tag_ = Tag::kUrl;
    new (&data_.url) UrlPtr(
        std::move(url));
  }
}

void BookmarkNode::set_folder(FolderPtr folder) {
  if (tag_ == Tag::kFolder) {
    data_.folder = std::move(folder);
  } else {
    DestroyActive();
    tag_ = Tag::kFolder;
    new (&data_.folder) FolderPtr(
        std::move(folder));
  }
}


BookmarkNode::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kUrl)>,
    UrlPtr value)
    : url(std::move(value)) {}

BookmarkNode::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kFolder)>,
    FolderPtr value)
    : folder(std::move(value)) {}

void BookmarkNode::DestroyActive() {
  switch (tag_) {

    case Tag::kUrl:
      std::destroy_at(&data_.url);
      break;
    case Tag::kFolder:
      std::destroy_at(&data_.folder);
      break;
  }
}

bool BookmarkNode::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
BookmarksEventPtr
BookmarksEvent::NewAdded(
    BookmarkNodeCreatedPtr value) {
  return BookmarksEventPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kAdded)>,
      std::move(value));
}

BookmarksEventPtr
BookmarksEvent::NewRemoved(
    BookmarkNodeRemovedPtr value) {
  return BookmarksEventPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kRemoved)>,
      std::move(value));
}

BookmarksEventPtr
BookmarksEvent::NewMoved(
    BookmarkNodeMovedPtr value) {
  return BookmarksEventPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kMoved)>,
      std::move(value));
}

BookmarksEventPtr
BookmarksEvent::NewChanged(
    BookmarkNodeChangedPtr value) {
  return BookmarksEventPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kChanged)>,
      std::move(value));
}

BookmarksEvent::BookmarksEvent(
    std::in_place_index_t<static_cast<size_t>(Tag::kAdded)>,
    BookmarkNodeCreatedPtr value)
    : tag_(Tag::kAdded),
      data_(std::in_place_index<static_cast<size_t>(Tag::kAdded)>,
            std::move(value)) {}

BookmarksEvent::BookmarksEvent(
    std::in_place_index_t<static_cast<size_t>(Tag::kRemoved)>,
    BookmarkNodeRemovedPtr value)
    : tag_(Tag::kRemoved),
      data_(std::in_place_index<static_cast<size_t>(Tag::kRemoved)>,
            std::move(value)) {}

BookmarksEvent::BookmarksEvent(
    std::in_place_index_t<static_cast<size_t>(Tag::kMoved)>,
    BookmarkNodeMovedPtr value)
    : tag_(Tag::kMoved),
      data_(std::in_place_index<static_cast<size_t>(Tag::kMoved)>,
            std::move(value)) {}

BookmarksEvent::BookmarksEvent(
    std::in_place_index_t<static_cast<size_t>(Tag::kChanged)>,
    BookmarkNodeChangedPtr value)
    : tag_(Tag::kChanged),
      data_(std::in_place_index<static_cast<size_t>(Tag::kChanged)>,
            std::move(value)) {}
BookmarksEvent::~BookmarksEvent() {
  DestroyActive();
}

void BookmarksEvent::set_added(BookmarkNodeCreatedPtr added) {
  if (tag_ == Tag::kAdded) {
    data_.added = std::move(added);
  } else {
    DestroyActive();
    tag_ = Tag::kAdded;
    new (&data_.added) BookmarkNodeCreatedPtr(
        std::move(added));
  }
}

void BookmarksEvent::set_removed(BookmarkNodeRemovedPtr removed) {
  if (tag_ == Tag::kRemoved) {
    data_.removed = std::move(removed);
  } else {
    DestroyActive();
    tag_ = Tag::kRemoved;
    new (&data_.removed) BookmarkNodeRemovedPtr(
        std::move(removed));
  }
}

void BookmarksEvent::set_moved(BookmarkNodeMovedPtr moved) {
  if (tag_ == Tag::kMoved) {
    data_.moved = std::move(moved);
  } else {
    DestroyActive();
    tag_ = Tag::kMoved;
    new (&data_.moved) BookmarkNodeMovedPtr(
        std::move(moved));
  }
}

void BookmarksEvent::set_changed(BookmarkNodeChangedPtr changed) {
  if (tag_ == Tag::kChanged) {
    data_.changed = std::move(changed);
  } else {
    DestroyActive();
    tag_ = Tag::kChanged;
    new (&data_.changed) BookmarkNodeChangedPtr(
        std::move(changed));
  }
}


BookmarksEvent::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kAdded)>,
    BookmarkNodeCreatedPtr value)
    : added(std::move(value)) {}

BookmarksEvent::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kRemoved)>,
    BookmarkNodeRemovedPtr value)
    : removed(std::move(value)) {}

BookmarksEvent::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kMoved)>,
    BookmarkNodeMovedPtr value)
    : moved(std::move(value)) {}

BookmarksEvent::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kChanged)>,
    BookmarkNodeChangedPtr value)
    : changed(std::move(value)) {}

void BookmarksEvent::DestroyActive() {
  switch (tag_) {

    case Tag::kAdded:
      std::destroy_at(&data_.added);
      break;
    case Tag::kRemoved:
      std::destroy_at(&data_.removed);
      break;
    case Tag::kMoved:
      std::destroy_at(&data_.moved);
      break;
    case Tag::kChanged:
      std::destroy_at(&data_.changed);
      break;
  }
}

bool BookmarksEvent::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
BookmarksService_GetBookmarks_ResponseParam_ResultPtr
BookmarksService_GetBookmarks_ResponseParam_Result::NewSuccess(
    BookmarksSnapshotPtr value) {
  return BookmarksService_GetBookmarks_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
      std::move(value));
}

BookmarksService_GetBookmarks_ResponseParam_ResultPtr
BookmarksService_GetBookmarks_ResponseParam_Result::NewFailure(
    ::mojo_base::mojom::ErrorPtr value) {
  return BookmarksService_GetBookmarks_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
      std::move(value));
}

BookmarksService_GetBookmarks_ResponseParam_Result::BookmarksService_GetBookmarks_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    BookmarksSnapshotPtr value)
    : tag_(Tag::kSuccess),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
            std::move(value)) {}

BookmarksService_GetBookmarks_ResponseParam_Result::BookmarksService_GetBookmarks_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    ::mojo_base::mojom::ErrorPtr value)
    : tag_(Tag::kFailure),
      data_(std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
            std::move(value)) {}
BookmarksService_GetBookmarks_ResponseParam_Result::~BookmarksService_GetBookmarks_ResponseParam_Result() {
  DestroyActive();
}

void BookmarksService_GetBookmarks_ResponseParam_Result::set_success(BookmarksSnapshotPtr success) {
  if (tag_ == Tag::kSuccess) {
    data_.success = std::move(success);
  } else {
    DestroyActive();
    tag_ = Tag::kSuccess;
    new (&data_.success) BookmarksSnapshotPtr(
        std::move(success));
  }
}

void BookmarksService_GetBookmarks_ResponseParam_Result::set_failure(::mojo_base::mojom::ErrorPtr failure) {
  if (tag_ == Tag::kFailure) {
    data_.failure = std::move(failure);
  } else {
    DestroyActive();
    tag_ = Tag::kFailure;
    new (&data_.failure) ::mojo_base::mojom::ErrorPtr(
        std::move(failure));
  }
}


BookmarksService_GetBookmarks_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    BookmarksSnapshotPtr value)
    : success(std::move(value)) {}

BookmarksService_GetBookmarks_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    ::mojo_base::mojom::ErrorPtr value)
    : failure(std::move(value)) {}

void BookmarksService_GetBookmarks_ResponseParam_Result::DestroyActive() {
  switch (tag_) {

    case Tag::kSuccess:
      std::destroy_at(&data_.success);
      break;
    case Tag::kFailure:
      std::destroy_at(&data_.failure);
      break;
  }
}

bool BookmarksService_GetBookmarks_ResponseParam_Result::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
BookmarksService_GetBookmark_ResponseParam_ResultPtr
BookmarksService_GetBookmark_ResponseParam_Result::NewSuccess(
    BookmarkNodePtr value) {
  return BookmarksService_GetBookmark_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
      std::move(value));
}

BookmarksService_GetBookmark_ResponseParam_ResultPtr
BookmarksService_GetBookmark_ResponseParam_Result::NewFailure(
    ::mojo_base::mojom::ErrorPtr value) {
  return BookmarksService_GetBookmark_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
      std::move(value));
}

BookmarksService_GetBookmark_ResponseParam_Result::BookmarksService_GetBookmark_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    BookmarkNodePtr value)
    : tag_(Tag::kSuccess),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
            std::move(value)) {}

BookmarksService_GetBookmark_ResponseParam_Result::BookmarksService_GetBookmark_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    ::mojo_base::mojom::ErrorPtr value)
    : tag_(Tag::kFailure),
      data_(std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
            std::move(value)) {}
BookmarksService_GetBookmark_ResponseParam_Result::~BookmarksService_GetBookmark_ResponseParam_Result() {
  DestroyActive();
}

void BookmarksService_GetBookmark_ResponseParam_Result::set_success(BookmarkNodePtr success) {
  if (tag_ == Tag::kSuccess) {
    data_.success = std::move(success);
  } else {
    DestroyActive();
    tag_ = Tag::kSuccess;
    new (&data_.success) BookmarkNodePtr(
        std::move(success));
  }
}

void BookmarksService_GetBookmark_ResponseParam_Result::set_failure(::mojo_base::mojom::ErrorPtr failure) {
  if (tag_ == Tag::kFailure) {
    data_.failure = std::move(failure);
  } else {
    DestroyActive();
    tag_ = Tag::kFailure;
    new (&data_.failure) ::mojo_base::mojom::ErrorPtr(
        std::move(failure));
  }
}


BookmarksService_GetBookmark_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    BookmarkNodePtr value)
    : success(std::move(value)) {}

BookmarksService_GetBookmark_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    ::mojo_base::mojom::ErrorPtr value)
    : failure(std::move(value)) {}

void BookmarksService_GetBookmark_ResponseParam_Result::DestroyActive() {
  switch (tag_) {

    case Tag::kSuccess:
      std::destroy_at(&data_.success);
      break;
    case Tag::kFailure:
      std::destroy_at(&data_.failure);
      break;
  }
}

bool BookmarksService_GetBookmark_ResponseParam_Result::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr
BookmarksService_CreateBookmarkNode_ResponseParam_Result::NewSuccess(
    BookmarkNodePtr value) {
  return BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
      std::move(value));
}

BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr
BookmarksService_CreateBookmarkNode_ResponseParam_Result::NewFailure(
    ::mojo_base::mojom::ErrorPtr value) {
  return BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
      std::move(value));
}

BookmarksService_CreateBookmarkNode_ResponseParam_Result::BookmarksService_CreateBookmarkNode_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    BookmarkNodePtr value)
    : tag_(Tag::kSuccess),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
            std::move(value)) {}

BookmarksService_CreateBookmarkNode_ResponseParam_Result::BookmarksService_CreateBookmarkNode_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    ::mojo_base::mojom::ErrorPtr value)
    : tag_(Tag::kFailure),
      data_(std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
            std::move(value)) {}
BookmarksService_CreateBookmarkNode_ResponseParam_Result::~BookmarksService_CreateBookmarkNode_ResponseParam_Result() {
  DestroyActive();
}

void BookmarksService_CreateBookmarkNode_ResponseParam_Result::set_success(BookmarkNodePtr success) {
  if (tag_ == Tag::kSuccess) {
    data_.success = std::move(success);
  } else {
    DestroyActive();
    tag_ = Tag::kSuccess;
    new (&data_.success) BookmarkNodePtr(
        std::move(success));
  }
}

void BookmarksService_CreateBookmarkNode_ResponseParam_Result::set_failure(::mojo_base::mojom::ErrorPtr failure) {
  if (tag_ == Tag::kFailure) {
    data_.failure = std::move(failure);
  } else {
    DestroyActive();
    tag_ = Tag::kFailure;
    new (&data_.failure) ::mojo_base::mojom::ErrorPtr(
        std::move(failure));
  }
}


BookmarksService_CreateBookmarkNode_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    BookmarkNodePtr value)
    : success(std::move(value)) {}

BookmarksService_CreateBookmarkNode_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    ::mojo_base::mojom::ErrorPtr value)
    : failure(std::move(value)) {}

void BookmarksService_CreateBookmarkNode_ResponseParam_Result::DestroyActive() {
  switch (tag_) {

    case Tag::kSuccess:
      std::destroy_at(&data_.success);
      break;
    case Tag::kFailure:
      std::destroy_at(&data_.failure);
      break;
  }
}

bool BookmarksService_CreateBookmarkNode_ResponseParam_Result::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr
BookmarksService_UpdateBookmarkNode_ResponseParam_Result::NewSuccess(
    BookmarkNodePtr value) {
  return BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
      std::move(value));
}

BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr
BookmarksService_UpdateBookmarkNode_ResponseParam_Result::NewFailure(
    ::mojo_base::mojom::ErrorPtr value) {
  return BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
      std::move(value));
}

BookmarksService_UpdateBookmarkNode_ResponseParam_Result::BookmarksService_UpdateBookmarkNode_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    BookmarkNodePtr value)
    : tag_(Tag::kSuccess),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
            std::move(value)) {}

BookmarksService_UpdateBookmarkNode_ResponseParam_Result::BookmarksService_UpdateBookmarkNode_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    ::mojo_base::mojom::ErrorPtr value)
    : tag_(Tag::kFailure),
      data_(std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
            std::move(value)) {}
BookmarksService_UpdateBookmarkNode_ResponseParam_Result::~BookmarksService_UpdateBookmarkNode_ResponseParam_Result() {
  DestroyActive();
}

void BookmarksService_UpdateBookmarkNode_ResponseParam_Result::set_success(BookmarkNodePtr success) {
  if (tag_ == Tag::kSuccess) {
    data_.success = std::move(success);
  } else {
    DestroyActive();
    tag_ = Tag::kSuccess;
    new (&data_.success) BookmarkNodePtr(
        std::move(success));
  }
}

void BookmarksService_UpdateBookmarkNode_ResponseParam_Result::set_failure(::mojo_base::mojom::ErrorPtr failure) {
  if (tag_ == Tag::kFailure) {
    data_.failure = std::move(failure);
  } else {
    DestroyActive();
    tag_ = Tag::kFailure;
    new (&data_.failure) ::mojo_base::mojom::ErrorPtr(
        std::move(failure));
  }
}


BookmarksService_UpdateBookmarkNode_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    BookmarkNodePtr value)
    : success(std::move(value)) {}

BookmarksService_UpdateBookmarkNode_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    ::mojo_base::mojom::ErrorPtr value)
    : failure(std::move(value)) {}

void BookmarksService_UpdateBookmarkNode_ResponseParam_Result::DestroyActive() {
  switch (tag_) {

    case Tag::kSuccess:
      std::destroy_at(&data_.success);
      break;
    case Tag::kFailure:
      std::destroy_at(&data_.failure);
      break;
  }
}

bool BookmarksService_UpdateBookmarkNode_ResponseParam_Result::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr
BookmarksService_MoveBookmarkNode_ResponseParam_Result::NewSuccess(
    const ::std::monostate& value) {
  return BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
      std::move(value));
}

BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr
BookmarksService_MoveBookmarkNode_ResponseParam_Result::NewFailure(
    ::mojo_base::mojom::ErrorPtr value) {
  return BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
      std::move(value));
}

BookmarksService_MoveBookmarkNode_ResponseParam_Result::BookmarksService_MoveBookmarkNode_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    const ::std::monostate& value)
    : tag_(Tag::kSuccess),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
            std::move(value)) {}

BookmarksService_MoveBookmarkNode_ResponseParam_Result::BookmarksService_MoveBookmarkNode_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    ::mojo_base::mojom::ErrorPtr value)
    : tag_(Tag::kFailure),
      data_(std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
            std::move(value)) {}
BookmarksService_MoveBookmarkNode_ResponseParam_Result::~BookmarksService_MoveBookmarkNode_ResponseParam_Result() {
  DestroyActive();
}

void BookmarksService_MoveBookmarkNode_ResponseParam_Result::set_success(const ::std::monostate& success) {
  if (tag_ == Tag::kSuccess) {
    data_.success = std::move(success);
  } else {
    DestroyActive();
    tag_ = Tag::kSuccess;
    new (&data_.success) ::std::monostate(
        std::move(success));
  }
}

void BookmarksService_MoveBookmarkNode_ResponseParam_Result::set_failure(::mojo_base::mojom::ErrorPtr failure) {
  if (tag_ == Tag::kFailure) {
    data_.failure = std::move(failure);
  } else {
    DestroyActive();
    tag_ = Tag::kFailure;
    new (&data_.failure) ::mojo_base::mojom::ErrorPtr(
        std::move(failure));
  }
}


BookmarksService_MoveBookmarkNode_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    const ::std::monostate& value)
    : success(std::move(value)) {}

BookmarksService_MoveBookmarkNode_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    ::mojo_base::mojom::ErrorPtr value)
    : failure(std::move(value)) {}

void BookmarksService_MoveBookmarkNode_ResponseParam_Result::DestroyActive() {
  switch (tag_) {

    case Tag::kSuccess:
      std::destroy_at(&data_.success);
      break;
    case Tag::kFailure:
      std::destroy_at(&data_.failure);
      break;
  }
}

bool BookmarksService_MoveBookmarkNode_ResponseParam_Result::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr
BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::NewSuccess(
    const ::std::monostate& value) {
  return BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
      std::move(value));
}

BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr
BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::NewFailure(
    ::mojo_base::mojom::ErrorPtr value) {
  return BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
      std::move(value));
}

BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::BookmarksService_DeleteBookmarkNodes_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    const ::std::monostate& value)
    : tag_(Tag::kSuccess),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSuccess)>,
            std::move(value)) {}

BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::BookmarksService_DeleteBookmarkNodes_ResponseParam_Result(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    ::mojo_base::mojom::ErrorPtr value)
    : tag_(Tag::kFailure),
      data_(std::in_place_index<static_cast<size_t>(Tag::kFailure)>,
            std::move(value)) {}
BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::~BookmarksService_DeleteBookmarkNodes_ResponseParam_Result() {
  DestroyActive();
}

void BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::set_success(const ::std::monostate& success) {
  if (tag_ == Tag::kSuccess) {
    data_.success = std::move(success);
  } else {
    DestroyActive();
    tag_ = Tag::kSuccess;
    new (&data_.success) ::std::monostate(
        std::move(success));
  }
}

void BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::set_failure(::mojo_base::mojom::ErrorPtr failure) {
  if (tag_ == Tag::kFailure) {
    data_.failure = std::move(failure);
  } else {
    DestroyActive();
    tag_ = Tag::kFailure;
    new (&data_.failure) ::mojo_base::mojom::ErrorPtr(
        std::move(failure));
  }
}


BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
    const ::std::monostate& value)
    : success(std::move(value)) {}

BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
    ::mojo_base::mojom::ErrorPtr value)
    : failure(std::move(value)) {}

void BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::DestroyActive() {
  switch (tag_) {

    case Tag::kSuccess:
      std::destroy_at(&data_.success);
      break;
    case Tag::kFailure:
      std::destroy_at(&data_.failure);
      break;
  }
}

bool BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
// The declaration includes the definition on other builds.

BookmarksObserver::IPCStableHashFunction BookmarksObserver::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::BookmarksObserver>(message.name())) {
    case messages::BookmarksObserver::kOnBookmarksEvents: {
      return &BookmarksObserver::OnBookmarksEvents_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* BookmarksObserver::MessageToMethodName_(mojo::Message& message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (!is_response) {
    switch (static_cast<messages::BookmarksObserver>(message.name())) {
      case messages::BookmarksObserver::kOnBookmarksEvents:
            return "Receive bookmarks_api::mojom::BookmarksObserver::OnBookmarksEvents";
    }
  } else {
    switch (static_cast<messages::BookmarksObserver>(message.name())) {
      case messages::BookmarksObserver::kOnBookmarksEvents:
            return "Receive reply bookmarks_api::mojom::BookmarksObserver::OnBookmarksEvents";
    }
  }
  return "Receive unknown mojo message";
#else
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (is_response) {
    return "Receive mojo reply";
  } else {
    return "Receive mojo message";
  }
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
}

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t BookmarksObserver::OnBookmarksEvents_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x6a354b08;  // IPCStableHash for bookmarks_api::mojom::BookmarksObserver::OnBookmarksEvents
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

BookmarksObserverProxy::BookmarksObserverProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void BookmarksObserverProxy::OnBookmarksEvents(
    std::vector<BookmarksEventPtr> in_events) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send bookmarks_api::mojom::BookmarksObserver::OnBookmarksEvents", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("events"), in_events,
                        "<value of type std::vector<BookmarksEventPtr>>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::BookmarksObserver::kOnBookmarksEvents), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::bookmarks_api::mojom::internal::BookmarksObserver_OnBookmarksEvents_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->events)::BaseType>
      events_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& events_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::bookmarks_api::mojom::BookmarksEventDataView>>(
    in_events,
    events_fragment,
    &events_validate_params);

  params->events.Set(
      events_fragment.is_null() ? nullptr : events_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->events.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null events in BookmarksObserver.OnBookmarksEvents request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(BookmarksObserver::Name_);
  message.set_method_name("OnBookmarksEvents");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

// static
bool BookmarksObserverStubDispatch::Accept(
    BookmarksObserver* impl,
    mojo::Message* message) {
  switch (static_cast<messages::BookmarksObserver>(message->header()->name)) {
    case messages::BookmarksObserver::kOnBookmarksEvents: {
      DCHECK(message->is_serialized());
      internal::BookmarksObserver_OnBookmarksEvents_Params_Data* params =
          reinterpret_cast<internal::BookmarksObserver_OnBookmarksEvents_Params_Data*>(
              message->mutable_payload());
      

      // Validation for BookmarksObserver.0
      bool success = true;
      std::vector<BookmarksEventPtr> p_events{};
      BookmarksObserver_OnBookmarksEvents_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadEvents(&p_events))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            BookmarksObserver::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnBookmarksEvents(        
        std::move(p_events));
      return true;
    }
  }
  return false;
}

// static
bool BookmarksObserverStubDispatch::AcceptWithResponder(
    BookmarksObserver* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  [[maybe_unused]] const bool message_is_sync =
      message->has_flag(mojo::Message::kFlagIsSync);
  [[maybe_unused]] const uint64_t request_id = message->request_id();
  switch (static_cast<messages::BookmarksObserver>(message->header()->name)) {
    case messages::BookmarksObserver::kOnBookmarksEvents: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kBookmarksObserverValidationInfo[] = {
    { &internal::BookmarksObserver_OnBookmarksEvents_Params_Data::Validate,
     nullptr /* no response */},
};

bool BookmarksObserverRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::bookmarks_api::mojom::BookmarksObserver::Name_,
    kBookmarksObserverValidationInfo);
}

// The declaration includes the definition on other builds.

BookmarksService::IPCStableHashFunction BookmarksService::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::BookmarksService>(message.name())) {
    case messages::BookmarksService::kGetBookmarks: {
      return &BookmarksService::GetBookmarks_Sym::IPCStableHash;
    }
    case messages::BookmarksService::kGetBookmark: {
      return &BookmarksService::GetBookmark_Sym::IPCStableHash;
    }
    case messages::BookmarksService::kCreateBookmarkNode: {
      return &BookmarksService::CreateBookmarkNode_Sym::IPCStableHash;
    }
    case messages::BookmarksService::kUpdateBookmarkNode: {
      return &BookmarksService::UpdateBookmarkNode_Sym::IPCStableHash;
    }
    case messages::BookmarksService::kMoveBookmarkNode: {
      return &BookmarksService::MoveBookmarkNode_Sym::IPCStableHash;
    }
    case messages::BookmarksService::kDeleteBookmarkNodes: {
      return &BookmarksService::DeleteBookmarkNodes_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* BookmarksService::MessageToMethodName_(mojo::Message& message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (!is_response) {
    switch (static_cast<messages::BookmarksService>(message.name())) {
      case messages::BookmarksService::kGetBookmarks:
            return "Receive bookmarks_api::mojom::BookmarksService::GetBookmarks";
      case messages::BookmarksService::kGetBookmark:
            return "Receive bookmarks_api::mojom::BookmarksService::GetBookmark";
      case messages::BookmarksService::kCreateBookmarkNode:
            return "Receive bookmarks_api::mojom::BookmarksService::CreateBookmarkNode";
      case messages::BookmarksService::kUpdateBookmarkNode:
            return "Receive bookmarks_api::mojom::BookmarksService::UpdateBookmarkNode";
      case messages::BookmarksService::kMoveBookmarkNode:
            return "Receive bookmarks_api::mojom::BookmarksService::MoveBookmarkNode";
      case messages::BookmarksService::kDeleteBookmarkNodes:
            return "Receive bookmarks_api::mojom::BookmarksService::DeleteBookmarkNodes";
    }
  } else {
    switch (static_cast<messages::BookmarksService>(message.name())) {
      case messages::BookmarksService::kGetBookmarks:
            return "Receive reply bookmarks_api::mojom::BookmarksService::GetBookmarks";
      case messages::BookmarksService::kGetBookmark:
            return "Receive reply bookmarks_api::mojom::BookmarksService::GetBookmark";
      case messages::BookmarksService::kCreateBookmarkNode:
            return "Receive reply bookmarks_api::mojom::BookmarksService::CreateBookmarkNode";
      case messages::BookmarksService::kUpdateBookmarkNode:
            return "Receive reply bookmarks_api::mojom::BookmarksService::UpdateBookmarkNode";
      case messages::BookmarksService::kMoveBookmarkNode:
            return "Receive reply bookmarks_api::mojom::BookmarksService::MoveBookmarkNode";
      case messages::BookmarksService::kDeleteBookmarkNodes:
            return "Receive reply bookmarks_api::mojom::BookmarksService::DeleteBookmarkNodes";
    }
  }
  return "Receive unknown mojo message";
#else
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (is_response) {
    return "Receive mojo reply";
  } else {
    return "Receive mojo message";
  }
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
}

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t BookmarksService::GetBookmarks_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x2c5c27aa;  // IPCStableHash for bookmarks_api::mojom::BookmarksService::GetBookmarks
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t BookmarksService::GetBookmark_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x3fe58609;  // IPCStableHash for bookmarks_api::mojom::BookmarksService::GetBookmark
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t BookmarksService::CreateBookmarkNode_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x6fb87b27;  // IPCStableHash for bookmarks_api::mojom::BookmarksService::CreateBookmarkNode
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t BookmarksService::UpdateBookmarkNode_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x0425d0b8;  // IPCStableHash for bookmarks_api::mojom::BookmarksService::UpdateBookmarkNode
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t BookmarksService::MoveBookmarkNode_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x05a008f4;  // IPCStableHash for bookmarks_api::mojom::BookmarksService::MoveBookmarkNode
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t BookmarksService::DeleteBookmarkNodes_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0xbbad3d87;  // IPCStableHash for bookmarks_api::mojom::BookmarksService::DeleteBookmarkNodes
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class BookmarksService_GetBookmarks_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  BookmarksService_GetBookmarks_ForwardToCallback(
      BookmarksService::GetBookmarksCallback callback
      ) : callback_(std::move(callback)) {
  }

  BookmarksService_GetBookmarks_ForwardToCallback(const BookmarksService_GetBookmarks_ForwardToCallback&) = delete;
  BookmarksService_GetBookmarks_ForwardToCallback& operator=(const BookmarksService_GetBookmarks_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  BookmarksService::GetBookmarksCallback callback_;
};

class BookmarksService_GetBookmark_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  BookmarksService_GetBookmark_ForwardToCallback(
      BookmarksService::GetBookmarkCallback callback
      ) : callback_(std::move(callback)) {
  }

  BookmarksService_GetBookmark_ForwardToCallback(const BookmarksService_GetBookmark_ForwardToCallback&) = delete;
  BookmarksService_GetBookmark_ForwardToCallback& operator=(const BookmarksService_GetBookmark_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  BookmarksService::GetBookmarkCallback callback_;
};

class BookmarksService_CreateBookmarkNode_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  BookmarksService_CreateBookmarkNode_ForwardToCallback(
      BookmarksService::CreateBookmarkNodeCallback callback
      ) : callback_(std::move(callback)) {
  }

  BookmarksService_CreateBookmarkNode_ForwardToCallback(const BookmarksService_CreateBookmarkNode_ForwardToCallback&) = delete;
  BookmarksService_CreateBookmarkNode_ForwardToCallback& operator=(const BookmarksService_CreateBookmarkNode_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  BookmarksService::CreateBookmarkNodeCallback callback_;
};

class BookmarksService_UpdateBookmarkNode_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  BookmarksService_UpdateBookmarkNode_ForwardToCallback(
      BookmarksService::UpdateBookmarkNodeCallback callback
      ) : callback_(std::move(callback)) {
  }

  BookmarksService_UpdateBookmarkNode_ForwardToCallback(const BookmarksService_UpdateBookmarkNode_ForwardToCallback&) = delete;
  BookmarksService_UpdateBookmarkNode_ForwardToCallback& operator=(const BookmarksService_UpdateBookmarkNode_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  BookmarksService::UpdateBookmarkNodeCallback callback_;
};

class BookmarksService_MoveBookmarkNode_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  BookmarksService_MoveBookmarkNode_ForwardToCallback(
      BookmarksService::MoveBookmarkNodeCallback callback
      ) : callback_(std::move(callback)) {
  }

  BookmarksService_MoveBookmarkNode_ForwardToCallback(const BookmarksService_MoveBookmarkNode_ForwardToCallback&) = delete;
  BookmarksService_MoveBookmarkNode_ForwardToCallback& operator=(const BookmarksService_MoveBookmarkNode_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  BookmarksService::MoveBookmarkNodeCallback callback_;
};

class BookmarksService_DeleteBookmarkNodes_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  BookmarksService_DeleteBookmarkNodes_ForwardToCallback(
      BookmarksService::DeleteBookmarkNodesCallback callback
      ) : callback_(std::move(callback)) {
  }

  BookmarksService_DeleteBookmarkNodes_ForwardToCallback(const BookmarksService_DeleteBookmarkNodes_ForwardToCallback&) = delete;
  BookmarksService_DeleteBookmarkNodes_ForwardToCallback& operator=(const BookmarksService_DeleteBookmarkNodes_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  BookmarksService::DeleteBookmarkNodesCallback callback_;
};

BookmarksServiceProxy::BookmarksServiceProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void BookmarksServiceProxy::GetBookmarks(
    GetBookmarksCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send bookmarks_api::mojom::BookmarksService::GetBookmarks");
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::BookmarksService::kGetBookmarks), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::bookmarks_api::mojom::internal::BookmarksService_GetBookmarks_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(BookmarksService::Name_);
  message.set_method_name("GetBookmarks");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new BookmarksService_GetBookmarks_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void BookmarksServiceProxy::GetBookmark(
    const ::base::Uuid& in_id, GetBookmarkCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send bookmarks_api::mojom::BookmarksService::GetBookmark", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("id"), in_id,
                        "<value of type const ::base::Uuid&>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::BookmarksService::kGetBookmark), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::bookmarks_api::mojom::internal::BookmarksService_GetBookmark_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->id)::BaseType> id_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
    in_id,
    id_fragment);

  params->id.Set(
      id_fragment.is_null() ? nullptr : id_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->id.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null id in BookmarksService.GetBookmark request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(BookmarksService::Name_);
  message.set_method_name("GetBookmark");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new BookmarksService_GetBookmark_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void BookmarksServiceProxy::CreateBookmarkNode(
    const ::base::Uuid& in_parent_id, std::optional<int32_t> in_index, BookmarkNodePtr in_node, CreateBookmarkNodeCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send bookmarks_api::mojom::BookmarksService::CreateBookmarkNode", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("parent_id"), in_parent_id,
                        "<value of type const ::base::Uuid&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("index"), in_index,
                        "<value of type std::optional<int32_t>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("node"), in_node,
                        "<value of type BookmarkNodePtr>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::BookmarksService::kCreateBookmarkNode), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::bookmarks_api::mojom::internal::BookmarksService_CreateBookmarkNode_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->parent_id)::BaseType> parent_id_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
    in_parent_id,
    parent_id_fragment);

  params->parent_id.Set(
      parent_id_fragment.is_null() ? nullptr : parent_id_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->parent_id.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null parent_id in BookmarksService.CreateBookmarkNode request");
  params->index_$flag = in_index.has_value();
  if (in_index.has_value()) {
    params->index_$value = in_index.value();
  }
  mojo::internal::MessageFragment<decltype(params->node)>
      node_fragment(params.message());
  node_fragment.Claim(&params->node);
  
  mojo::internal::Serialize<::bookmarks_api::mojom::BookmarkNodeDataView>(
    in_node,
    node_fragment,
    true);

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->node.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null node in BookmarksService.CreateBookmarkNode request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(BookmarksService::Name_);
  message.set_method_name("CreateBookmarkNode");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new BookmarksService_CreateBookmarkNode_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void BookmarksServiceProxy::UpdateBookmarkNode(
    BookmarkNodePtr in_node, UpdateBookmarkNodeCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send bookmarks_api::mojom::BookmarksService::UpdateBookmarkNode", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("node"), in_node,
                        "<value of type BookmarkNodePtr>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::BookmarksService::kUpdateBookmarkNode), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::bookmarks_api::mojom::internal::BookmarksService_UpdateBookmarkNode_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->node)>
      node_fragment(params.message());
  node_fragment.Claim(&params->node);
  
  mojo::internal::Serialize<::bookmarks_api::mojom::BookmarkNodeDataView>(
    in_node,
    node_fragment,
    true);

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->node.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null node in BookmarksService.UpdateBookmarkNode request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(BookmarksService::Name_);
  message.set_method_name("UpdateBookmarkNode");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new BookmarksService_UpdateBookmarkNode_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void BookmarksServiceProxy::MoveBookmarkNode(
    const ::base::Uuid& in_id, const ::base::Uuid& in_new_parent_id, std::optional<int32_t> in_index, MoveBookmarkNodeCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send bookmarks_api::mojom::BookmarksService::MoveBookmarkNode", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("id"), in_id,
                        "<value of type const ::base::Uuid&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("new_parent_id"), in_new_parent_id,
                        "<value of type const ::base::Uuid&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("index"), in_index,
                        "<value of type std::optional<int32_t>>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::BookmarksService::kMoveBookmarkNode), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::bookmarks_api::mojom::internal::BookmarksService_MoveBookmarkNode_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->id)::BaseType> id_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
    in_id,
    id_fragment);

  params->id.Set(
      id_fragment.is_null() ? nullptr : id_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->id.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null id in BookmarksService.MoveBookmarkNode request");
  mojo::internal::MessageFragment<
      typename decltype(params->new_parent_id)::BaseType> new_parent_id_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
    in_new_parent_id,
    new_parent_id_fragment);

  params->new_parent_id.Set(
      new_parent_id_fragment.is_null() ? nullptr : new_parent_id_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->new_parent_id.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null new_parent_id in BookmarksService.MoveBookmarkNode request");
  params->index_$flag = in_index.has_value();
  if (in_index.has_value()) {
    params->index_$value = in_index.value();
  }

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(BookmarksService::Name_);
  message.set_method_name("MoveBookmarkNode");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new BookmarksService_MoveBookmarkNode_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void BookmarksServiceProxy::DeleteBookmarkNodes(
    const std::vector<::base::Uuid>& in_ids, DeleteBookmarkNodesCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send bookmarks_api::mojom::BookmarksService::DeleteBookmarkNodes", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("ids"), in_ids,
                        "<value of type const std::vector<::base::Uuid>&>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::BookmarksService::kDeleteBookmarkNodes), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::bookmarks_api::mojom::internal::BookmarksService_DeleteBookmarkNodes_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->ids)::BaseType>
      ids_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& ids_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::mojo_base::mojom::UuidDataView>>(
    in_ids,
    ids_fragment,
    &ids_validate_params);

  params->ids.Set(
      ids_fragment.is_null() ? nullptr : ids_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->ids.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null ids in BookmarksService.DeleteBookmarkNodes request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(BookmarksService::Name_);
  message.set_method_name("DeleteBookmarkNodes");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new BookmarksService_DeleteBookmarkNodes_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}
class BookmarksService_GetBookmarks_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static BookmarksService::GetBookmarksCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<BookmarksService_GetBookmarks_ProxyToResponder> proxy(
        new BookmarksService_GetBookmarks_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&Transform)
      .Then(base::BindOnce(&BookmarksService_GetBookmarks_ProxyToResponder::Run,
                          std::move(proxy)));
  }

  static BookmarksService_GetBookmarks_ResponseParam_ResultPtr Transform(base::expected<
  BookmarksSnapshotPtr,
  ::mojo_base::mojom::ErrorPtr> in) {
    return in.has_value() ? ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_Result::NewSuccess(std::move(in.value())) :
                            ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_Result::NewFailure(std::move(in.error()));
  }



  ~BookmarksService_GetBookmarks_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  BookmarksService_GetBookmarks_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "BookmarksService::GetBookmarksCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      BookmarksService_GetBookmarks_ResponseParam_ResultPtr in_result);
};

bool BookmarksService_GetBookmarks_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::BookmarksService_GetBookmarks_ResponseParams_Data* params =
      reinterpret_cast<
          internal::BookmarksService_GetBookmarks_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for BookmarksService.0
  bool success = true;
  BookmarksService_GetBookmarks_ResponseParam_ResultPtr p_result{};
  BookmarksService_GetBookmarks_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        BookmarksService::Name_, 0, true);
    return false;
  }
  if (!callback_.is_null()) {
    if (p_result->is_success()) {
      std::move(callback_).Run(base::ok(std::move(p_result->get_success())));
    } else {
      std::move(callback_).Run(base::unexpected(std::move(p_result->get_failure())));
    }
  }
  return true;
}

void BookmarksService_GetBookmarks_ProxyToResponder::Run(
    BookmarksService_GetBookmarks_ResponseParam_ResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply bookmarks_api::mojom::BookmarksService::GetBookmarks", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type BookmarksService_GetBookmarks_ResponseParam_ResultPtr>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::BookmarksService::kGetBookmarks), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::bookmarks_api::mojom::internal::BookmarksService_GetBookmarks_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_ResultDataView>(
    in_result,
    result_fragment,
    true);

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->result.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null result in ");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(BookmarksService::Name_);
  message.set_method_name("GetBookmarks");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class BookmarksService_GetBookmark_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static BookmarksService::GetBookmarkCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<BookmarksService_GetBookmark_ProxyToResponder> proxy(
        new BookmarksService_GetBookmark_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&Transform)
      .Then(base::BindOnce(&BookmarksService_GetBookmark_ProxyToResponder::Run,
                          std::move(proxy)));
  }

  static BookmarksService_GetBookmark_ResponseParam_ResultPtr Transform(base::expected<
  BookmarkNodePtr,
  ::mojo_base::mojom::ErrorPtr> in) {
    return in.has_value() ? ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_Result::NewSuccess(std::move(in.value())) :
                            ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_Result::NewFailure(std::move(in.error()));
  }



  ~BookmarksService_GetBookmark_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  BookmarksService_GetBookmark_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "BookmarksService::GetBookmarkCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      BookmarksService_GetBookmark_ResponseParam_ResultPtr in_result);
};

bool BookmarksService_GetBookmark_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::BookmarksService_GetBookmark_ResponseParams_Data* params =
      reinterpret_cast<
          internal::BookmarksService_GetBookmark_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for BookmarksService.1
  bool success = true;
  BookmarksService_GetBookmark_ResponseParam_ResultPtr p_result{};
  BookmarksService_GetBookmark_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        BookmarksService::Name_, 1, true);
    return false;
  }
  if (!callback_.is_null()) {
    if (p_result->is_success()) {
      std::move(callback_).Run(base::ok(std::move(p_result->get_success())));
    } else {
      std::move(callback_).Run(base::unexpected(std::move(p_result->get_failure())));
    }
  }
  return true;
}

void BookmarksService_GetBookmark_ProxyToResponder::Run(
    BookmarksService_GetBookmark_ResponseParam_ResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply bookmarks_api::mojom::BookmarksService::GetBookmark", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type BookmarksService_GetBookmark_ResponseParam_ResultPtr>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::BookmarksService::kGetBookmark), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::bookmarks_api::mojom::internal::BookmarksService_GetBookmark_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_ResultDataView>(
    in_result,
    result_fragment,
    true);

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->result.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null result in ");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(BookmarksService::Name_);
  message.set_method_name("GetBookmark");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class BookmarksService_CreateBookmarkNode_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static BookmarksService::CreateBookmarkNodeCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<BookmarksService_CreateBookmarkNode_ProxyToResponder> proxy(
        new BookmarksService_CreateBookmarkNode_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&Transform)
      .Then(base::BindOnce(&BookmarksService_CreateBookmarkNode_ProxyToResponder::Run,
                          std::move(proxy)));
  }

  static BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr Transform(base::expected<
  BookmarkNodePtr,
  ::mojo_base::mojom::ErrorPtr> in) {
    return in.has_value() ? ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_Result::NewSuccess(std::move(in.value())) :
                            ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_Result::NewFailure(std::move(in.error()));
  }



  ~BookmarksService_CreateBookmarkNode_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  BookmarksService_CreateBookmarkNode_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "BookmarksService::CreateBookmarkNodeCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr in_result);
};

bool BookmarksService_CreateBookmarkNode_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::BookmarksService_CreateBookmarkNode_ResponseParams_Data* params =
      reinterpret_cast<
          internal::BookmarksService_CreateBookmarkNode_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for BookmarksService.2
  bool success = true;
  BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr p_result{};
  BookmarksService_CreateBookmarkNode_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        BookmarksService::Name_, 2, true);
    return false;
  }
  if (!callback_.is_null()) {
    if (p_result->is_success()) {
      std::move(callback_).Run(base::ok(std::move(p_result->get_success())));
    } else {
      std::move(callback_).Run(base::unexpected(std::move(p_result->get_failure())));
    }
  }
  return true;
}

void BookmarksService_CreateBookmarkNode_ProxyToResponder::Run(
    BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply bookmarks_api::mojom::BookmarksService::CreateBookmarkNode", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::BookmarksService::kCreateBookmarkNode), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::bookmarks_api::mojom::internal::BookmarksService_CreateBookmarkNode_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_ResultDataView>(
    in_result,
    result_fragment,
    true);

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->result.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null result in ");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(BookmarksService::Name_);
  message.set_method_name("CreateBookmarkNode");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class BookmarksService_UpdateBookmarkNode_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static BookmarksService::UpdateBookmarkNodeCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<BookmarksService_UpdateBookmarkNode_ProxyToResponder> proxy(
        new BookmarksService_UpdateBookmarkNode_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&Transform)
      .Then(base::BindOnce(&BookmarksService_UpdateBookmarkNode_ProxyToResponder::Run,
                          std::move(proxy)));
  }

  static BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr Transform(base::expected<
  BookmarkNodePtr,
  ::mojo_base::mojom::ErrorPtr> in) {
    return in.has_value() ? ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_Result::NewSuccess(std::move(in.value())) :
                            ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_Result::NewFailure(std::move(in.error()));
  }



  ~BookmarksService_UpdateBookmarkNode_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  BookmarksService_UpdateBookmarkNode_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "BookmarksService::UpdateBookmarkNodeCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr in_result);
};

bool BookmarksService_UpdateBookmarkNode_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::BookmarksService_UpdateBookmarkNode_ResponseParams_Data* params =
      reinterpret_cast<
          internal::BookmarksService_UpdateBookmarkNode_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for BookmarksService.3
  bool success = true;
  BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr p_result{};
  BookmarksService_UpdateBookmarkNode_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        BookmarksService::Name_, 3, true);
    return false;
  }
  if (!callback_.is_null()) {
    if (p_result->is_success()) {
      std::move(callback_).Run(base::ok(std::move(p_result->get_success())));
    } else {
      std::move(callback_).Run(base::unexpected(std::move(p_result->get_failure())));
    }
  }
  return true;
}

void BookmarksService_UpdateBookmarkNode_ProxyToResponder::Run(
    BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply bookmarks_api::mojom::BookmarksService::UpdateBookmarkNode", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::BookmarksService::kUpdateBookmarkNode), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::bookmarks_api::mojom::internal::BookmarksService_UpdateBookmarkNode_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_ResultDataView>(
    in_result,
    result_fragment,
    true);

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->result.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null result in ");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(BookmarksService::Name_);
  message.set_method_name("UpdateBookmarkNode");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class BookmarksService_MoveBookmarkNode_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static BookmarksService::MoveBookmarkNodeCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<BookmarksService_MoveBookmarkNode_ProxyToResponder> proxy(
        new BookmarksService_MoveBookmarkNode_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&Transform)
      .Then(base::BindOnce(&BookmarksService_MoveBookmarkNode_ProxyToResponder::Run,
                          std::move(proxy)));
  }

  static BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr Transform(base::expected<
  ::std::monostate,
  ::mojo_base::mojom::ErrorPtr> in) {
    return in.has_value() ? ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_Result::NewSuccess(std::move(in.value())) :
                            ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_Result::NewFailure(std::move(in.error()));
  }



  ~BookmarksService_MoveBookmarkNode_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  BookmarksService_MoveBookmarkNode_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "BookmarksService::MoveBookmarkNodeCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr in_result);
};

bool BookmarksService_MoveBookmarkNode_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::BookmarksService_MoveBookmarkNode_ResponseParams_Data* params =
      reinterpret_cast<
          internal::BookmarksService_MoveBookmarkNode_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for BookmarksService.4
  bool success = true;
  BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr p_result{};
  BookmarksService_MoveBookmarkNode_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        BookmarksService::Name_, 4, true);
    return false;
  }
  if (!callback_.is_null()) {
    if (p_result->is_success()) {
      std::move(callback_).Run(base::ok(std::move(p_result->get_success())));
    } else {
      std::move(callback_).Run(base::unexpected(std::move(p_result->get_failure())));
    }
  }
  return true;
}

void BookmarksService_MoveBookmarkNode_ProxyToResponder::Run(
    BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply bookmarks_api::mojom::BookmarksService::MoveBookmarkNode", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::BookmarksService::kMoveBookmarkNode), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::bookmarks_api::mojom::internal::BookmarksService_MoveBookmarkNode_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_ResultDataView>(
    in_result,
    result_fragment,
    true);

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->result.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null result in ");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(BookmarksService::Name_);
  message.set_method_name("MoveBookmarkNode");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class BookmarksService_DeleteBookmarkNodes_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static BookmarksService::DeleteBookmarkNodesCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<BookmarksService_DeleteBookmarkNodes_ProxyToResponder> proxy(
        new BookmarksService_DeleteBookmarkNodes_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&Transform)
      .Then(base::BindOnce(&BookmarksService_DeleteBookmarkNodes_ProxyToResponder::Run,
                          std::move(proxy)));
  }

  static BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr Transform(base::expected<
  ::std::monostate,
  ::mojo_base::mojom::ErrorPtr> in) {
    return in.has_value() ? ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::NewSuccess(std::move(in.value())) :
                            ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::NewFailure(std::move(in.error()));
  }



  ~BookmarksService_DeleteBookmarkNodes_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  BookmarksService_DeleteBookmarkNodes_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "BookmarksService::DeleteBookmarkNodesCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr in_result);
};

bool BookmarksService_DeleteBookmarkNodes_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::BookmarksService_DeleteBookmarkNodes_ResponseParams_Data* params =
      reinterpret_cast<
          internal::BookmarksService_DeleteBookmarkNodes_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for BookmarksService.5
  bool success = true;
  BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr p_result{};
  BookmarksService_DeleteBookmarkNodes_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResult(&p_result))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        BookmarksService::Name_, 5, true);
    return false;
  }
  if (!callback_.is_null()) {
    if (p_result->is_success()) {
      std::move(callback_).Run(base::ok(std::move(p_result->get_success())));
    } else {
      std::move(callback_).Run(base::unexpected(std::move(p_result->get_failure())));
    }
  }
  return true;
}

void BookmarksService_DeleteBookmarkNodes_ProxyToResponder::Run(
    BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr in_result) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply bookmarks_api::mojom::BookmarksService::DeleteBookmarkNodes", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("result"), in_result,
                        "<value of type BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::BookmarksService::kDeleteBookmarkNodes), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::bookmarks_api::mojom::internal::BookmarksService_DeleteBookmarkNodes_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<decltype(params->result)>
      result_fragment(params.message());
  result_fragment.Claim(&params->result);
  
  mojo::internal::Serialize<::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultDataView>(
    in_result,
    result_fragment,
    true);

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->result.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null result in ");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(BookmarksService::Name_);
  message.set_method_name("DeleteBookmarkNodes");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}

// static
bool BookmarksServiceStubDispatch::Accept(
    BookmarksService* impl,
    mojo::Message* message) {
  switch (static_cast<messages::BookmarksService>(message->header()->name)) {
    case messages::BookmarksService::kGetBookmarks: {
      break;
    }
    case messages::BookmarksService::kGetBookmark: {
      break;
    }
    case messages::BookmarksService::kCreateBookmarkNode: {
      break;
    }
    case messages::BookmarksService::kUpdateBookmarkNode: {
      break;
    }
    case messages::BookmarksService::kMoveBookmarkNode: {
      break;
    }
    case messages::BookmarksService::kDeleteBookmarkNodes: {
      break;
    }
  }
  return false;
}

// static
bool BookmarksServiceStubDispatch::AcceptWithResponder(
    BookmarksService* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  [[maybe_unused]] const bool message_is_sync =
      message->has_flag(mojo::Message::kFlagIsSync);
  [[maybe_unused]] const uint64_t request_id = message->request_id();
  switch (static_cast<messages::BookmarksService>(message->header()->name)) {
    case messages::BookmarksService::kGetBookmarks: {
      internal::BookmarksService_GetBookmarks_Params_Data* params =
          reinterpret_cast<
              internal::BookmarksService_GetBookmarks_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for BookmarksService.0
      bool success = true;
      BookmarksService_GetBookmarks_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            BookmarksService::Name_, 0, false);
        return false;
      }
      auto callback =
          BookmarksService_GetBookmarks_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetBookmarks(std::move(callback));
      return true;
    }
    case messages::BookmarksService::kGetBookmark: {
      internal::BookmarksService_GetBookmark_Params_Data* params =
          reinterpret_cast<
              internal::BookmarksService_GetBookmark_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for BookmarksService.1
      bool success = true;
      ::base::Uuid p_id{};
      BookmarksService_GetBookmark_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadId(&p_id))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            BookmarksService::Name_, 1, false);
        return false;
      }
      auto callback =
          BookmarksService_GetBookmark_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetBookmark(        
        std::move(p_id), std::move(callback));
      return true;
    }
    case messages::BookmarksService::kCreateBookmarkNode: {
      internal::BookmarksService_CreateBookmarkNode_Params_Data* params =
          reinterpret_cast<
              internal::BookmarksService_CreateBookmarkNode_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for BookmarksService.2
      bool success = true;
      ::base::Uuid p_parent_id{};
      std::optional<int32_t> p_index{};
      BookmarkNodePtr p_node{};
      BookmarksService_CreateBookmarkNode_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadParentId(&p_parent_id))
        success = false;
      if (success) {
        p_index = input_data_view.index();
      }
      if (success && !input_data_view.ReadNode(&p_node))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            BookmarksService::Name_, 2, false);
        return false;
      }
      auto callback =
          BookmarksService_CreateBookmarkNode_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreateBookmarkNode(        
        std::move(p_parent_id), 
        std::move(p_index), 
        std::move(p_node), std::move(callback));
      return true;
    }
    case messages::BookmarksService::kUpdateBookmarkNode: {
      internal::BookmarksService_UpdateBookmarkNode_Params_Data* params =
          reinterpret_cast<
              internal::BookmarksService_UpdateBookmarkNode_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for BookmarksService.3
      bool success = true;
      BookmarkNodePtr p_node{};
      BookmarksService_UpdateBookmarkNode_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadNode(&p_node))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            BookmarksService::Name_, 3, false);
        return false;
      }
      auto callback =
          BookmarksService_UpdateBookmarkNode_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->UpdateBookmarkNode(        
        std::move(p_node), std::move(callback));
      return true;
    }
    case messages::BookmarksService::kMoveBookmarkNode: {
      internal::BookmarksService_MoveBookmarkNode_Params_Data* params =
          reinterpret_cast<
              internal::BookmarksService_MoveBookmarkNode_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for BookmarksService.4
      bool success = true;
      ::base::Uuid p_id{};
      ::base::Uuid p_new_parent_id{};
      std::optional<int32_t> p_index{};
      BookmarksService_MoveBookmarkNode_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadId(&p_id))
        success = false;
      if (success && !input_data_view.ReadNewParentId(&p_new_parent_id))
        success = false;
      if (success) {
        p_index = input_data_view.index();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            BookmarksService::Name_, 4, false);
        return false;
      }
      auto callback =
          BookmarksService_MoveBookmarkNode_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->MoveBookmarkNode(        
        std::move(p_id), 
        std::move(p_new_parent_id), 
        std::move(p_index), std::move(callback));
      return true;
    }
    case messages::BookmarksService::kDeleteBookmarkNodes: {
      internal::BookmarksService_DeleteBookmarkNodes_Params_Data* params =
          reinterpret_cast<
              internal::BookmarksService_DeleteBookmarkNodes_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for BookmarksService.5
      bool success = true;
      std::vector<::base::Uuid> p_ids{};
      BookmarksService_DeleteBookmarkNodes_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadIds(&p_ids))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            BookmarksService::Name_, 5, false);
        return false;
      }
      auto callback =
          BookmarksService_DeleteBookmarkNodes_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->DeleteBookmarkNodes(        
        std::move(p_ids), std::move(callback));
      return true;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kBookmarksServiceValidationInfo[] = {
    { &internal::BookmarksService_GetBookmarks_Params_Data::Validate,
     &internal::BookmarksService_GetBookmarks_ResponseParams_Data::Validate},
    { &internal::BookmarksService_GetBookmark_Params_Data::Validate,
     &internal::BookmarksService_GetBookmark_ResponseParams_Data::Validate},
    { &internal::BookmarksService_CreateBookmarkNode_Params_Data::Validate,
     &internal::BookmarksService_CreateBookmarkNode_ResponseParams_Data::Validate},
    { &internal::BookmarksService_UpdateBookmarkNode_Params_Data::Validate,
     &internal::BookmarksService_UpdateBookmarkNode_ResponseParams_Data::Validate},
    { &internal::BookmarksService_MoveBookmarkNode_Params_Data::Validate,
     &internal::BookmarksService_MoveBookmarkNode_ResponseParams_Data::Validate},
    { &internal::BookmarksService_DeleteBookmarkNodes_Params_Data::Validate,
     &internal::BookmarksService_DeleteBookmarkNodes_ResponseParams_Data::Validate},
};

bool BookmarksServiceRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::bookmarks_api::mojom::BookmarksService::Name_,
    kBookmarksServiceValidationInfo);
}

bool BookmarksServiceResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::bookmarks_api::mojom::BookmarksService::Name_,
    kBookmarksServiceValidationInfo);
}



BookmarksServiceBridge::BookmarksServiceBridge(BookmarksServiceDirectReturnStub* stub)
        : stub_(stub) {
    CHECK(stub_);
}

BookmarksServiceBridge::~BookmarksServiceBridge() = default;


void BookmarksServiceBridge::GetBookmarks(GetBookmarksCallback callback) {

    std::move(callback).Run(stub_->GetBookmarks(
    ));
}

void BookmarksServiceBridge::GetBookmark(const ::base::Uuid& id, GetBookmarkCallback callback) {

    std::move(callback).Run(stub_->GetBookmark(
      std::move(id)

    ));
}

void BookmarksServiceBridge::CreateBookmarkNode(const ::base::Uuid& parent_id, std::optional<int32_t> index, BookmarkNodePtr node, CreateBookmarkNodeCallback callback) {

    std::move(callback).Run(stub_->CreateBookmarkNode(
      std::move(parent_id)
, 
      std::move(index)
, 
      std::move(node)

    ));
}

void BookmarksServiceBridge::UpdateBookmarkNode(BookmarkNodePtr node, UpdateBookmarkNodeCallback callback) {

    std::move(callback).Run(stub_->UpdateBookmarkNode(
      std::move(node)

    ));
}

void BookmarksServiceBridge::MoveBookmarkNode(const ::base::Uuid& id, const ::base::Uuid& new_parent_id, std::optional<int32_t> index, MoveBookmarkNodeCallback callback) {

    std::move(callback).Run(stub_->MoveBookmarkNode(
      std::move(id)
, 
      std::move(new_parent_id)
, 
      std::move(index)

    ));
}

void BookmarksServiceBridge::DeleteBookmarkNodes(const std::vector<::base::Uuid>& ids, DeleteBookmarkNodesCallback callback) {

    std::move(callback).Run(stub_->DeleteBookmarkNodes(
      std::move(ids)

    ));
}



}  // bookmarks_api::mojom


namespace mojo {


// static
bool StructTraits<::bookmarks_api::mojom::LegacyFields::DataView, ::bookmarks_api::mojom::LegacyFieldsPtr>::Read(
    ::bookmarks_api::mojom::LegacyFields::DataView input,
    ::bookmarks_api::mojom::LegacyFieldsPtr* output) {
  bool success = true;
  ::bookmarks_api::mojom::LegacyFieldsPtr result(::bookmarks_api::mojom::LegacyFields::New());
  
      if (success) {
        result->id = input.id();
      }
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::bookmarks_api::mojom::RootNode::DataView, ::bookmarks_api::mojom::RootNodePtr>::Read(
    ::bookmarks_api::mojom::RootNode::DataView input,
    ::bookmarks_api::mojom::RootNodePtr* output) {
  bool success = true;
  ::bookmarks_api::mojom::RootNodePtr result(::bookmarks_api::mojom::RootNode::New());
  
      if (success && !input.ReadId(&result->id))
        success = false;
      if (success && !input.ReadChildren(&result->children))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::bookmarks_api::mojom::Url::DataView, ::bookmarks_api::mojom::UrlPtr>::Read(
    ::bookmarks_api::mojom::Url::DataView input,
    ::bookmarks_api::mojom::UrlPtr* output) {
  bool success = true;
  ::bookmarks_api::mojom::UrlPtr result(::bookmarks_api::mojom::Url::New());
  
      if (success && !input.ReadId(&result->id))
        success = false;
      if (success && !input.ReadLegacy(&result->legacy))
        success = false;
      if (success && !input.ReadTitle(&result->title))
        success = false;
      if (success && !input.ReadUrl(&result->url))
        success = false;
      if (success && !input.ReadFaviconUrl(&result->favicon_url))
        success = false;
      if (success)
        result->is_synced = input.is_synced();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::bookmarks_api::mojom::Folder::DataView, ::bookmarks_api::mojom::FolderPtr>::Read(
    ::bookmarks_api::mojom::Folder::DataView input,
    ::bookmarks_api::mojom::FolderPtr* output) {
  bool success = true;
  ::bookmarks_api::mojom::FolderPtr result(::bookmarks_api::mojom::Folder::New());
  
      if (success && !input.ReadId(&result->id))
        success = false;
      if (success && !input.ReadLegacy(&result->legacy))
        success = false;
      if (success && !input.ReadTitle(&result->title))
        success = false;
      if (success && !input.ReadChildren(&result->children))
        success = false;
      if (success && !input.ReadPermanentFolderType(&result->permanent_folder_type)) {
        success = false;
      }
      if (success)
        result->is_synced = input.is_synced();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::bookmarks_api::mojom::BookmarksSnapshot::DataView, ::bookmarks_api::mojom::BookmarksSnapshotPtr>::Read(
    ::bookmarks_api::mojom::BookmarksSnapshot::DataView input,
    ::bookmarks_api::mojom::BookmarksSnapshotPtr* output) {
  bool success = true;
  ::bookmarks_api::mojom::BookmarksSnapshotPtr result(::bookmarks_api::mojom::BookmarksSnapshot::New());
  
      if (success && !input.ReadRoot(&result->root))
        success = false;
      if (success) {
        result->stream =
            input.TakeStream<decltype(result->stream)>();
      }
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::bookmarks_api::mojom::BookmarkNodeCreated::DataView, ::bookmarks_api::mojom::BookmarkNodeCreatedPtr>::Read(
    ::bookmarks_api::mojom::BookmarkNodeCreated::DataView input,
    ::bookmarks_api::mojom::BookmarkNodeCreatedPtr* output) {
  bool success = true;
  ::bookmarks_api::mojom::BookmarkNodeCreatedPtr result(::bookmarks_api::mojom::BookmarkNodeCreated::New());
  
      if (success && !input.ReadParentId(&result->parent_id))
        success = false;
      if (success)
        result->index = input.index();
      if (success && !input.ReadNode(&result->node))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::bookmarks_api::mojom::BookmarkNodeRemoved::DataView, ::bookmarks_api::mojom::BookmarkNodeRemovedPtr>::Read(
    ::bookmarks_api::mojom::BookmarkNodeRemoved::DataView input,
    ::bookmarks_api::mojom::BookmarkNodeRemovedPtr* output) {
  bool success = true;
  ::bookmarks_api::mojom::BookmarkNodeRemovedPtr result(::bookmarks_api::mojom::BookmarkNodeRemoved::New());
  
      if (success && !input.ReadId(&result->id))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::bookmarks_api::mojom::BookmarkNodeMoved::DataView, ::bookmarks_api::mojom::BookmarkNodeMovedPtr>::Read(
    ::bookmarks_api::mojom::BookmarkNodeMoved::DataView input,
    ::bookmarks_api::mojom::BookmarkNodeMovedPtr* output) {
  bool success = true;
  ::bookmarks_api::mojom::BookmarkNodeMovedPtr result(::bookmarks_api::mojom::BookmarkNodeMoved::New());
  
      if (success && !input.ReadOldParentId(&result->old_parent_id))
        success = false;
      if (success)
        result->old_index = input.old_index();
      if (success && !input.ReadNewParentId(&result->new_parent_id))
        success = false;
      if (success)
        result->new_index = input.new_index();
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::bookmarks_api::mojom::BookmarkNodeChanged::DataView, ::bookmarks_api::mojom::BookmarkNodeChangedPtr>::Read(
    ::bookmarks_api::mojom::BookmarkNodeChanged::DataView input,
    ::bookmarks_api::mojom::BookmarkNodeChangedPtr* output) {
  bool success = true;
  ::bookmarks_api::mojom::BookmarkNodeChangedPtr result(::bookmarks_api::mojom::BookmarkNodeChanged::New());
  
      if (success && !input.ReadNode(&result->node))
        success = false;
  *output = std::move(result);
  return success;
}

// static
bool UnionTraits<::bookmarks_api::mojom::BookmarkNode::DataView, ::bookmarks_api::mojom::BookmarkNodePtr>::Read(
    ::bookmarks_api::mojom::BookmarkNode::DataView input,
    ::bookmarks_api::mojom::BookmarkNodePtr* output) {
  using UnionType = ::bookmarks_api::mojom::BookmarkNode;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kUrl: {
      ::bookmarks_api::mojom::UrlPtr result_url{};
      if (!input.ReadUrl(&result_url))
        return false;

      *output = UnionType::NewUrl(
          std::move(result_url));
      break;
    }
    case Tag::kFolder: {
      ::bookmarks_api::mojom::FolderPtr result_folder{};
      if (!input.ReadFolder(&result_folder))
        return false;

      *output = UnionType::NewFolder(
          std::move(result_folder));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::bookmarks_api::mojom::BookmarksEvent::DataView, ::bookmarks_api::mojom::BookmarksEventPtr>::Read(
    ::bookmarks_api::mojom::BookmarksEvent::DataView input,
    ::bookmarks_api::mojom::BookmarksEventPtr* output) {
  using UnionType = ::bookmarks_api::mojom::BookmarksEvent;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kAdded: {
      ::bookmarks_api::mojom::BookmarkNodeCreatedPtr result_added{};
      if (!input.ReadAdded(&result_added))
        return false;

      *output = UnionType::NewAdded(
          std::move(result_added));
      break;
    }
    case Tag::kRemoved: {
      ::bookmarks_api::mojom::BookmarkNodeRemovedPtr result_removed{};
      if (!input.ReadRemoved(&result_removed))
        return false;

      *output = UnionType::NewRemoved(
          std::move(result_removed));
      break;
    }
    case Tag::kMoved: {
      ::bookmarks_api::mojom::BookmarkNodeMovedPtr result_moved{};
      if (!input.ReadMoved(&result_moved))
        return false;

      *output = UnionType::NewMoved(
          std::move(result_moved));
      break;
    }
    case Tag::kChanged: {
      ::bookmarks_api::mojom::BookmarkNodeChangedPtr result_changed{};
      if (!input.ReadChanged(&result_changed))
        return false;

      *output = UnionType::NewChanged(
          std::move(result_changed));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_Result::DataView, ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_ResultPtr>::Read(
    ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_Result::DataView input,
    ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_ResultPtr* output) {
  using UnionType = ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_Result;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kSuccess: {
      ::bookmarks_api::mojom::BookmarksSnapshotPtr result_success{};
      if (!input.ReadSuccess(&result_success))
        return false;

      *output = UnionType::NewSuccess(
          std::move(result_success));
      break;
    }
    case Tag::kFailure: {
      ::mojo_base::mojom::ErrorPtr result_failure{};
      if (!input.ReadFailure(&result_failure))
        return false;

      *output = UnionType::NewFailure(
          std::move(result_failure));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_Result::DataView, ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_ResultPtr>::Read(
    ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_Result::DataView input,
    ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_ResultPtr* output) {
  using UnionType = ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_Result;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kSuccess: {
      ::bookmarks_api::mojom::BookmarkNodePtr result_success{};
      if (!input.ReadSuccess(&result_success))
        return false;

      *output = UnionType::NewSuccess(
          std::move(result_success));
      break;
    }
    case Tag::kFailure: {
      ::mojo_base::mojom::ErrorPtr result_failure{};
      if (!input.ReadFailure(&result_failure))
        return false;

      *output = UnionType::NewFailure(
          std::move(result_failure));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_Result::DataView, ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr>::Read(
    ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_Result::DataView input,
    ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr* output) {
  using UnionType = ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_Result;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kSuccess: {
      ::bookmarks_api::mojom::BookmarkNodePtr result_success{};
      if (!input.ReadSuccess(&result_success))
        return false;

      *output = UnionType::NewSuccess(
          std::move(result_success));
      break;
    }
    case Tag::kFailure: {
      ::mojo_base::mojom::ErrorPtr result_failure{};
      if (!input.ReadFailure(&result_failure))
        return false;

      *output = UnionType::NewFailure(
          std::move(result_failure));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_Result::DataView, ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr>::Read(
    ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_Result::DataView input,
    ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr* output) {
  using UnionType = ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_Result;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kSuccess: {
      ::bookmarks_api::mojom::BookmarkNodePtr result_success{};
      if (!input.ReadSuccess(&result_success))
        return false;

      *output = UnionType::NewSuccess(
          std::move(result_success));
      break;
    }
    case Tag::kFailure: {
      ::mojo_base::mojom::ErrorPtr result_failure{};
      if (!input.ReadFailure(&result_failure))
        return false;

      *output = UnionType::NewFailure(
          std::move(result_failure));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_Result::DataView, ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr>::Read(
    ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_Result::DataView input,
    ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr* output) {
  using UnionType = ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_Result;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kSuccess: {
      ::std::monostate result_success{};
      if (!input.ReadSuccess(&result_success))
        return false;

      *output = UnionType::NewSuccess(
          std::move(result_success));
      break;
    }
    case Tag::kFailure: {
      ::mojo_base::mojom::ErrorPtr result_failure{};
      if (!input.ReadFailure(&result_failure))
        return false;

      *output = UnionType::NewFailure(
          std::move(result_failure));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::DataView, ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr>::Read(
    ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::DataView input,
    ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr* output) {
  using UnionType = ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_Result;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kSuccess: {
      ::std::monostate result_success{};
      if (!input.ReadSuccess(&result_success))
        return false;

      *output = UnionType::NewSuccess(
          std::move(result_success));
      break;
    }
    case Tag::kFailure: {
      ::mojo_base::mojom::ErrorPtr result_failure{};
      if (!input.ReadFailure(&result_failure))
        return false;

      *output = UnionType::NewFailure(
          std::move(result_failure));
      break;
    }
    default:

      return false;
  }
  return true;
}

}  // namespace mojo


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


namespace bookmarks_api::mojom {


void BookmarksObserverInterceptorForTesting::OnBookmarksEvents(std::vector<BookmarksEventPtr> events) {
  GetForwardingInterface()->OnBookmarksEvents(
    std::move(events)
    );
}
BookmarksObserverAsyncWaiter::BookmarksObserverAsyncWaiter(
    BookmarksObserver* proxy) : proxy_(proxy) {}

BookmarksObserverAsyncWaiter::~BookmarksObserverAsyncWaiter() = default;





void BookmarksServiceInterceptorForTesting::GetBookmarks(GetBookmarksCallback callback) {
  GetForwardingInterface()->GetBookmarks(std::move(callback));
}
void BookmarksServiceInterceptorForTesting::GetBookmark(const ::base::Uuid& id, GetBookmarkCallback callback) {
  GetForwardingInterface()->GetBookmark(
    std::move(id)
    , std::move(callback));
}
void BookmarksServiceInterceptorForTesting::CreateBookmarkNode(const ::base::Uuid& parent_id, std::optional<int32_t> index, BookmarkNodePtr node, CreateBookmarkNodeCallback callback) {
  GetForwardingInterface()->CreateBookmarkNode(
    std::move(parent_id)
    , 
    std::move(index)
    , 
    std::move(node)
    , std::move(callback));
}
void BookmarksServiceInterceptorForTesting::UpdateBookmarkNode(BookmarkNodePtr node, UpdateBookmarkNodeCallback callback) {
  GetForwardingInterface()->UpdateBookmarkNode(
    std::move(node)
    , std::move(callback));
}
void BookmarksServiceInterceptorForTesting::MoveBookmarkNode(const ::base::Uuid& id, const ::base::Uuid& new_parent_id, std::optional<int32_t> index, MoveBookmarkNodeCallback callback) {
  GetForwardingInterface()->MoveBookmarkNode(
    std::move(id)
    , 
    std::move(new_parent_id)
    , 
    std::move(index)
    , std::move(callback));
}
void BookmarksServiceInterceptorForTesting::DeleteBookmarkNodes(const std::vector<::base::Uuid>& ids, DeleteBookmarkNodesCallback callback) {
  GetForwardingInterface()->DeleteBookmarkNodes(
    std::move(ids)
    , std::move(callback));
}
BookmarksServiceAsyncWaiter::BookmarksServiceAsyncWaiter(
    BookmarksService* proxy) : proxy_(proxy) {}

BookmarksServiceAsyncWaiter::~BookmarksServiceAsyncWaiter() = default;







}  // bookmarks_api::mojom


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