win-Debug/gen/chrome/services/util_win/public/mojom/util_win.mojom-blink.h

// chrome/services/util_win/public/mojom/util_win.mojom-blink.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef CHROME_SERVICES_UTIL_WIN_PUBLIC_MOJOM_UTIL_WIN_MOJOM_BLINK_H_
#define CHROME_SERVICES_UTIL_WIN_PUBLIC_MOJOM_UTIL_WIN_MOJOM_BLINK_H_

#include <stdint.h>

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

#include "base/types/cxx23_to_underlying.h"
#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 "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h"

#include "chrome/services/util_win/public/mojom/util_win.mojom-features.h"
#include "chrome/services/util_win/public/mojom/util_win.mojom-shared.h"
#include "chrome/services/util_win/public/mojom/util_win.mojom-blink-forward.h"
#include "mojo/public/mojom/base/file_path.mojom-blink.h"
#include "mojo/public/mojom/base/string16.mojom-blink.h"
#include "mojo/public/mojom/base/wstring.mojom-blink.h"
#include "sandbox/policy/mojom/sandbox.mojom-blink-forward.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/lib/control_message_handler.h"
#include "mojo/public/cpp/bindings/lib/message_size_estimator.h"
#include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"



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


namespace chrome::mojom::blink {

class UtilWinProxy;

template <typename ImplRefTraits>
class UtilWinStub;

class UtilWinRequestValidator;
class UtilWinResponseValidator;


// @generated_from: chrome.mojom.UtilWin
class UtilWin
    : public UtilWinInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();

  static const char Name_[];
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr auto kServiceSandbox = sandbox::mojom::Sandbox::kNoSandbox;
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = UtilWinInterfaceBase;
  using Proxy_ = UtilWinProxy;

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

  using RequestValidator_ = UtilWinRequestValidator;
  using ResponseValidator_ = UtilWinResponseValidator;
  enum MethodMinVersions : uint32_t {
    kIsPinnedToTaskbarMinVersion = 0,
    kUnpinShortcutsMinVersion = 0,
    kCreateOrUpdateShortcutsMinVersion = 0,
    kCallExecuteSelectFileMinVersion = 0,
    kInspectModuleMinVersion = 0,
    kGetAntiVirusProductsMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct IsPinnedToTaskbar_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct UnpinShortcuts_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CreateOrUpdateShortcuts_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CallExecuteSelectFile_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct InspectModule_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetAntiVirusProducts_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~UtilWin() = default;


  using IsPinnedToTaskbarCallback = base::OnceCallback<void(bool, bool)>;
  
// @generated_from: chrome.mojom.UtilWin.IsPinnedToTaskbar
  virtual void IsPinnedToTaskbar(IsPinnedToTaskbarCallback callback) = 0;


  using UnpinShortcutsCallback = base::OnceCallback<void()>;
  
// @generated_from: chrome.mojom.UtilWin.UnpinShortcuts
  virtual void UnpinShortcuts(const WTF::Vector<::base::FilePath>& shortcut_paths, UnpinShortcutsCallback callback) = 0;


  using CreateOrUpdateShortcutsCallback = base::OnceCallback<void(bool)>;
  
// @generated_from: chrome.mojom.UtilWin.CreateOrUpdateShortcuts
  virtual void CreateOrUpdateShortcuts(const WTF::Vector<::base::FilePath>& shortcut_paths, WTF::Vector<ShortcutPropertiesPtr> properties, ShortcutOperation operation, CreateOrUpdateShortcutsCallback callback) = 0;


  using CallExecuteSelectFileCallback = base::OnceCallback<void(const WTF::Vector<::base::FilePath>&, int32_t)>;
  
// @generated_from: chrome.mojom.UtilWin.CallExecuteSelectFile
  virtual void CallExecuteSelectFile(SelectFileDialogType type, uint32_t owner, const ::WTF::String& title, const ::base::FilePath& default_path, WTF::Vector<FileFilterSpecPtr> filter, int32_t file_type_index, const ::WTF::String& default_extension, CallExecuteSelectFileCallback callback) = 0;


  using InspectModuleCallback = base::OnceCallback<void(InspectionResultPtr)>;
  
// @generated_from: chrome.mojom.UtilWin.InspectModule
  virtual void InspectModule(const ::base::FilePath& module_path, InspectModuleCallback callback) = 0;


  using GetAntiVirusProductsCallback = base::OnceCallback<void(WTF::Vector<AntiVirusProductPtr>)>;
  
// @generated_from: chrome.mojom.UtilWin.GetAntiVirusProducts
  virtual void GetAntiVirusProducts(bool report_full_names, GetAntiVirusProductsCallback callback) = 0;
};

class ProcessorMetricsProxy;

template <typename ImplRefTraits>
class ProcessorMetricsStub;

class ProcessorMetricsRequestValidator;
class ProcessorMetricsResponseValidator;


// @generated_from: chrome.mojom.ProcessorMetrics
class ProcessorMetrics
    : public ProcessorMetricsInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();

  static const char Name_[];
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr auto kServiceSandbox = sandbox::mojom::Sandbox::kNoSandbox;
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = ProcessorMetricsInterfaceBase;
  using Proxy_ = ProcessorMetricsProxy;

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

  using RequestValidator_ = ProcessorMetricsRequestValidator;
  using ResponseValidator_ = ProcessorMetricsResponseValidator;
  enum MethodMinVersions : uint32_t {
    kRecordProcessorMetricsMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct RecordProcessorMetrics_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~ProcessorMetrics() = default;


  using RecordProcessorMetricsCallback = base::OnceCallback<void()>;
  
// @generated_from: chrome.mojom.ProcessorMetrics.RecordProcessorMetrics
  virtual void RecordProcessorMetrics(RecordProcessorMetricsCallback callback) = 0;
};



// @generated_from: chrome.mojom.UtilWin
class  UtilWinProxy
    : public UtilWin {
 public:
  using InterfaceType = UtilWin;

  explicit UtilWinProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: chrome.mojom.UtilWin.IsPinnedToTaskbar
  void IsPinnedToTaskbar(IsPinnedToTaskbarCallback callback) final;
  
// @generated_from: chrome.mojom.UtilWin.UnpinShortcuts
  void UnpinShortcuts(const WTF::Vector<::base::FilePath>& shortcut_paths, UnpinShortcutsCallback callback) final;
  
// @generated_from: chrome.mojom.UtilWin.CreateOrUpdateShortcuts
  void CreateOrUpdateShortcuts(const WTF::Vector<::base::FilePath>& shortcut_paths, WTF::Vector<ShortcutPropertiesPtr> properties, ShortcutOperation operation, CreateOrUpdateShortcutsCallback callback) final;
  
// @generated_from: chrome.mojom.UtilWin.CallExecuteSelectFile
  void CallExecuteSelectFile(SelectFileDialogType type, uint32_t owner, const ::WTF::String& title, const ::base::FilePath& default_path, WTF::Vector<FileFilterSpecPtr> filter, int32_t file_type_index, const ::WTF::String& default_extension, CallExecuteSelectFileCallback callback) final;
  
// @generated_from: chrome.mojom.UtilWin.InspectModule
  void InspectModule(const ::base::FilePath& module_path, InspectModuleCallback callback) final;
  
// @generated_from: chrome.mojom.UtilWin.GetAntiVirusProducts
  void GetAntiVirusProducts(bool report_full_names, GetAntiVirusProductsCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



// @generated_from: chrome.mojom.ProcessorMetrics
class  ProcessorMetricsProxy
    : public ProcessorMetrics {
 public:
  using InterfaceType = ProcessorMetrics;

  explicit ProcessorMetricsProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: chrome.mojom.ProcessorMetrics.RecordProcessorMetrics
  void RecordProcessorMetrics(RecordProcessorMetricsCallback callback) final;

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

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

  UtilWinStub() = default;
  ~UtilWinStub() override = default;

  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 UtilWinStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

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

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

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

  ProcessorMetricsStub() = default;
  ~ProcessorMetricsStub() override = default;

  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 ProcessorMetricsStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

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

 private:
  ImplPointerType sink_;
};
class  UtilWinRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ProcessorMetricsRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  UtilWinResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ProcessorMetricsResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};












// @generated_from: chrome.mojom.FileFilterSpec
class  FileFilterSpec {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<FileFilterSpec, T>::value>;
  using DataView = FileFilterSpecDataView;
  using Data_ = internal::FileFilterSpec_Data;

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

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

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


  FileFilterSpec();

  FileFilterSpec(
      const ::WTF::String& description,
      const ::WTF::String& extension_spec);


  ~FileFilterSpec();

  // 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 = FileFilterSpecPtr>
  FileFilterSpecPtr 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, FileFilterSpec::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

  template <typename T, FileFilterSpec::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        FileFilterSpec::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        FileFilterSpec::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::FileFilterSpec_UnserializedMessageContext<
            UserType, FileFilterSpec::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

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

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return FileFilterSpec::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::FileFilterSpec_UnserializedMessageContext<
            UserType, FileFilterSpec::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<FileFilterSpec::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: chrome.mojom.FileFilterSpec.description
  ::WTF::String description;
  
// @generated_from: chrome.mojom.FileFilterSpec.extension_spec
  ::WTF::String extension_spec;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 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, FileFilterSpec::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





// @generated_from: chrome.mojom.InspectionResult
class  InspectionResult {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<InspectionResult, T>::value>;
  using DataView = InspectionResultDataView;
  using Data_ = internal::InspectionResult_Data;

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

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

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


  InspectionResult();

  InspectionResult(
      const ::WTF::String& location,
      const ::WTF::String& basename,
      const ::WTF::String& product_name,
      const ::WTF::String& description,
      const ::WTF::String& version,
      CertificateType certificate_type,
      const ::base::FilePath& certificate_path,
      const ::WTF::String& certificate_subject);


  ~InspectionResult();

  // 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 = InspectionResultPtr>
  InspectionResultPtr 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, InspectionResult::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

  template <typename T, InspectionResult::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        InspectionResult::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        InspectionResult::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::InspectionResult_UnserializedMessageContext<
            UserType, InspectionResult::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

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

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return InspectionResult::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::InspectionResult_UnserializedMessageContext<
            UserType, InspectionResult::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<InspectionResult::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: chrome.mojom.InspectionResult.location
  ::WTF::String location;
  
// @generated_from: chrome.mojom.InspectionResult.basename
  ::WTF::String basename;
  
// @generated_from: chrome.mojom.InspectionResult.product_name
  ::WTF::String product_name;
  
// @generated_from: chrome.mojom.InspectionResult.description
  ::WTF::String description;
  
// @generated_from: chrome.mojom.InspectionResult.version
  ::WTF::String version;
  
// @generated_from: chrome.mojom.InspectionResult.certificate_type
  CertificateType certificate_type;
  
// @generated_from: chrome.mojom.InspectionResult.certificate_path
  ::base::FilePath certificate_path;
  
// @generated_from: chrome.mojom.InspectionResult.certificate_subject
  ::WTF::String certificate_subject;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 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, InspectionResult::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





// @generated_from: chrome.mojom.AntiVirusProduct
class  AntiVirusProduct {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<AntiVirusProduct, T>::value>;
  using DataView = AntiVirusProductDataView;
  using Data_ = internal::AntiVirusProduct_Data;

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

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

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


  AntiVirusProduct();

  AntiVirusProduct(
      const WTF::String& product_name,
      uint32_t product_name_hash,
      const WTF::String& product_version,
      uint32_t product_version_hash,
      AntiVirusProductState state);


  ~AntiVirusProduct();

  // 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 = AntiVirusProductPtr>
  AntiVirusProductPtr 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, AntiVirusProduct::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

  template <typename T, AntiVirusProduct::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  size_t Hash(size_t seed) const;
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        AntiVirusProduct::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        AntiVirusProduct::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::AntiVirusProduct_UnserializedMessageContext<
            UserType, AntiVirusProduct::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

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

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return AntiVirusProduct::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::AntiVirusProduct_UnserializedMessageContext<
            UserType, AntiVirusProduct::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<AntiVirusProduct::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: chrome.mojom.AntiVirusProduct.product_name
  WTF::String product_name;
  
// @generated_from: chrome.mojom.AntiVirusProduct.product_name_hash
  uint32_t product_name_hash;
  
// @generated_from: chrome.mojom.AntiVirusProduct.product_version
  WTF::String product_version;
  
// @generated_from: chrome.mojom.AntiVirusProduct.product_version_hash
  uint32_t product_version_hash;
  
// @generated_from: chrome.mojom.AntiVirusProduct.state
  AntiVirusProductState state;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 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, AntiVirusProduct::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





// @generated_from: chrome.mojom.ClsId
class  ClsId {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ClsId, T>::value>;
  using DataView = ClsIdDataView;
  using Data_ = internal::ClsId_Data;

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

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

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


  ClsId();

  explicit ClsId(
      WTF::Vector<uint8_t> bytes);


  ~ClsId();

  // 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 = ClsIdPtr>
  ClsIdPtr 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, ClsId::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

  template <typename T, ClsId::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ClsId::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ClsId::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::ClsId_UnserializedMessageContext<
            UserType, ClsId::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

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

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return ClsId::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::ClsId_UnserializedMessageContext<
            UserType, ClsId::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ClsId::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: chrome.mojom.ClsId.bytes
  WTF::Vector<uint8_t> bytes;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 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, ClsId::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





// @generated_from: chrome.mojom.ShortcutProperties
class  ShortcutProperties {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ShortcutProperties, T>::value>;
  using DataView = ShortcutPropertiesDataView;
  using Data_ = internal::ShortcutProperties_Data;

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

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

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


  ShortcutProperties();

  ShortcutProperties(
      const ::base::FilePath& target,
      const ::base::FilePath& working_dir,
      ::mojo_base::mojom::blink::WStringPtr arguments,
      ::mojo_base::mojom::blink::WStringPtr description,
      const ::base::FilePath& icon,
      int32_t icon_index,
      ::mojo_base::mojom::blink::WStringPtr app_id,
      bool dual_mode,
      ClsIdPtr toast_activator_clsid,
      uint32_t options);

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

  ~ShortcutProperties();

  // 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 = ShortcutPropertiesPtr>
  ShortcutPropertiesPtr 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, ShortcutProperties::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

  template <typename T, ShortcutProperties::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ShortcutProperties::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ShortcutProperties::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::ShortcutProperties_UnserializedMessageContext<
            UserType, ShortcutProperties::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

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

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return ShortcutProperties::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::ShortcutProperties_UnserializedMessageContext<
            UserType, ShortcutProperties::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ShortcutProperties::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: chrome.mojom.ShortcutProperties.target
  ::base::FilePath target;
  
// @generated_from: chrome.mojom.ShortcutProperties.working_dir
  ::base::FilePath working_dir;
  
// @generated_from: chrome.mojom.ShortcutProperties.arguments
  ::mojo_base::mojom::blink::WStringPtr arguments;
  
// @generated_from: chrome.mojom.ShortcutProperties.description
  ::mojo_base::mojom::blink::WStringPtr description;
  
// @generated_from: chrome.mojom.ShortcutProperties.icon
  ::base::FilePath icon;
  
// @generated_from: chrome.mojom.ShortcutProperties.icon_index
  int32_t icon_index;
  
// @generated_from: chrome.mojom.ShortcutProperties.app_id
  ::mojo_base::mojom::blink::WStringPtr app_id;
  
// @generated_from: chrome.mojom.ShortcutProperties.dual_mode
  bool dual_mode;
  
// @generated_from: chrome.mojom.ShortcutProperties.toast_activator_clsid
  ClsIdPtr toast_activator_clsid;
  
// @generated_from: chrome.mojom.ShortcutProperties.options
  uint32_t options;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 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, ShortcutProperties::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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

template <typename StructPtrType>
FileFilterSpecPtr FileFilterSpec::Clone() const {
  return New(
      mojo::Clone(description),
      mojo::Clone(extension_spec)
  );
}

template <typename T, FileFilterSpec::EnableIfSame<T>*>
bool FileFilterSpec::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->description, other_struct.description))
    return false;
  if (!mojo::Equals(this->extension_spec, other_struct.extension_spec))
    return false;
  return true;
}

template <typename T, FileFilterSpec::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.description < rhs.description)
    return true;
  if (rhs.description < lhs.description)
    return false;
  if (lhs.extension_spec < rhs.extension_spec)
    return true;
  if (rhs.extension_spec < lhs.extension_spec)
    return false;
  return false;
}
template <typename StructPtrType>
InspectionResultPtr InspectionResult::Clone() const {
  return New(
      mojo::Clone(location),
      mojo::Clone(basename),
      mojo::Clone(product_name),
      mojo::Clone(description),
      mojo::Clone(version),
      mojo::Clone(certificate_type),
      mojo::Clone(certificate_path),
      mojo::Clone(certificate_subject)
  );
}

template <typename T, InspectionResult::EnableIfSame<T>*>
bool InspectionResult::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->location, other_struct.location))
    return false;
  if (!mojo::Equals(this->basename, other_struct.basename))
    return false;
  if (!mojo::Equals(this->product_name, other_struct.product_name))
    return false;
  if (!mojo::Equals(this->description, other_struct.description))
    return false;
  if (!mojo::Equals(this->version, other_struct.version))
    return false;
  if (!mojo::Equals(this->certificate_type, other_struct.certificate_type))
    return false;
  if (!mojo::Equals(this->certificate_path, other_struct.certificate_path))
    return false;
  if (!mojo::Equals(this->certificate_subject, other_struct.certificate_subject))
    return false;
  return true;
}

template <typename T, InspectionResult::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.location < rhs.location)
    return true;
  if (rhs.location < lhs.location)
    return false;
  if (lhs.basename < rhs.basename)
    return true;
  if (rhs.basename < lhs.basename)
    return false;
  if (lhs.product_name < rhs.product_name)
    return true;
  if (rhs.product_name < lhs.product_name)
    return false;
  if (lhs.description < rhs.description)
    return true;
  if (rhs.description < lhs.description)
    return false;
  if (lhs.version < rhs.version)
    return true;
  if (rhs.version < lhs.version)
    return false;
  if (lhs.certificate_type < rhs.certificate_type)
    return true;
  if (rhs.certificate_type < lhs.certificate_type)
    return false;
  if (lhs.certificate_path < rhs.certificate_path)
    return true;
  if (rhs.certificate_path < lhs.certificate_path)
    return false;
  if (lhs.certificate_subject < rhs.certificate_subject)
    return true;
  if (rhs.certificate_subject < lhs.certificate_subject)
    return false;
  return false;
}
template <typename StructPtrType>
AntiVirusProductPtr AntiVirusProduct::Clone() const {
  return New(
      mojo::Clone(product_name),
      mojo::Clone(product_name_hash),
      mojo::Clone(product_version),
      mojo::Clone(product_version_hash),
      mojo::Clone(state)
  );
}

template <typename T, AntiVirusProduct::EnableIfSame<T>*>
bool AntiVirusProduct::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->product_name, other_struct.product_name))
    return false;
  if (!mojo::Equals(this->product_name_hash, other_struct.product_name_hash))
    return false;
  if (!mojo::Equals(this->product_version, other_struct.product_version))
    return false;
  if (!mojo::Equals(this->product_version_hash, other_struct.product_version_hash))
    return false;
  if (!mojo::Equals(this->state, other_struct.state))
    return false;
  return true;
}

template <typename T, AntiVirusProduct::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.product_name < rhs.product_name)
    return true;
  if (rhs.product_name < lhs.product_name)
    return false;
  if (lhs.product_name_hash < rhs.product_name_hash)
    return true;
  if (rhs.product_name_hash < lhs.product_name_hash)
    return false;
  if (lhs.product_version < rhs.product_version)
    return true;
  if (rhs.product_version < lhs.product_version)
    return false;
  if (lhs.product_version_hash < rhs.product_version_hash)
    return true;
  if (rhs.product_version_hash < lhs.product_version_hash)
    return false;
  if (lhs.state < rhs.state)
    return true;
  if (rhs.state < lhs.state)
    return false;
  return false;
}
template <typename StructPtrType>
ClsIdPtr ClsId::Clone() const {
  return New(
      mojo::Clone(bytes)
  );
}

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

template <typename T, ClsId::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.bytes < rhs.bytes)
    return true;
  if (rhs.bytes < lhs.bytes)
    return false;
  return false;
}
template <typename StructPtrType>
ShortcutPropertiesPtr ShortcutProperties::Clone() const {
  return New(
      mojo::Clone(target),
      mojo::Clone(working_dir),
      mojo::Clone(arguments),
      mojo::Clone(description),
      mojo::Clone(icon),
      mojo::Clone(icon_index),
      mojo::Clone(app_id),
      mojo::Clone(dual_mode),
      mojo::Clone(toast_activator_clsid),
      mojo::Clone(options)
  );
}

template <typename T, ShortcutProperties::EnableIfSame<T>*>
bool ShortcutProperties::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->target, other_struct.target))
    return false;
  if (!mojo::Equals(this->working_dir, other_struct.working_dir))
    return false;
  if (!mojo::Equals(this->arguments, other_struct.arguments))
    return false;
  if (!mojo::Equals(this->description, other_struct.description))
    return false;
  if (!mojo::Equals(this->icon, other_struct.icon))
    return false;
  if (!mojo::Equals(this->icon_index, other_struct.icon_index))
    return false;
  if (!mojo::Equals(this->app_id, other_struct.app_id))
    return false;
  if (!mojo::Equals(this->dual_mode, other_struct.dual_mode))
    return false;
  if (!mojo::Equals(this->toast_activator_clsid, other_struct.toast_activator_clsid))
    return false;
  if (!mojo::Equals(this->options, other_struct.options))
    return false;
  return true;
}

template <typename T, ShortcutProperties::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.target < rhs.target)
    return true;
  if (rhs.target < lhs.target)
    return false;
  if (lhs.working_dir < rhs.working_dir)
    return true;
  if (rhs.working_dir < lhs.working_dir)
    return false;
  if (lhs.arguments < rhs.arguments)
    return true;
  if (rhs.arguments < lhs.arguments)
    return false;
  if (lhs.description < rhs.description)
    return true;
  if (rhs.description < lhs.description)
    return false;
  if (lhs.icon < rhs.icon)
    return true;
  if (rhs.icon < lhs.icon)
    return false;
  if (lhs.icon_index < rhs.icon_index)
    return true;
  if (rhs.icon_index < lhs.icon_index)
    return false;
  if (lhs.app_id < rhs.app_id)
    return true;
  if (rhs.app_id < lhs.app_id)
    return false;
  if (lhs.dual_mode < rhs.dual_mode)
    return true;
  if (rhs.dual_mode < lhs.dual_mode)
    return false;
  if (lhs.toast_activator_clsid < rhs.toast_activator_clsid)
    return true;
  if (rhs.toast_activator_clsid < lhs.toast_activator_clsid)
    return false;
  if (lhs.options < rhs.options)
    return true;
  if (rhs.options < lhs.options)
    return false;
  return false;
}


}  // chrome::mojom::blink

namespace mojo {


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

  static const decltype(::chrome::mojom::blink::FileFilterSpec::description)& description(
      const ::chrome::mojom::blink::FileFilterSpecPtr& input) {
    return input->description;
  }

  static const decltype(::chrome::mojom::blink::FileFilterSpec::extension_spec)& extension_spec(
      const ::chrome::mojom::blink::FileFilterSpecPtr& input) {
    return input->extension_spec;
  }

