// 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_URL_LOADER_MOJOM_BLINK_H_
#define SERVICES_NETWORK_PUBLIC_MOJOM_URL_LOADER_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/url_loader.mojom-shared.h"
#include "services/network/public/mojom/url_loader.mojom-blink-forward.h"
#include "mojo/public/mojom/base/big_buffer.mojom-blink.h"
#include "mojo/public/mojom/base/file.mojom-blink.h"
#include "mojo/public/mojom/base/file_path.mojom-blink.h"
#include "mojo/public/mojom/base/time.mojom-blink.h"
#include "mojo/public/mojom/base/unguessable_token.mojom-blink.h"
#include "services/network/public/mojom/cors.mojom-blink.h"
#include "services/network/public/mojom/chunked_data_pipe_getter.mojom-blink.h"
#include "services/network/public/mojom/data_pipe_getter.mojom-blink.h"
#include "services/network/public/mojom/fetch_api.mojom-blink.h"
#include "services/network/public/mojom/http_request_headers.mojom-blink.h"
#include "services/network/public/mojom/network_param.mojom-blink.h"
#include "url/mojom/origin.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/renderer/platform/network/encoded_form_data.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_RequestPriority_DataHashFn {
  static unsigned GetHash(const ::network::mojom::RequestPriority& value) {
    using utype = std::underlying_type<::network::mojom::RequestPriority>::type;
    return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
  }
  static bool Equal(const ::network::mojom::RequestPriority& left, const ::network::mojom::RequestPriority& right) {
    return left == right;
  }
  static const bool safe_to_compare_to_empty_or_deleted = true;
};

template <>
struct HashTraits<::network::mojom::RequestPriority>
    : public GenericHashTraits<::network::mojom::RequestPriority> {
  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::RequestPriority& value) {
    return value == static_cast<::network::mojom::RequestPriority>(-1000000);
  }
  static void ConstructDeletedValue(::network::mojom::RequestPriority& slot, bool) {
    slot = static_cast<::network::mojom::RequestPriority>(-1000001);
  }
  static bool IsDeletedValue(const ::network::mojom::RequestPriority& value) {
    return value == static_cast<::network::mojom::RequestPriority>(-1000001);
  }
};
}  // namespace WTF


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

template <>
struct HashTraits<::network::mojom::URLRequestReferrerPolicy>
    : public GenericHashTraits<::network::mojom::URLRequestReferrerPolicy> {
  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::URLRequestReferrerPolicy& value) {
    return value == static_cast<::network::mojom::URLRequestReferrerPolicy>(-1000000);
  }
  static void ConstructDeletedValue(::network::mojom::URLRequestReferrerPolicy& slot, bool) {
    slot = static_cast<::network::mojom::URLRequestReferrerPolicy>(-1000001);
  }
  static bool IsDeletedValue(const ::network::mojom::URLRequestReferrerPolicy& value) {
    return value == static_cast<::network::mojom::URLRequestReferrerPolicy>(-1000001);
  }
};
}  // namespace WTF


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

template <>
struct HashTraits<::network::mojom::DataElementType>
    : public GenericHashTraits<::network::mojom::DataElementType> {
  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::DataElementType& value) {
    return value == static_cast<::network::mojom::DataElementType>(-1000000);
  }
  static void ConstructDeletedValue(::network::mojom::DataElementType& slot, bool) {
    slot = static_cast<::network::mojom::DataElementType>(-1000001);
  }
  static bool IsDeletedValue(const ::network::mojom::DataElementType& value) {
    return value == static_cast<::network::mojom::DataElementType>(-1000001);
  }
};
}  // namespace WTF


namespace network {
namespace mojom {
namespace blink {

class URLLoaderProxy;

template <typename ImplRefTraits>
class URLLoaderStub;

class URLLoaderRequestValidator;


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

  using Base_ = URLLoaderInterfaceBase;
  using Proxy_ = URLLoaderProxy;

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

  using RequestValidator_ = URLLoaderRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kFollowRedirectMinVersion = 0,
    kProceedWithResponseMinVersion = 0,
    kSetPriorityMinVersion = 0,
    kPauseReadingBodyFromNetMinVersion = 0,
    kResumeReadingBodyFromNetMinVersion = 0,
  };
  
// @generated_from: network.mojom.URLLoader.kClientDisconnectReason
  static constexpr uint32_t kClientDisconnectReason = 1U;
  virtual ~URLLoader() {}

  
// @generated_from: network.mojom.URLLoader.FollowRedirect
  virtual void FollowRedirect(const WTF::Vector<WTF::String>& removed_headers, const ::blink::HTTPHeaderMap& modified_headers, const base::Optional<::blink::KURL>& new_url) = 0;

  
// @generated_from: network.mojom.URLLoader.ProceedWithResponse
  virtual void ProceedWithResponse() = 0;

  
// @generated_from: network.mojom.URLLoader.SetPriority
  virtual void SetPriority(RequestPriority priority, int32_t intra_priority_value) = 0;

  
// @generated_from: network.mojom.URLLoader.PauseReadingBodyFromNet
  virtual void PauseReadingBodyFromNet() = 0;

  
// @generated_from: network.mojom.URLLoader.ResumeReadingBodyFromNet
  virtual void ResumeReadingBodyFromNet() = 0;
};

class URLLoaderClientProxy;

template <typename ImplRefTraits>
class URLLoaderClientStub;

class URLLoaderClientRequestValidator;
class URLLoaderClientResponseValidator;


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

  using Base_ = URLLoaderClientInterfaceBase;
  using Proxy_ = URLLoaderClientProxy;

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

  using RequestValidator_ = URLLoaderClientRequestValidator;
  using ResponseValidator_ = URLLoaderClientResponseValidator;
  enum MethodMinVersions : uint32_t {
    kOnReceiveResponseMinVersion = 0,
    kOnReceiveRedirectMinVersion = 0,
    kOnUploadProgressMinVersion = 0,
    kOnReceiveCachedMetadataMinVersion = 0,
    kOnTransferSizeUpdatedMinVersion = 0,
    kOnStartLoadingResponseBodyMinVersion = 0,
    kOnCompleteMinVersion = 0,
  };
  virtual ~URLLoaderClient() {}

  
// @generated_from: network.mojom.URLLoaderClient.OnReceiveResponse
  virtual void OnReceiveResponse(URLResponseHeadPtr head) = 0;

  
// @generated_from: network.mojom.URLLoaderClient.OnReceiveRedirect
  virtual void OnReceiveRedirect(URLRequestRedirectInfoPtr redirect_info, URLResponseHeadPtr head) = 0;


