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

#ifndef SERVICES_NETWORK_PUBLIC_MOJOM_COOKIE_MANAGER_MOJOM_BLINK_H_
#define SERVICES_NETWORK_PUBLIC_MOJOM_COOKIE_MANAGER_MOJOM_BLINK_H_

#include <stdint.h>

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

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

#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#if BUILDFLAG(MOJO_TRACE_ENABLED)
#include "base/trace_event/trace_event.h"
#endif
#include "mojo/public/cpp/bindings/clone_traits.h"
#include "mojo/public/cpp/bindings/equals_traits.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/struct_ptr.h"
#include "mojo/public/cpp/bindings/struct_traits.h"
#include "mojo/public/cpp/bindings/union_traits.h"
#include "services/network/public/mojom/cookie_manager.mojom-shared.h"
#include "services/network/public/mojom/cookie_manager.mojom-blink-forward.h"
#include "components/content_settings/core/common/content_settings.mojom-blink.h"
#include "mojo/public/mojom/base/time.mojom-blink.h"
#include "url/mojom/url.mojom-blink.h"

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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


namespace network {
namespace mojom {
namespace blink {

class CookieChangeListenerProxy;

template <typename ImplRefTraits>
class CookieChangeListenerStub;

class CookieChangeListenerRequestValidator;


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

  using Base_ = CookieChangeListenerInterfaceBase;
  using Proxy_ = CookieChangeListenerProxy;

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

  using RequestValidator_ = CookieChangeListenerRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kOnCookieChangeMinVersion = 0,
  };
  virtual ~CookieChangeListener() {}

  
// @generated_from: network.mojom.CookieChangeListener.OnCookieChange
  virtual void OnCookieChange(const ::blink::WebCanonicalCookie& cookie, CookieChangeCause cause) = 0;
};

class CookieManagerProxy;

template <typename ImplRefTraits>
class CookieManagerStub;

class CookieManagerRequestValidator;
class CookieManagerResponseValidator;


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

  using Base_ = CookieManagerInterfaceBase;
  using Proxy_ = CookieManagerProxy;

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

  using RequestValidator_ = CookieManagerRequestValidator;
  using ResponseValidator_ = CookieManagerResponseValidator;
  enum MethodMinVersions : uint32_t {
    kGetAllCookiesMinVersion = 0,
    kGetCookieListMinVersion = 0,
    kSetCanonicalCookieMinVersion = 0,
    kDeleteCanonicalCookieMinVersion = 0,
    kDeleteCookiesMinVersion = 0,
    kAddCookieChangeListenerMinVersion = 0,
    kAddGlobalChangeListenerMinVersion = 0,
    kCloneInterfaceMinVersion = 0,
    kFlushCookieStoreMinVersion = 0,
    kAllowFileSchemeCookiesMinVersion = 0,
    kSetContentSettingsMinVersion = 0,
    kSetForceKeepSessionStateMinVersion = 0,
    kBlockThirdPartyCookiesMinVersion = 0,
  };
  virtual ~CookieManager() {}


  using GetAllCookiesCallback = base::OnceCallback<void(const WTF::Vector<::blink::WebCanonicalCookie>&)>;
  
// @generated_from: network.mojom.CookieManager.GetAllCookies
  virtual void GetAllCookies(GetAllCookiesCallback callback) = 0;


  using GetCookieListCallback = base::OnceCallback<void(const WTF::Vector<::blink::WebCanonicalCookie>&, WTF::Vector<CookieWithStatusPtr>)>;
  
// @generated_from: network.mojom.CookieManager.GetCookieList
  virtual void GetCookieList(const ::blink::KURL& url, CookieOptionsPtr cookie_options, GetCookieListCallback callback) = 0;


  using SetCanonicalCookieCallback = base::OnceCallback<void(CookieInclusionStatus)>;
  
// @generated_from: network.mojom.CookieManager.SetCanonicalCookie
  virtual void SetCanonicalCookie(const ::blink::WebCanonicalCookie& cookie, const WTF::String& source_scheme, CookieOptionsPtr cookie_options, SetCanonicalCookieCallback callback) = 0;


  using DeleteCanonicalCookieCallback = base::OnceCallback<void(bool)>;
  
// @generated_from: network.mojom.CookieManager.DeleteCanonicalCookie
  virtual void DeleteCanonicalCookie(const ::blink::WebCanonicalCookie& cookie, DeleteCanonicalCookieCallback callback) = 0;


  using DeleteCookiesCallback = base::OnceCallback<void(uint32_t)>;
  
// @generated_from: network.mojom.CookieManager.DeleteCookies
  virtual void DeleteCookies(CookieDeletionFilterPtr filter, DeleteCookiesCallback callback) = 0;

  
// @generated_from: network.mojom.CookieManager.AddCookieChangeListener
  virtual void AddCookieChangeListener(const ::blink::KURL& url, const WTF::String& name, CookieChangeListenerPtr listener) = 0;

  
// @generated_from: network.mojom.CookieManager.AddGlobalChangeListener
  virtual void AddGlobalChangeListener(CookieChangeListenerPtr notification_pointer) = 0;

  
// @generated_from: network.mojom.CookieManager.CloneInterface
  virtual void CloneInterface(CookieManagerRequest new_interface) = 0;


  using FlushCookieStoreCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.CookieManager.FlushCookieStore
  virtual void FlushCookieStore(FlushCookieStoreCallback callback) = 0;


  using AllowFileSchemeCookiesCallback = base::OnceCallback<void(bool)>;
  
// @generated_from: network.mojom.CookieManager.AllowFileSchemeCookies
  virtual void AllowFileSchemeCookies(bool allow, AllowFileSchemeCookiesCallback callback) = 0;

  
// @generated_from: network.mojom.CookieManager.SetContentSettings
  virtual void SetContentSettings(WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings) = 0;

  
// @generated_from: network.mojom.CookieManager.SetForceKeepSessionState
  virtual void SetForceKeepSessionState() = 0;

  
// @generated_from: network.mojom.CookieManager.BlockThirdPartyCookies
  virtual void BlockThirdPartyCookies(bool block) = 0;
};

class BLINK_PLATFORM_EXPORT CookieChangeListenerProxy
    : public CookieChangeListener {
 public:
  using InterfaceType = CookieChangeListener;

  explicit CookieChangeListenerProxy(mojo::MessageReceiverWithResponder* receiver);
  void OnCookieChange(const ::blink::WebCanonicalCookie& cookie, CookieChangeCause cause) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};

class BLINK_PLATFORM_EXPORT CookieManagerProxy
    : public CookieManager {
 public:
  using InterfaceType = CookieManager;

  explicit CookieManagerProxy(mojo::MessageReceiverWithResponder* receiver);
  void GetAllCookies(GetAllCookiesCallback callback) final;
  void GetCookieList(const ::blink::KURL& url, CookieOptionsPtr cookie_options, GetCookieListCallback callback) final;
  void SetCanonicalCookie(const ::blink::WebCanonicalCookie& cookie, const WTF::String& source_scheme, CookieOptionsPtr cookie_options, SetCanonicalCookieCallback callback) final;
  void DeleteCanonicalCookie(const ::blink::WebCanonicalCookie& cookie, DeleteCanonicalCookieCallback callback) final;
  void DeleteCookies(CookieDeletionFilterPtr filter, DeleteCookiesCallback callback) final;
  void AddCookieChangeListener(const ::blink::KURL& url, const WTF::String& name, CookieChangeListenerPtr listener) final;
  void AddGlobalChangeListener(CookieChangeListenerPtr notification_pointer) final;
  void CloneInterface(CookieManagerRequest new_interface) final;
  void FlushCookieStore(FlushCookieStoreCallback callback) final;
  void AllowFileSchemeCookies(bool allow, AllowFileSchemeCookiesCallback callback) final;
  void SetContentSettings(WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings) final;
  void SetForceKeepSessionState() final;
  void BlockThirdPartyCookies(bool block) final;

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

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

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

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

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

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

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

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

 private:
  ImplPointerType sink_;
};
class BLINK_PLATFORM_EXPORT CookieChangeListenerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class BLINK_PLATFORM_EXPORT CookieManagerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class BLINK_PLATFORM_EXPORT CookieManagerResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};


// @generated_from: network.mojom.CookieManagerParams
class BLINK_PLATFORM_EXPORT CookieManagerParams {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<CookieManagerParams, T>::value>;
  using DataView = CookieManagerParamsDataView;
  using Data_ = internal::CookieManagerParams_Data;

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

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

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


  CookieManagerParams();

  CookieManagerParams(
      bool block_third_party_cookies,
      WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings,
      const WTF::Vector<WTF::String>& secure_origin_cookies_allowed_schemes,
      const WTF::Vector<WTF::String>& matching_scheme_cookies_allowed_schemes,
      const WTF::Vector<WTF::String>& third_party_cookies_allowed_schemes,
      bool allow_file_scheme_cookies);

  ~CookieManagerParams();

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

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

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

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

  
// @generated_from: network.mojom.CookieManagerParams.block_third_party_cookies
  bool block_third_party_cookies;
  
// @generated_from: network.mojom.CookieManagerParams.settings
  WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings;
  
// @generated_from: network.mojom.CookieManagerParams.secure_origin_cookies_allowed_schemes
  WTF::Vector<WTF::String> secure_origin_cookies_allowed_schemes;
  
// @generated_from: network.mojom.CookieManagerParams.matching_scheme_cookies_allowed_schemes
  WTF::Vector<WTF::String> matching_scheme_cookies_allowed_schemes;
  
// @generated_from: network.mojom.CookieManagerParams.third_party_cookies_allowed_schemes
  WTF::Vector<WTF::String> third_party_cookies_allowed_schemes;
  
// @generated_from: network.mojom.CookieManagerParams.allow_file_scheme_cookies
  bool allow_file_scheme_cookies;

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

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

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

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

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


// @generated_from: network.mojom.CookieOptions
class BLINK_PLATFORM_EXPORT CookieOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<CookieOptions, T>::value>;
  using DataView = CookieOptionsDataView;
  using Data_ = internal::CookieOptions_Data;

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

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

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


  CookieOptions();

  CookieOptions(
      bool exclude_httponly,
      CookieSameSiteContext same_site_cookie_context,
      bool update_access_time,
      base::Optional<base::Time> server_time,
      bool return_excluded_cookies);

  ~CookieOptions();

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

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

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

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

  
// @generated_from: network.mojom.CookieOptions.exclude_httponly
  bool exclude_httponly;
  
// @generated_from: network.mojom.CookieOptions.same_site_cookie_context
  CookieSameSiteContext same_site_cookie_context;
  
// @generated_from: network.mojom.CookieOptions.update_access_time
  bool update_access_time;
  
// @generated_from: network.mojom.CookieOptions.server_time
  base::Optional<base::Time> server_time;
  
// @generated_from: network.mojom.CookieOptions.return_excluded_cookies
  bool return_excluded_cookies;

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

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

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

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


// @generated_from: network.mojom.CanonicalCookie
class BLINK_PLATFORM_EXPORT CanonicalCookie {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<CanonicalCookie, T>::value>;
  using DataView = CanonicalCookieDataView;
  using Data_ = internal::CanonicalCookie_Data;

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

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

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


  CanonicalCookie();

  CanonicalCookie(
      const WTF::String& name,
      const WTF::String& value,
      const WTF::String& domain,
      const WTF::String& path,
      base::Time creation,
      base::Time expiry,
      base::Time last_access,
      bool secure,
      bool httponly,
      CookieSameSite site_restrictions,
      CookiePriority priority);

  ~CanonicalCookie();

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

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

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

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

  
// @generated_from: network.mojom.CanonicalCookie.name
  WTF::String name;
  
// @generated_from: network.mojom.CanonicalCookie.value
  WTF::String value;
  
// @generated_from: network.mojom.CanonicalCookie.domain
  WTF::String domain;
  
// @generated_from: network.mojom.CanonicalCookie.path
  WTF::String path;
  
// @generated_from: network.mojom.CanonicalCookie.creation
  base::Time creation;
  
// @generated_from: network.mojom.CanonicalCookie.expiry
  base::Time expiry;
  
// @generated_from: network.mojom.CanonicalCookie.last_access
  base::Time last_access;
  
// @generated_from: network.mojom.CanonicalCookie.secure
  bool secure;
  
// @generated_from: network.mojom.CanonicalCookie.httponly
  bool httponly;
  
// @generated_from: network.mojom.CanonicalCookie.site_restrictions
  CookieSameSite site_restrictions;
  
// @generated_from: network.mojom.CanonicalCookie.priority
  CookiePriority priority;

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

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

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

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


// @generated_from: network.mojom.CookieWithStatus
class BLINK_PLATFORM_EXPORT CookieWithStatus {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<CookieWithStatus, T>::value>;
  using DataView = CookieWithStatusDataView;
  using Data_ = internal::CookieWithStatus_Data;

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

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

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


  CookieWithStatus();

  CookieWithStatus(
      const ::blink::WebCanonicalCookie& cookie,
      CookieInclusionStatus status);

  ~CookieWithStatus();

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

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

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

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

  
// @generated_from: network.mojom.CookieWithStatus.cookie
  ::blink::WebCanonicalCookie cookie;
  
// @generated_from: network.mojom.CookieWithStatus.status
  CookieInclusionStatus status;

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

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

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

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


// @generated_from: network.mojom.CookieAndLineWithStatus
class BLINK_PLATFORM_EXPORT CookieAndLineWithStatus {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<CookieAndLineWithStatus, T>::value>;
  using DataView = CookieAndLineWithStatusDataView;
  using Data_ = internal::CookieAndLineWithStatus_Data;

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

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

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


  CookieAndLineWithStatus();

  CookieAndLineWithStatus(
      const base::Optional<::blink::WebCanonicalCookie>& cookie,
      const WTF::String& cookie_string,
      CookieInclusionStatus status);

  ~CookieAndLineWithStatus();

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

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

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

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

  
// @generated_from: network.mojom.CookieAndLineWithStatus.cookie
  base::Optional<::blink::WebCanonicalCookie> cookie;
  
// @generated_from: network.mojom.CookieAndLineWithStatus.cookie_string
  WTF::String cookie_string;
  
// @generated_from: network.mojom.CookieAndLineWithStatus.status
  CookieInclusionStatus status;

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

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

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

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


// @generated_from: network.mojom.CookieDeletionFilter
class BLINK_PLATFORM_EXPORT CookieDeletionFilter {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<CookieDeletionFilter, T>::value>;
  using DataView = CookieDeletionFilterDataView;
  using Data_ = internal::CookieDeletionFilter_Data;

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

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

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


  CookieDeletionFilter();

  CookieDeletionFilter(
      base::Optional<base::Time> created_after_time,
      base::Optional<base::Time> created_before_time,
      const base::Optional<WTF::Vector<WTF::String>>& excluding_domains,
      const base::Optional<WTF::Vector<WTF::String>>& including_domains,
      const WTF::String& cookie_name,
      const WTF::String& host_name,
      const base::Optional<::blink::KURL>& url,
      CookieDeletionSessionControl session_control);

  ~CookieDeletionFilter();

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

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

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

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

  
// @generated_from: network.mojom.CookieDeletionFilter.created_after_time
  base::Optional<base::Time> created_after_time;
  
// @generated_from: network.mojom.CookieDeletionFilter.created_before_time
  base::Optional<base::Time> created_before_time;
  
// @generated_from: network.mojom.CookieDeletionFilter.excluding_domains
  base::Optional<WTF::Vector<WTF::String>> excluding_domains;
  
// @generated_from: network.mojom.CookieDeletionFilter.including_domains
  base::Optional<WTF::Vector<WTF::String>> including_domains;
  
// @generated_from: network.mojom.CookieDeletionFilter.cookie_name
  WTF::String cookie_name;
  
// @generated_from: network.mojom.CookieDeletionFilter.host_name
  WTF::String host_name;
  
// @generated_from: network.mojom.CookieDeletionFilter.url
  base::Optional<::blink::KURL> url;
  
// @generated_from: network.mojom.CookieDeletionFilter.session_control
  CookieDeletionSessionControl session_control;

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

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

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

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

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

template <typename StructPtrType>
CookieManagerParamsPtr CookieManagerParams::Clone() const {
  return New(
      mojo::Clone(block_third_party_cookies),
      mojo::Clone(settings),
      mojo::Clone(secure_origin_cookies_allowed_schemes),
      mojo::Clone(matching_scheme_cookies_allowed_schemes),
      mojo::Clone(third_party_cookies_allowed_schemes),
      mojo::Clone(allow_file_scheme_cookies)
  );
}

template <typename T, CookieManagerParams::EnableIfSame<T>*>
bool CookieManagerParams::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->block_third_party_cookies, other_struct.block_third_party_cookies))
    return false;
  if (!mojo::Equals(this->settings, other_struct.settings))
    return false;
  if (!mojo::Equals(this->secure_origin_cookies_allowed_schemes, other_struct.secure_origin_cookies_allowed_schemes))
    return false;
  if (!mojo::Equals(this->matching_scheme_cookies_allowed_schemes, other_struct.matching_scheme_cookies_allowed_schemes))
    return false;
  if (!mojo::Equals(this->third_party_cookies_allowed_schemes, other_struct.third_party_cookies_allowed_schemes))
    return false;
  if (!mojo::Equals(this->allow_file_scheme_cookies, other_struct.allow_file_scheme_cookies))
    return false;
  return true;
}

template <typename T, CookieManagerParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.block_third_party_cookies < rhs.block_third_party_cookies)
    return true;
  if (rhs.block_third_party_cookies < lhs.block_third_party_cookies)
    return false;
  if (lhs.settings < rhs.settings)
    return true;
  if (rhs.settings < lhs.settings)
    return false;
  if (lhs.secure_origin_cookies_allowed_schemes < rhs.secure_origin_cookies_allowed_schemes)
    return true;
  if (rhs.secure_origin_cookies_allowed_schemes < lhs.secure_origin_cookies_allowed_schemes)
    return false;
  if (lhs.matching_scheme_cookies_allowed_schemes < rhs.matching_scheme_cookies_allowed_schemes)
    return true;
  if (rhs.matching_scheme_cookies_allowed_schemes < lhs.matching_scheme_cookies_allowed_schemes)
    return false;
  if (lhs.third_party_cookies_allowed_schemes < rhs.third_party_cookies_allowed_schemes)
    return true;
  if (rhs.third_party_cookies_allowed_schemes < lhs.third_party_cookies_allowed_schemes)
    return false;
  if (lhs.allow_file_scheme_cookies < rhs.allow_file_scheme_cookies)
    return true;
  if (rhs.allow_file_scheme_cookies < lhs.allow_file_scheme_cookies)
    return false;
  return false;
}
template <typename StructPtrType>
CookieOptionsPtr CookieOptions::Clone() const {
  return New(
      mojo::Clone(exclude_httponly),
      mojo::Clone(same_site_cookie_context),
      mojo::Clone(update_access_time),
      mojo::Clone(server_time),
      mojo::Clone(return_excluded_cookies)
  );
}

template <typename T, CookieOptions::EnableIfSame<T>*>
bool CookieOptions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->exclude_httponly, other_struct.exclude_httponly))
    return false;
  if (!mojo::Equals(this->same_site_cookie_context, other_struct.same_site_cookie_context))
    return false;
  if (!mojo::Equals(this->update_access_time, other_struct.update_access_time))
    return false;
  if (!mojo::Equals(this->server_time, other_struct.server_time))
    return false;
  if (!mojo::Equals(this->return_excluded_cookies, other_struct.return_excluded_cookies))
    return false;
  return true;
}

template <typename T, CookieOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.exclude_httponly < rhs.exclude_httponly)
    return true;
  if (rhs.exclude_httponly < lhs.exclude_httponly)
    return false;
  if (lhs.same_site_cookie_context < rhs.same_site_cookie_context)
    return true;
  if (rhs.same_site_cookie_context < lhs.same_site_cookie_context)
    return false;
  if (lhs.update_access_time < rhs.update_access_time)
    return true;
  if (rhs.update_access_time < lhs.update_access_time)
    return false;
  if (lhs.server_time < rhs.server_time)
    return true;
  if (rhs.server_time < lhs.server_time)
    return false;
  if (lhs.return_excluded_cookies < rhs.return_excluded_cookies)
    return true;
  if (rhs.return_excluded_cookies < lhs.return_excluded_cookies)
    return false;
  return false;
}
template <typename StructPtrType>
CanonicalCookiePtr CanonicalCookie::Clone() const {
  return New(
      mojo::Clone(name),
      mojo::Clone(value),
      mojo::Clone(domain),
      mojo::Clone(path),
      mojo::Clone(creation),
      mojo::Clone(expiry),
      mojo::Clone(last_access),
      mojo::Clone(secure),
      mojo::Clone(httponly),
      mojo::Clone(site_restrictions),
      mojo::Clone(priority)
  );
}

template <typename T, CanonicalCookie::EnableIfSame<T>*>
bool CanonicalCookie::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->name, other_struct.name))
    return false;
  if (!mojo::Equals(this->value, other_struct.value))
    return false;
  if (!mojo::Equals(this->domain, other_struct.domain))
    return false;
  if (!mojo::Equals(this->path, other_struct.path))
    return false;
  if (!mojo::Equals(this->creation, other_struct.creation))
    return false;
  if (!mojo::Equals(this->expiry, other_struct.expiry))
    return false;
  if (!mojo::Equals(this->last_access, other_struct.last_access))
    return false;
  if (!mojo::Equals(this->secure, other_struct.secure))
    return false;
  if (!mojo::Equals(this->httponly, other_struct.httponly))
    return false;
  if (!mojo::Equals(this->site_restrictions, other_struct.site_restrictions))
    return false;
  if (!mojo::Equals(this->priority, other_struct.priority))
    return false;
  return true;
}

