// chrome/common/actor.mojom-shared.cc is auto generated by mojom_bindings_generator.py, do not edit

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

#include "chrome/common/actor.mojom-shared.h"
#include <ostream>
#include <utility>
#include "base/strings/stringprintf.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/lib/validation_util.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "chrome/common/actor.mojom-params-data.h"
namespace actor {
namespace mojom {

NOINLINE static const char* ClickTypeToStringHelper(ClickType value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ClickType::kLeft:
      return "kLeft";
    case ClickType::kRight:
      return "kRight";
    case ClickType::kLeftOnOccludedTarget:
      return "kLeftOnOccludedTarget";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, ClickType value) {
  return os << ClickTypeToString(value);
}

NOINLINE static const char* ClickCountToStringHelper(ClickCount value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ClickCount::kSingle:
      return "kSingle";
    case ClickCount::kDouble:
      return "kDouble";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, ClickCount value) {
  return os << ClickCountToString(value);
}

NOINLINE static const char* ScreenshotPolicyToStringHelper(ScreenshotPolicy value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ScreenshotPolicy::kSkipped:
      return "kSkipped";
    case ScreenshotPolicy::kRequested:
      return "kRequested";
    case ScreenshotPolicy::kRequired:
      return "kRequired";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, ScreenshotPolicy value) {
  return os << ScreenshotPolicyToString(value);
}

NOINLINE static const char* PageContentExtractionPolicyToStringHelper(PageContentExtractionPolicy value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case PageContentExtractionPolicy::kSkipped:
      return "kSkipped";
    case PageContentExtractionPolicy::kRequested:
      return "kRequested";
    case PageContentExtractionPolicy::kRequired:
      return "kRequired";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, PageContentExtractionPolicy value) {
  return os << PageContentExtractionPolicyToString(value);
}

NOINLINE static const char* AttemptLoginStatusToStringHelper(AttemptLoginStatus value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case AttemptLoginStatus::kPasswordManager:
      return "kPasswordManager";
    case AttemptLoginStatus::kFederated:
      return "kFederated";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, AttemptLoginStatus value) {
  return os << AttemptLoginStatusToString(value);
}

NOINLINE static const char* TypeAction_ModeToStringHelper(TypeAction_Mode value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case TypeAction_Mode::kDeleteExisting:
      return "kDeleteExisting";
    case TypeAction_Mode::kPrepend:
      return "kPrepend";
    case TypeAction_Mode::kAppend:
      return "kAppend";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, TypeAction_Mode value) {
  return os << TypeAction_ModeToString(value);
}

NOINLINE static const char* ScrollAction_ScrollDirectionToStringHelper(ScrollAction_ScrollDirection value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ScrollAction_ScrollDirection::kLeft:
      return "kLeft";
    case ScrollAction_ScrollDirection::kRight:
      return "kRight";
    case ScrollAction_ScrollDirection::kUp:
      return "kUp";
    case ScrollAction_ScrollDirection::kDown:
      return "kDown";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, ScrollAction_ScrollDirection value) {
  return os << ScrollAction_ScrollDirectionToString(value);
}

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

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

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

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

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

  switch (object->tag) {

    case ToolTarget_Tag::kDomNodeId: {

      return true;
    }
    case ToolTarget_Tag::kCoordinateDip: {

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

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

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

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

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

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

  switch (object->tag) {

    case ToolAction_Tag::kClick: {

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

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

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

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_scroll, 4, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_scroll, validation_context))
        return false;
      return true;
    }
    case ToolAction_Tag::kSelect: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_select, 5, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_select, validation_context))
        return false;
      return true;
    }
    case ToolAction_Tag::kType: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_type, 6, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_type, validation_context))
        return false;
      return true;
    }
    case ToolAction_Tag::kScriptTool: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_script_tool, 7, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_script_tool, validation_context))
        return false;
      return true;
    }
    case ToolAction_Tag::kScrollTo: {

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

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

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

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

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

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

  switch (object->tag) {

    case InitializeToolResult_Tag::kSuccessPoint: {

      if (!mojo::internal::ValidateStruct(object->data.f_success_point, validation_context))
        return false;
      return true;
    }
    case InitializeToolResult_Tag::kErrorResult: {

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

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


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

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

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

  return true;
}

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


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

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


  if (!::actor::mojom::internal::ClickType_Data
        ::Validate(object->type, validation_context))
    return false;


  if (!::actor::mojom::internal::ClickCount_Data
        ::Validate(object->count, validation_context))
    return false;

  return true;
}

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


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

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

  return true;
}

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


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

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

  return true;
}

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


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

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


  if (!::actor::mojom::internal::TypeAction_Mode_Data
        ::Validate(object->mode, validation_context))
    return false;

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

  return true;
}

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


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

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


  if (!::actor::mojom::internal::ScrollAction_ScrollDirection_Data
        ::Validate(object->direction, validation_context))
    return false;

  return true;
}

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


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

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

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

  return true;
}

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


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

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

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

  return true;
}

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


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

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

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

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

  return true;
}

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


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

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

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

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

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

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

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

  return true;
}

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


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

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

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

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

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

  return true;
}

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


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

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


  if (!::actor::mojom::internal::ActionResultCode_Data
        ::Validate(object->code, validation_context))
    return false;

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

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

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


  if (!::actor::mojom::internal::ScreenshotPolicy_Data
        ::Validate(object->screenshot_policy, validation_context))
    return false;


  if (!::actor::mojom::internal::PageContentExtractionPolicy_Data
        ::Validate(object->page_content_policy, validation_context))
    return false;


  if (!::actor::mojom::internal::AttemptLoginStatus_Data
        ::Validate(object->attempt_login_status_$value, validation_context))
    return false;

  return true;
}

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

}  // namespace internal
}  // namespace mojom
}  // namespace actor

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto