win-Debug/gen/chrome/browser/ui/webui/omnibox/omnibox.mojom.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 CHROME_BROWSER_UI_WEBUI_OMNIBOX_OMNIBOX_MOJOM_H_
#define CHROME_BROWSER_UI_WEBUI_OMNIBOX_OMNIBOX_MOJOM_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 "chrome/browser/ui/webui/omnibox/omnibox.mojom-shared.h"
#include "chrome/browser/ui/webui/omnibox/omnibox.mojom-forward.h"
#include <string>
#include <vector>

#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"

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


namespace mojom {

class OmniboxPageHandlerProxy;

template <typename ImplRefTraits>
class OmniboxPageHandlerStub;

class OmniboxPageHandlerRequestValidator;


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

  using Base_ = OmniboxPageHandlerInterfaceBase;
  using Proxy_ = OmniboxPageHandlerProxy;

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

  using RequestValidator_ = OmniboxPageHandlerRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kSetClientPageMinVersion = 0,
    kStartOmniboxQueryMinVersion = 0,
  };
  virtual ~OmniboxPageHandler() {}

  
// @generated_from: mojom.OmniboxPageHandler.SetClientPage
  virtual void SetClientPage(OmniboxPagePtr page) = 0;

  
// @generated_from: mojom.OmniboxPageHandler.StartOmniboxQuery
  virtual void StartOmniboxQuery(const std::string& input_string, bool reset_autocomplete_controller, int32_t cursor_position, bool zero_suggest, bool prevent_inline_autocomplete, bool prefer_keyword, const std::string& current_url, int32_t page_classification) = 0;
};

class OmniboxPageProxy;

template <typename ImplRefTraits>
class OmniboxPageStub;

class OmniboxPageRequestValidator;


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

  using Base_ = OmniboxPageInterfaceBase;
  using Proxy_ = OmniboxPageProxy;

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

  using RequestValidator_ = OmniboxPageRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    khandleNewAutocompleteResponseMinVersion = 0,
    kHandleNewAutocompleteQueryMinVersion = 0,
    kHandleAnswerImageDataMinVersion = 0,
  };
  virtual ~OmniboxPage() {}

  
// @generated_from: mojom.OmniboxPage.handleNewAutocompleteResponse
  virtual void handleNewAutocompleteResponse(OmniboxResponsePtr response, bool isPageController) = 0;

  
// @generated_from: mojom.OmniboxPage.HandleNewAutocompleteQuery
  virtual void HandleNewAutocompleteQuery(bool isPageController, const std::string& input_text) = 0;

  
// @generated_from: mojom.OmniboxPage.HandleAnswerImageData
  virtual void HandleAnswerImageData(const std::string& image_url, const std::string& image_data) = 0;
};

class  OmniboxPageHandlerProxy
    : public OmniboxPageHandler {
 public:
  using InterfaceType = OmniboxPageHandler;

  explicit OmniboxPageHandlerProxy(mojo::MessageReceiverWithResponder* receiver);
  void SetClientPage(OmniboxPagePtr page) final;
  void StartOmniboxQuery(const std::string& input_string, bool reset_autocomplete_controller, int32_t cursor_position, bool zero_suggest, bool prevent_inline_autocomplete, bool prefer_keyword, const std::string& current_url, int32_t page_classification) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};

class  OmniboxPageProxy
    : public OmniboxPage {
 public:
  using InterfaceType = OmniboxPage;

  explicit OmniboxPageProxy(mojo::MessageReceiverWithResponder* receiver);
  void handleNewAutocompleteResponse(OmniboxResponsePtr response, bool isPageController) final;
  void HandleNewAutocompleteQuery(bool isPageController, const std::string& input_text) final;
  void HandleAnswerImageData(const std::string& image_url, const std::string& image_data) final;

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

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

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

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

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

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

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

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

 private:
  ImplPointerType sink_;
};
class  OmniboxPageHandlerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  OmniboxPageRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};





// @generated_from: mojom.ACMatchClassification
class  ACMatchClassification {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ACMatchClassification, T>::value>;
  using DataView = ACMatchClassificationDataView;
  using Data_ = internal::ACMatchClassification_Data;

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

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

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


  ACMatchClassification();