template <typename T, CanonicalCookie::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.name < rhs.name)
    return true;
  if (rhs.name < lhs.name)
    return false;
  if (lhs.value < rhs.value)
    return true;
  if (rhs.value < lhs.value)
    return false;
  if (lhs.domain < rhs.domain)
    return true;
  if (rhs.domain < lhs.domain)
    return false;
  if (lhs.path < rhs.path)
    return true;
  if (rhs.path < lhs.path)
    return false;
  if (lhs.creation < rhs.creation)
    return true;
  if (rhs.creation < lhs.creation)
    return false;
  if (lhs.expiry < rhs.expiry)
    return true;
  if (rhs.expiry < lhs.expiry)
    return false;
  if (lhs.last_access < rhs.last_access)
    return true;
  if (rhs.last_access < lhs.last_access)
    return false;
  if (lhs.secure < rhs.secure)
    return true;
  if (rhs.secure < lhs.secure)
    return false;
  if (lhs.httponly < rhs.httponly)
    return true;
  if (rhs.httponly < lhs.httponly)
    return false;
  if (lhs.site_restrictions < rhs.site_restrictions)
    return true;
  if (rhs.site_restrictions < lhs.site_restrictions)
    return false;
  if (lhs.priority < rhs.priority)
    return true;
  if (rhs.priority < lhs.priority)
    return false;
  return false;
}
template <typename StructPtrType>
CookieWithStatusPtr CookieWithStatus::Clone() const {
  return New(
      mojo::Clone(cookie),
      mojo::Clone(status)
  );
}

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

template <typename T, CookieWithStatus::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.cookie < rhs.cookie)
    return true;
  if (rhs.cookie < lhs.cookie)
    return false;
  if (lhs.status < rhs.status)
    return true;
  if (rhs.status < lhs.status)
    return false;
  return false;
}
template <typename StructPtrType>
CookieAndLineWithStatusPtr CookieAndLineWithStatus::Clone() const {
  return New(
      mojo::Clone(cookie),
      mojo::Clone(cookie_string),
      mojo::Clone(status)
  );
}

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

template <typename T, CookieAndLineWithStatus::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.cookie < rhs.cookie)
    return true;
  if (rhs.cookie < lhs.cookie)
    return false;
  if (lhs.cookie_string < rhs.cookie_string)
    return true;
  if (rhs.cookie_string < lhs.cookie_string)
    return false;
  if (lhs.status < rhs.status)
    return true;
  if (rhs.status < lhs.status)
    return false;
  return false;
}
template <typename StructPtrType>
CookieDeletionFilterPtr CookieDeletionFilter::Clone() const {
  return New(
      mojo::Clone(created_after_time),
      mojo::Clone(created_before_time),
      mojo::Clone(excluding_domains),
      mojo::Clone(including_domains),
      mojo::Clone(cookie_name),
      mojo::Clone(host_name),
      mojo::Clone(url),
      mojo::Clone(session_control)
  );
}

template <typename T, CookieDeletionFilter::EnableIfSame<T>*>
bool CookieDeletionFilter::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->created_after_time, other_struct.created_after_time))
    return false;
  if (!mojo::Equals(this->created_before_time, other_struct.created_before_time))
    return false;
  if (!mojo::Equals(this->excluding_domains, other_struct.excluding_domains))
    return false;
  if (!mojo::Equals(this->including_domains, other_struct.including_domains))
    return false;
  if (!mojo::Equals(this->cookie_name, other_struct.cookie_name))
    return false;
  if (!mojo::Equals(this->host_name, other_struct.host_name))
    return false;
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  if (!mojo::Equals(this->session_control, other_struct.session_control))
    return false;
  return true;
}

template <typename T, CookieDeletionFilter::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.created_after_time < rhs.created_after_time)
    return true;
  if (rhs.created_after_time < lhs.created_after_time)
    return false;
  if (lhs.created_before_time < rhs.created_before_time)
    return true;
  if (rhs.created_before_time < lhs.created_before_time)
    return false;
  if (lhs.excluding_domains < rhs.excluding_domains)
    return true;
  if (rhs.excluding_domains < lhs.excluding_domains)
    return false;
  if (lhs.including_domains < rhs.including_domains)
    return true;
  if (rhs.including_domains < lhs.including_domains)
    return false;
  if (lhs.cookie_name < rhs.cookie_name)
    return true;
  if (rhs.cookie_name < lhs.cookie_name)
    return false;
  if (lhs.host_name < rhs.host_name)
    return true;
  if (rhs.host_name < lhs.host_name)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  if (lhs.session_control < rhs.session_control)
    return true;
  if (rhs.session_control < lhs.session_control)
    return false;
  return false;
}


}  // namespace blink
}  // namespace mojom
}  // namespace network

