win-Debug/gen/services/device/public/mojom/serial.mojom-blink.h

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

#ifndef SERVICES_DEVICE_PUBLIC_MOJOM_SERIAL_MOJOM_BLINK_H_
#define SERVICES_DEVICE_PUBLIC_MOJOM_SERIAL_MOJOM_BLINK_H_

#include <stdint.h>

#include <limits>
#include <type_traits>
#include <utility>

#include "base/callback.h"
#include "base/macros.h"
#include "base/optional.h"

#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#if BUILDFLAG(MOJO_TRACE_ENABLED)
#include "base/trace_event/trace_event.h"
#endif
#include "mojo/public/cpp/bindings/clone_traits.h"
#include "mojo/public/cpp/bindings/equals_traits.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/struct_ptr.h"
#include "mojo/public/cpp/bindings/struct_traits.h"
#include "mojo/public/cpp/bindings/union_traits.h"
#include "services/device/public/mojom/serial.mojom-shared.h"
#include "services/device/public/mojom/serial.mojom-blink-forward.h"
#include "mojo/public/mojom/base/file_path.mojom-blink.h"
#include "mojo/public/mojom/base/unguessable_token.mojom-blink.h"

#include "mojo/public/cpp/bindings/lib/wtf_clone_equals_util.h"
#include "mojo/public/cpp/bindings/lib/wtf_hash_util.h"
#include "third_party/blink/renderer/platform/wtf/hash_functions.h"
#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"

#include "mojo/public/cpp/bindings/associated_interface_ptr.h"
#include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
#include "mojo/public/cpp/bindings/associated_interface_request.h"
#include "mojo/public/cpp/bindings/interface_ptr.h"
#include "mojo/public/cpp/bindings/interface_request.h"
#include "mojo/public/cpp/bindings/lib/control_message_handler.h"
#include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"
#include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h"


#include "mojo/public/cpp/bindings/lib/native_enum_serialization.h"
#include "mojo/public/cpp/bindings/lib/native_struct_serialization.h"
#include "third_party/blink/public/platform/web_common.h"

#ifdef KYTHE_IS_RUNNING
#pragma kythe_inline_metadata "Metadata comment"
#endif


namespace WTF {
struct device_mojom_internal_SerialSendError_DataHashFn {
  static unsigned GetHash(const ::device::mojom::SerialSendError& value) {
    using utype = std::underlying_type<::device::mojom::SerialSendError>::type;
    return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
  }
  static bool Equal(const ::device::mojom::SerialSendError& left, const ::device::mojom::SerialSendError& right) {
    return left == right;
  }
  static const bool safe_to_compare_to_empty_or_deleted = true;
};

template <>
struct HashTraits<::device::mojom::SerialSendError>
    : public GenericHashTraits<::device::mojom::SerialSendError> {
  static_assert(true,
                "-1000000 is a reserved enum value");
  static_assert(true,
                "-1000001 is a reserved enum value");
  static const bool hasIsEmptyValueFunction = true;
  static bool IsEmptyValue(const ::device::mojom::SerialSendError& value) {
    return value == static_cast<::device::mojom::SerialSendError>(-1000000);
  }
  static void ConstructDeletedValue(::device::mojom::SerialSendError& slot, bool) {
    slot = static_cast<::device::mojom::SerialSendError>(-1000001);
  }
  static bool IsDeletedValue(const ::device::mojom::SerialSendError& value) {
    return value == static_cast<::device::mojom::SerialSendError>(-1000001);
  }
};
}  // namespace WTF


namespace WTF {
struct device_mojom_internal_SerialReceiveError_DataHashFn {
  static unsigned GetHash(const ::device::mojom::SerialReceiveError& value) {
    using utype = std::underlying_type<::device::mojom::SerialReceiveError>::type;
    return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
  }
  static bool Equal(const ::device::mojom::SerialReceiveError& left, const ::device::mojom::SerialReceiveError& right) {
    return left == right;
  }
  static const bool safe_to_compare_to_empty_or_deleted = true;
};

template <>
struct HashTraits<::device::mojom::SerialReceiveError>
    : public GenericHashTraits<::device::mojom::SerialReceiveError> {
  static_assert(true,
                "-1000000 is a reserved enum value");
  static_assert(true,
                "-1000001 is a reserved enum value");
  static const bool hasIsEmptyValueFunction = true;
  static bool IsEmptyValue(const ::device::mojom::SerialReceiveError& value) {
    return value == static_cast<::device::mojom::SerialReceiveError>(-1000000);
  }
  static void ConstructDeletedValue(::device::mojom::SerialReceiveError& slot, bool) {
    slot = static_cast<::device::mojom::SerialReceiveError>(-1000001);
  }
  static bool IsDeletedValue(const ::device::mojom::SerialReceiveError& value) {
    return value == static_cast<::device::mojom::SerialReceiveError>(-1000001);
  }
};
}  // namespace WTF


namespace WTF {
struct device_mojom_internal_SerialDataBits_DataHashFn {
  static unsigned GetHash(const ::device::mojom::SerialDataBits& value) {
    using utype = std::underlying_type<::device::mojom::SerialDataBits>::type;
    return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
  }
  static bool Equal(const ::device::mojom::SerialDataBits& left, const ::device::mojom::SerialDataBits& right) {
    return left == right;
  }
  static const bool safe_to_compare_to_empty_or_deleted = true;
};

template <>
struct HashTraits<::device::mojom::SerialDataBits>
    : public GenericHashTraits<::device::mojom::SerialDataBits> {
  static_assert(true,
                "-1000000 is a reserved enum value");
  static_assert(true,
                "-1000001 is a reserved enum value");
  static const bool hasIsEmptyValueFunction = true;
  static bool IsEmptyValue(const ::device::mojom::SerialDataBits& value) {
    return value == static_cast<::device::mojom::SerialDataBits>(-1000000);
  }
  static void ConstructDeletedValue(::device::mojom::SerialDataBits& slot, bool) {
    slot = static_cast<::device::mojom::SerialDataBits>(-1000001);
  }
  static bool IsDeletedValue(const ::device::mojom::SerialDataBits& value) {
    return value == static_cast<::device::mojom::SerialDataBits>(-1000001);
  }
};
}  // namespace WTF


namespace WTF {
struct device_mojom_internal_SerialParityBit_DataHashFn {
  static unsigned GetHash(const ::device::mojom::SerialParityBit& value) {
    using utype = std::underlying_type<::device::mojom::SerialParityBit>::type;
    return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
  }
  static bool Equal(const ::device::mojom::SerialParityBit& left, const ::device::mojom::SerialParityBit& right) {
    return left == right;
  }
  static const bool safe_to_compare_to_empty_or_deleted = true;
};

template <>
struct HashTraits<::device::mojom::SerialParityBit>
    : public GenericHashTraits<::device::mojom::SerialParityBit> {
  static_assert(true,
                "-1000000 is a reserved enum value");
  static_assert(true,
                "-1000001 is a reserved enum value");
  static const bool hasIsEmptyValueFunction = true;
  static bool IsEmptyValue(const ::device::mojom::SerialParityBit& value) {
    return value == static_cast<::device::mojom::SerialParityBit>(-1000000);
  }
  static void ConstructDeletedValue(::device::mojom::SerialParityBit& slot, bool) {
    slot = static_cast<::device::mojom::SerialParityBit>(-1000001);
  }
  static bool IsDeletedValue(const ::device::mojom::SerialParityBit& value) {
    return value == static_cast<::device::mojom::SerialParityBit>(-1000001);
  }
};
}  // namespace WTF


namespace WTF {
struct device_mojom_internal_SerialStopBits_DataHashFn {
  static unsigned GetHash(const ::device::mojom::SerialStopBits& value) {
    using utype = std::underlying_type<::device::mojom::SerialStopBits>::type;
    return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
  }
  static bool Equal(const ::device::mojom::SerialStopBits& left, const ::device::mojom::SerialStopBits& right) {
    return left == right;
  }
  static const bool safe_to_compare_to_empty_or_deleted = true;
};

template <>
struct HashTraits<::device::mojom::SerialStopBits>
    : public GenericHashTraits<::device::mojom::SerialStopBits> {
  static_assert(true,
                "-1000000 is a reserved enum value");
  static_assert(true,
                "-1000001 is a reserved enum value");
  static const bool hasIsEmptyValueFunction = true;
  static bool IsEmptyValue(const ::device::mojom::SerialStopBits& value) {
    return value == static_cast<::device::mojom::SerialStopBits>(-1000000);
  }
  static void ConstructDeletedValue(::device::mojom::SerialStopBits& slot, bool) {
    slot = static_cast<::device::mojom::SerialStopBits>(-1000001);
  }
  static bool IsDeletedValue(const ::device::mojom::SerialStopBits& value) {
    return value == static_cast<::device::mojom::SerialStopBits>(-1000001);
  }
};
}  // namespace WTF


namespace device {
namespace mojom {
namespace blink {

class SerialPortManagerProxy;

template <typename ImplRefTraits>
class SerialPortManagerStub;

class SerialPortManagerRequestValidator;
class SerialPortManagerResponseValidator;


// @generated_from: device.mojom.SerialPortManager
class BLINK_PLATFORM_EXPORT SerialPortManager
    : public SerialPortManagerInterfaceBase {
 public:
  static const char Name_[];
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasSyncMethods_ = false;

  using Base_ = SerialPortManagerInterfaceBase;
  using Proxy_ = SerialPortManagerProxy;

  template <typename ImplRefTraits>
  using Stub_ = SerialPortManagerStub<ImplRefTraits>;

  using RequestValidator_ = SerialPortManagerRequestValidator;
  using ResponseValidator_ = SerialPortManagerResponseValidator;
  enum MethodMinVersions : uint32_t {
    kGetDevicesMinVersion = 0,
    kGetPortMinVersion = 0,
  };
  virtual ~SerialPortManager() {}


  using GetDevicesCallback = base::OnceCallback<void(WTF::Vector<SerialPortInfoPtr>)>;
  
// @generated_from: device.mojom.SerialPortManager.GetDevices
  virtual void GetDevices(GetDevicesCallback callback) = 0;

  
// @generated_from: device.mojom.SerialPortManager.GetPort
  virtual void GetPort(const base::UnguessableToken& token, SerialPortRequest port_request, SerialPortConnectionWatcherPtr watcher) = 0;
};

class SerialPortProxy;

template <typename ImplRefTraits>
class SerialPortStub;

class SerialPortRequestValidator;
class SerialPortResponseValidator;


// @generated_from: device.mojom.SerialPort
class BLINK_PLATFORM_EXPORT SerialPort
    : public SerialPortInterfaceBase {
 public:
  static const char Name_[];
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasSyncMethods_ = false;

  using Base_ = SerialPortInterfaceBase;
  using Proxy_ = SerialPortProxy;

  template <typename ImplRefTraits>
  using Stub_ = SerialPortStub<ImplRefTraits>;

  using RequestValidator_ = SerialPortRequestValidator;
  using ResponseValidator_ = SerialPortResponseValidator;
  enum MethodMinVersions : uint32_t {
    kOpenMinVersion = 0,
    kClearSendErrorMinVersion = 0,
    kClearReadErrorMinVersion = 0,
    kFlushMinVersion = 0,
    kGetControlSignalsMinVersion = 0,
    kSetControlSignalsMinVersion = 0,
    kConfigurePortMinVersion = 0,
    kGetPortInfoMinVersion = 0,
    kSetBreakMinVersion = 0,
    kClearBreakMinVersion = 0,
  };
  virtual ~SerialPort() {}


  using OpenCallback = base::OnceCallback<void(bool)>;
  
// @generated_from: device.mojom.SerialPort.Open
  virtual void Open(SerialConnectionOptionsPtr options, mojo::ScopedDataPipeConsumerHandle in_stream, mojo::ScopedDataPipeProducerHandle out_stream, SerialPortClientPtr client, OpenCallback callback) = 0;

  
// @generated_from: device.mojom.SerialPort.ClearSendError
  virtual void ClearSendError(mojo::ScopedDataPipeConsumerHandle consumer) = 0;

  
// @generated_from: device.mojom.SerialPort.ClearReadError
  virtual void ClearReadError(mojo::ScopedDataPipeProducerHandle producer) = 0;


  using FlushCallback = base::OnceCallback<void(bool)>;
  
// @generated_from: device.mojom.SerialPort.Flush
  virtual void Flush(FlushCallback callback) = 0;


  using GetControlSignalsCallback = base::OnceCallback<void(SerialPortControlSignalsPtr)>;
  
// @generated_from: device.mojom.SerialPort.GetControlSignals
  virtual void GetControlSignals(GetControlSignalsCallback callback) = 0;


  using SetControlSignalsCallback = base::OnceCallback<void(bool)>;
  
// @generated_from: device.mojom.SerialPort.SetControlSignals
  virtual void SetControlSignals(SerialHostControlSignalsPtr signals, SetControlSignalsCallback callback) = 0;


  using ConfigurePortCallback = base::OnceCallback<void(bool)>;
  
// @generated_from: device.mojom.SerialPort.ConfigurePort
  virtual void ConfigurePort(SerialConnectionOptionsPtr options, ConfigurePortCallback callback) = 0;


  using GetPortInfoCallback = base::OnceCallback<void(SerialConnectionInfoPtr)>;
  
// @generated_from: device.mojom.SerialPort.GetPortInfo
  virtual void GetPortInfo(GetPortInfoCallback callback) = 0;


  using SetBreakCallback = base::OnceCallback<void(bool)>;
  
// @generated_from: device.mojom.SerialPort.SetBreak
  virtual void SetBreak(SetBreakCallback callback) = 0;


  using ClearBreakCallback = base::OnceCallback<void(bool)>;
  
// @generated_from: device.mojom.SerialPort.ClearBreak
  virtual void ClearBreak(ClearBreakCallback callback) = 0;
};

class SerialPortClientProxy;

template <typename ImplRefTraits>
class SerialPortClientStub;

class SerialPortClientRequestValidator;


// @generated_from: device.mojom.SerialPortClient
class BLINK_PLATFORM_EXPORT SerialPortClient
    : public SerialPortClientInterfaceBase {
 public:
  static const char Name_[];
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasSyncMethods_ = false;

  using Base_ = SerialPortClientInterfaceBase;
  using Proxy_ = SerialPortClientProxy;

  template <typename ImplRefTraits>
  using Stub_ = SerialPortClientStub<ImplRefTraits>;

  using RequestValidator_ = SerialPortClientRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kOnReadErrorMinVersion = 0,
    kOnSendErrorMinVersion = 0,
  };
  virtual ~SerialPortClient() {}

  
// @generated_from: device.mojom.SerialPortClient.OnReadError
  virtual void OnReadError(SerialReceiveError error) = 0;

  
// @generated_from: device.mojom.SerialPortClient.OnSendError
  virtual void OnSendError(SerialSendError error) = 0;
};

class SerialPortConnectionWatcherProxy;

template <typename ImplRefTraits>
class SerialPortConnectionWatcherStub;

class SerialPortConnectionWatcherRequestValidator;


// @generated_from: device.mojom.SerialPortConnectionWatcher
class BLINK_PLATFORM_EXPORT SerialPortConnectionWatcher
    : public SerialPortConnectionWatcherInterfaceBase {
 public:
  static const char Name_[];
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasSyncMethods_ = false;

  using Base_ = SerialPortConnectionWatcherInterfaceBase;
  using Proxy_ = SerialPortConnectionWatcherProxy;

  template <typename ImplRefTraits>
  using Stub_ = SerialPortConnectionWatcherStub<ImplRefTraits>;

  using RequestValidator_ = SerialPortConnectionWatcherRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
  };
  virtual ~SerialPortConnectionWatcher() {}
};

class BLINK_PLATFORM_EXPORT SerialPortManagerProxy
    : public SerialPortManager {
 public:
  using InterfaceType = SerialPortManager;

  explicit SerialPortManagerProxy(mojo::MessageReceiverWithResponder* receiver);
  void GetDevices(GetDevicesCallback callback) final;
  void GetPort(const base::UnguessableToken& token, SerialPortRequest port_request, SerialPortConnectionWatcherPtr watcher) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};

class BLINK_PLATFORM_EXPORT SerialPortProxy
    : public SerialPort {
 public:
  using InterfaceType = SerialPort;

  explicit SerialPortProxy(mojo::MessageReceiverWithResponder* receiver);
  void Open(SerialConnectionOptionsPtr options, mojo::ScopedDataPipeConsumerHandle in_stream, mojo::ScopedDataPipeProducerHandle out_stream, SerialPortClientPtr client, OpenCallback callback) final;
  void ClearSendError(mojo::ScopedDataPipeConsumerHandle consumer) final;
  void ClearReadError(mojo::ScopedDataPipeProducerHandle producer) final;
  void Flush(FlushCallback callback) final;
  void GetControlSignals(GetControlSignalsCallback callback) final;
  void SetControlSignals(SerialHostControlSignalsPtr signals, SetControlSignalsCallback callback) final;
  void ConfigurePort(SerialConnectionOptionsPtr options, ConfigurePortCallback callback) final;
  void GetPortInfo(GetPortInfoCallback callback) final;
  void SetBreak(SetBreakCallback callback) final;
  void ClearBreak(ClearBreakCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};

class BLINK_PLATFORM_EXPORT SerialPortClientProxy
    : public SerialPortClient {
 public:
  using InterfaceType = SerialPortClient;

  explicit SerialPortClientProxy(mojo::MessageReceiverWithResponder* receiver);
  void OnReadError(SerialReceiveError error) final;
  void OnSendError(SerialSendError error) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};

class BLINK_PLATFORM_EXPORT SerialPortConnectionWatcherProxy
    : public SerialPortConnectionWatcher {
 public:
  using InterfaceType = SerialPortConnectionWatcher;

  explicit SerialPortConnectionWatcherProxy(mojo::MessageReceiverWithResponder* receiver);

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};
class BLINK_PLATFORM_EXPORT SerialPortManagerStubDispatch {
 public:
  static bool Accept(SerialPortManager* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      SerialPortManager* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<SerialPortManager>>
class SerialPortManagerStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  SerialPortManagerStub() {}
  ~SerialPortManagerStub() override {}

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return SerialPortManagerStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return SerialPortManagerStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class BLINK_PLATFORM_EXPORT SerialPortStubDispatch {
 public:
  static bool Accept(SerialPort* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      SerialPort* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<SerialPort>>
class SerialPortStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  SerialPortStub() {}
  ~SerialPortStub() override {}

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return SerialPortStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return SerialPortStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class BLINK_PLATFORM_EXPORT SerialPortClientStubDispatch {
 public:
  static bool Accept(SerialPortClient* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      SerialPortClient* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<SerialPortClient>>
class SerialPortClientStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  SerialPortClientStub() {}
  ~SerialPortClientStub() override {}

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return SerialPortClientStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return SerialPortClientStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class BLINK_PLATFORM_EXPORT SerialPortConnectionWatcherStubDispatch {
 public:
  static bool Accept(SerialPortConnectionWatcher* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      SerialPortConnectionWatcher* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<SerialPortConnectionWatcher>>
class SerialPortConnectionWatcherStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  SerialPortConnectionWatcherStub() {}
  ~SerialPortConnectionWatcherStub() override {}

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return SerialPortConnectionWatcherStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return SerialPortConnectionWatcherStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class BLINK_PLATFORM_EXPORT SerialPortManagerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class BLINK_PLATFORM_EXPORT SerialPortRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class BLINK_PLATFORM_EXPORT SerialPortClientRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class BLINK_PLATFORM_EXPORT SerialPortConnectionWatcherRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class BLINK_PLATFORM_EXPORT SerialPortManagerResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class BLINK_PLATFORM_EXPORT SerialPortResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};








// @generated_from: device.mojom.SerialHostControlSignals
class BLINK_PLATFORM_EXPORT SerialHostControlSignals {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<SerialHostControlSignals, T>::value>;
  using DataView = SerialHostControlSignalsDataView;
  using Data_ = internal::SerialHostControlSignals_Data;

  template <typename... Args>
  static SerialHostControlSignalsPtr New(Args&&... args) {
    return SerialHostControlSignalsPtr(
        base::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static SerialHostControlSignalsPtr From(const U& u) {
    return mojo::TypeConverter<SerialHostControlSignalsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, SerialHostControlSignals>::Convert(*this);
  }


  SerialHostControlSignals();

  SerialHostControlSignals(
      bool dtr,
      bool has_dtr,
      bool rts,
      bool has_rts);

  ~SerialHostControlSignals();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = SerialHostControlSignalsPtr>
  SerialHostControlSignalsPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, SerialHostControlSignals::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;
  size_t Hash(size_t seed) const;

  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        SerialHostControlSignals::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        SerialHostControlSignals::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::SerialHostControlSignals_UnserializedMessageContext<
            UserType, SerialHostControlSignals::DataView>>(0, 0, std::move(input)));
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    return mojo::internal::DeserializeImpl<SerialHostControlSignals::DataView>(
        data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return SerialHostControlSignals::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::SerialHostControlSignals_UnserializedMessageContext<
            UserType, SerialHostControlSignals::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<SerialHostControlSignals::DataView>(
        input.payload(), input.payload_num_bytes(),
        std::move(*input.mutable_handles()), output, Validate);
  }

  
// @generated_from: device.mojom.SerialHostControlSignals.dtr
  bool dtr;
  
// @generated_from: device.mojom.SerialHostControlSignals.has_dtr
  bool has_dtr;
  
// @generated_from: device.mojom.SerialHostControlSignals.rts
  bool rts;
  
// @generated_from: device.mojom.SerialHostControlSignals.has_rts
  bool has_rts;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, SerialHostControlSignals::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, SerialHostControlSignals::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, SerialHostControlSignals::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, SerialHostControlSignals::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





// @generated_from: device.mojom.SerialPortControlSignals
class BLINK_PLATFORM_EXPORT SerialPortControlSignals {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<SerialPortControlSignals, T>::value>;
  using DataView = SerialPortControlSignalsDataView;
  using Data_ = internal::SerialPortControlSignals_Data;

  template <typename... Args>
  static SerialPortControlSignalsPtr New(Args&&... args) {
    return SerialPortControlSignalsPtr(
        base::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static SerialPortControlSignalsPtr From(const U& u) {
    return mojo::TypeConverter<SerialPortControlSignalsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, SerialPortControlSignals>::Convert(*this);
  }


  SerialPortControlSignals();

  SerialPortControlSignals(
      bool dcd,
      bool cts,
      bool ri,
      bool dsr);

  ~SerialPortControlSignals();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = SerialPortControlSignalsPtr>
  SerialPortControlSignalsPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, SerialPortControlSignals::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;
  size_t Hash(size_t seed) const;

  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        SerialPortControlSignals::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        SerialPortControlSignals::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::SerialPortControlSignals_UnserializedMessageContext<
            UserType, SerialPortControlSignals::DataView>>(0, 0, std::move(input)));
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    return mojo::internal::DeserializeImpl<SerialPortControlSignals::DataView>(
        data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return SerialPortControlSignals::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::SerialPortControlSignals_UnserializedMessageContext<
            UserType, SerialPortControlSignals::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<SerialPortControlSignals::DataView>(
        input.payload(), input.payload_num_bytes(),
        std::move(*input.mutable_handles()), output, Validate);
  }

  
// @generated_from: device.mojom.SerialPortControlSignals.dcd
  bool dcd;
  
// @generated_from: device.mojom.SerialPortControlSignals.cts
  bool cts;
  
// @generated_from: device.mojom.SerialPortControlSignals.ri
  bool ri;
  
// @generated_from: device.mojom.SerialPortControlSignals.dsr
  bool dsr;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, SerialPortControlSignals::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, SerialPortControlSignals::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, SerialPortControlSignals::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, SerialPortControlSignals::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}







// @generated_from: device.mojom.SerialPortInfo
class BLINK_PLATFORM_EXPORT SerialPortInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<SerialPortInfo, T>::value>;
  using DataView = SerialPortInfoDataView;
  using Data_ = internal::SerialPortInfo_Data;

  template <typename... Args>
  static SerialPortInfoPtr New(Args&&... args) {
    return SerialPortInfoPtr(
        base::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static SerialPortInfoPtr From(const U& u) {
    return mojo::TypeConverter<SerialPortInfoPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, SerialPortInfo>::Convert(*this);
  }


  SerialPortInfo();

  SerialPortInfo(
      const base::UnguessableToken& token,
      const base::FilePath& path,
      uint16_t vendor_id,
      bool has_vendor_id,
      uint16_t product_id,
      bool has_product_id,
      const WTF::String& display_name);

  ~SerialPortInfo();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = SerialPortInfoPtr>
  SerialPortInfoPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, SerialPortInfo::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        SerialPortInfo::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        SerialPortInfo::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::SerialPortInfo_UnserializedMessageContext<
            UserType, SerialPortInfo::DataView>>(0, 0, std::move(input)));
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    return mojo::internal::DeserializeImpl<SerialPortInfo::DataView>(
        data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return SerialPortInfo::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::SerialPortInfo_UnserializedMessageContext<
            UserType, SerialPortInfo::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<SerialPortInfo::DataView>(
        input.payload(), input.payload_num_bytes(),
        std::move(*input.mutable_handles()), output, Validate);
  }

  
// @generated_from: device.mojom.SerialPortInfo.token
  base::UnguessableToken token;
  
// @generated_from: device.mojom.SerialPortInfo.path
  base::FilePath path;
  
// @generated_from: device.mojom.SerialPortInfo.vendor_id
  uint16_t vendor_id;
  
// @generated_from: device.mojom.SerialPortInfo.has_vendor_id
  bool has_vendor_id;
  
// @generated_from: device.mojom.SerialPortInfo.product_id
  uint16_t product_id;
  
// @generated_from: device.mojom.SerialPortInfo.has_product_id
  bool has_product_id;
  
// @generated_from: device.mojom.SerialPortInfo.display_name
  WTF::String display_name;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, SerialPortInfo::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, SerialPortInfo::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, SerialPortInfo::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, SerialPortInfo::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





// @generated_from: device.mojom.SerialConnectionOptions
class BLINK_PLATFORM_EXPORT SerialConnectionOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<SerialConnectionOptions, T>::value>;
  using DataView = SerialConnectionOptionsDataView;
  using Data_ = internal::SerialConnectionOptions_Data;

  template <typename... Args>
  static SerialConnectionOptionsPtr New(Args&&... args) {
    return SerialConnectionOptionsPtr(
        base::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static SerialConnectionOptionsPtr From(const U& u) {
    return mojo::TypeConverter<SerialConnectionOptionsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, SerialConnectionOptions>::Convert(*this);
  }


  SerialConnectionOptions();

  SerialConnectionOptions(
      uint32_t bitrate,
      SerialDataBits data_bits,
      SerialParityBit parity_bit,
      SerialStopBits stop_bits,
      bool cts_flow_control,
      bool has_cts_flow_control);

  ~SerialConnectionOptions();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = SerialConnectionOptionsPtr>
  SerialConnectionOptionsPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, SerialConnectionOptions::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;
  size_t Hash(size_t seed) const;

  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        SerialConnectionOptions::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        SerialConnectionOptions::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::SerialConnectionOptions_UnserializedMessageContext<
            UserType, SerialConnectionOptions::DataView>>(0, 0, std::move(input)));
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    return mojo::internal::DeserializeImpl<SerialConnectionOptions::DataView>(
        data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return SerialConnectionOptions::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::SerialConnectionOptions_UnserializedMessageContext<
            UserType, SerialConnectionOptions::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<SerialConnectionOptions::DataView>(
        input.payload(), input.payload_num_bytes(),
        std::move(*input.mutable_handles()), output, Validate);
  }

  
// @generated_from: device.mojom.SerialConnectionOptions.bitrate
  uint32_t bitrate;
  
// @generated_from: device.mojom.SerialConnectionOptions.data_bits
  SerialDataBits data_bits;
  
// @generated_from: device.mojom.SerialConnectionOptions.parity_bit
  SerialParityBit parity_bit;
  
// @generated_from: device.mojom.SerialConnectionOptions.stop_bits
  SerialStopBits stop_bits;
  
// @generated_from: device.mojom.SerialConnectionOptions.cts_flow_control
  bool cts_flow_control;
  
// @generated_from: device.mojom.SerialConnectionOptions.has_cts_flow_control
  bool has_cts_flow_control;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, SerialConnectionOptions::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, SerialConnectionOptions::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, SerialConnectionOptions::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, SerialConnectionOptions::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





// @generated_from: device.mojom.SerialConnectionInfo
class BLINK_PLATFORM_EXPORT SerialConnectionInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<SerialConnectionInfo, T>::value>;
  using DataView = SerialConnectionInfoDataView;
  using Data_ = internal::SerialConnectionInfo_Data;

  template <typename... Args>
  static SerialConnectionInfoPtr New(Args&&... args) {
    return SerialConnectionInfoPtr(
        base::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static SerialConnectionInfoPtr From(const U& u) {
    return mojo::TypeConverter<SerialConnectionInfoPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, SerialConnectionInfo>::Convert(*this);
  }


  SerialConnectionInfo();

  SerialConnectionInfo(
      uint32_t bitrate,
      SerialDataBits data_bits,
      SerialParityBit parity_bit,
      SerialStopBits stop_bits,
      bool cts_flow_control);

  ~SerialConnectionInfo();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = SerialConnectionInfoPtr>
  SerialConnectionInfoPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, SerialConnectionInfo::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;
  size_t Hash(size_t seed) const;

  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        SerialConnectionInfo::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        SerialConnectionInfo::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::SerialConnectionInfo_UnserializedMessageContext<
            UserType, SerialConnectionInfo::DataView>>(0, 0, std::move(input)));
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    return mojo::internal::DeserializeImpl<SerialConnectionInfo::DataView>(
        data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return SerialConnectionInfo::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::SerialConnectionInfo_UnserializedMessageContext<
            UserType, SerialConnectionInfo::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<SerialConnectionInfo::DataView>(
        input.payload(), input.payload_num_bytes(),
        std::move(*input.mutable_handles()), output, Validate);
  }

  
// @generated_from: device.mojom.SerialConnectionInfo.bitrate
  uint32_t bitrate;
  
// @generated_from: device.mojom.SerialConnectionInfo.data_bits
  SerialDataBits data_bits;
  
// @generated_from: device.mojom.SerialConnectionInfo.parity_bit
  SerialParityBit parity_bit;
  
// @generated_from: device.mojom.SerialConnectionInfo.stop_bits
  SerialStopBits stop_bits;
  
// @generated_from: device.mojom.SerialConnectionInfo.cts_flow_control
  bool cts_flow_control;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, SerialConnectionInfo::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, SerialConnectionInfo::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, SerialConnectionInfo::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, SerialConnectionInfo::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}



template <typename StructPtrType>
SerialPortInfoPtr SerialPortInfo::Clone() const {
  return New(
      mojo::Clone(token),
      mojo::Clone(path),
      mojo::Clone(vendor_id),
      mojo::Clone(has_vendor_id),
      mojo::Clone(product_id),
      mojo::Clone(has_product_id),
      mojo::Clone(display_name)
  );
}

template <typename T, SerialPortInfo::EnableIfSame<T>*>
bool SerialPortInfo::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->token, other_struct.token))
    return false;
  if (!mojo::Equals(this->path, other_struct.path))
    return false;
  if (!mojo::Equals(this->vendor_id, other_struct.vendor_id))
    return false;
  if (!mojo::Equals(this->has_vendor_id, other_struct.has_vendor_id))
    return false;
  if (!mojo::Equals(this->product_id, other_struct.product_id))
    return false;
  if (!mojo::Equals(this->has_product_id, other_struct.has_product_id))
    return false;
  if (!mojo::Equals(this->display_name, other_struct.display_name))
    return false;
  return true;
}

template <typename T, SerialPortInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.token < rhs.token)
    return true;
  if (rhs.token < lhs.token)
    return false;
  if (lhs.path < rhs.path)
    return true;
  if (rhs.path < lhs.path)
    return false;
  if (lhs.vendor_id < rhs.vendor_id)
    return true;
  if (rhs.vendor_id < lhs.vendor_id)
    return false;
  if (lhs.has_vendor_id < rhs.has_vendor_id)
    return true;
  if (rhs.has_vendor_id < lhs.has_vendor_id)
    return false;
  if (lhs.product_id < rhs.product_id)
    return true;
  if (rhs.product_id < lhs.product_id)
    return false;
  if (lhs.has_product_id < rhs.has_product_id)
    return true;
  if (rhs.has_product_id < lhs.has_product_id)
    return false;
  if (lhs.display_name < rhs.display_name)
    return true;
  if (rhs.display_name < lhs.display_name)
    return false;
  return false;
}
template <typename StructPtrType>
SerialConnectionOptionsPtr SerialConnectionOptions::Clone() const {
  return New(
      mojo::Clone(bitrate),
      mojo::Clone(data_bits),
      mojo::Clone(parity_bit),
      mojo::Clone(stop_bits),
      mojo::Clone(cts_flow_control),
      mojo::Clone(has_cts_flow_control)
  );
}

template <typename T, SerialConnectionOptions::EnableIfSame<T>*>
bool SerialConnectionOptions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->bitrate, other_struct.bitrate))
    return false;
  if (!mojo::Equals(this->data_bits, other_struct.data_bits))
    return false;
  if (!mojo::Equals(this->parity_bit, other_struct.parity_bit))
    return false;
  if (!mojo::Equals(this->stop_bits, other_struct.stop_bits))
    return false;
  if (!mojo::Equals(this->cts_flow_control, other_struct.cts_flow_control))
    return false;
  if (!mojo::Equals(this->has_cts_flow_control, other_struct.has_cts_flow_control))
    return false;
  return true;
}

template <typename T, SerialConnectionOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.bitrate < rhs.bitrate)
    return true;
  if (rhs.bitrate < lhs.bitrate)
    return false;
  if (lhs.data_bits < rhs.data_bits)
    return true;
  if (rhs.data_bits < lhs.data_bits)
    return false;
  if (lhs.parity_bit < rhs.parity_bit)
    return true;
  if (rhs.parity_bit < lhs.parity_bit)
    return false;
  if (lhs.stop_bits < rhs.stop_bits)
    return true;
  if (rhs.stop_bits < lhs.stop_bits)
    return false;
  if (lhs.cts_flow_control < rhs.cts_flow_control)
    return true;
  if (rhs.cts_flow_control < lhs.cts_flow_control)
    return false;
  if (lhs.has_cts_flow_control < rhs.has_cts_flow_control)
    return true;
  if (rhs.has_cts_flow_control < lhs.has_cts_flow_control)
    return false;
  return false;
}
template <typename StructPtrType>
SerialConnectionInfoPtr SerialConnectionInfo::Clone() const {
  return New(
      mojo::Clone(bitrate),
      mojo::Clone(data_bits),
      mojo::Clone(parity_bit),
      mojo::Clone(stop_bits),
      mojo::Clone(cts_flow_control)
  );
}

template <typename T, SerialConnectionInfo::EnableIfSame<T>*>
bool SerialConnectionInfo::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->bitrate, other_struct.bitrate))
    return false;
  if (!mojo::Equals(this->data_bits, other_struct.data_bits))
    return false;
  if (!mojo::Equals(this->parity_bit, other_struct.parity_bit))
    return false;
  if (!mojo::Equals(this->stop_bits, other_struct.stop_bits))
    return false;
  if (!mojo::Equals(this->cts_flow_control, other_struct.cts_flow_control))
    return false;
  return true;
}

template <typename T, SerialConnectionInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.bitrate < rhs.bitrate)
    return true;
  if (rhs.bitrate < lhs.bitrate)
    return false;
  if (lhs.data_bits < rhs.data_bits)
    return true;
  if (rhs.data_bits < lhs.data_bits)
    return false;
  if (lhs.parity_bit < rhs.parity_bit)
    return true;
  if (rhs.parity_bit < lhs.parity_bit)
    return false;
  if (lhs.stop_bits < rhs.stop_bits)
    return true;
  if (rhs.stop_bits < lhs.stop_bits)
    return false;
  if (lhs.cts_flow_control < rhs.cts_flow_control)
    return true;
  if (rhs.cts_flow_control < lhs.cts_flow_control)
    return false;
  return false;
}
template <typename StructPtrType>
SerialHostControlSignalsPtr SerialHostControlSignals::Clone() const {
  return New(
      mojo::Clone(dtr),
      mojo::Clone(has_dtr),
      mojo::Clone(rts),
      mojo::Clone(has_rts)
  );
}

