Debug/gen/chrome/browser/ui/webui/tab_search/tab_search.mojom.h

// chrome/browser/ui/webui/tab_search/tab_search.mojom.h is auto generated by mojom_bindings_generator.py, do not edit

// 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_TAB_SEARCH_TAB_SEARCH_MOJOM_H_
#define CHROME_BROWSER_UI_WEBUI_TAB_SEARCH_TAB_SEARCH_MOJOM_H_

#include <stdint.h>

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

#include "third_party/abseil-cpp/absl/types/optional.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/browser/ui/webui/tab_search/tab_search.mojom-shared.h"
#include "chrome/browser/ui/webui/tab_search/tab_search.mojom-forward.h"
#include "components/tab_groups/public/mojom/tab_group_types.mojom.h"
#include "mojo/public/mojom/base/time.mojom.h"
#include "mojo/public/mojom/base/token.mojom.h"
#include "url/mojom/url.mojom.h"
#include "chrome/browser/ui/webui/tabs/tabs.mojom.h"
#include <string>
#include <vector>

#include "mojo/public/cpp/bindings/lib/control_message_handler.h"
#include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"



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


namespace tab_search {
namespace mojom {

class PageHandlerFactoryProxy;

template <typename ImplRefTraits>
class PageHandlerFactoryStub;

class PageHandlerFactoryRequestValidator;


// @generated_from: tab_search.mojom.PageHandlerFactory
class  PageHandlerFactory
    : public PageHandlerFactoryInterfaceBase {
 public:
  static const char Name_[];
  static std::pair<uint32_t, const void*> MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasSyncMethods_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = PageHandlerFactoryInterfaceBase;
  using Proxy_ = PageHandlerFactoryProxy;

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

  using RequestValidator_ = PageHandlerFactoryRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kCreatePageHandlerMinVersion = 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 CreatePageHandler_Sym {
    NOINLINE static void IPCSymbol();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~PageHandlerFactory() = default;

  
// @generated_from: tab_search.mojom.PageHandlerFactory.CreatePageHandler
  virtual void CreatePageHandler(::mojo::PendingRemote<Page> page, ::mojo::PendingReceiver<PageHandler> handler) = 0;
};

class PageHandlerProxy;

template <typename ImplRefTraits>
class PageHandlerStub;

class PageHandlerRequestValidator;
class PageHandlerResponseValidator;


// @generated_from: tab_search.mojom.PageHandler
class  PageHandler
    : public PageHandlerInterfaceBase {
 public:
  static const char Name_[];
  static std::pair<uint32_t, const void*> MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasSyncMethods_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = PageHandlerInterfaceBase;
  using Proxy_ = PageHandlerProxy;

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

  using RequestValidator_ = PageHandlerRequestValidator;
  using ResponseValidator_ = PageHandlerResponseValidator;
  enum MethodMinVersions : uint32_t {
    kCloseTabMinVersion = 0,
    kGetProfileDataMinVersion = 0,
    kSwitchToTabMinVersion = 0,
    kOpenRecentlyClosedEntryMinVersion = 0,
    kSaveRecentlyClosedExpandedPrefMinVersion = 0,
    kShowUIMinVersion = 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 CloseTab_Sym {
    NOINLINE static void IPCSymbol();
  };
  struct GetProfileData_Sym {
    NOINLINE static void IPCSymbol();
  };
  struct SwitchToTab_Sym {
    NOINLINE static void IPCSymbol();
  };
  struct OpenRecentlyClosedEntry_Sym {
    NOINLINE static void IPCSymbol();
  };
  struct SaveRecentlyClosedExpandedPref_Sym {
    NOINLINE static void IPCSymbol();
  };
  struct ShowUI_Sym {
    NOINLINE static void IPCSymbol();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~PageHandler() = default;

  
// @generated_from: tab_search.mojom.PageHandler.CloseTab
  virtual void CloseTab(int32_t tab_id) = 0;


  using GetProfileDataCallback = base::OnceCallback<void(ProfileDataPtr)>;
  
// @generated_from: tab_search.mojom.PageHandler.GetProfileData
  virtual void GetProfileData(GetProfileDataCallback callback) = 0;

  
// @generated_from: tab_search.mojom.PageHandler.SwitchToTab
  virtual void SwitchToTab(SwitchToTabInfoPtr switch_to_tab_info) = 0;

  
// @generated_from: tab_search.mojom.PageHandler.OpenRecentlyClosedEntry
  virtual void OpenRecentlyClosedEntry(int32_t session_id) = 0;

  
// @generated_from: tab_search.mojom.PageHandler.SaveRecentlyClosedExpandedPref
  virtual void SaveRecentlyClosedExpandedPref(bool expanded) = 0;

  
// @generated_from: tab_search.mojom.PageHandler.ShowUI
  virtual void ShowUI() = 0;
};

class PageProxy;

template <typename ImplRefTraits>
class PageStub;

class PageRequestValidator;


// @generated_from: tab_search.mojom.Page
class  Page
    : public PageInterfaceBase {
 public:
  static const char Name_[];
  static std::pair<uint32_t, const void*> MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasSyncMethods_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = PageInterfaceBase;
  using Proxy_ = PageProxy;

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

  using RequestValidator_ = PageRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kTabsChangedMinVersion = 0,
    kTabUpdatedMinVersion = 0,
    kTabsRemovedMinVersion = 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 TabsChanged_Sym {
    NOINLINE static void IPCSymbol();
  };
  struct TabUpdated_Sym {
    NOINLINE static void IPCSymbol();
  };
  struct TabsRemoved_Sym {
    NOINLINE static void IPCSymbol();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~Page() = default;

  
// @generated_from: tab_search.mojom.Page.TabsChanged
  virtual void TabsChanged(ProfileDataPtr profile_tabs) = 0;

  
// @generated_from: tab_search.mojom.Page.TabUpdated
  virtual void TabUpdated(TabUpdateInfoPtr tabUpdateInfo) = 0;

  
// @generated_from: tab_search.mojom.Page.TabsRemoved
  virtual void TabsRemoved(TabsRemovedInfoPtr tabsRemovedInfo) = 0;
};



// @generated_from: tab_search.mojom.PageHandlerFactory
class  PageHandlerFactoryProxy
    : public PageHandlerFactory {
 public:
  using InterfaceType = PageHandlerFactory;

  explicit PageHandlerFactoryProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: tab_search.mojom.PageHandlerFactory.CreatePageHandler
  void CreatePageHandler(::mojo::PendingRemote<Page> page, ::mojo::PendingReceiver<PageHandler> handler) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



// @generated_from: tab_search.mojom.PageHandler
class  PageHandlerProxy
    : public PageHandler {
 public:
  using InterfaceType = PageHandler;

  explicit PageHandlerProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: tab_search.mojom.PageHandler.CloseTab
  void CloseTab(int32_t tab_id) final;
  
// @generated_from: tab_search.mojom.PageHandler.GetProfileData
  void GetProfileData(GetProfileDataCallback callback) final;
  
// @generated_from: tab_search.mojom.PageHandler.SwitchToTab
  void SwitchToTab(SwitchToTabInfoPtr switch_to_tab_info) final;
  
// @generated_from: tab_search.mojom.PageHandler.OpenRecentlyClosedEntry
  void OpenRecentlyClosedEntry(int32_t session_id) final;
  
// @generated_from: tab_search.mojom.PageHandler.SaveRecentlyClosedExpandedPref
  void SaveRecentlyClosedExpandedPref(bool expanded) final;
  
// @generated_from: tab_search.mojom.PageHandler.ShowUI
  void ShowUI() final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



// @generated_from: tab_search.mojom.Page
class  PageProxy
    : public Page {
 public:
  using InterfaceType = Page;

  explicit PageProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: tab_search.mojom.Page.TabsChanged
  void TabsChanged(ProfileDataPtr profile_tabs) final;
  
// @generated_from: tab_search.mojom.Page.TabUpdated
  void TabUpdated(TabUpdateInfoPtr tabUpdateInfo) final;
  
// @generated_from: tab_search.mojom.Page.TabsRemoved
  void TabsRemoved(TabsRemovedInfoPtr tabsRemovedInfo) final;

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

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

  PageHandlerFactoryStub() = default;
  ~PageHandlerFactoryStub() 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 PageHandlerFactoryStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

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

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

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

  PageHandlerStub() = default;
  ~PageHandlerStub() 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 PageHandlerStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

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

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

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

  PageStub() = default;
  ~PageStub() 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 PageStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

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

 private:
  ImplPointerType sink_;
};
class  PageHandlerFactoryRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  PageHandlerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  PageRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  PageHandlerResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};











// @generated_from: tab_search.mojom.SwitchToTabInfo
class  SwitchToTabInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<SwitchToTabInfo, T>::value>;
  using DataView = SwitchToTabInfoDataView;
  using Data_ = internal::SwitchToTabInfo_Data;

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

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

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


  SwitchToTabInfo();

  explicit SwitchToTabInfo(
      int32_t tab_id);


  ~SwitchToTabInfo();

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

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

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

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

  
// @generated_from: tab_search.mojom.SwitchToTabInfo.tab_id
  int32_t tab_id;

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

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

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

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









// @generated_from: tab_search.mojom.ProfileData
class  ProfileData {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ProfileData, T>::value>;
  using DataView = ProfileDataDataView;
  using Data_ = internal::ProfileData_Data;

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

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

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


  ProfileData();

  ProfileData(
      std::vector<WindowPtr> windows,
      std::vector<TabGroupPtr> tab_groups,
      std::vector<RecentlyClosedTabPtr> recently_closed_tabs,
      std::vector<RecentlyClosedTabGroupPtr> recently_closed_tab_groups,
      bool recently_closed_section_expanded);

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

  ~ProfileData();

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

  template <typename T, ProfileData::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ProfileData::DataView, std::vector<uint8_t>>(input);
  }

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

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

  
// @generated_from: tab_search.mojom.ProfileData.windows
  std::vector<WindowPtr> windows;
  
// @generated_from: tab_search.mojom.ProfileData.tab_groups
  std::vector<TabGroupPtr> tab_groups;
  
// @generated_from: tab_search.mojom.ProfileData.recently_closed_tabs
  std::vector<RecentlyClosedTabPtr> recently_closed_tabs;
  
// @generated_from: tab_search.mojom.ProfileData.recently_closed_tab_groups
  std::vector<RecentlyClosedTabGroupPtr> recently_closed_tab_groups;
  
// @generated_from: tab_search.mojom.ProfileData.recently_closed_section_expanded
  bool recently_closed_section_expanded;

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

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

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

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





// @generated_from: tab_search.mojom.Window
class  Window {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Window, T>::value>;
  using DataView = WindowDataView;
  using Data_ = internal::Window_Data;

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

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

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


  Window();

  Window(
      bool active,
      uint32_t height,
      std::vector<TabPtr> tabs);

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

  ~Window();

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

  template <typename T, Window::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Window::DataView, std::vector<uint8_t>>(input);
  }

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

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

  
// @generated_from: tab_search.mojom.Window.active
  bool active;
  
// @generated_from: tab_search.mojom.Window.height
  uint32_t height;
  
// @generated_from: tab_search.mojom.Window.tabs
  std::vector<TabPtr> tabs;

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

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

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

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





// @generated_from: tab_search.mojom.Tab
class  Tab {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Tab, T>::value>;
  using DataView = TabDataView;
  using Data_ = internal::Tab_Data;

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

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

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


  Tab();

  Tab(
      bool active,
      std::vector<::TabAlertState> alert_states,
      int32_t index,
      int32_t tab_id,
      const absl::optional<::base::Token>& group_id,
      bool pinned,
      const std::string& title,
      const ::GURL& url,
      const absl::optional<::GURL>& favicon_url,
      bool is_default_favicon,
      bool show_icon,
      ::base::TimeTicks last_active_time_ticks,
      const std::string& last_active_elapsed_text);


  ~Tab();

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

  template <typename T, Tab::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Tab::DataView, std::vector<uint8_t>>(input);
  }

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

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

  
// @generated_from: tab_search.mojom.Tab.active
  bool active;
  
// @generated_from: tab_search.mojom.Tab.alert_states
  std::vector<::TabAlertState> alert_states;
  
// @generated_from: tab_search.mojom.Tab.index
  int32_t index;
  
// @generated_from: tab_search.mojom.Tab.tab_id
  int32_t tab_id;
  
// @generated_from: tab_search.mojom.Tab.group_id
  absl::optional<::base::Token> group_id;
  
// @generated_from: tab_search.mojom.Tab.pinned
  bool pinned;
  
// @generated_from: tab_search.mojom.Tab.title
  std::string title;
  
// @generated_from: tab_search.mojom.Tab.url
  ::GURL url;
  
// @generated_from: tab_search.mojom.Tab.favicon_url
  absl::optional<::GURL> favicon_url;
  
// @generated_from: tab_search.mojom.Tab.is_default_favicon
  bool is_default_favicon;
  
// @generated_from: tab_search.mojom.Tab.show_icon
  bool show_icon;
  
// @generated_from: tab_search.mojom.Tab.last_active_time_ticks
  ::base::TimeTicks last_active_time_ticks;
  
// @generated_from: tab_search.mojom.Tab.last_active_elapsed_text
  std::string last_active_elapsed_text;

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

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

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

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





// @generated_from: tab_search.mojom.RecentlyClosedTab
class  RecentlyClosedTab {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<RecentlyClosedTab, T>::value>;
  using DataView = RecentlyClosedTabDataView;
  using Data_ = internal::RecentlyClosedTab_Data;

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

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

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


  RecentlyClosedTab();

  RecentlyClosedTab(
      int32_t tab_id,
      const absl::optional<::base::Token>& group_id,
      const std::string& title,
      const ::GURL& url,
      ::base::Time last_active_time,
      const std::string& last_active_elapsed_text);


  ~RecentlyClosedTab();

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

  template <typename T, RecentlyClosedTab::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        RecentlyClosedTab::DataView, std::vector<uint8_t>>(input);
  }

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

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

  
// @generated_from: tab_search.mojom.RecentlyClosedTab.tab_id
  int32_t tab_id;
  
// @generated_from: tab_search.mojom.RecentlyClosedTab.group_id
  absl::optional<::base::Token> group_id;
  
// @generated_from: tab_search.mojom.RecentlyClosedTab.title
  std::string title;
  
// @generated_from: tab_search.mojom.RecentlyClosedTab.url
  ::GURL url;
  
// @generated_from: tab_search.mojom.RecentlyClosedTab.last_active_time
  ::base::Time last_active_time;
  
// @generated_from: tab_search.mojom.RecentlyClosedTab.last_active_elapsed_text
  std::string last_active_elapsed_text;

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

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

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

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





// @generated_from: tab_search.mojom.TabGroup
class  TabGroup {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<TabGroup, T>::value>;
  using DataView = TabGroupDataView;
  using Data_ = internal::TabGroup_Data;

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

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

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


  TabGroup();

  TabGroup(
      const ::base::Token& id,
      ::tab_groups::TabGroupColorId color,
      const std::string& title);


  ~TabGroup();

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

  template <typename T, TabGroup::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        TabGroup::DataView, std::vector<uint8_t>>(input);
  }

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

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

  
// @generated_from: tab_search.mojom.TabGroup.id
  ::base::Token id;
  
// @generated_from: tab_search.mojom.TabGroup.color
  ::tab_groups::TabGroupColorId color;
  
// @generated_from: tab_search.mojom.TabGroup.title
  std::string title;

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

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

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

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





// @generated_from: tab_search.mojom.RecentlyClosedTabGroup
class  RecentlyClosedTabGroup {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<RecentlyClosedTabGroup, T>::value>;
  using DataView = RecentlyClosedTabGroupDataView;
  using Data_ = internal::RecentlyClosedTabGroup_Data;

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

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

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


  RecentlyClosedTabGroup();

  RecentlyClosedTabGroup(
      int32_t session_id,
      const ::base::Token& id,
      ::tab_groups::TabGroupColorId color,
      const std::string& title,
      uint32_t tab_count,
      ::base::Time last_active_time,
      const std::string& last_active_elapsed_text);


  ~RecentlyClosedTabGroup();

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

  template <typename T, RecentlyClosedTabGroup::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        RecentlyClosedTabGroup::DataView, std::vector<uint8_t>>(input);
  }

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

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

  
// @generated_from: tab_search.mojom.RecentlyClosedTabGroup.session_id
  int32_t session_id;
  
// @generated_from: tab_search.mojom.RecentlyClosedTabGroup.id
  ::base::Token id;
  
// @generated_from: tab_search.mojom.RecentlyClosedTabGroup.color
  ::tab_groups::TabGroupColorId color;
  
// @generated_from: tab_search.mojom.RecentlyClosedTabGroup.title
  std::string title;
  
// @generated_from: tab_search.mojom.RecentlyClosedTabGroup.tab_count
  uint32_t tab_count;
  
// @generated_from: tab_search.mojom.RecentlyClosedTabGroup.last_active_time
  ::base::Time last_active_time;
  
// @generated_from: tab_search.mojom.RecentlyClosedTabGroup.last_active_elapsed_text
  std::string last_active_elapsed_text;

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

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

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

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






// @generated_from: tab_search.mojom.TabUpdateInfo
class  TabUpdateInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<TabUpdateInfo, T>::value>;
  using DataView = TabUpdateInfoDataView;
  using Data_ = internal::TabUpdateInfo_Data;

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

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

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


  TabUpdateInfo();

  TabUpdateInfo(
      bool in_active_window,
      TabPtr tab);

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

  ~TabUpdateInfo();

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

  template <typename T, TabUpdateInfo::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        TabUpdateInfo::DataView, std::vector<uint8_t>>(input);
  }

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

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

  
// @generated_from: tab_search.mojom.TabUpdateInfo.in_active_window
  bool in_active_window;
  
// @generated_from: tab_search.mojom.TabUpdateInfo.tab
  TabPtr tab;

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

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

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

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





// @generated_from: tab_search.mojom.TabsRemovedInfo
class  TabsRemovedInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<TabsRemovedInfo, T>::value>;
  using DataView = TabsRemovedInfoDataView;
  using Data_ = internal::TabsRemovedInfo_Data;

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

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

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


  TabsRemovedInfo();

  TabsRemovedInfo(
      std::vector<int32_t> tab_ids,
      std::vector<RecentlyClosedTabPtr> recently_closed_tabs);

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

  ~TabsRemovedInfo();

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

  template <typename T, TabsRemovedInfo::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        TabsRemovedInfo::DataView, std::vector<uint8_t>>(input);
  }

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

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

  
// @generated_from: tab_search.mojom.TabsRemovedInfo.tab_ids
  std::vector<int32_t> tab_ids;
  
// @generated_from: tab_search.mojom.TabsRemovedInfo.recently_closed_tabs
  std::vector<RecentlyClosedTabPtr> recently_closed_tabs;

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

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

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

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

template <typename StructPtrType>
ProfileDataPtr ProfileData::Clone() const {
  return New(
      mojo::Clone(windows),
      mojo::Clone(tab_groups),
      mojo::Clone(recently_closed_tabs),
      mojo::Clone(recently_closed_tab_groups),
      mojo::Clone(recently_closed_section_expanded)
  );
}

template <typename T, ProfileData::EnableIfSame<T>*>
bool ProfileData::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->windows, other_struct.windows))
    return false;
  if (!mojo::Equals(this->tab_groups, other_struct.tab_groups))
    return false;
  if (!mojo::Equals(this->recently_closed_tabs, other_struct.recently_closed_tabs))
    return false;
  if (!mojo::Equals(this->recently_closed_tab_groups, other_struct.recently_closed_tab_groups))
    return false;
  if (!mojo::Equals(this->recently_closed_section_expanded, other_struct.recently_closed_section_expanded))
    return false;
  return true;
}

template <typename T, ProfileData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.windows < rhs.windows)
    return true;
  if (rhs.windows < lhs.windows)
    return false;
  if (lhs.tab_groups < rhs.tab_groups)
    return true;
  if (rhs.tab_groups < lhs.tab_groups)
    return false;
  if (lhs.recently_closed_tabs < rhs.recently_closed_tabs)
    return true;
  if (rhs.recently_closed_tabs < lhs.recently_closed_tabs)
    return false;
  if (lhs.recently_closed_tab_groups < rhs.recently_closed_tab_groups)
    return true;
  if (rhs.recently_closed_tab_groups < lhs.recently_closed_tab_groups)
    return false;
  if (lhs.recently_closed_section_expanded < rhs.recently_closed_section_expanded)
    return true;
  if (rhs.recently_closed_section_expanded < lhs.recently_closed_section_expanded)
    return false;
  return false;
}
template <typename StructPtrType>
WindowPtr Window::Clone() const {
  return New(
      mojo::Clone(active),
      mojo::Clone(height),
      mojo::Clone(tabs)
  );
}

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

template <typename T, Window::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.active < rhs.active)
    return true;
  if (rhs.active < lhs.active)
    return false;
  if (lhs.height < rhs.height)
    return true;
  if (rhs.height < lhs.height)
    return false;
  if (lhs.tabs < rhs.tabs)
    return true;
  if (rhs.tabs < lhs.tabs)
    return false;
  return false;
}
template <typename StructPtrType>
TabPtr Tab::Clone() const {
  return New(
      mojo::Clone(active),
      mojo::Clone(alert_states),
      mojo::Clone(index),
      mojo::Clone(tab_id),
      mojo::Clone(group_id),
      mojo::Clone(pinned),
      mojo::Clone(title),
      mojo::Clone(url),
      mojo::Clone(favicon_url),
      mojo::Clone(is_default_favicon),
      mojo::Clone(show_icon),
      mojo::Clone(last_active_time_ticks),
      mojo::Clone(last_active_elapsed_text)
  );
}

template <typename T, Tab::EnableIfSame<T>*>
bool Tab::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->active, other_struct.active))
    return false;
  if (!mojo::Equals(this->alert_states, other_struct.alert_states))
    return false;
  if (!mojo::Equals(this->index, other_struct.index))
    return false;
  if (!mojo::Equals(this->tab_id, other_struct.tab_id))
    return false;
  if (!mojo::Equals(this->group_id, other_struct.group_id))
    return false;
  if (!mojo::Equals(this->pinned, other_struct.pinned))
    return false;
  if (!mojo::Equals(this->title, other_struct.title))
    return false;
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  if (!mojo::Equals(this->favicon_url, other_struct.favicon_url))
    return false;
  if (!mojo::Equals(this->is_default_favicon, other_struct.is_default_favicon))
    return false;
  if (!mojo::Equals(this->show_icon, other_struct.show_icon))
    return false;
  if (!mojo::Equals(this->last_active_time_ticks, other_struct.last_active_time_ticks))
    return false;
  if (!mojo::Equals(this->last_active_elapsed_text, other_struct.last_active_elapsed_text))
    return false;
  return true;
}

template <typename T, Tab::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.active < rhs.active)
    return true;
  if (rhs.active < lhs.active)
    return false;
  if (lhs.alert_states < rhs.alert_states)
    return true;
  if (rhs.alert_states < lhs.alert_states)
    return false;
  if (lhs.index < rhs.index)
    return true;
  if (rhs.index < lhs.index)
    return false;
  if (lhs.tab_id < rhs.tab_id)
    return true;
  if (rhs.tab_id < lhs.tab_id)
    return false;
  if (lhs.group_id < rhs.group_id)
    return true;
  if (rhs.group_id < lhs.group_id)
    return false;
  if (lhs.pinned < rhs.pinned)
    return true;
  if (rhs.pinned < lhs.pinned)
    return false;
  if (lhs.title < rhs.title)
    return true;
  if (rhs.title < lhs.title)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  if (lhs.favicon_url < rhs.favicon_url)
    return true;
  if (rhs.favicon_url < lhs.favicon_url)
    return false;
  if (lhs.is_default_favicon < rhs.is_default_favicon)
    return true;
  if (rhs.is_default_favicon < lhs.is_default_favicon)
    return false;
  if (lhs.show_icon < rhs.show_icon)
    return true;
  if (rhs.show_icon < lhs.show_icon)
    return false;
  if (lhs.last_active_time_ticks < rhs.last_active_time_ticks)
    return true;
  if (rhs.last_active_time_ticks < lhs.last_active_time_ticks)
    return false;
  if (lhs.last_active_elapsed_text < rhs.last_active_elapsed_text)
    return true;
  if (rhs.last_active_elapsed_text < lhs.last_active_elapsed_text)
    return false;
  return false;
}
template <typename StructPtrType>
RecentlyClosedTabPtr RecentlyClosedTab::Clone() const {
  return New(
      mojo::Clone(tab_id),
      mojo::Clone(group_id),
      mojo::Clone(title),
      mojo::Clone(url),
      mojo::Clone(last_active_time),
      mojo::Clone(last_active_elapsed_text)
  );
}

template <typename T, RecentlyClosedTab::EnableIfSame<T>*>
bool RecentlyClosedTab::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->tab_id, other_struct.tab_id))
    return false;
  if (!mojo::Equals(this->group_id, other_struct.group_id))
    return false;
  if (!mojo::Equals(this->title, other_struct.title))
    return false;
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  if (!mojo::Equals(this->last_active_time, other_struct.last_active_time))
    return false;
  if (!mojo::Equals(this->last_active_elapsed_text, other_struct.last_active_elapsed_text))
    return false;
  return true;
}

template <typename T, RecentlyClosedTab::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.tab_id < rhs.tab_id)
    return true;
  if (rhs.tab_id < lhs.tab_id)
    return false;
  if (lhs.group_id < rhs.group_id)
    return true;
  if (rhs.group_id < lhs.group_id)
    return false;
  if (lhs.title < rhs.title)
    return true;
  if (rhs.title < lhs.title)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  if (lhs.last_active_time < rhs.last_active_time)
    return true;
  if (rhs.last_active_time < lhs.last_active_time)
    return false;
  if (lhs.last_active_elapsed_text < rhs.last_active_elapsed_text)
    return true;
  if (rhs.last_active_elapsed_text < lhs.last_active_elapsed_text)
    return false;
  return false;
}
template <typename StructPtrType>
TabGroupPtr TabGroup::Clone() const {
  return New(
      mojo::Clone(id),
      mojo::Clone(color),
      mojo::Clone(title)
  );
}

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

template <typename T, TabGroup::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.id < rhs.id)
    return true;
  if (rhs.id < lhs.id)
    return false;
  if (lhs.color < rhs.color)
    return true;
  if (rhs.color < lhs.color)
    return false;
  if (lhs.title < rhs.title)
    return true;
  if (rhs.title < lhs.title)
    return false;
  return false;
}
template <typename StructPtrType>
RecentlyClosedTabGroupPtr RecentlyClosedTabGroup::Clone() const {
  return New(
      mojo::Clone(session_id),
      mojo::Clone(id),
      mojo::Clone(color),
      mojo::Clone(title),
      mojo::Clone(tab_count),
      mojo::Clone(last_active_time),
      mojo::Clone(last_active_elapsed_text)
  );
}

template <typename T, RecentlyClosedTabGroup::EnableIfSame<T>*>
bool RecentlyClosedTabGroup::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->session_id, other_struct.session_id))
    return false;
  if (!mojo::Equals(this->id, other_struct.id))
    return false;
  if (!mojo::Equals(this->color, other_struct.color))
    return false;
  if (!mojo::Equals(this->title, other_struct.title))
    return false;
  if (!mojo::Equals(this->tab_count, other_struct.tab_count))
    return false;
  if (!mojo::Equals(this->last_active_time, other_struct.last_active_time))
    return false;
  if (!mojo::Equals(this->last_active_elapsed_text, other_struct.last_active_elapsed_text))
    return false;
  return true;
}