  using OnUploadProgressCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.URLLoaderClient.OnUploadProgress
  virtual void OnUploadProgress(int64_t current_position, int64_t total_size, OnUploadProgressCallback callback) = 0;

  
// @generated_from: network.mojom.URLLoaderClient.OnReceiveCachedMetadata
  virtual void OnReceiveCachedMetadata(mojo_base::BigBuffer data) = 0;

  
// @generated_from: network.mojom.URLLoaderClient.OnTransferSizeUpdated
  virtual void OnTransferSizeUpdated(int32_t transfer_size_diff) = 0;

  
// @generated_from: network.mojom.URLLoaderClient.OnStartLoadingResponseBody
  virtual void OnStartLoadingResponseBody(mojo::ScopedDataPipeConsumerHandle body) = 0;

  
// @generated_from: network.mojom.URLLoaderClient.OnComplete
  virtual void OnComplete(URLLoaderCompletionStatusPtr status) = 0;
};

class BLINK_PLATFORM_EXPORT URLLoaderProxy
    : public URLLoader {
 public:
  using InterfaceType = URLLoader;

  explicit URLLoaderProxy(mojo::MessageReceiverWithResponder* receiver);
  void FollowRedirect(const WTF::Vector<WTF::String>& removed_headers, const ::blink::HTTPHeaderMap& modified_headers, const base::Optional<::blink::KURL>& new_url) final;
  void ProceedWithResponse() final;
  void SetPriority(RequestPriority priority, int32_t intra_priority_value) final;
  void PauseReadingBodyFromNet() final;
  void ResumeReadingBodyFromNet() final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};

class BLINK_PLATFORM_EXPORT URLLoaderClientProxy
    : public URLLoaderClient {
 public:
  using InterfaceType = URLLoaderClient;

  explicit URLLoaderClientProxy(mojo::MessageReceiverWithResponder* receiver);
  void OnReceiveResponse(URLResponseHeadPtr head) final;
  void OnReceiveRedirect(URLRequestRedirectInfoPtr redirect_info, URLResponseHeadPtr head) final;
  void OnUploadProgress(int64_t current_position, int64_t total_size, OnUploadProgressCallback callback) final;
  void OnReceiveCachedMetadata(mojo_base::BigBuffer data) final;
  void OnTransferSizeUpdated(int32_t transfer_size_diff) final;
  void OnStartLoadingResponseBody(mojo::ScopedDataPipeConsumerHandle body) final;
  void OnComplete(URLLoaderCompletionStatusPtr status) final;

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

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

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

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

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

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

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

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

 private:
  ImplPointerType sink_;
};
class BLINK_PLATFORM_EXPORT URLLoaderRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class BLINK_PLATFORM_EXPORT URLLoaderClientRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class BLINK_PLATFORM_EXPORT URLLoaderClientResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};


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

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

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

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


  URLRequest();

  URLRequest(
      const WTF::String& method,
      const ::blink::KURL& url,
      const ::blink::KURL& site_for_cookies,
      const scoped_refptr<const ::blink::SecurityOrigin>& top_frame_origin,
      bool attach_same_site_cookies,
      bool update_first_party_url_on_redirect,
      const scoped_refptr<const ::blink::SecurityOrigin>& request_initiator,
      const ::blink::KURL& referrer,
      URLRequestReferrerPolicy referrer_policy,
      bool is_prerendering,
      const ::blink::HTTPHeaderMap& headers,
      const ::blink::HTTPHeaderMap& cors_exempt_headers,
      int32_t load_flags,
      bool allow_credentials,
      int32_t plugin_child_id,
      int32_t resource_type,
      RequestPriority priority,
      const base::Optional<base::UnguessableToken>& appcache_host_id,
      bool should_reset_appcache,
      bool is_external_request,
      ::network::mojom::blink::CorsPreflightPolicy cors_preflight_policy,
      bool originated_from_service_worker,
      bool skip_service_worker,
      bool corb_detachable,
      bool corb_excluded,
      ::network::mojom::blink::RequestMode mode,
      ::network::mojom::blink::CredentialsMode credentials_mode,
      ::network::mojom::blink::RedirectMode redirect_mode,
      const WTF::String& fetch_integrity,
      int32_t fetch_request_context_type,
      URLRequestBodyPtr request_body,
      bool keepalive,
      bool has_user_gesture,
      bool enable_load_timing,
      bool enable_upload_progress,
      bool do_not_prompt_for_login,
      int32_t render_frame_id,
      bool is_main_frame,
      int32_t transition_type,
      bool allow_download,
      bool report_raw_headers,
      int32_t previews_state,
      bool initiated_in_secure_context,
      bool upgrade_if_insecure,
      bool is_revalidating,
      bool should_also_use_factory_bound_origin_for_cors,
      const base::Optional<base::UnguessableToken>& throttling_profile_id,
      const ::blink::HTTPHeaderMap& custom_proxy_pre_cache_headers,
      const ::blink::HTTPHeaderMap& custom_proxy_post_cache_headers,
      const base::Optional<base::UnguessableToken>& fetch_window_id,
      const WTF::String& devtools_request_id);

  ~URLRequest();

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

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

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        URLRequest::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::URLRequest_UnserializedMessageContext<
            UserType, URLRequest::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<URLRequest::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 URLRequest::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::URLRequest_UnserializedMessageContext<
            UserType, URLRequest::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<URLRequest::DataView>(
        input.payload(), input.payload_num_bytes(),
        std::move(*input.mutable_handles()), output, Validate);
  }

  
// @generated_from: network.mojom.URLRequest.method
  WTF::String method;
  
// @generated_from: network.mojom.URLRequest.url
  ::blink::KURL url;
  
// @generated_from: network.mojom.URLRequest.site_for_cookies
  ::blink::KURL site_for_cookies;
  
// @generated_from: network.mojom.URLRequest.top_frame_origin
  scoped_refptr<const ::blink::SecurityOrigin> top_frame_origin;
  
// @generated_from: network.mojom.URLRequest.attach_same_site_cookies
  bool attach_same_site_cookies;
  
// @generated_from: network.mojom.URLRequest.update_first_party_url_on_redirect
  bool update_first_party_url_on_redirect;
  