  ACMatchClassification(
      int32_t offset,
      int32_t style);

  ~ACMatchClassification();

  // 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 = ACMatchClassificationPtr>
  ACMatchClassificationPtr 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, ACMatchClassification::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;
  size_t Hash(size_t seed) const;

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ACMatchClassification::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ACMatchClassification::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::ACMatchClassification_UnserializedMessageContext<
            UserType, ACMatchClassification::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<ACMatchClassification::DataView>(
        data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate);
  }

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

  
// @generated_from: mojom.ACMatchClassification.offset
  int32_t offset;
  
// @generated_from: mojom.ACMatchClassification.style
  int32_t style;

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

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

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

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





// @generated_from: mojom.AutocompleteAdditionalInfo
class  AutocompleteAdditionalInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<AutocompleteAdditionalInfo, T>::value>;
  using DataView = AutocompleteAdditionalInfoDataView;
  using Data_ = internal::AutocompleteAdditionalInfo_Data;

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

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

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


  AutocompleteAdditionalInfo();

  AutocompleteAdditionalInfo(
      const std::string& key,
      const std::string& value);

  ~AutocompleteAdditionalInfo();

  // 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 = AutocompleteAdditionalInfoPtr>
  AutocompleteAdditionalInfoPtr 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, AutocompleteAdditionalInfo::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;
  size_t Hash(size_t seed) const;

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        AutocompleteAdditionalInfo::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        AutocompleteAdditionalInfo::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::AutocompleteAdditionalInfo_UnserializedMessageContext<
            UserType, AutocompleteAdditionalInfo::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<AutocompleteAdditionalInfo::DataView>(
        data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate);
  }

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

  
// @generated_from: mojom.AutocompleteAdditionalInfo.key
  std::string key;
  
// @generated_from: mojom.AutocompleteAdditionalInfo.value
  std::string value;

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

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

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

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












// @generated_from: mojom.AutocompleteMatch
class  AutocompleteMatch {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<AutocompleteMatch, T>::value>;
  using DataView = AutocompleteMatchDataView;
  using Data_ = internal::AutocompleteMatch_Data;

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

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

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


  AutocompleteMatch();

  AutocompleteMatch(
      const base::Optional<std::string>& provider_name,
      bool provider_done,
      int32_t relevance,
      bool deletable,
      const std::string& fill_into_edit,
      const std::string& inline_autocompletion,
      const std::string& destination_url,
      const std::string& stripped_destination_url,
      const std::string& image,
      const std::string& contents,
      std::vector<ACMatchClassificationPtr> contents_class,
      const std::string& description,
      std::vector<ACMatchClassificationPtr> description_class,
      const std::string& answer,
      const std::string& transition,
      bool allowed_to_be_default_match,
      const std::string& type,
      bool is_search_type,
      bool has_tab_match,
      const base::Optional<std::string>& associated_keyword,
      const std::string& keyword,
      bool starred,
      int32_t duplicates,
      bool from_previous,
      std::vector<AutocompleteAdditionalInfoPtr> additional_info,
      const std::string& document_type);

  ~AutocompleteMatch();

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

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        AutocompleteMatch::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        AutocompleteMatch::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::AutocompleteMatch_UnserializedMessageContext<
            UserType, AutocompleteMatch::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<AutocompleteMatch::DataView>(
        data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate);
  }

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

  
// @generated_from: mojom.AutocompleteMatch.provider_name
  base::Optional<std::string> provider_name;
  
// @generated_from: mojom.AutocompleteMatch.provider_done
  bool provider_done;
  
// @generated_from: mojom.AutocompleteMatch.relevance
  int32_t relevance;
  
// @generated_from: mojom.AutocompleteMatch.deletable
  bool deletable;
  
// @generated_from: mojom.AutocompleteMatch.fill_into_edit
  std::string fill_into_edit;
  
// @generated_from: mojom.AutocompleteMatch.inline_autocompletion
  std::string inline_autocompletion;
  
// @generated_from: mojom.AutocompleteMatch.destination_url
  std::string destination_url;
  
// @generated_from: mojom.AutocompleteMatch.stripped_destination_url
  std::string stripped_destination_url;
  
// @generated_from: mojom.AutocompleteMatch.image
  std::string image;
  