template <typename T, RecentlyClosedTabGroup::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.session_id < rhs.session_id)
    return true;
  if (rhs.session_id < lhs.session_id)
    return false;
  if (lhs.id < rhs.id)
    return true;
  if (rhs.id < lhs.id)
    return false;
  if (lhs.color < rhs.color)
    return true;
  if (rhs.color < lhs.color)
    return false;
  if (lhs.title < rhs.title)
    return true;
  if (rhs.title < lhs.title)
    return false;
  if (lhs.tab_count < rhs.tab_count)
    return true;
  if (rhs.tab_count < lhs.tab_count)
    return false;
  if (lhs.last_active_time < rhs.last_active_time)
    return true;
  if (rhs.last_active_time < lhs.last_active_time)
    return false;
  if (lhs.last_active_elapsed_text < rhs.last_active_elapsed_text)
    return true;
  if (rhs.last_active_elapsed_text < lhs.last_active_elapsed_text)
    return false;
  return false;
}
template <typename StructPtrType>
SwitchToTabInfoPtr SwitchToTabInfo::Clone() const {
  return New(
      mojo::Clone(tab_id)
  );
}

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

template <typename T, SwitchToTabInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.tab_id < rhs.tab_id)
    return true;
  if (rhs.tab_id < lhs.tab_id)
    return false;
  return false;
}
template <typename StructPtrType>
TabUpdateInfoPtr TabUpdateInfo::Clone() const {
  return New(
      mojo::Clone(in_active_window),
      mojo::Clone(tab)
  );
}

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

template <typename T, TabUpdateInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.in_active_window < rhs.in_active_window)
    return true;
  if (rhs.in_active_window < lhs.in_active_window)
    return false;
  if (lhs.tab < rhs.tab)
    return true;
  if (rhs.tab < lhs.tab)
    return false;
  return false;
}
template <typename StructPtrType>
TabsRemovedInfoPtr TabsRemovedInfo::Clone() const {
  return New(
      mojo::Clone(tab_ids),
      mojo::Clone(recently_closed_tabs)
  );
}

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