// @generated_from: network.mojom.URLRequest.request_initiator
  scoped_refptr<const ::blink::SecurityOrigin> request_initiator;
  
// @generated_from: network.mojom.URLRequest.referrer
  ::blink::KURL referrer;
  
// @generated_from: network.mojom.URLRequest.referrer_policy
  URLRequestReferrerPolicy referrer_policy;
  
// @generated_from: network.mojom.URLRequest.is_prerendering
  bool is_prerendering;
  
// @generated_from: network.mojom.URLRequest.headers
  ::blink::HTTPHeaderMap headers;
  
// @generated_from: network.mojom.URLRequest.cors_exempt_headers
  ::blink::HTTPHeaderMap cors_exempt_headers;
  
// @generated_from: network.mojom.URLRequest.load_flags
  int32_t load_flags;
  
// @generated_from: network.mojom.URLRequest.allow_credentials
  bool allow_credentials;
  
// @generated_from: network.mojom.URLRequest.plugin_child_id
  int32_t plugin_child_id;
  
// @generated_from: network.mojom.URLRequest.resource_type
  int32_t resource_type;
  
// @generated_from: network.mojom.URLRequest.priority
  RequestPriority priority;
  
// @generated_from: network.mojom.URLRequest.appcache_host_id
  base::Optional<base::UnguessableToken> appcache_host_id;
  
// @generated_from: network.mojom.URLRequest.should_reset_appcache
  bool should_reset_appcache;
  
// @generated_from: network.mojom.URLRequest.is_external_request
  bool is_external_request;
  
// @generated_from: network.mojom.URLRequest.cors_preflight_policy
  ::network::mojom::blink::CorsPreflightPolicy cors_preflight_policy;
  
// @generated_from: network.mojom.URLRequest.originated_from_service_worker
  bool originated_from_service_worker;
  
// @generated_from: network.mojom.URLRequest.skip_service_worker
  bool skip_service_worker;
  
// @generated_from: network.mojom.URLRequest.corb_detachable
  bool corb_detachable;
  
// @generated_from: network.mojom.URLRequest.corb_excluded
  bool corb_excluded;
  
// @generated_from: network.mojom.URLRequest.mode
  ::network::mojom::blink::RequestMode mode;
  
// @generated_from: network.mojom.URLRequest.credentials_mode
  ::network::mojom::blink::CredentialsMode credentials_mode;
  
// @generated_from: network.mojom.URLRequest.redirect_mode
  ::network::mojom::blink::RedirectMode redirect_mode;
  
// @generated_from: network.mojom.URLRequest.fetch_integrity
  WTF::String fetch_integrity;
  
// @generated_from: network.mojom.URLRequest.fetch_request_context_type
  int32_t fetch_request_context_type;
  
// @generated_from: network.mojom.URLRequest.request_body
  URLRequestBodyPtr request_body;
  
// @generated_from: network.mojom.URLRequest.keepalive
  bool keepalive;
  
// @generated_from: network.mojom.URLRequest.has_user_gesture
  bool has_user_gesture;
  
// @generated_from: network.mojom.URLRequest.enable_load_timing
  bool enable_load_timing;
  
// @generated_from: network.mojom.URLRequest.enable_upload_progress
  bool enable_upload_progress;
  
// @generated_from: network.mojom.URLRequest.do_not_prompt_for_login
  bool do_not_prompt_for_login;
  
// @generated_from: network.mojom.URLRequest.render_frame_id
  int32_t render_frame_id;
  
// @generated_from: network.mojom.URLRequest.is_main_frame
  bool is_main_frame;
  
// @generated_from: network.mojom.URLRequest.transition_type
  int32_t transition_type;
  
// @generated_from: network.mojom.URLRequest.allow_download
  bool allow_download;
  
// @generated_from: network.mojom.URLRequest.report_raw_headers
  bool report_raw_headers;
  
// @generated_from: network.mojom.URLRequest.previews_state
  int32_t previews_state;
  
// @generated_from: network.mojom.URLRequest.initiated_in_secure_context
  bool initiated_in_secure_context;
  
// @generated_from: network.mojom.URLRequest.upgrade_if_insecure
  bool upgrade_if_insecure;
  
// @generated_from: network.mojom.URLRequest.is_revalidating
  bool is_revalidating;
  
// @generated_from: network.mojom.URLRequest.should_also_use_factory_bound_origin_for_cors
  bool should_also_use_factory_bound_origin_for_cors;
  
// @generated_from: network.mojom.URLRequest.throttling_profile_id
  base::Optional<base::UnguessableToken> throttling_profile_id;
  
// @generated_from: network.mojom.URLRequest.custom_proxy_pre_cache_headers
  ::blink::HTTPHeaderMap custom_proxy_pre_cache_headers;
  
// @generated_from: network.mojom.URLRequest.custom_proxy_post_cache_headers
  ::blink::HTTPHeaderMap custom_proxy_post_cache_headers;
  
// @generated_from: network.mojom.URLRequest.fetch_window_id
  base::Optional<base::UnguessableToken> fetch_window_id;
  
// @generated_from: network.mojom.URLRequest.devtools_request_id
  WTF::String devtools_request_id;

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

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

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

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

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


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

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

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

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


  URLRequestBody();

  URLRequestBody(
      WTF::Vector<::blink::FormDataElement> elements,
      uint64_t identifier,
      bool contains_sensitive_info);

  ~URLRequestBody();

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

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

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        URLRequestBody::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::URLRequestBody_UnserializedMessageContext<
            UserType, URLRequestBody::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<URLRequestBody::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 URLRequestBody::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::URLRequestBody_UnserializedMessageContext<
            UserType, URLRequestBody::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<URLRequestBody::DataView>(
        input.payload(), input.payload_num_bytes(),
        std::move(*input.mutable_handles()), output, Validate);
  }

  
// @generated_from: network.mojom.URLRequestBody.elements
  WTF::Vector<::blink::FormDataElement> elements;
  
// @generated_from: network.mojom.URLRequestBody.identifier
  uint64_t identifier;
  
// @generated_from: network.mojom.URLRequestBody.contains_sensitive_info
  bool contains_sensitive_info;

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

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

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

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

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


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

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

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

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


  DataElement();

  DataElement(
      DataElementType type,
      const WTF::Vector<uint8_t>& buf,
      const base::FilePath& path,
      base::File file,
      const WTF::String& blob_uuid,
      ::network::mojom::blink::DataPipeGetterPtrInfo data_pipe_getter,
      ::network::mojom::blink::ChunkedDataPipeGetterPtrInfo chunked_data_pipe_getter,
      uint64_t offset,
      uint64_t length,
      base::Time expected_modification_time);

  ~DataElement();

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

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

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        DataElement::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::DataElement_UnserializedMessageContext<
            UserType, DataElement::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<DataElement::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 DataElement::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::DataElement_UnserializedMessageContext<
            UserType, DataElement::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<DataElement::DataView>(
        input.payload(), input.payload_num_bytes(),
        std::move(*input.mutable_handles()), output, Validate);
  }

  
// @generated_from: network.mojom.DataElement.type
  DataElementType type;
  
// @generated_from: network.mojom.DataElement.buf
  WTF::Vector<uint8_t> buf;
  
// @generated_from: network.mojom.DataElement.path
  base::FilePath path;
  
// @generated_from: network.mojom.DataElement.file
  base::File file;
  
// @generated_from: network.mojom.DataElement.blob_uuid
  WTF::String blob_uuid;
  
// @generated_from: network.mojom.DataElement.data_pipe_getter
  ::network::mojom::blink::DataPipeGetterPtrInfo data_pipe_getter;
  
// @generated_from: network.mojom.DataElement.chunked_data_pipe_getter
  ::network::mojom::blink::ChunkedDataPipeGetterPtrInfo chunked_data_pipe_getter;
  
// @generated_from: network.mojom.DataElement.offset
  uint64_t offset;
  
// @generated_from: network.mojom.DataElement.length
  uint64_t length;
  
// @generated_from: network.mojom.DataElement.expected_modification_time
  base::Time expected_modification_time;

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

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

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

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

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


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

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

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

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


  URLLoaderClientEndpoints();

  URLLoaderClientEndpoints(
      URLLoaderPtrInfo url_loader,
      URLLoaderClientRequest url_loader_client);

  ~URLLoaderClientEndpoints();

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

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

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        URLLoaderClientEndpoints::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::URLLoaderClientEndpoints_UnserializedMessageContext<
            UserType, URLLoaderClientEndpoints::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<URLLoaderClientEndpoints::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 URLLoaderClientEndpoints::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::URLLoaderClientEndpoints_UnserializedMessageContext<
            UserType, URLLoaderClientEndpoints::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<URLLoaderClientEndpoints::DataView>(
        input.payload(), input.payload_num_bytes(),
        std::move(*input.mutable_handles()), output, Validate);
  }

  
// @generated_from: network.mojom.URLLoaderClientEndpoints.url_loader
  URLLoaderPtrInfo url_loader;
  
// @generated_from: network.mojom.URLLoaderClientEndpoints.url_loader_client
  URLLoaderClientRequest url_loader_client;

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

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

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

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

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

template <typename StructPtrType>
URLRequestPtr URLRequest::Clone() const {
  return New(
      mojo::Clone(method),
      mojo::Clone(url),
      mojo::Clone(site_for_cookies),
      mojo::Clone(top_frame_origin),
      mojo::Clone(attach_same_site_cookies),
      mojo::Clone(update_first_party_url_on_redirect),
      mojo::Clone(request_initiator),
      mojo::Clone(referrer),
      mojo::Clone(referrer_policy),
      mojo::Clone(is_prerendering),
      mojo::Clone(headers),
      mojo::Clone(cors_exempt_headers),
      mojo::Clone(load_flags),
      mojo::Clone(allow_credentials),
      mojo::Clone(plugin_child_id),
      mojo::Clone(resource_type),
      mojo::Clone(priority),
      mojo::Clone(appcache_host_id),
      mojo::Clone(should_reset_appcache),
      mojo::Clone(is_external_request),
      mojo::Clone(cors_preflight_policy),
      mojo::Clone(originated_from_service_worker),
      mojo::Clone(skip_service_worker),
      mojo::Clone(corb_detachable),
      mojo::Clone(corb_excluded),
      mojo::Clone(mode),
      mojo::Clone(credentials_mode),
      mojo::Clone(redirect_mode),
      mojo::Clone(fetch_integrity),
      mojo::Clone(fetch_request_context_type),
      mojo::Clone(request_body),
      mojo::Clone(keepalive),
      mojo::Clone(has_user_gesture),
      mojo::Clone(enable_load_timing),
      mojo::Clone(enable_upload_progress),
      mojo::Clone(do_not_prompt_for_login),
      mojo::Clone(render_frame_id),
      mojo::Clone(is_main_frame),
      mojo::Clone(transition_type),
      mojo::Clone(allow_download),
      mojo::Clone(report_raw_headers),
      mojo::Clone(previews_state),
      mojo::Clone(initiated_in_secure_context),
      mojo::Clone(upgrade_if_insecure),
      mojo::Clone(is_revalidating),
      mojo::Clone(should_also_use_factory_bound_origin_for_cors),
      mojo::Clone(throttling_profile_id),
      mojo::Clone(custom_proxy_pre_cache_headers),
      mojo::Clone(custom_proxy_post_cache_headers),
      mojo::Clone(fetch_window_id),
      mojo::Clone(devtools_request_id)
  );
}

template <typename T, URLRequest::EnableIfSame<T>*>
bool URLRequest::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->method, other_struct.method))
    return false;
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  if (!mojo::Equals(this->site_for_cookies, other_struct.site_for_cookies))
    return false;
  if (!mojo::Equals(this->top_frame_origin, other_struct.top_frame_origin))
    return false;
  if (!mojo::Equals(this->attach_same_site_cookies, other_struct.attach_same_site_cookies))
    return false;
  if (!mojo::Equals(this->update_first_party_url_on_redirect, other_struct.update_first_party_url_on_redirect))
    return false;
  if (!mojo::Equals(this->request_initiator, other_struct.request_initiator))
    return false;
  if (!mojo::Equals(this->referrer, other_struct.referrer))
    return false;
  if (!mojo::Equals(this->referrer_policy, other_struct.referrer_policy))
    return false;
  if (!mojo::Equals(this->is_prerendering, other_struct.is_prerendering))
    return false;
  if (!mojo::Equals(this->headers, other_struct.headers))
    return false;
  if (!mojo::Equals(this->cors_exempt_headers, other_struct.cors_exempt_headers))
    return false;
  if (!mojo::Equals(this->load_flags, other_struct.load_flags))
    return false;
  if (!mojo::Equals(this->allow_credentials, other_struct.allow_credentials))
    return false;
  if (!mojo::Equals(this->plugin_child_id, other_struct.plugin_child_id))
    return false;
  if (!mojo::Equals(this->resource_type, other_struct.resource_type))
    return false;
  if (!mojo::Equals(this->priority, other_struct.priority))
    return false;
  if (!mojo::Equals(this->appcache_host_id, other_struct.appcache_host_id))
    return false;
  if (!mojo::Equals(this->should_reset_appcache, other_struct.should_reset_appcache))
    return false;
  if (!mojo::Equals(this->is_external_request, other_struct.is_external_request))
    return false;
  if (!mojo::Equals(this->cors_preflight_policy, other_struct.cors_preflight_policy))
    return false;
  if (!mojo::Equals(this->originated_from_service_worker, other_struct.originated_from_service_worker))
    return false;
  if (!mojo::Equals(this->skip_service_worker, other_struct.skip_service_worker))
    return false;
  if (!mojo::Equals(this->corb_detachable, other_struct.corb_detachable))
    return false;
  if (!mojo::Equals(this->corb_excluded, other_struct.corb_excluded))
    return false;
  if (!mojo::Equals(this->mode, other_struct.mode))
    return false;
  if (!mojo::Equals(this->credentials_mode, other_struct.credentials_mode))
    return false;
  if (!mojo::Equals(this->redirect_mode, other_struct.redirect_mode))
    return false;
  if (!mojo::Equals(this->fetch_integrity, other_struct.fetch_integrity))
    return false;
  if (!mojo::Equals(this->fetch_request_context_type, other_struct.fetch_request_context_type))
    return false;
  if (!mojo::Equals(this->request_body, other_struct.request_body))
    return false;
  if (!mojo::Equals(this->keepalive, other_struct.keepalive))
    return false;
  if (!mojo::Equals(this->has_user_gesture, other_struct.has_user_gesture))
    return false;
  if (!mojo::Equals(this->enable_load_timing, other_struct.enable_load_timing))
    return false;
  if (!mojo::Equals(this->enable_upload_progress, other_struct.enable_upload_progress))
    return false;
  if (!mojo::Equals(this->do_not_prompt_for_login, other_struct.do_not_prompt_for_login))
    return false;
  if (!mojo::Equals(this->render_frame_id, other_struct.render_frame_id))
    return false;
  if (!mojo::Equals(this->is_main_frame, other_struct.is_main_frame))
    return false;
  if (!mojo::Equals(this->transition_type, other_struct.transition_type))
    return false;
  if (!mojo::Equals(this->allow_download, other_struct.allow_download))
    return false;
  if (!mojo::Equals(this->report_raw_headers, other_struct.report_raw_headers))
    return false;
  if (!mojo::Equals(this->previews_state, other_struct.previews_state))
    return false;
  if (!mojo::Equals(this->initiated_in_secure_context, other_struct.initiated_in_secure_context))
    return false;
  if (!mojo::Equals(this->upgrade_if_insecure, other_struct.upgrade_if_insecure))
    return false;
  if (!mojo::Equals(this->is_revalidating, other_struct.is_revalidating))
    return false;
  if (!mojo::Equals(this->should_also_use_factory_bound_origin_for_cors, other_struct.should_also_use_factory_bound_origin_for_cors))
    return false;
  if (!mojo::Equals(this->throttling_profile_id, other_struct.throttling_profile_id))
    return false;
  if (!mojo::Equals(this->custom_proxy_pre_cache_headers, other_struct.custom_proxy_pre_cache_headers))
    return false;
  if (!mojo::Equals(this->custom_proxy_post_cache_headers, other_struct.custom_proxy_post_cache_headers))
    return false;
  if (!mojo::Equals(this->fetch_window_id, other_struct.fetch_window_id))
    return false;
  if (!mojo::Equals(this->devtools_request_id, other_struct.devtools_request_id))
    return false;
  return true;
}