// @generated_from: mojom.AutocompleteMatch.contents
  std::string contents;
  
// @generated_from: mojom.AutocompleteMatch.contents_class
  std::vector<ACMatchClassificationPtr> contents_class;
  
// @generated_from: mojom.AutocompleteMatch.description
  std::string description;
  
// @generated_from: mojom.AutocompleteMatch.description_class
  std::vector<ACMatchClassificationPtr> description_class;
  
// @generated_from: mojom.AutocompleteMatch.answer
  std::string answer;
  
// @generated_from: mojom.AutocompleteMatch.transition
  std::string transition;
  
// @generated_from: mojom.AutocompleteMatch.allowed_to_be_default_match
  bool allowed_to_be_default_match;
  
// @generated_from: mojom.AutocompleteMatch.type
  std::string type;
  
// @generated_from: mojom.AutocompleteMatch.is_search_type
  bool is_search_type;
  
// @generated_from: mojom.AutocompleteMatch.has_tab_match
  bool has_tab_match;
  
// @generated_from: mojom.AutocompleteMatch.associated_keyword
  base::Optional<std::string> associated_keyword;
  
// @generated_from: mojom.AutocompleteMatch.keyword
  std::string keyword;
  
// @generated_from: mojom.AutocompleteMatch.starred
  bool starred;
  
// @generated_from: mojom.AutocompleteMatch.duplicates
  int32_t duplicates;
  
// @generated_from: mojom.AutocompleteMatch.from_previous
  bool from_previous;
  
// @generated_from: mojom.AutocompleteMatch.additional_info
  std::vector<AutocompleteAdditionalInfoPtr> additional_info;
  
// @generated_from: mojom.AutocompleteMatch.document_type
  std::string document_type;

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

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

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

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

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





// @generated_from: mojom.AutocompleteResultsForProvider
class  AutocompleteResultsForProvider {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<AutocompleteResultsForProvider, T>::value>;
  using DataView = AutocompleteResultsForProviderDataView;
  using Data_ = internal::AutocompleteResultsForProvider_Data;

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

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

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


  AutocompleteResultsForProvider();

  AutocompleteResultsForProvider(
      const std::string& provider_name,
      std::vector<AutocompleteMatchPtr> results);

  ~AutocompleteResultsForProvider();

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

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        AutocompleteResultsForProvider::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        AutocompleteResultsForProvider::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::AutocompleteResultsForProvider_UnserializedMessageContext<
            UserType, AutocompleteResultsForProvider::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<AutocompleteResultsForProvider::DataView>(
        data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate);
  }

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

  
// @generated_from: mojom.AutocompleteResultsForProvider.provider_name
  std::string provider_name;
  
// @generated_from: mojom.AutocompleteResultsForProvider.results
  std::vector<AutocompleteMatchPtr> results;

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

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

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

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

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





// @generated_from: mojom.OmniboxResponse
class  OmniboxResponse {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<OmniboxResponse, T>::value>;
  using DataView = OmniboxResponseDataView;
  using Data_ = internal::OmniboxResponse_Data;

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

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

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


  OmniboxResponse();

  OmniboxResponse(
      bool done,
      int32_t time_since_omnibox_started_ms,
      const std::string& type,
      const std::string& host,
      bool is_typed_host,
      std::vector<AutocompleteMatchPtr> combined_results,
      std::vector<AutocompleteResultsForProviderPtr> results_by_provider);

  ~OmniboxResponse();

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

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        OmniboxResponse::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        OmniboxResponse::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::OmniboxResponse_UnserializedMessageContext<
            UserType, OmniboxResponse::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<OmniboxResponse::DataView>(
        data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate);
  }

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

  
// @generated_from: mojom.OmniboxResponse.done
  bool done;
  
// @generated_from: mojom.OmniboxResponse.time_since_omnibox_started_ms
  int32_t time_since_omnibox_started_ms;
  
// @generated_from: mojom.OmniboxResponse.type
  std::string type;
  
// @generated_from: mojom.OmniboxResponse.host
  std::string host;
  
// @generated_from: mojom.OmniboxResponse.is_typed_host
  bool is_typed_host;
  
// @generated_from: mojom.OmniboxResponse.combined_results
  std::vector<AutocompleteMatchPtr> combined_results;
  
// @generated_from: mojom.OmniboxResponse.results_by_provider
  std::vector<AutocompleteResultsForProviderPtr> results_by_provider;

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

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

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

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

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

template <typename StructPtrType>
ACMatchClassificationPtr ACMatchClassification::Clone() const {
  return New(
      mojo::Clone(offset),
      mojo::Clone(style)
  );
}

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

template <typename T, ACMatchClassification::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.offset < rhs.offset)
    return true;
  if (rhs.offset < lhs.offset)
    return false;
  if (lhs.style < rhs.style)
    return true;
  if (rhs.style < lhs.style)
    return false;
  return false;
}
template <typename StructPtrType>
AutocompleteAdditionalInfoPtr AutocompleteAdditionalInfo::Clone() const {
  return New(
      mojo::Clone(key),
      mojo::Clone(value)
  );
}

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

template <typename T, AutocompleteAdditionalInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.key < rhs.key)
    return true;
  if (rhs.key < lhs.key)
    return false;
  if (lhs.value < rhs.value)
    return true;
  if (rhs.value < lhs.value)
    return false;
  return false;
}
template <typename StructPtrType>
AutocompleteMatchPtr AutocompleteMatch::Clone() const {
  return New(
      mojo::Clone(provider_name),
      mojo::Clone(provider_done),
      mojo::Clone(relevance),
      mojo::Clone(deletable),
      mojo::Clone(fill_into_edit),
      mojo::Clone(inline_autocompletion),
      mojo::Clone(destination_url),
      mojo::Clone(stripped_destination_url),
      mojo::Clone(image),
      mojo::Clone(contents),
      mojo::Clone(contents_class),
      mojo::Clone(description),
      mojo::Clone(description_class),
      mojo::Clone(answer),
      mojo::Clone(transition),
      mojo::Clone(allowed_to_be_default_match),
      mojo::Clone(type),
      mojo::Clone(is_search_type),
      mojo::Clone(has_tab_match),
      mojo::Clone(associated_keyword),
      mojo::Clone(keyword),
      mojo::Clone(starred),
      mojo::Clone(duplicates),
      mojo::Clone(from_previous),
      mojo::Clone(additional_info),
      mojo::Clone(document_type)
  );
}

template <typename T, AutocompleteMatch::EnableIfSame<T>*>
bool AutocompleteMatch::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->provider_name, other_struct.provider_name))
    return false;
  if (!mojo::Equals(this->provider_done, other_struct.provider_done))
    return false;
  if (!mojo::Equals(this->relevance, other_struct.relevance))
    return false;
  if (!mojo::Equals(this->deletable, other_struct.deletable))
    return false;
  if (!mojo::Equals(this->fill_into_edit, other_struct.fill_into_edit))
    return false;
  if (!mojo::Equals(this->inline_autocompletion, other_struct.inline_autocompletion))
    return false;
  if (!mojo::Equals(this->destination_url, other_struct.destination_url))
    return false;
  if (!mojo::Equals(this->stripped_destination_url, other_struct.stripped_destination_url))
    return false;
  if (!mojo::Equals(this->image, other_struct.image))
    return false;
  if (!mojo::Equals(this->contents, other_struct.contents))
    return false;
  if (!mojo::Equals(this->contents_class, other_struct.contents_class))
    return false;
  if (!mojo::Equals(this->description, other_struct.description))
    return false;
  if (!mojo::Equals(this->description_class, other_struct.description_class))
    return false;
  if (!mojo::Equals(this->answer, other_struct.answer))
    return false;
  if (!mojo::Equals(this->transition, other_struct.transition))
    return false;
  if (!mojo::Equals(this->allowed_to_be_default_match, other_struct.allowed_to_be_default_match))
    return false;
  if (!mojo::Equals(this->type, other_struct.type))
    return false;
  if (!mojo::Equals(this->is_search_type, other_struct.is_search_type))
    return false;
  if (!mojo::Equals(this->has_tab_match, other_struct.has_tab_match))
    return false;
  if (!mojo::Equals(this->associated_keyword, other_struct.associated_keyword))
    return false;
  if (!mojo::Equals(this->keyword, other_struct.keyword))
    return false;
  if (!mojo::Equals(this->starred, other_struct.starred))
    return false;
  if (!mojo::Equals(this->duplicates, other_struct.duplicates))
    return false;
  if (!mojo::Equals(this->from_previous, other_struct.from_previous))
    return false;
  if (!mojo::Equals(this->additional_info, other_struct.additional_info))
    return false;
  if (!mojo::Equals(this->document_type, other_struct.document_type))
    return false;
  return true;
}