template <typename T, TabsRemovedInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.tab_ids < rhs.tab_ids)
    return true;
  if (rhs.tab_ids < lhs.tab_ids)
    return false;
  if (lhs.recently_closed_tabs < rhs.recently_closed_tabs)
    return true;
  if (rhs.recently_closed_tabs < lhs.recently_closed_tabs)
    return false;
  return false;
}


}  // namespace mojom
}  // namespace tab_search

namespace mojo {


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

  static const decltype(::tab_search::mojom::ProfileData::windows)& windows(
      const ::tab_search::mojom::ProfileDataPtr& input) {
    return input->windows;
  }

  static const decltype(::tab_search::mojom::ProfileData::tab_groups)& tab_groups(
      const ::tab_search::mojom::ProfileDataPtr& input) {
    return input->tab_groups;
  }

  static const decltype(::tab_search::mojom::ProfileData::recently_closed_tabs)& recently_closed_tabs(
      const ::tab_search::mojom::ProfileDataPtr& input) {
    return input->recently_closed_tabs;
  }

  static const decltype(::tab_search::mojom::ProfileData::recently_closed_tab_groups)& recently_closed_tab_groups(
      const ::tab_search::mojom::ProfileDataPtr& input) {
    return input->recently_closed_tab_groups;
  }

  static decltype(::tab_search::mojom::ProfileData::recently_closed_section_expanded) recently_closed_section_expanded(
      const ::tab_search::mojom::ProfileDataPtr& input) {
    return input->recently_closed_section_expanded;
  }