template <typename T, URLRequest::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.method < rhs.method)
    return true;
  if (rhs.method < lhs.method)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  if (lhs.site_for_cookies < rhs.site_for_cookies)
    return true;
  if (rhs.site_for_cookies < lhs.site_for_cookies)
    return false;
  if (lhs.top_frame_origin < rhs.top_frame_origin)
    return true;
  if (rhs.top_frame_origin < lhs.top_frame_origin)
    return false;
  if (lhs.attach_same_site_cookies < rhs.attach_same_site_cookies)
    return true;
  if (rhs.attach_same_site_cookies < lhs.attach_same_site_cookies)
    return false;
  if (lhs.update_first_party_url_on_redirect < rhs.update_first_party_url_on_redirect)
    return true;
  if (rhs.update_first_party_url_on_redirect < lhs.update_first_party_url_on_redirect)
    return false;
  if (lhs.request_initiator < rhs.request_initiator)
    return true;
  if (rhs.request_initiator < lhs.request_initiator)
    return false;
  if (lhs.referrer < rhs.referrer)
    return true;
  if (rhs.referrer < lhs.referrer)
    return false;
  if (lhs.referrer_policy < rhs.referrer_policy)
    return true;
  if (rhs.referrer_policy < lhs.referrer_policy)
    return false;
  if (lhs.is_prerendering < rhs.is_prerendering)
    return true;
  if (rhs.is_prerendering < lhs.is_prerendering)
    return false;
  if (lhs.headers < rhs.headers)
    return true;
  if (rhs.headers < lhs.headers)
    return false;
  if (lhs.cors_exempt_headers < rhs.cors_exempt_headers)
    return true;
  if (rhs.cors_exempt_headers < lhs.cors_exempt_headers)
    return false;
  if (lhs.load_flags < rhs.load_flags)
    return true;
  if (rhs.load_flags < lhs.load_flags)
    return false;
  if (lhs.allow_credentials < rhs.allow_credentials)
    return true;
  if (rhs.allow_credentials < lhs.allow_credentials)
    return false;
  if (lhs.plugin_child_id < rhs.plugin_child_id)
    return true;
  if (rhs.plugin_child_id < lhs.plugin_child_id)
    return false;
  if (lhs.resource_type < rhs.resource_type)
    return true;
  if (rhs.resource_type < lhs.resource_type)
    return false;
  if (lhs.priority < rhs.priority)
    return true;
  if (rhs.priority < lhs.priority)
    return false;
  if (lhs.appcache_host_id < rhs.appcache_host_id)
    return true;
  if (rhs.appcache_host_id < lhs.appcache_host_id)
    return false;
  if (lhs.should_reset_appcache < rhs.should_reset_appcache)
    return true;
  if (rhs.should_reset_appcache < lhs.should_reset_appcache)
    return false;
  if (lhs.is_external_request < rhs.is_external_request)
    return true;
  if (rhs.is_external_request < lhs.is_external_request)
    return false;
  if (lhs.cors_preflight_policy < rhs.cors_preflight_policy)
    return true;
  if (rhs.cors_preflight_policy < lhs.cors_preflight_policy)
    return false;
  if (lhs.originated_from_service_worker < rhs.originated_from_service_worker)
    return true;
  if (rhs.originated_from_service_worker < lhs.originated_from_service_worker)
    return false;
  if (lhs.skip_service_worker < rhs.skip_service_worker)
    return true;
  if (rhs.skip_service_worker < lhs.skip_service_worker)
    return false;
  if (lhs.corb_detachable < rhs.corb_detachable)
    return true;
  if (rhs.corb_detachable < lhs.corb_detachable)
    return false;
  if (lhs.corb_excluded < rhs.corb_excluded)
    return true;
  if (rhs.corb_excluded < lhs.corb_excluded)
    return false;
  if (lhs.mode < rhs.mode)
    return true;
  if (rhs.mode < lhs.mode)
    return false;
  if (lhs.credentials_mode < rhs.credentials_mode)
    return true;
  if (rhs.credentials_mode < lhs.credentials_mode)
    return false;
  if (lhs.redirect_mode < rhs.redirect_mode)
    return true;
  if (rhs.redirect_mode < lhs.redirect_mode)
    return false;
  if (lhs.fetch_integrity < rhs.fetch_integrity)
    return true;
  if (rhs.fetch_integrity < lhs.fetch_integrity)
    return false;
  if (lhs.fetch_request_context_type < rhs.fetch_request_context_type)
    return true;
  if (rhs.fetch_request_context_type < lhs.fetch_request_context_type)
    return false;
  if (lhs.request_body < rhs.request_body)
    return true;
  if (rhs.request_body < lhs.request_body)
    return false;
  if (lhs.keepalive < rhs.keepalive)
    return true;
  if (rhs.keepalive < lhs.keepalive)
    return false;
  if (lhs.has_user_gesture < rhs.has_user_gesture)
    return true;
  if (rhs.has_user_gesture < lhs.has_user_gesture)
    return false;
  if (lhs.enable_load_timing < rhs.enable_load_timing)
    return true;
  if (rhs.enable_load_timing < lhs.enable_load_timing)
    return false;
  if (lhs.enable_upload_progress < rhs.enable_upload_progress)
    return true;
  if (rhs.enable_upload_progress < lhs.enable_upload_progress)
    return false;
  if (lhs.do_not_prompt_for_login < rhs.do_not_prompt_for_login)
    return true;
  if (rhs.do_not_prompt_for_login < lhs.do_not_prompt_for_login)
    return false;
  if (lhs.render_frame_id < rhs.render_frame_id)
    return true;
  if (rhs.render_frame_id < lhs.render_frame_id)
    return false;
  if (lhs.is_main_frame < rhs.is_main_frame)
    return true;
  if (rhs.is_main_frame < lhs.is_main_frame)
    return false;
  if (lhs.transition_type < rhs.transition_type)
    return true;
  if (rhs.transition_type < lhs.transition_type)
    return false;
  if (lhs.allow_download < rhs.allow_download)
    return true;
  if (rhs.allow_download < lhs.allow_download)
    return false;
  if (lhs.report_raw_headers < rhs.report_raw_headers)
    return true;
  if (rhs.report_raw_headers < lhs.report_raw_headers)
    return false;
  if (lhs.previews_state < rhs.previews_state)
    return true;
  if (rhs.previews_state < lhs.previews_state)
    return false;
  if (lhs.initiated_in_secure_context < rhs.initiated_in_secure_context)
    return true;
  if (rhs.initiated_in_secure_context < lhs.initiated_in_secure_context)
    return false;
  if (lhs.upgrade_if_insecure < rhs.upgrade_if_insecure)
    return true;
  if (rhs.upgrade_if_insecure < lhs.upgrade_if_insecure)
    return false;
  if (lhs.is_revalidating < rhs.is_revalidating)
    return true;
  if (rhs.is_revalidating < lhs.is_revalidating)
    return false;
  if (lhs.should_also_use_factory_bound_origin_for_cors < rhs.should_also_use_factory_bound_origin_for_cors)
    return true;
  if (rhs.should_also_use_factory_bound_origin_for_cors < lhs.should_also_use_factory_bound_origin_for_cors)
    return false;
  if (lhs.throttling_profile_id < rhs.throttling_profile_id)
    return true;
  if (rhs.throttling_profile_id < lhs.throttling_profile_id)
    return false;
  if (lhs.custom_proxy_pre_cache_headers < rhs.custom_proxy_pre_cache_headers)
    return true;
  if (rhs.custom_proxy_pre_cache_headers < lhs.custom_proxy_pre_cache_headers)
    return false;
  if (lhs.custom_proxy_post_cache_headers < rhs.custom_proxy_post_cache_headers)
    return true;
  if (rhs.custom_proxy_post_cache_headers < lhs.custom_proxy_post_cache_headers)
    return false;
  if (lhs.fetch_window_id < rhs.fetch_window_id)
    return true;
  if (rhs.fetch_window_id < lhs.fetch_window_id)
    return false;
  if (lhs.devtools_request_id < rhs.devtools_request_id)
    return true;
  if (rhs.devtools_request_id < lhs.devtools_request_id)
    return false;
  return false;
}
template <typename StructPtrType>
URLRequestBodyPtr URLRequestBody::Clone() const {
  return New(
      mojo::Clone(elements),
      mojo::Clone(identifier),
      mojo::Clone(contains_sensitive_info)
  );
}

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