namespace mojo {


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

  static decltype(::network::mojom::blink::CookieManagerParams::block_third_party_cookies) block_third_party_cookies(
      const ::network::mojom::blink::CookieManagerParamsPtr& input) {
    return input->block_third_party_cookies;
  }

  static const decltype(::network::mojom::blink::CookieManagerParams::settings)& settings(
      const ::network::mojom::blink::CookieManagerParamsPtr& input) {
    return input->settings;
  }

  static const decltype(::network::mojom::blink::CookieManagerParams::secure_origin_cookies_allowed_schemes)& secure_origin_cookies_allowed_schemes(
      const ::network::mojom::blink::CookieManagerParamsPtr& input) {
    return input->secure_origin_cookies_allowed_schemes;
  }

  static const decltype(::network::mojom::blink::CookieManagerParams::matching_scheme_cookies_allowed_schemes)& matching_scheme_cookies_allowed_schemes(
      const ::network::mojom::blink::CookieManagerParamsPtr& input) {
    return input->matching_scheme_cookies_allowed_schemes;
  }

  static const decltype(::network::mojom::blink::CookieManagerParams::third_party_cookies_allowed_schemes)& third_party_cookies_allowed_schemes(
      const ::network::mojom::blink::CookieManagerParamsPtr& input) {
    return input->third_party_cookies_allowed_schemes;
  }

  static decltype(::network::mojom::blink::CookieManagerParams::allow_file_scheme_cookies) allow_file_scheme_cookies(
      const ::network::mojom::blink::CookieManagerParamsPtr& input) {
    return input->allow_file_scheme_cookies;
  }