template <typename T, SerialHostControlSignals::EnableIfSame<T>*>
bool SerialHostControlSignals::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->dtr, other_struct.dtr))
    return false;
  if (!mojo::Equals(this->has_dtr, other_struct.has_dtr))
    return false;
  if (!mojo::Equals(this->rts, other_struct.rts))
    return false;
  if (!mojo::Equals(this->has_rts, other_struct.has_rts))
    return false;
  return true;
}

template <typename T, SerialHostControlSignals::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.dtr < rhs.dtr)
    return true;
  if (rhs.dtr < lhs.dtr)
    return false;
  if (lhs.has_dtr < rhs.has_dtr)
    return true;
  if (rhs.has_dtr < lhs.has_dtr)
    return false;
  if (lhs.rts < rhs.rts)
    return true;
  if (rhs.rts < lhs.rts)
    return false;
  if (lhs.has_rts < rhs.has_rts)
    return true;
  if (rhs.has_rts < lhs.has_rts)
    return false;
  return false;
}
template <typename StructPtrType>
SerialPortControlSignalsPtr SerialPortControlSignals::Clone() const {
  return New(
      mojo::Clone(dcd),
      mojo::Clone(cts),
      mojo::Clone(ri),
      mojo::Clone(dsr)
  );
}

template <typename T, SerialPortControlSignals::EnableIfSame<T>*>
bool SerialPortControlSignals::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->dcd, other_struct.dcd))
    return false;
  if (!mojo::Equals(this->cts, other_struct.cts))
    return false;
  if (!mojo::Equals(this->ri, other_struct.ri))
    return false;
  if (!mojo::Equals(this->dsr, other_struct.dsr))
    return false;
  return true;
}