template <typename T, URLRequestBody::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.elements < rhs.elements)
    return true;
  if (rhs.elements < lhs.elements)
    return false;
  if (lhs.identifier < rhs.identifier)
    return true;
  if (rhs.identifier < lhs.identifier)
    return false;
  if (lhs.contains_sensitive_info < rhs.contains_sensitive_info)
    return true;
  if (rhs.contains_sensitive_info < lhs.contains_sensitive_info)
    return false;
  return false;
}
template <typename StructPtrType>
DataElementPtr DataElement::Clone() const {
  return New(
      mojo::Clone(type),
      mojo::Clone(buf),
      mojo::Clone(path),
      mojo::Clone(file),
      mojo::Clone(blob_uuid),
      mojo::Clone(data_pipe_getter),
      mojo::Clone(chunked_data_pipe_getter),
      mojo::Clone(offset),
      mojo::Clone(length),
      mojo::Clone(expected_modification_time)
  );
}

template <typename T, DataElement::EnableIfSame<T>*>
bool DataElement::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->type, other_struct.type))
    return false;
  if (!mojo::Equals(this->buf, other_struct.buf))
    return false;
  if (!mojo::Equals(this->path, other_struct.path))
    return false;
  if (!mojo::Equals(this->file, other_struct.file))
    return false;
  if (!mojo::Equals(this->blob_uuid, other_struct.blob_uuid))
    return false;
  if (!mojo::Equals(this->data_pipe_getter, other_struct.data_pipe_getter))
    return false;
  if (!mojo::Equals(this->chunked_data_pipe_getter, other_struct.chunked_data_pipe_getter))
    return false;
  if (!mojo::Equals(this->offset, other_struct.offset))
    return false;
  if (!mojo::Equals(this->length, other_struct.length))
    return false;
  if (!mojo::Equals(this->expected_modification_time, other_struct.expected_modification_time))
    return false;
  return true;
}

template <typename T, DataElement::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.type < rhs.type)
    return true;
  if (rhs.type < lhs.type)
    return false;
  if (lhs.buf < rhs.buf)
    return true;
  if (rhs.buf < lhs.buf)
    return false;
  if (lhs.path < rhs.path)
    return true;
  if (rhs.path < lhs.path)
    return false;
  if (lhs.file < rhs.file)
    return true;
  if (rhs.file < lhs.file)
    return false;
  if (lhs.blob_uuid < rhs.blob_uuid)
    return true;
  if (rhs.blob_uuid < lhs.blob_uuid)
    return false;
  if (lhs.data_pipe_getter < rhs.data_pipe_getter)
    return true;
  if (rhs.data_pipe_getter < lhs.data_pipe_getter)
    return false;
  if (lhs.chunked_data_pipe_getter < rhs.chunked_data_pipe_getter)
    return true;
  if (rhs.chunked_data_pipe_getter < lhs.chunked_data_pipe_getter)
    return false;
  if (lhs.offset < rhs.offset)
    return true;
  if (rhs.offset < lhs.offset)
    return false;
  if (lhs.length < rhs.length)
    return true;
  if (rhs.length < lhs.length)
    return false;
  if (lhs.expected_modification_time < rhs.expected_modification_time)
    return true;
  if (rhs.expected_modification_time < lhs.expected_modification_time)
    return false;
  return false;
}
template <typename StructPtrType>
URLLoaderClientEndpointsPtr URLLoaderClientEndpoints::Clone() const {
  return New(
      mojo::Clone(url_loader),
      mojo::Clone(url_loader_client)
  );
}

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

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


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

namespace mojo {


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

  static const decltype(::network::mojom::blink::URLRequest::method)& method(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->method;
  }

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

  static const decltype(::network::mojom::blink::URLRequest::site_for_cookies)& site_for_cookies(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->site_for_cookies;
  }

  static const decltype(::network::mojom::blink::URLRequest::top_frame_origin)& top_frame_origin(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->top_frame_origin;
  }

  static decltype(::network::mojom::blink::URLRequest::attach_same_site_cookies) attach_same_site_cookies(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->attach_same_site_cookies;
  }

  static decltype(::network::mojom::blink::URLRequest::update_first_party_url_on_redirect) update_first_party_url_on_redirect(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->update_first_party_url_on_redirect;
  }

  static const decltype(::network::mojom::blink::URLRequest::request_initiator)& request_initiator(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->request_initiator;
  }

  static const decltype(::network::mojom::blink::URLRequest::referrer)& referrer(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->referrer;
  }

  static decltype(::network::mojom::blink::URLRequest::referrer_policy) referrer_policy(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->referrer_policy;
  }

  static decltype(::network::mojom::blink::URLRequest::is_prerendering) is_prerendering(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->is_prerendering;
  }

  static const decltype(::network::mojom::blink::URLRequest::headers)& headers(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->headers;
  }

  static const decltype(::network::mojom::blink::URLRequest::cors_exempt_headers)& cors_exempt_headers(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->cors_exempt_headers;
  }

  static decltype(::network::mojom::blink::URLRequest::load_flags) load_flags(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->load_flags;
  }

  static decltype(::network::mojom::blink::URLRequest::allow_credentials) allow_credentials(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->allow_credentials;
  }

  static decltype(::network::mojom::blink::URLRequest::plugin_child_id) plugin_child_id(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->plugin_child_id;
  }

  static decltype(::network::mojom::blink::URLRequest::resource_type) resource_type(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->resource_type;
  }

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

  static const decltype(::network::mojom::blink::URLRequest::appcache_host_id)& appcache_host_id(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->appcache_host_id;
  }

  static decltype(::network::mojom::blink::URLRequest::should_reset_appcache) should_reset_appcache(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->should_reset_appcache;
  }

  static decltype(::network::mojom::blink::URLRequest::is_external_request) is_external_request(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->is_external_request;
  }

  static decltype(::network::mojom::blink::URLRequest::cors_preflight_policy) cors_preflight_policy(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->cors_preflight_policy;
  }

  static decltype(::network::mojom::blink::URLRequest::originated_from_service_worker) originated_from_service_worker(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->originated_from_service_worker;
  }

  static decltype(::network::mojom::blink::URLRequest::skip_service_worker) skip_service_worker(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->skip_service_worker;
  }

  static decltype(::network::mojom::blink::URLRequest::corb_detachable) corb_detachable(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->corb_detachable;
  }

  static decltype(::network::mojom::blink::URLRequest::corb_excluded) corb_excluded(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->corb_excluded;
  }

  static decltype(::network::mojom::blink::URLRequest::mode) mode(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->mode;
  }