template <typename T, AutocompleteMatch::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.provider_name < rhs.provider_name)
    return true;
  if (rhs.provider_name < lhs.provider_name)
    return false;
  if (lhs.provider_done < rhs.provider_done)
    return true;
  if (rhs.provider_done < lhs.provider_done)
    return false;
  if (lhs.relevance < rhs.relevance)
    return true;
  if (rhs.relevance < lhs.relevance)
    return false;
  if (lhs.deletable < rhs.deletable)
    return true;
  if (rhs.deletable < lhs.deletable)
    return false;
  if (lhs.fill_into_edit < rhs.fill_into_edit)
    return true;
  if (rhs.fill_into_edit < lhs.fill_into_edit)
    return false;
  if (lhs.inline_autocompletion < rhs.inline_autocompletion)
    return true;
  if (rhs.inline_autocompletion < lhs.inline_autocompletion)
    return false;
  if (lhs.destination_url < rhs.destination_url)
    return true;
  if (rhs.destination_url < lhs.destination_url)
    return false;
  if (lhs.stripped_destination_url < rhs.stripped_destination_url)
    return true;
  if (rhs.stripped_destination_url < lhs.stripped_destination_url)
    return false;
  if (lhs.image < rhs.image)
    return true;
  if (rhs.image < lhs.image)
    return false;
  if (lhs.contents < rhs.contents)
    return true;
  if (rhs.contents < lhs.contents)
    return false;
  if (lhs.contents_class < rhs.contents_class)
    return true;
  if (rhs.contents_class < lhs.contents_class)
    return false;
  if (lhs.description < rhs.description)
    return true;
  if (rhs.description < lhs.description)
    return false;
  if (lhs.description_class < rhs.description_class)
    return true;
  if (rhs.description_class < lhs.description_class)
    return false;
  if (lhs.answer < rhs.answer)
    return true;
  if (rhs.answer < lhs.answer)
    return false;
  if (lhs.transition < rhs.transition)
    return true;
  if (rhs.transition < lhs.transition)
    return false;
  if (lhs.allowed_to_be_default_match < rhs.allowed_to_be_default_match)
    return true;
  if (rhs.allowed_to_be_default_match < lhs.allowed_to_be_default_match)
    return false;
  if (lhs.type < rhs.type)
    return true;
  if (rhs.type < lhs.type)
    return false;
  if (lhs.is_search_type < rhs.is_search_type)
    return true;
  if (rhs.is_search_type < lhs.is_search_type)
    return false;
  if (lhs.has_tab_match < rhs.has_tab_match)
    return true;
  if (rhs.has_tab_match < lhs.has_tab_match)
    return false;
  if (lhs.associated_keyword < rhs.associated_keyword)
    return true;
  if (rhs.associated_keyword < lhs.associated_keyword)
    return false;
  if (lhs.keyword < rhs.keyword)
    return true;
  if (rhs.keyword < lhs.keyword)
    return false;
  if (lhs.starred < rhs.starred)
    return true;
  if (rhs.starred < lhs.starred)
    return false;
  if (lhs.duplicates < rhs.duplicates)
    return true;
  if (rhs.duplicates < lhs.duplicates)
    return false;
  if (lhs.from_previous < rhs.from_previous)
    return true;
  if (rhs.from_previous < lhs.from_previous)
    return false;
  if (lhs.additional_info < rhs.additional_info)
    return true;
  if (rhs.additional_info < lhs.additional_info)
    return false;
  if (lhs.document_type < rhs.document_type)
    return true;
  if (rhs.document_type < lhs.document_type)
    return false;
  return false;
}
template <typename StructPtrType>
AutocompleteResultsForProviderPtr AutocompleteResultsForProvider::Clone() const {
  return New(
      mojo::Clone(provider_name),
      mojo::Clone(results)
  );
}

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

template <typename T, AutocompleteResultsForProvider::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.provider_name < rhs.provider_name)
    return true;
  if (rhs.provider_name < lhs.provider_name)
    return false;
  if (lhs.results < rhs.results)
    return true;
  if (rhs.results < lhs.results)
    return false;
  return false;
}
template <typename StructPtrType>
OmniboxResponsePtr OmniboxResponse::Clone() const {
  return New(
      mojo::Clone(done),
      mojo::Clone(time_since_omnibox_started_ms),
      mojo::Clone(type),
      mojo::Clone(host),
      mojo::Clone(is_typed_host),
      mojo::Clone(combined_results),
      mojo::Clone(results_by_provider)
  );
}

template <typename T, OmniboxResponse::EnableIfSame<T>*>
bool OmniboxResponse::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->done, other_struct.done))
    return false;
  if (!mojo::Equals(this->time_since_omnibox_started_ms, other_struct.time_since_omnibox_started_ms))
    return false;
  if (!mojo::Equals(this->type, other_struct.type))
    return false;
  if (!mojo::Equals(this->host, other_struct.host))
    return false;
  if (!mojo::Equals(this->is_typed_host, other_struct.is_typed_host))
    return false;
  if (!mojo::Equals(this->combined_results, other_struct.combined_results))
    return false;
  if (!mojo::Equals(this->results_by_provider, other_struct.results_by_provider))
    return false;
  return true;
}

template <typename T, OmniboxResponse::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.done < rhs.done)
    return true;
  if (rhs.done < lhs.done)
    return false;
  if (lhs.time_since_omnibox_started_ms < rhs.time_since_omnibox_started_ms)
    return true;
  if (rhs.time_since_omnibox_started_ms < lhs.time_since_omnibox_started_ms)
    return false;
  if (lhs.type < rhs.type)
    return true;
  if (rhs.type < lhs.type)
    return false;
  if (lhs.host < rhs.host)
    return true;
  if (rhs.host < lhs.host)
    return false;
  if (lhs.is_typed_host < rhs.is_typed_host)
    return true;
  if (rhs.is_typed_host < lhs.is_typed_host)
    return false;
  if (lhs.combined_results < rhs.combined_results)
    return true;
  if (rhs.combined_results < lhs.combined_results)
    return false;
  if (lhs.results_by_provider < rhs.results_by_provider)
    return true;
  if (rhs.results_by_provider < lhs.results_by_provider)
    return false;
  return false;
}


}  // namespace mojom

namespace mojo {


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

  static decltype(::mojom::ACMatchClassification::offset) offset(
      const ::mojom::ACMatchClassificationPtr& input) {
    return input->offset;
  }

  static decltype(::mojom::ACMatchClassification::style) style(
      const ::mojom::ACMatchClassificationPtr& input) {
    return input->style;
  }