  static bool Read(::tab_search::mojom::ProfileData::DataView input, ::tab_search::mojom::ProfileDataPtr* output);
};


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

  static decltype(::tab_search::mojom::Window::active) active(
      const ::tab_search::mojom::WindowPtr& input) {
    return input->active;
  }

  static decltype(::tab_search::mojom::Window::height) height(
      const ::tab_search::mojom::WindowPtr& input) {
    return input->height;
  }

  static const decltype(::tab_search::mojom::Window::tabs)& tabs(
      const ::tab_search::mojom::WindowPtr& input) {
    return input->tabs;
  }

  static bool Read(::tab_search::mojom::Window::DataView input, ::tab_search::mojom::WindowPtr* output);
};


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

  static decltype(::tab_search::mojom::Tab::active) active(
      const ::tab_search::mojom::TabPtr& input) {
    return input->active;
  }

  static const decltype(::tab_search::mojom::Tab::alert_states)& alert_states(
      const ::tab_search::mojom::TabPtr& input) {
    return input->alert_states;
  }

  static decltype(::tab_search::mojom::Tab::index) index(
      const ::tab_search::mojom::TabPtr& input) {
    return input->index;
  }

  static decltype(::tab_search::mojom::Tab::tab_id) tab_id(
      const ::tab_search::mojom::TabPtr& input) {
    return input->tab_id;
  }

  static const decltype(::tab_search::mojom::Tab::group_id)& group_id(
      const ::tab_search::mojom::TabPtr& input) {
    return input->group_id;
  }

  static decltype(::tab_search::mojom::Tab::pinned) pinned(
      const ::tab_search::mojom::TabPtr& input) {
    return input->pinned;
  }

  static const decltype(::tab_search::mojom::Tab::title)& title(
      const ::tab_search::mojom::TabPtr& input) {
    return input->title;
  }

  static const decltype(::tab_search::mojom::Tab::url)& url(
      const ::tab_search::mojom::TabPtr& input) {
    return input->url;
  }

  static const decltype(::tab_search::mojom::Tab::favicon_url)& favicon_url(
      const ::tab_search::mojom::TabPtr& input) {
    return input->favicon_url;
  }

  static decltype(::tab_search::mojom::Tab::is_default_favicon) is_default_favicon(
      const ::tab_search::mojom::TabPtr& input) {
    return input->is_default_favicon;
  }

  static decltype(::tab_search::mojom::Tab::show_icon) show_icon(
      const ::tab_search::mojom::TabPtr& input) {
    return input->show_icon;
  }

  static const decltype(::tab_search::mojom::Tab::last_active_time_ticks)& last_active_time_ticks(
      const ::tab_search::mojom::TabPtr& input) {
    return input->last_active_time_ticks;
  }

  static const decltype(::tab_search::mojom::Tab::last_active_elapsed_text)& last_active_elapsed_text(
      const ::tab_search::mojom::TabPtr& input) {
    return input->last_active_elapsed_text;
  }

  static bool Read(::tab_search::mojom::Tab::DataView input, ::tab_search::mojom::TabPtr* output);
};


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

  static decltype(::tab_search::mojom::RecentlyClosedTab::tab_id) tab_id(
      const ::tab_search::mojom::RecentlyClosedTabPtr& input) {
    return input->tab_id;
  }

  static const decltype(::tab_search::mojom::RecentlyClosedTab::group_id)& group_id(
      const ::tab_search::mojom::RecentlyClosedTabPtr& input) {
    return input->group_id;
  }

  static const decltype(::tab_search::mojom::RecentlyClosedTab::title)& title(
      const ::tab_search::mojom::RecentlyClosedTabPtr& input) {
    return input->title;
  }

  static const decltype(::tab_search::mojom::RecentlyClosedTab::url)& url(
      const ::tab_search::mojom::RecentlyClosedTabPtr& input) {
    return input->url;
  }

  static const decltype(::tab_search::mojom::RecentlyClosedTab::last_active_time)& last_active_time(
      const ::tab_search::mojom::RecentlyClosedTabPtr& input) {
    return input->last_active_time;
  }

  static const decltype(::tab_search::mojom::RecentlyClosedTab::last_active_elapsed_text)& last_active_elapsed_text(
      const ::tab_search::mojom::RecentlyClosedTabPtr& input) {
    return input->last_active_elapsed_text;
  }

  static bool Read(::tab_search::mojom::RecentlyClosedTab::DataView input, ::tab_search::mojom::RecentlyClosedTabPtr* output);
};


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

  static const decltype(::tab_search::mojom::TabGroup::id)& id(
      const ::tab_search::mojom::TabGroupPtr& input) {
    return input->id;
  }

  static decltype(::tab_search::mojom::TabGroup::color) color(
      const ::tab_search::mojom::TabGroupPtr& input) {
    return input->color;
  }

  static const decltype(::tab_search::mojom::TabGroup::title)& title(
      const ::tab_search::mojom::TabGroupPtr& input) {
    return input->title;
  }

  static bool Read(::tab_search::mojom::TabGroup::DataView input, ::tab_search::mojom::TabGroupPtr* output);
};


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

  static decltype(::tab_search::mojom::RecentlyClosedTabGroup::session_id) session_id(
      const ::tab_search::mojom::RecentlyClosedTabGroupPtr& input) {
    return input->session_id;
  }

  static const decltype(::tab_search::mojom::RecentlyClosedTabGroup::id)& id(
      const ::tab_search::mojom::RecentlyClosedTabGroupPtr& input) {
    return input->id;
  }

  static decltype(::tab_search::mojom::RecentlyClosedTabGroup::color) color(
      const ::tab_search::mojom::RecentlyClosedTabGroupPtr& input) {
    return input->color;
  }

  static const decltype(::tab_search::mojom::RecentlyClosedTabGroup::title)& title(
      const ::tab_search::mojom::RecentlyClosedTabGroupPtr& input) {
    return input->title;
  }

  static decltype(::tab_search::mojom::RecentlyClosedTabGroup::tab_count) tab_count(
      const ::tab_search::mojom::RecentlyClosedTabGroupPtr& input) {
    return input->tab_count;
  }

  static const decltype(::tab_search::mojom::RecentlyClosedTabGroup::last_active_time)& last_active_time(
      const ::tab_search::mojom::RecentlyClosedTabGroupPtr& input) {
    return input->last_active_time;
  }

  static const decltype(::tab_search::mojom::RecentlyClosedTabGroup::last_active_elapsed_text)& last_active_elapsed_text(
      const ::tab_search::mojom::RecentlyClosedTabGroupPtr& input) {
    return input->last_active_elapsed_text;
  }

  static bool Read(::tab_search::mojom::RecentlyClosedTabGroup::DataView input, ::tab_search::mojom::RecentlyClosedTabGroupPtr* output);
};


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

  static decltype(::tab_search::mojom::SwitchToTabInfo::tab_id) tab_id(
      const ::tab_search::mojom::SwitchToTabInfoPtr& input) {
    return input->tab_id;
  }

  static bool Read(::tab_search::mojom::SwitchToTabInfo::DataView input, ::tab_search::mojom::SwitchToTabInfoPtr* output);
};


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

  static decltype(::tab_search::mojom::TabUpdateInfo::in_active_window) in_active_window(
      const ::tab_search::mojom::TabUpdateInfoPtr& input) {
    return input->in_active_window;
  }

  static const decltype(::tab_search::mojom::TabUpdateInfo::tab)& tab(
      const ::tab_search::mojom::TabUpdateInfoPtr& input) {
    return input->tab;
  }

  static bool Read(::tab_search::mojom::TabUpdateInfo::DataView input, ::tab_search::mojom::TabUpdateInfoPtr* output);
};


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

  static const decltype(::tab_search::mojom::TabsRemovedInfo::tab_ids)& tab_ids(
      const ::tab_search::mojom::TabsRemovedInfoPtr& input) {
    return input->tab_ids;
  }

  static const decltype(::tab_search::mojom::TabsRemovedInfo::recently_closed_tabs)& recently_closed_tabs(
      const ::tab_search::mojom::TabsRemovedInfoPtr& input) {
    return input->recently_closed_tabs;
  }

  static bool Read(::tab_search::mojom::TabsRemovedInfo::DataView input, ::tab_search::mojom::TabsRemovedInfoPtr* output);
};

}  // namespace mojo

#endif  // CHROME_BROWSER_UI_WEBUI_TAB_SEARCH_TAB_SEARCH_MOJOM_H_

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