  static bool Read(::chrome::mojom::blink::FileFilterSpec::DataView input, ::chrome::mojom::blink::FileFilterSpecPtr* output);
};


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

  static const decltype(::chrome::mojom::blink::InspectionResult::location)& location(
      const ::chrome::mojom::blink::InspectionResultPtr& input) {
    return input->location;
  }

  static const decltype(::chrome::mojom::blink::InspectionResult::basename)& basename(
      const ::chrome::mojom::blink::InspectionResultPtr& input) {
    return input->basename;
  }

  static const decltype(::chrome::mojom::blink::InspectionResult::product_name)& product_name(
      const ::chrome::mojom::blink::InspectionResultPtr& input) {
    return input->product_name;
  }

  static const decltype(::chrome::mojom::blink::InspectionResult::description)& description(
      const ::chrome::mojom::blink::InspectionResultPtr& input) {
    return input->description;
  }

  static const decltype(::chrome::mojom::blink::InspectionResult::version)& version(
      const ::chrome::mojom::blink::InspectionResultPtr& input) {
    return input->version;
  }

  static decltype(::chrome::mojom::blink::InspectionResult::certificate_type) certificate_type(
      const ::chrome::mojom::blink::InspectionResultPtr& input) {
    return input->certificate_type;
  }

  static const decltype(::chrome::mojom::blink::InspectionResult::certificate_path)& certificate_path(
      const ::chrome::mojom::blink::InspectionResultPtr& input) {
    return input->certificate_path;
  }

  static const decltype(::chrome::mojom::blink::InspectionResult::certificate_subject)& certificate_subject(
      const ::chrome::mojom::blink::InspectionResultPtr& input) {
    return input->certificate_subject;
  }

  static bool Read(::chrome::mojom::blink::InspectionResult::DataView input, ::chrome::mojom::blink::InspectionResultPtr* output);
};


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

  static const decltype(::chrome::mojom::blink::AntiVirusProduct::product_name)& product_name(
      const ::chrome::mojom::blink::AntiVirusProductPtr& input) {
    return input->product_name;
  }

  static decltype(::chrome::mojom::blink::AntiVirusProduct::product_name_hash) product_name_hash(
      const ::chrome::mojom::blink::AntiVirusProductPtr& input) {
    return input->product_name_hash;
  }

  static const decltype(::chrome::mojom::blink::AntiVirusProduct::product_version)& product_version(
      const ::chrome::mojom::blink::AntiVirusProductPtr& input) {
    return input->product_version;
  }

  static decltype(::chrome::mojom::blink::AntiVirusProduct::product_version_hash) product_version_hash(
      const ::chrome::mojom::blink::AntiVirusProductPtr& input) {
    return input->product_version_hash;
  }

  static decltype(::chrome::mojom::blink::AntiVirusProduct::state) state(
      const ::chrome::mojom::blink::AntiVirusProductPtr& input) {
    return input->state;
  }

  static bool Read(::chrome::mojom::blink::AntiVirusProduct::DataView input, ::chrome::mojom::blink::AntiVirusProductPtr* output);
};


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

  static const decltype(::chrome::mojom::blink::ClsId::bytes)& bytes(
      const ::chrome::mojom::blink::ClsIdPtr& input) {
    return input->bytes;
  }

  static bool Read(::chrome::mojom::blink::ClsId::DataView input, ::chrome::mojom::blink::ClsIdPtr* output);
};


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

  static const decltype(::chrome::mojom::blink::ShortcutProperties::target)& target(
      const ::chrome::mojom::blink::ShortcutPropertiesPtr& input) {
    return input->target;
  }

  static const decltype(::chrome::mojom::blink::ShortcutProperties::working_dir)& working_dir(
      const ::chrome::mojom::blink::ShortcutPropertiesPtr& input) {
    return input->working_dir;
  }

  static const decltype(::chrome::mojom::blink::ShortcutProperties::arguments)& arguments(
      const ::chrome::mojom::blink::ShortcutPropertiesPtr& input) {
    return input->arguments;
  }

  static const decltype(::chrome::mojom::blink::ShortcutProperties::description)& description(
      const ::chrome::mojom::blink::ShortcutPropertiesPtr& input) {
    return input->description;
  }

  static const decltype(::chrome::mojom::blink::ShortcutProperties::icon)& icon(
      const ::chrome::mojom::blink::ShortcutPropertiesPtr& input) {
    return input->icon;
  }

  static decltype(::chrome::mojom::blink::ShortcutProperties::icon_index) icon_index(
      const ::chrome::mojom::blink::ShortcutPropertiesPtr& input) {
    return input->icon_index;
  }

  static const decltype(::chrome::mojom::blink::ShortcutProperties::app_id)& app_id(
      const ::chrome::mojom::blink::ShortcutPropertiesPtr& input) {
    return input->app_id;
  }

  static decltype(::chrome::mojom::blink::ShortcutProperties::dual_mode) dual_mode(
      const ::chrome::mojom::blink::ShortcutPropertiesPtr& input) {
    return input->dual_mode;
  }

  static const decltype(::chrome::mojom::blink::ShortcutProperties::toast_activator_clsid)& toast_activator_clsid(
      const ::chrome::mojom::blink::ShortcutPropertiesPtr& input) {
    return input->toast_activator_clsid;
  }

  static decltype(::chrome::mojom::blink::ShortcutProperties::options) options(
      const ::chrome::mojom::blink::ShortcutPropertiesPtr& input) {
    return input->options;
  }

  static bool Read(::chrome::mojom::blink::ShortcutProperties::DataView input, ::chrome::mojom::blink::ShortcutPropertiesPtr* output);
};

}  // namespace mojo

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