template <typename T, SerialPortControlSignals::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.dcd < rhs.dcd)
    return true;
  if (rhs.dcd < lhs.dcd)
    return false;
  if (lhs.cts < rhs.cts)
    return true;
  if (rhs.cts < lhs.cts)
    return false;
  if (lhs.ri < rhs.ri)
    return true;
  if (rhs.ri < lhs.ri)
    return false;
  if (lhs.dsr < rhs.dsr)
    return true;
  if (rhs.dsr < lhs.dsr)
    return false;
  return false;
}


}  // namespace blink
}  // namespace mojom
}  // namespace device

namespace mojo {


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::SerialPortInfo::DataView,
                                         ::device::mojom::blink::SerialPortInfoPtr> {
  static bool IsNull(const ::device::mojom::blink::SerialPortInfoPtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::SerialPortInfoPtr* output) { output->reset(); }

  static const decltype(::device::mojom::blink::SerialPortInfo::token)& token(
      const ::device::mojom::blink::SerialPortInfoPtr& input) {
    return input->token;
  }

  static const decltype(::device::mojom::blink::SerialPortInfo::path)& path(
      const ::device::mojom::blink::SerialPortInfoPtr& input) {
    return input->path;
  }

  static decltype(::device::mojom::blink::SerialPortInfo::vendor_id) vendor_id(
      const ::device::mojom::blink::SerialPortInfoPtr& input) {
    return input->vendor_id;
  }

  static decltype(::device::mojom::blink::SerialPortInfo::has_vendor_id) has_vendor_id(
      const ::device::mojom::blink::SerialPortInfoPtr& input) {
    return input->has_vendor_id;
  }

  static decltype(::device::mojom::blink::SerialPortInfo::product_id) product_id(
      const ::device::mojom::blink::SerialPortInfoPtr& input) {
    return input->product_id;
  }

  static decltype(::device::mojom::blink::SerialPortInfo::has_product_id) has_product_id(
      const ::device::mojom::blink::SerialPortInfoPtr& input) {
    return input->has_product_id;
  }

  static const decltype(::device::mojom::blink::SerialPortInfo::display_name)& display_name(
      const ::device::mojom::blink::SerialPortInfoPtr& input) {
    return input->display_name;
  }

  static bool Read(::device::mojom::blink::SerialPortInfo::DataView input, ::device::mojom::blink::SerialPortInfoPtr* output);
};


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::SerialConnectionOptions::DataView,
                                         ::device::mojom::blink::SerialConnectionOptionsPtr> {
  static bool IsNull(const ::device::mojom::blink::SerialConnectionOptionsPtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::SerialConnectionOptionsPtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::SerialConnectionOptions::bitrate) bitrate(
      const ::device::mojom::blink::SerialConnectionOptionsPtr& input) {
    return input->bitrate;
  }

  static decltype(::device::mojom::blink::SerialConnectionOptions::data_bits) data_bits(
      const ::device::mojom::blink::SerialConnectionOptionsPtr& input) {
    return input->data_bits;
  }

  static decltype(::device::mojom::blink::SerialConnectionOptions::parity_bit) parity_bit(
      const ::device::mojom::blink::SerialConnectionOptionsPtr& input) {
    return input->parity_bit;
  }

  static decltype(::device::mojom::blink::SerialConnectionOptions::stop_bits) stop_bits(
      const ::device::mojom::blink::SerialConnectionOptionsPtr& input) {
    return input->stop_bits;
  }

  static decltype(::device::mojom::blink::SerialConnectionOptions::cts_flow_control) cts_flow_control(
      const ::device::mojom::blink::SerialConnectionOptionsPtr& input) {
    return input->cts_flow_control;
  }

  static decltype(::device::mojom::blink::SerialConnectionOptions::has_cts_flow_control) has_cts_flow_control(
      const ::device::mojom::blink::SerialConnectionOptionsPtr& input) {
    return input->has_cts_flow_control;
  }

  static bool Read(::device::mojom::blink::SerialConnectionOptions::DataView input, ::device::mojom::blink::SerialConnectionOptionsPtr* output);
};


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::SerialConnectionInfo::DataView,
                                         ::device::mojom::blink::SerialConnectionInfoPtr> {
  static bool IsNull(const ::device::mojom::blink::SerialConnectionInfoPtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::SerialConnectionInfoPtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::SerialConnectionInfo::bitrate) bitrate(
      const ::device::mojom::blink::SerialConnectionInfoPtr& input) {
    return input->bitrate;
  }

  static decltype(::device::mojom::blink::SerialConnectionInfo::data_bits) data_bits(
      const ::device::mojom::blink::SerialConnectionInfoPtr& input) {
    return input->data_bits;
  }

  static decltype(::device::mojom::blink::SerialConnectionInfo::parity_bit) parity_bit(
      const ::device::mojom::blink::SerialConnectionInfoPtr& input) {
    return input->parity_bit;
  }

  static decltype(::device::mojom::blink::SerialConnectionInfo::stop_bits) stop_bits(
      const ::device::mojom::blink::SerialConnectionInfoPtr& input) {
    return input->stop_bits;
  }

  static decltype(::device::mojom::blink::SerialConnectionInfo::cts_flow_control) cts_flow_control(
      const ::device::mojom::blink::SerialConnectionInfoPtr& input) {
    return input->cts_flow_control;
  }

  static bool Read(::device::mojom::blink::SerialConnectionInfo::DataView input, ::device::mojom::blink::SerialConnectionInfoPtr* output);
};


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::SerialHostControlSignals::DataView,
                                         ::device::mojom::blink::SerialHostControlSignalsPtr> {
  static bool IsNull(const ::device::mojom::blink::SerialHostControlSignalsPtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::SerialHostControlSignalsPtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::SerialHostControlSignals::dtr) dtr(
      const ::device::mojom::blink::SerialHostControlSignalsPtr& input) {
    return input->dtr;
  }

  static decltype(::device::mojom::blink::SerialHostControlSignals::has_dtr) has_dtr(
      const ::device::mojom::blink::SerialHostControlSignalsPtr& input) {
    return input->has_dtr;
  }

  static decltype(::device::mojom::blink::SerialHostControlSignals::rts) rts(
      const ::device::mojom::blink::SerialHostControlSignalsPtr& input) {
    return input->rts;
  }

  static decltype(::device::mojom::blink::SerialHostControlSignals::has_rts) has_rts(
      const ::device::mojom::blink::SerialHostControlSignalsPtr& input) {
    return input->has_rts;
  }

  static bool Read(::device::mojom::blink::SerialHostControlSignals::DataView input, ::device::mojom::blink::SerialHostControlSignalsPtr* output);
};


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::SerialPortControlSignals::DataView,
                                         ::device::mojom::blink::SerialPortControlSignalsPtr> {
  static bool IsNull(const ::device::mojom::blink::SerialPortControlSignalsPtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::SerialPortControlSignalsPtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::SerialPortControlSignals::dcd) dcd(
      const ::device::mojom::blink::SerialPortControlSignalsPtr& input) {
    return input->dcd;
  }

  static decltype(::device::mojom::blink::SerialPortControlSignals::cts) cts(
      const ::device::mojom::blink::SerialPortControlSignalsPtr& input) {
    return input->cts;
  }

  static decltype(::device::mojom::blink::SerialPortControlSignals::ri) ri(
      const ::device::mojom::blink::SerialPortControlSignalsPtr& input) {
    return input->ri;
  }

  static decltype(::device::mojom::blink::SerialPortControlSignals::dsr) dsr(
      const ::device::mojom::blink::SerialPortControlSignalsPtr& input) {
    return input->dsr;
  }

  static bool Read(::device::mojom::blink::SerialPortControlSignals::DataView input, ::device::mojom::blink::SerialPortControlSignalsPtr* output);
};

}  // namespace mojo

#endif  // SERVICES_DEVICE_PUBLIC_MOJOM_SERIAL_MOJOM_BLINK_H_
/* Metadata comment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*/