  static bool Read(::network::mojom::blink::CookieManagerParams::DataView input, ::network::mojom::blink::CookieManagerParamsPtr* output);
};


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

  static decltype(::network::mojom::blink::CookieOptions::exclude_httponly) exclude_httponly(
      const ::network::mojom::blink::CookieOptionsPtr& input) {
    return input->exclude_httponly;
  }

  static decltype(::network::mojom::blink::CookieOptions::same_site_cookie_context) same_site_cookie_context(
      const ::network::mojom::blink::CookieOptionsPtr& input) {
    return input->same_site_cookie_context;
  }

  static decltype(::network::mojom::blink::CookieOptions::update_access_time) update_access_time(
      const ::network::mojom::blink::CookieOptionsPtr& input) {
    return input->update_access_time;
  }

  static const decltype(::network::mojom::blink::CookieOptions::server_time)& server_time(
      const ::network::mojom::blink::CookieOptionsPtr& input) {
    return input->server_time;
  }

  static decltype(::network::mojom::blink::CookieOptions::return_excluded_cookies) return_excluded_cookies(
      const ::network::mojom::blink::CookieOptionsPtr& input) {
    return input->return_excluded_cookies;
  }

  static bool Read(::network::mojom::blink::CookieOptions::DataView input, ::network::mojom::blink::CookieOptionsPtr* output);
};


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

  static const decltype(::network::mojom::blink::CanonicalCookie::name)& name(
      const ::network::mojom::blink::CanonicalCookiePtr& input) {
    return input->name;
  }

  static const decltype(::network::mojom::blink::CanonicalCookie::value)& value(
      const ::network::mojom::blink::CanonicalCookiePtr& input) {
    return input->value;
  }

  static const decltype(::network::mojom::blink::CanonicalCookie::domain)& domain(
      const ::network::mojom::blink::CanonicalCookiePtr& input) {
    return input->domain;
  }

  static const decltype(::network::mojom::blink::CanonicalCookie::path)& path(
      const ::network::mojom::blink::CanonicalCookiePtr& input) {
    return input->path;
  }

  static const decltype(::network::mojom::blink::CanonicalCookie::creation)& creation(
      const ::network::mojom::blink::CanonicalCookiePtr& input) {
    return input->creation;
  }

  static const decltype(::network::mojom::blink::CanonicalCookie::expiry)& expiry(
      const ::network::mojom::blink::CanonicalCookiePtr& input) {
    return input->expiry;
  }

  static const decltype(::network::mojom::blink::CanonicalCookie::last_access)& last_access(
      const ::network::mojom::blink::CanonicalCookiePtr& input) {
    return input->last_access;
  }

  static decltype(::network::mojom::blink::CanonicalCookie::secure) secure(
      const ::network::mojom::blink::CanonicalCookiePtr& input) {
    return input->secure;
  }

  static decltype(::network::mojom::blink::CanonicalCookie::httponly) httponly(
      const ::network::mojom::blink::CanonicalCookiePtr& input) {
    return input->httponly;
  }

  static decltype(::network::mojom::blink::CanonicalCookie::site_restrictions) site_restrictions(
      const ::network::mojom::blink::CanonicalCookiePtr& input) {
    return input->site_restrictions;
  }

  static decltype(::network::mojom::blink::CanonicalCookie::priority) priority(
      const ::network::mojom::blink::CanonicalCookiePtr& input) {
    return input->priority;
  }

  static bool Read(::network::mojom::blink::CanonicalCookie::DataView input, ::network::mojom::blink::CanonicalCookiePtr* output);
};


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

  static const decltype(::network::mojom::blink::CookieWithStatus::cookie)& cookie(
      const ::network::mojom::blink::CookieWithStatusPtr& input) {
    return input->cookie;
  }

  static decltype(::network::mojom::blink::CookieWithStatus::status) status(
      const ::network::mojom::blink::CookieWithStatusPtr& input) {
    return input->status;
  }

  static bool Read(::network::mojom::blink::CookieWithStatus::DataView input, ::network::mojom::blink::CookieWithStatusPtr* output);
};


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

  static const decltype(::network::mojom::blink::CookieAndLineWithStatus::cookie)& cookie(
      const ::network::mojom::blink::CookieAndLineWithStatusPtr& input) {
    return input->cookie;
  }

  static const decltype(::network::mojom::blink::CookieAndLineWithStatus::cookie_string)& cookie_string(
      const ::network::mojom::blink::CookieAndLineWithStatusPtr& input) {
    return input->cookie_string;
  }

  static decltype(::network::mojom::blink::CookieAndLineWithStatus::status) status(
      const ::network::mojom::blink::CookieAndLineWithStatusPtr& input) {
    return input->status;
  }

  static bool Read(::network::mojom::blink::CookieAndLineWithStatus::DataView input, ::network::mojom::blink::CookieAndLineWithStatusPtr* output);
};


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

  static const decltype(::network::mojom::blink::CookieDeletionFilter::created_after_time)& created_after_time(
      const ::network::mojom::blink::CookieDeletionFilterPtr& input) {
    return input->created_after_time;
  }

  static const decltype(::network::mojom::blink::CookieDeletionFilter::created_before_time)& created_before_time(
      const ::network::mojom::blink::CookieDeletionFilterPtr& input) {
    return input->created_before_time;
  }

  static const decltype(::network::mojom::blink::CookieDeletionFilter::excluding_domains)& excluding_domains(
      const ::network::mojom::blink::CookieDeletionFilterPtr& input) {
    return input->excluding_domains;
  }

  static const decltype(::network::mojom::blink::CookieDeletionFilter::including_domains)& including_domains(
      const ::network::mojom::blink::CookieDeletionFilterPtr& input) {
    return input->including_domains;
  }

  static const decltype(::network::mojom::blink::CookieDeletionFilter::cookie_name)& cookie_name(
      const ::network::mojom::blink::CookieDeletionFilterPtr& input) {
    return input->cookie_name;
  }

  static const decltype(::network::mojom::blink::CookieDeletionFilter::host_name)& host_name(
      const ::network::mojom::blink::CookieDeletionFilterPtr& input) {
    return input->host_name;
  }

  static const decltype(::network::mojom::blink::CookieDeletionFilter::url)& url(
      const ::network::mojom::blink::CookieDeletionFilterPtr& input) {
    return input->url;
  }

  static decltype(::network::mojom::blink::CookieDeletionFilter::session_control) session_control(
      const ::network::mojom::blink::CookieDeletionFilterPtr& input) {
    return input->session_control;
  }

  static bool Read(::network::mojom::blink::CookieDeletionFilter::DataView input, ::network::mojom::blink::CookieDeletionFilterPtr* output);
};

}  // namespace mojo

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