  static decltype(::network::mojom::blink::URLRequest::credentials_mode) credentials_mode(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->credentials_mode;
  }

  static decltype(::network::mojom::blink::URLRequest::redirect_mode) redirect_mode(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->redirect_mode;
  }

  static const decltype(::network::mojom::blink::URLRequest::fetch_integrity)& fetch_integrity(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->fetch_integrity;
  }

  static decltype(::network::mojom::blink::URLRequest::fetch_request_context_type) fetch_request_context_type(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->fetch_request_context_type;
  }

  static  decltype(::network::mojom::blink::URLRequest::request_body)& request_body(
       ::network::mojom::blink::URLRequestPtr& input) {
    return input->request_body;
  }

  static decltype(::network::mojom::blink::URLRequest::keepalive) keepalive(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->keepalive;
  }

  static decltype(::network::mojom::blink::URLRequest::has_user_gesture) has_user_gesture(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->has_user_gesture;
  }

  static decltype(::network::mojom::blink::URLRequest::enable_load_timing) enable_load_timing(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->enable_load_timing;
  }

  static decltype(::network::mojom::blink::URLRequest::enable_upload_progress) enable_upload_progress(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->enable_upload_progress;
  }

  static decltype(::network::mojom::blink::URLRequest::do_not_prompt_for_login) do_not_prompt_for_login(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->do_not_prompt_for_login;
  }

  static decltype(::network::mojom::blink::URLRequest::render_frame_id) render_frame_id(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->render_frame_id;
  }

  static decltype(::network::mojom::blink::URLRequest::is_main_frame) is_main_frame(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->is_main_frame;
  }

  static decltype(::network::mojom::blink::URLRequest::transition_type) transition_type(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->transition_type;
  }

  static decltype(::network::mojom::blink::URLRequest::allow_download) allow_download(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->allow_download;
  }

  static decltype(::network::mojom::blink::URLRequest::report_raw_headers) report_raw_headers(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->report_raw_headers;
  }

  static decltype(::network::mojom::blink::URLRequest::previews_state) previews_state(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->previews_state;
  }

  static decltype(::network::mojom::blink::URLRequest::initiated_in_secure_context) initiated_in_secure_context(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->initiated_in_secure_context;
  }

  static decltype(::network::mojom::blink::URLRequest::upgrade_if_insecure) upgrade_if_insecure(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->upgrade_if_insecure;
  }

  static decltype(::network::mojom::blink::URLRequest::is_revalidating) is_revalidating(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->is_revalidating;
  }

  static decltype(::network::mojom::blink::URLRequest::should_also_use_factory_bound_origin_for_cors) should_also_use_factory_bound_origin_for_cors(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->should_also_use_factory_bound_origin_for_cors;
  }

  static const decltype(::network::mojom::blink::URLRequest::throttling_profile_id)& throttling_profile_id(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->throttling_profile_id;
  }

  static const decltype(::network::mojom::blink::URLRequest::custom_proxy_pre_cache_headers)& custom_proxy_pre_cache_headers(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->custom_proxy_pre_cache_headers;
  }

  static const decltype(::network::mojom::blink::URLRequest::custom_proxy_post_cache_headers)& custom_proxy_post_cache_headers(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->custom_proxy_post_cache_headers;
  }

  static const decltype(::network::mojom::blink::URLRequest::fetch_window_id)& fetch_window_id(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->fetch_window_id;
  }

  static const decltype(::network::mojom::blink::URLRequest::devtools_request_id)& devtools_request_id(
      const ::network::mojom::blink::URLRequestPtr& input) {
    return input->devtools_request_id;
  }

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


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

  static  decltype(::network::mojom::blink::URLRequestBody::elements)& elements(
       ::network::mojom::blink::URLRequestBodyPtr& input) {
    return input->elements;
  }

  static decltype(::network::mojom::blink::URLRequestBody::identifier) identifier(
      const ::network::mojom::blink::URLRequestBodyPtr& input) {
    return input->identifier;
  }

  static decltype(::network::mojom::blink::URLRequestBody::contains_sensitive_info) contains_sensitive_info(
      const ::network::mojom::blink::URLRequestBodyPtr& input) {
    return input->contains_sensitive_info;
  }

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


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

  static decltype(::network::mojom::blink::DataElement::type) type(
      const ::network::mojom::blink::DataElementPtr& input) {
    return input->type;
  }

  static const decltype(::network::mojom::blink::DataElement::buf)& buf(
      const ::network::mojom::blink::DataElementPtr& input) {
    return input->buf;
  }

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

  static  decltype(::network::mojom::blink::DataElement::file)& file(
       ::network::mojom::blink::DataElementPtr& input) {
    return input->file;
  }

  static const decltype(::network::mojom::blink::DataElement::blob_uuid)& blob_uuid(
      const ::network::mojom::blink::DataElementPtr& input) {
    return input->blob_uuid;
  }

  static  decltype(::network::mojom::blink::DataElement::data_pipe_getter)& data_pipe_getter(
       ::network::mojom::blink::DataElementPtr& input) {
    return input->data_pipe_getter;
  }

  static  decltype(::network::mojom::blink::DataElement::chunked_data_pipe_getter)& chunked_data_pipe_getter(
       ::network::mojom::blink::DataElementPtr& input) {
    return input->chunked_data_pipe_getter;
  }

  static decltype(::network::mojom::blink::DataElement::offset) offset(
      const ::network::mojom::blink::DataElementPtr& input) {
    return input->offset;
  }

  static decltype(::network::mojom::blink::DataElement::length) length(
      const ::network::mojom::blink::DataElementPtr& input) {
    return input->length;
  }

  static const decltype(::network::mojom::blink::DataElement::expected_modification_time)& expected_modification_time(
      const ::network::mojom::blink::DataElementPtr& input) {
    return input->expected_modification_time;
  }

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


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

  static  decltype(::network::mojom::blink::URLLoaderClientEndpoints::url_loader)& url_loader(
       ::network::mojom::blink::URLLoaderClientEndpointsPtr& input) {
    return input->url_loader;
  }

  static  decltype(::network::mojom::blink::URLLoaderClientEndpoints::url_loader_client)& url_loader_client(
       ::network::mojom::blink::URLLoaderClientEndpointsPtr& input) {
    return input->url_loader_client;
  }

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

}  // namespace mojo

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