  static bool Read(::mojom::ACMatchClassification::DataView input, ::mojom::ACMatchClassificationPtr* output);
};


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

  static const decltype(::mojom::AutocompleteAdditionalInfo::key)& key(
      const ::mojom::AutocompleteAdditionalInfoPtr& input) {
    return input->key;
  }

  static const decltype(::mojom::AutocompleteAdditionalInfo::value)& value(
      const ::mojom::AutocompleteAdditionalInfoPtr& input) {
    return input->value;
  }

  static bool Read(::mojom::AutocompleteAdditionalInfo::DataView input, ::mojom::AutocompleteAdditionalInfoPtr* output);
};


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

  static const decltype(::mojom::AutocompleteMatch::provider_name)& provider_name(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->provider_name;
  }

  static decltype(::mojom::AutocompleteMatch::provider_done) provider_done(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->provider_done;
  }

  static decltype(::mojom::AutocompleteMatch::relevance) relevance(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->relevance;
  }

  static decltype(::mojom::AutocompleteMatch::deletable) deletable(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->deletable;
  }

  static const decltype(::mojom::AutocompleteMatch::fill_into_edit)& fill_into_edit(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->fill_into_edit;
  }

  static const decltype(::mojom::AutocompleteMatch::inline_autocompletion)& inline_autocompletion(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->inline_autocompletion;
  }

  static const decltype(::mojom::AutocompleteMatch::destination_url)& destination_url(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->destination_url;
  }

  static const decltype(::mojom::AutocompleteMatch::stripped_destination_url)& stripped_destination_url(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->stripped_destination_url;
  }

  static const decltype(::mojom::AutocompleteMatch::image)& image(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->image;
  }

  static const decltype(::mojom::AutocompleteMatch::contents)& contents(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->contents;
  }

  static const decltype(::mojom::AutocompleteMatch::contents_class)& contents_class(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->contents_class;
  }

  static const decltype(::mojom::AutocompleteMatch::description)& description(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->description;
  }

  static const decltype(::mojom::AutocompleteMatch::description_class)& description_class(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->description_class;
  }

  static const decltype(::mojom::AutocompleteMatch::answer)& answer(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->answer;
  }

  static const decltype(::mojom::AutocompleteMatch::transition)& transition(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->transition;
  }

  static decltype(::mojom::AutocompleteMatch::allowed_to_be_default_match) allowed_to_be_default_match(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->allowed_to_be_default_match;
  }

  static const decltype(::mojom::AutocompleteMatch::type)& type(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->type;
  }

  static decltype(::mojom::AutocompleteMatch::is_search_type) is_search_type(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->is_search_type;
  }

  static decltype(::mojom::AutocompleteMatch::has_tab_match) has_tab_match(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->has_tab_match;
  }

  static const decltype(::mojom::AutocompleteMatch::associated_keyword)& associated_keyword(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->associated_keyword;
  }

  static const decltype(::mojom::AutocompleteMatch::keyword)& keyword(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->keyword;
  }

  static decltype(::mojom::AutocompleteMatch::starred) starred(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->starred;
  }

  static decltype(::mojom::AutocompleteMatch::duplicates) duplicates(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->duplicates;
  }

  static decltype(::mojom::AutocompleteMatch::from_previous) from_previous(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->from_previous;
  }

  static const decltype(::mojom::AutocompleteMatch::additional_info)& additional_info(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->additional_info;
  }

  static const decltype(::mojom::AutocompleteMatch::document_type)& document_type(
      const ::mojom::AutocompleteMatchPtr& input) {
    return input->document_type;
  }

  static bool Read(::mojom::AutocompleteMatch::DataView input, ::mojom::AutocompleteMatchPtr* output);
};


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

  static const decltype(::mojom::AutocompleteResultsForProvider::provider_name)& provider_name(
      const ::mojom::AutocompleteResultsForProviderPtr& input) {
    return input->provider_name;
  }

  static const decltype(::mojom::AutocompleteResultsForProvider::results)& results(
      const ::mojom::AutocompleteResultsForProviderPtr& input) {
    return input->results;
  }

  static bool Read(::mojom::AutocompleteResultsForProvider::DataView input, ::mojom::AutocompleteResultsForProviderPtr* output);
};


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

  static decltype(::mojom::OmniboxResponse::done) done(
      const ::mojom::OmniboxResponsePtr& input) {
    return input->done;
  }

  static decltype(::mojom::OmniboxResponse::time_since_omnibox_started_ms) time_since_omnibox_started_ms(
      const ::mojom::OmniboxResponsePtr& input) {
    return input->time_since_omnibox_started_ms;
  }

  static const decltype(::mojom::OmniboxResponse::type)& type(
      const ::mojom::OmniboxResponsePtr& input) {
    return input->type;
  }

  static const decltype(::mojom::OmniboxResponse::host)& host(
      const ::mojom::OmniboxResponsePtr& input) {
    return input->host;
  }

  static decltype(::mojom::OmniboxResponse::is_typed_host) is_typed_host(
      const ::mojom::OmniboxResponsePtr& input) {
    return input->is_typed_host;
  }

  static const decltype(::mojom::OmniboxResponse::combined_results)& combined_results(
      const ::mojom::OmniboxResponsePtr& input) {
    return input->combined_results;
  }

  static const decltype(::mojom::OmniboxResponse::results_by_provider)& results_by_provider(
      const ::mojom::OmniboxResponsePtr& input) {
    return input->results_by_provider;
  }

  static bool Read(::mojom::OmniboxResponse::DataView input, ::mojom::OmniboxResponsePtr* output);
};

}  // namespace mojo

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