android-Debug/gen/content/common/navigation_client.mojom.h

// content/common/navigation_client.mojom.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef CONTENT_COMMON_NAVIGATION_CLIENT_MOJOM_H_
#define CONTENT_COMMON_NAVIGATION_CLIENT_MOJOM_H_

#include <stdint.h>

#include <limits>
#include <optional>
#include <type_traits>
#include <utility>
#include "mojo/public/cpp/bindings/clone_traits.h"
#include "mojo/public/cpp/bindings/equals_traits.h"
#include "mojo/public/cpp/bindings/struct_ptr.h"
#include "mojo/public/cpp/bindings/struct_traits.h"
#include "mojo/public/cpp/bindings/union_traits.h"

#include "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h"

#include "content/common/navigation_client.mojom-features.h"  // IWYU pragma: export
#include "content/common/navigation_client.mojom-shared.h"  // IWYU pragma: export
#include "content/common/navigation_client.mojom-forward.h"  // IWYU pragma: export
#include "content/common/frame_messages.mojom-forward.h"
#include "content/public/common/alternative_error_page_override_info.mojom-forward.h"
#include "mojo/public/mojom/base/time.mojom.h"
#include "mojo/public/mojom/base/unguessable_token.mojom.h"
#include "mojo/public/mojom/base/uuid.mojom.h"
#include "services/network/public/mojom/network_param.mojom.h"
#include "services/network/public/mojom/restricted_cookie_manager.mojom-forward.h"
#include "services/network/public/mojom/url_loader.mojom-forward.h"
#include "services/network/public/mojom/url_loader_factory.mojom-forward.h"
#include "services/network/public/mojom/url_response_head.mojom-forward.h"
#include "third_party/blink/public/mojom/commit_result/commit_result.mojom-forward.h"
#include "third_party/blink/public/mojom/dom_storage/storage_area.mojom-forward.h"
#include "third_party/blink/public/mojom/frame/policy_container.mojom-forward.h"
#include "third_party/blink/public/mojom/loader/code_cache.mojom-forward.h"
#include "third_party/blink/public/mojom/loader/referrer.mojom.h"
#include "third_party/blink/public/mojom/loader/fetch_later.mojom-forward.h"
#include "third_party/blink/public/mojom/loader/same_document_navigation_type.mojom-forward.h"
#include "third_party/blink/public/mojom/loader/transferrable_url_loader.mojom-forward.h"
#include "third_party/blink/public/mojom/loader/url_loader_factory_bundle.mojom.h"
#include "third_party/blink/public/mojom/navigation/navigation_params.mojom-forward.h"
#include "third_party/blink/public/mojom/permissions_policy/document_policy_feature.mojom.h"
#include "services/network/public/mojom/permissions_policy/permissions_policy.mojom.h"
#include "third_party/blink/public/mojom/permissions_policy/policy_value.mojom.h"
#include "third_party/blink/public/mojom/security_context/insecure_request_policy.mojom-forward.h"
#include "third_party/blink/public/mojom/service_worker/controller_service_worker.mojom-forward.h"
#include "third_party/blink/public/mojom/service_worker/service_worker_container.mojom-forward.h"
#include "third_party/blink/public/mojom/tokens/tokens.mojom.h"
#include "url/mojom/origin.mojom.h"
#include "url/mojom/url.mojom.h"
#include <string>
#include <vector>

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


#include "mojo/public/cpp/bindings/lib/native_enum_serialization.h"
#include "mojo/public/cpp/bindings/lib/native_struct_serialization.h"
#include "content/common/frame_owner_element_type_mojom_traits.h"
#include "content/common/input/input_injector_mojom_traits.h"
#include "content/common/input/synthetic_pinch_gesture_params.h"
#include "content/common/input/synthetic_pointer_action_list_params.h"
#include "content/common/input/synthetic_smooth_drag_gesture_params.h"
#include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
#include "content/common/input/synthetic_tap_gesture_params.h"
#include "content/common/navigation_gesture.h"
#include "content/public/common/common_param_traits.h"
#include "net/base/network_change_notifier.h"
#include "third_party/blink/public/common/navigation/impression.h"
#include "third_party/blink/public/common/page_state/page_state.h"
#include "third_party/blink/public/common/widget/visual_properties.h"
#include "ui/base/page_transition_types.h"
#include "ui/events/types/scroll_types.h"
#include "ui/native_theme/native_theme.h"
#include "content/common/content_export.h"

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


namespace content::mojom {

class NavigationClientProxy;

template <typename ImplRefTraits>
class NavigationClientStub;

class NavigationClientRequestValidator;
class NavigationClientResponseValidator;


// @generated_from: content.mojom.NavigationClient
class CONTENT_EXPORT NavigationClient
    : public NavigationClientInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();
  static constexpr const char* Name_ = "content.mojom.NavigationClient";
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = true;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = NavigationClientInterfaceBase;
  using Proxy_ = NavigationClientProxy;

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

  using RequestValidator_ = NavigationClientRequestValidator;
  using ResponseValidator_ = NavigationClientResponseValidator;
  enum MethodMinVersions : uint32_t {
    kCommitNavigationMinVersion = 0,
    kCommitFailedNavigationMinVersion = 0,
  };

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

  using CommitNavigationCallback = base::OnceCallback<void(DidCommitProvisionalLoadParamsPtr, ::content::mojom::DidCommitProvisionalLoadInterfaceParamsPtr)>;
  using CommitNavigationMojoCallback = base::OnceCallback<void(DidCommitProvisionalLoadParamsPtr, ::content::mojom::DidCommitProvisionalLoadInterfaceParamsPtr)>;

// @generated_from: content.mojom.NavigationClient.CommitNavigation
  virtual void CommitNavigation(::blink::mojom::CommonNavigationParamsPtr common_params, ::blink::mojom::CommitNavigationParamsPtr request_params, ::network::mojom::URLResponseHeadPtr response_head, ::mojo::ScopedDataPipeConsumerHandle response_body, ::network::mojom::URLLoaderClientEndpointsPtr url_loader_client_endpoints, ::std::unique_ptr<::blink::PendingURLLoaderFactoryBundle> subresource_loader_factories, std::optional<std::vector<::blink::mojom::TransferrableURLLoaderPtr>> subresource_overrides, ::blink::mojom::ControllerServiceWorkerInfoPtr controller_service_worker_info, ::blink::mojom::ServiceWorkerContainerInfoForClientPtr container_info, ::mojo::PendingRemote<::network::mojom::URLLoaderFactory> subresource_proxying_loader_factory, ::mojo::PendingRemote<::network::mojom::URLLoaderFactory> keep_alive_loader_factory, ::mojo::PendingAssociatedRemote<::blink::mojom::FetchLaterLoaderFactory> fetch_later_loader_factory, const ::blink::DocumentToken& document_token, const ::base::UnguessableToken& devtools_navigation_token, const ::base::Uuid& base_auction_nonce, const std::optional<std::vector<::network::ParsedPermissionsPolicyDeclaration>>& permissions_policy, ::blink::mojom::PolicyContainerPtr policy_container, ::mojo::PendingRemote<::blink::mojom::CodeCacheHost> code_cache_host, ::mojo::PendingRemote<::blink::mojom::CodeCacheHost> code_cache_host_for_background, CookieManagerInfoPtr cookie_manager_info, StorageInfoPtr storage_info, CommitNavigationCallback callback) = 0;

  using CommitFailedNavigationCallback = base::OnceCallback<void(DidCommitProvisionalLoadParamsPtr, ::content::mojom::DidCommitProvisionalLoadInterfaceParamsPtr)>;
  using CommitFailedNavigationMojoCallback = base::OnceCallback<void(DidCommitProvisionalLoadParamsPtr, ::content::mojom::DidCommitProvisionalLoadInterfaceParamsPtr)>;

// @generated_from: content.mojom.NavigationClient.CommitFailedNavigation
  virtual void CommitFailedNavigation(::blink::mojom::CommonNavigationParamsPtr common_params, ::blink::mojom::CommitNavigationParamsPtr request_params, bool has_stale_copy_in_cache, int32_t error_code, int32_t extended_error_code, const ::net::ResolveErrorInfo& resolve_error_info, const std::optional<std::string>& error_page_content, ::std::unique_ptr<::blink::PendingURLLoaderFactoryBundle> subresource_loader_factories, const ::blink::DocumentToken& document_token, const ::base::UnguessableToken& devtools_navigation_token, ::blink::mojom::PolicyContainerPtr policy_container, ::content::mojom::AlternativeErrorPageOverrideInfoPtr alternative_error_page_info, CommitFailedNavigationCallback callback) = 0;
};



// @generated_from: content.mojom.NavigationClient
class CONTENT_EXPORT NavigationClientProxy
    : public NavigationClient {
 public:
  using InterfaceType = NavigationClient;

  explicit NavigationClientProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: content.mojom.NavigationClient.CommitNavigation
  void CommitNavigation(::blink::mojom::CommonNavigationParamsPtr common_params, ::blink::mojom::CommitNavigationParamsPtr request_params, ::network::mojom::URLResponseHeadPtr response_head, ::mojo::ScopedDataPipeConsumerHandle response_body, ::network::mojom::URLLoaderClientEndpointsPtr url_loader_client_endpoints, ::std::unique_ptr<::blink::PendingURLLoaderFactoryBundle> subresource_loader_factories, std::optional<std::vector<::blink::mojom::TransferrableURLLoaderPtr>> subresource_overrides, ::blink::mojom::ControllerServiceWorkerInfoPtr controller_service_worker_info, ::blink::mojom::ServiceWorkerContainerInfoForClientPtr container_info, ::mojo::PendingRemote<::network::mojom::URLLoaderFactory> subresource_proxying_loader_factory, ::mojo::PendingRemote<::network::mojom::URLLoaderFactory> keep_alive_loader_factory, ::mojo::PendingAssociatedRemote<::blink::mojom::FetchLaterLoaderFactory> fetch_later_loader_factory, const ::blink::DocumentToken& document_token, const ::base::UnguessableToken& devtools_navigation_token, const ::base::Uuid& base_auction_nonce, const std::optional<std::vector<::network::ParsedPermissionsPolicyDeclaration>>& permissions_policy, ::blink::mojom::PolicyContainerPtr policy_container, ::mojo::PendingRemote<::blink::mojom::CodeCacheHost> code_cache_host, ::mojo::PendingRemote<::blink::mojom::CodeCacheHost> code_cache_host_for_background, CookieManagerInfoPtr cookie_manager_info, StorageInfoPtr storage_info, CommitNavigationCallback callback) final;
  
// @generated_from: content.mojom.NavigationClient.CommitFailedNavigation
  void CommitFailedNavigation(::blink::mojom::CommonNavigationParamsPtr common_params, ::blink::mojom::CommitNavigationParamsPtr request_params, bool has_stale_copy_in_cache, int32_t error_code, int32_t extended_error_code, const ::net::ResolveErrorInfo& resolve_error_info, const std::optional<std::string>& error_page_content, ::std::unique_ptr<::blink::PendingURLLoaderFactoryBundle> subresource_loader_factories, const ::blink::DocumentToken& document_token, const ::base::UnguessableToken& devtools_navigation_token, ::blink::mojom::PolicyContainerPtr policy_container, ::content::mojom::AlternativeErrorPageOverrideInfoPtr alternative_error_page_info, CommitFailedNavigationCallback callback) final;

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

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

  NavigationClientStub() = default;
  ~NavigationClientStub() override = default;

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return NavigationClientStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

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

 private:
  ImplPointerType sink_;
};
class CONTENT_EXPORT NavigationClientRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class CONTENT_EXPORT NavigationClientResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};













// @generated_from: content.mojom.DidCommitProvisionalLoadParams
class CONTENT_EXPORT DidCommitProvisionalLoadParams {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<DidCommitProvisionalLoadParams, T>::value>;
  using DataView = DidCommitProvisionalLoadParamsDataView;
  using Data_ = internal::DidCommitProvisionalLoadParams_Data;

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

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

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


  DidCommitProvisionalLoadParams();

  DidCommitProvisionalLoadParams(
      int64_t item_sequence_number,
      int64_t document_sequence_number,
      const std::string& navigation_api_key,
      const ::GURL& url,
      ::blink::mojom::ReferrerPtr referrer,
      ::ui::PageTransition transition,
      bool should_update_history,
      const std::string& contents_mime_type,
      bool did_create_new_entry,
      const std::string& method,
      int64_t post_id,
      int32_t http_status_code,
      bool url_is_unreachable,
      const std::optional<::blink::PageState>& previous_page_state,
      const ::blink::PageState& page_state,
      bool is_overriding_user_agent,
      bool history_list_was_cleared,
      const ::url::Origin& origin,
      const std::optional<::GURL>& initiator_base_url,
      std::vector<::network::ParsedPermissionsPolicyDeclaration> permissions_policy_header,
      const base::flat_map<::blink::mojom::DocumentPolicyFeature, ::blink::PolicyValue>& document_policy_header,
      ::blink::mojom::InsecureRequestPolicy insecure_request_policy,
      std::vector<uint32_t> insecure_navigations_set,
      bool has_potentially_trustworthy_unique_origin,
      int32_t request_id,
      const ::base::UnguessableToken& navigation_token,
      const std::optional<::base::UnguessableToken>& embedding_token,
      std::optional<::base::TimeTicks> unload_start,
      std::optional<::base::TimeTicks> unload_end,
      ::base::TimeTicks commit_navigation_start,
      std::optional<::base::TimeTicks> commit_navigation_end,
      ::base::TimeTicks commit_reply_sent);

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

  ~DidCommitProvisionalLoadParams();

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

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

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

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

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

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

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

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return DidCommitProvisionalLoadParams::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::DidCommitProvisionalLoadParams_UnserializedMessageContext<
            UserType, DidCommitProvisionalLoadParams::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<DidCommitProvisionalLoadParams::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.item_sequence_number
  int64_t item_sequence_number;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.document_sequence_number
  int64_t document_sequence_number;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.navigation_api_key
  std::string navigation_api_key;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.url
  ::GURL url;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.referrer
  ::blink::mojom::ReferrerPtr referrer;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.transition
  ::ui::PageTransition transition;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.should_update_history
  bool should_update_history;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.contents_mime_type
  std::string contents_mime_type;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.did_create_new_entry
  bool did_create_new_entry;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.method
  std::string method;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.post_id
  int64_t post_id;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.http_status_code
  int32_t http_status_code;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.url_is_unreachable
  bool url_is_unreachable;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.previous_page_state
  std::optional<::blink::PageState> previous_page_state;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.page_state
  ::blink::PageState page_state;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.is_overriding_user_agent
  bool is_overriding_user_agent;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.history_list_was_cleared
  bool history_list_was_cleared;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.origin
  ::url::Origin origin;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.initiator_base_url
  std::optional<::GURL> initiator_base_url;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.permissions_policy_header
  std::vector<::network::ParsedPermissionsPolicyDeclaration> permissions_policy_header;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.document_policy_header
  base::flat_map<::blink::mojom::DocumentPolicyFeature, ::blink::PolicyValue> document_policy_header;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.insecure_request_policy
  ::blink::mojom::InsecureRequestPolicy insecure_request_policy;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.insecure_navigations_set
  std::vector<uint32_t> insecure_navigations_set;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.has_potentially_trustworthy_unique_origin
  bool has_potentially_trustworthy_unique_origin;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.request_id
  int32_t request_id;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.navigation_token
  ::base::UnguessableToken navigation_token;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.embedding_token
  std::optional<::base::UnguessableToken> embedding_token;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.unload_start
  std::optional<::base::TimeTicks> unload_start;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.unload_end
  std::optional<::base::TimeTicks> unload_end;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.commit_navigation_start
  ::base::TimeTicks commit_navigation_start;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.commit_navigation_end
  std::optional<::base::TimeTicks> commit_navigation_end;
  
// @generated_from: content.mojom.DidCommitProvisionalLoadParams.commit_reply_sent
  ::base::TimeTicks commit_reply_sent;

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

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

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

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

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

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





// @generated_from: content.mojom.DidCommitSameDocumentNavigationParams
class CONTENT_EXPORT DidCommitSameDocumentNavigationParams {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<DidCommitSameDocumentNavigationParams, T>::value>;
  using DataView = DidCommitSameDocumentNavigationParamsDataView;
  using Data_ = internal::DidCommitSameDocumentNavigationParams_Data;

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

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

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


  DidCommitSameDocumentNavigationParams();

  DidCommitSameDocumentNavigationParams(
      ::blink::mojom::SameDocumentNavigationType same_document_navigation_type,
      bool is_client_redirect,
      bool started_with_transient_activation,
      bool should_replace_current_entry,
      const std::optional<::blink::SameDocNavigationScreenshotDestinationToken>& navigation_entry_screenshot_destination);


  ~DidCommitSameDocumentNavigationParams();

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

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

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

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

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

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

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

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return DidCommitSameDocumentNavigationParams::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::DidCommitSameDocumentNavigationParams_UnserializedMessageContext<
            UserType, DidCommitSameDocumentNavigationParams::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<DidCommitSameDocumentNavigationParams::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: content.mojom.DidCommitSameDocumentNavigationParams.same_document_navigation_type
  ::blink::mojom::SameDocumentNavigationType same_document_navigation_type;
  
// @generated_from: content.mojom.DidCommitSameDocumentNavigationParams.is_client_redirect
  bool is_client_redirect;
  
// @generated_from: content.mojom.DidCommitSameDocumentNavigationParams.started_with_transient_activation
  bool started_with_transient_activation;
  
// @generated_from: content.mojom.DidCommitSameDocumentNavigationParams.should_replace_current_entry
  bool should_replace_current_entry;
  
// @generated_from: content.mojom.DidCommitSameDocumentNavigationParams.navigation_entry_screenshot_destination
  std::optional<::blink::SameDocNavigationScreenshotDestinationToken> navigation_entry_screenshot_destination;

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

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

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

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

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

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





// @generated_from: content.mojom.CookieManagerInfo
class CONTENT_EXPORT CookieManagerInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<CookieManagerInfo, T>::value>;
  using DataView = CookieManagerInfoDataView;
  using Data_ = internal::CookieManagerInfo_Data;

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

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

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


  CookieManagerInfo();

  CookieManagerInfo(
      const ::url::Origin& origin,
      ::mojo::PendingRemote<::network::mojom::RestrictedCookieManager> cookie_manager);

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

  ~CookieManagerInfo();

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

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

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

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

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

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return CookieManagerInfo::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::CookieManagerInfo_UnserializedMessageContext<
            UserType, CookieManagerInfo::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<CookieManagerInfo::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: content.mojom.CookieManagerInfo.origin
  ::url::Origin origin;
  
// @generated_from: content.mojom.CookieManagerInfo.cookie_manager
  ::mojo::PendingRemote<::network::mojom::RestrictedCookieManager> cookie_manager;

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

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

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

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

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

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





// @generated_from: content.mojom.StorageInfo
class CONTENT_EXPORT StorageInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<StorageInfo, T>::value>;
  using DataView = StorageInfoDataView;
  using Data_ = internal::StorageInfo_Data;

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

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

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


  StorageInfo();

  StorageInfo(
      ::mojo::PendingRemote<::blink::mojom::StorageArea> local_storage_area,
      ::mojo::PendingRemote<::blink::mojom::StorageArea> session_storage_area);

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

  ~StorageInfo();

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

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

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

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

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

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return StorageInfo::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::StorageInfo_UnserializedMessageContext<
            UserType, StorageInfo::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<StorageInfo::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: content.mojom.StorageInfo.local_storage_area
  ::mojo::PendingRemote<::blink::mojom::StorageArea> local_storage_area;
  
// @generated_from: content.mojom.StorageInfo.session_storage_area
  ::mojo::PendingRemote<::blink::mojom::StorageArea> session_storage_area;

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

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

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

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

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

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

template <typename StructPtrType>
DidCommitProvisionalLoadParamsPtr DidCommitProvisionalLoadParams::Clone() const {
  return New(
      mojo::Clone(item_sequence_number),
      mojo::Clone(document_sequence_number),
      mojo::Clone(navigation_api_key),
      mojo::Clone(url),
      mojo::Clone(referrer),
      mojo::Clone(transition),
      mojo::Clone(should_update_history),
      mojo::Clone(contents_mime_type),
      mojo::Clone(did_create_new_entry),
      mojo::Clone(method),
      mojo::Clone(post_id),
      mojo::Clone(http_status_code),
      mojo::Clone(url_is_unreachable),
      mojo::Clone(previous_page_state),
      mojo::Clone(page_state),
      mojo::Clone(is_overriding_user_agent),
      mojo::Clone(history_list_was_cleared),
      mojo::Clone(origin),
      mojo::Clone(initiator_base_url),
      mojo::Clone(permissions_policy_header),
      mojo::Clone(document_policy_header),
      mojo::Clone(insecure_request_policy),
      mojo::Clone(insecure_navigations_set),
      mojo::Clone(has_potentially_trustworthy_unique_origin),
      mojo::Clone(request_id),
      mojo::Clone(navigation_token),
      mojo::Clone(embedding_token),
      mojo::Clone(unload_start),
      mojo::Clone(unload_end),
      mojo::Clone(commit_navigation_start),
      mojo::Clone(commit_navigation_end),
      mojo::Clone(commit_reply_sent)
  );
}

template <typename T, DidCommitProvisionalLoadParams::EnableIfSame<T>*>
bool DidCommitProvisionalLoadParams::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->item_sequence_number, other_struct.item_sequence_number))
    return false;
  if (!mojo::Equals(this->document_sequence_number, other_struct.document_sequence_number))
    return false;
  if (!mojo::Equals(this->navigation_api_key, other_struct.navigation_api_key))
    return false;
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  if (!mojo::Equals(this->referrer, other_struct.referrer))
    return false;
  if (!mojo::Equals(this->transition, other_struct.transition))
    return false;
  if (!mojo::Equals(this->should_update_history, other_struct.should_update_history))
    return false;
  if (!mojo::Equals(this->contents_mime_type, other_struct.contents_mime_type))
    return false;
  if (!mojo::Equals(this->did_create_new_entry, other_struct.did_create_new_entry))
    return false;
  if (!mojo::Equals(this->method, other_struct.method))
    return false;
  if (!mojo::Equals(this->post_id, other_struct.post_id))
    return false;
  if (!mojo::Equals(this->http_status_code, other_struct.http_status_code))
    return false;
  if (!mojo::Equals(this->url_is_unreachable, other_struct.url_is_unreachable))
    return false;
  if (!mojo::Equals(this->previous_page_state, other_struct.previous_page_state))
    return false;
  if (!mojo::Equals(this->page_state, other_struct.page_state))
    return false;
  if (!mojo::Equals(this->is_overriding_user_agent, other_struct.is_overriding_user_agent))
    return false;
  if (!mojo::Equals(this->history_list_was_cleared, other_struct.history_list_was_cleared))
    return false;
  if (!mojo::Equals(this->origin, other_struct.origin))
    return false;
  if (!mojo::Equals(this->initiator_base_url, other_struct.initiator_base_url))
    return false;
  if (!mojo::Equals(this->permissions_policy_header, other_struct.permissions_policy_header))
    return false;
  if (!mojo::Equals(this->document_policy_header, other_struct.document_policy_header))
    return false;
  if (!mojo::Equals(this->insecure_request_policy, other_struct.insecure_request_policy))
    return false;
  if (!mojo::Equals(this->insecure_navigations_set, other_struct.insecure_navigations_set))
    return false;
  if (!mojo::Equals(this->has_potentially_trustworthy_unique_origin, other_struct.has_potentially_trustworthy_unique_origin))
    return false;
  if (!mojo::Equals(this->request_id, other_struct.request_id))
    return false;
  if (!mojo::Equals(this->navigation_token, other_struct.navigation_token))
    return false;
  if (!mojo::Equals(this->embedding_token, other_struct.embedding_token))
    return false;
  if (!mojo::Equals(this->unload_start, other_struct.unload_start))
    return false;
  if (!mojo::Equals(this->unload_end, other_struct.unload_end))
    return false;
  if (!mojo::Equals(this->commit_navigation_start, other_struct.commit_navigation_start))
    return false;
  if (!mojo::Equals(this->commit_navigation_end, other_struct.commit_navigation_end))
    return false;
  if (!mojo::Equals(this->commit_reply_sent, other_struct.commit_reply_sent))
    return false;
  return true;
}

template <typename T, DidCommitProvisionalLoadParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.item_sequence_number < rhs.item_sequence_number)
    return true;
  if (rhs.item_sequence_number < lhs.item_sequence_number)
    return false;
  if (lhs.document_sequence_number < rhs.document_sequence_number)
    return true;
  if (rhs.document_sequence_number < lhs.document_sequence_number)
    return false;
  if (lhs.navigation_api_key < rhs.navigation_api_key)
    return true;
  if (rhs.navigation_api_key < lhs.navigation_api_key)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  if (lhs.referrer < rhs.referrer)
    return true;
  if (rhs.referrer < lhs.referrer)
    return false;
  if (lhs.transition < rhs.transition)
    return true;
  if (rhs.transition < lhs.transition)
    return false;
  if (lhs.should_update_history < rhs.should_update_history)
    return true;
  if (rhs.should_update_history < lhs.should_update_history)
    return false;
  if (lhs.contents_mime_type < rhs.contents_mime_type)
    return true;
  if (rhs.contents_mime_type < lhs.contents_mime_type)
    return false;
  if (lhs.did_create_new_entry < rhs.did_create_new_entry)
    return true;
  if (rhs.did_create_new_entry < lhs.did_create_new_entry)
    return false;
  if (lhs.method < rhs.method)
    return true;
  if (rhs.method < lhs.method)
    return false;
  if (lhs.post_id < rhs.post_id)
    return true;
  if (rhs.post_id < lhs.post_id)
    return false;
  if (lhs.http_status_code < rhs.http_status_code)
    return true;
  if (rhs.http_status_code < lhs.http_status_code)
    return false;
  if (lhs.url_is_unreachable < rhs.url_is_unreachable)
    return true;
  if (rhs.url_is_unreachable < lhs.url_is_unreachable)
    return false;
  if (lhs.previous_page_state < rhs.previous_page_state)
    return true;
  if (rhs.previous_page_state < lhs.previous_page_state)
    return false;
  if (lhs.page_state < rhs.page_state)
    return true;
  if (rhs.page_state < lhs.page_state)
    return false;
  if (lhs.is_overriding_user_agent < rhs.is_overriding_user_agent)
    return true;
  if (rhs.is_overriding_user_agent < lhs.is_overriding_user_agent)
    return false;
  if (lhs.history_list_was_cleared < rhs.history_list_was_cleared)
    return true;
  if (rhs.history_list_was_cleared < lhs.history_list_was_cleared)
    return false;
  if (lhs.origin < rhs.origin)
    return true;
  if (rhs.origin < lhs.origin)
    return false;
  if (lhs.initiator_base_url < rhs.initiator_base_url)
    return true;
  if (rhs.initiator_base_url < lhs.initiator_base_url)
    return false;
  if (lhs.permissions_policy_header < rhs.permissions_policy_header)
    return true;
  if (rhs.permissions_policy_header < lhs.permissions_policy_header)
    return false;
  if (lhs.document_policy_header < rhs.document_policy_header)
    return true;
  if (rhs.document_policy_header < lhs.document_policy_header)
    return false;
  if (lhs.insecure_request_policy < rhs.insecure_request_policy)
    return true;
  if (rhs.insecure_request_policy < lhs.insecure_request_policy)
    return false;
  if (lhs.insecure_navigations_set < rhs.insecure_navigations_set)
    return true;
  if (rhs.insecure_navigations_set < lhs.insecure_navigations_set)
    return false;
  if (lhs.has_potentially_trustworthy_unique_origin < rhs.has_potentially_trustworthy_unique_origin)
    return true;
  if (rhs.has_potentially_trustworthy_unique_origin < lhs.has_potentially_trustworthy_unique_origin)
    return false;
  if (lhs.request_id < rhs.request_id)
    return true;
  if (rhs.request_id < lhs.request_id)
    return false;
  if (lhs.navigation_token < rhs.navigation_token)
    return true;
  if (rhs.navigation_token < lhs.navigation_token)
    return false;
  if (lhs.embedding_token < rhs.embedding_token)
    return true;
  if (rhs.embedding_token < lhs.embedding_token)
    return false;
  if (lhs.unload_start < rhs.unload_start)
    return true;
  if (rhs.unload_start < lhs.unload_start)
    return false;
  if (lhs.unload_end < rhs.unload_end)
    return true;
  if (rhs.unload_end < lhs.unload_end)
    return false;
  if (lhs.commit_navigation_start < rhs.commit_navigation_start)
    return true;
  if (rhs.commit_navigation_start < lhs.commit_navigation_start)
    return false;
  if (lhs.commit_navigation_end < rhs.commit_navigation_end)
    return true;
  if (rhs.commit_navigation_end < lhs.commit_navigation_end)
    return false;
  if (lhs.commit_reply_sent < rhs.commit_reply_sent)
    return true;
  if (rhs.commit_reply_sent < lhs.commit_reply_sent)
    return false;
  return false;
}
template <typename StructPtrType>
DidCommitSameDocumentNavigationParamsPtr DidCommitSameDocumentNavigationParams::Clone() const {
  return New(
      mojo::Clone(same_document_navigation_type),
      mojo::Clone(is_client_redirect),
      mojo::Clone(started_with_transient_activation),
      mojo::Clone(should_replace_current_entry),
      mojo::Clone(navigation_entry_screenshot_destination)
  );
}

template <typename T, DidCommitSameDocumentNavigationParams::EnableIfSame<T>*>
bool DidCommitSameDocumentNavigationParams::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->same_document_navigation_type, other_struct.same_document_navigation_type))
    return false;
  if (!mojo::Equals(this->is_client_redirect, other_struct.is_client_redirect))
    return false;
  if (!mojo::Equals(this->started_with_transient_activation, other_struct.started_with_transient_activation))
    return false;
  if (!mojo::Equals(this->should_replace_current_entry, other_struct.should_replace_current_entry))
    return false;
  if (!mojo::Equals(this->navigation_entry_screenshot_destination, other_struct.navigation_entry_screenshot_destination))
    return false;
  return true;
}

template <typename T, DidCommitSameDocumentNavigationParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.same_document_navigation_type < rhs.same_document_navigation_type)
    return true;
  if (rhs.same_document_navigation_type < lhs.same_document_navigation_type)
    return false;
  if (lhs.is_client_redirect < rhs.is_client_redirect)
    return true;
  if (rhs.is_client_redirect < lhs.is_client_redirect)
    return false;
  if (lhs.started_with_transient_activation < rhs.started_with_transient_activation)
    return true;
  if (rhs.started_with_transient_activation < lhs.started_with_transient_activation)
    return false;
  if (lhs.should_replace_current_entry < rhs.should_replace_current_entry)
    return true;
  if (rhs.should_replace_current_entry < lhs.should_replace_current_entry)
    return false;
  if (lhs.navigation_entry_screenshot_destination < rhs.navigation_entry_screenshot_destination)
    return true;
  if (rhs.navigation_entry_screenshot_destination < lhs.navigation_entry_screenshot_destination)
    return false;
  return false;
}
template <typename StructPtrType>
CookieManagerInfoPtr CookieManagerInfo::Clone() const {
  return New(
      mojo::Clone(origin),
      mojo::Clone(cookie_manager)
  );
}

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

template <typename T, CookieManagerInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.origin < rhs.origin)
    return true;
  if (rhs.origin < lhs.origin)
    return false;
  if (lhs.cookie_manager < rhs.cookie_manager)
    return true;
  if (rhs.cookie_manager < lhs.cookie_manager)
    return false;
  return false;
}
template <typename StructPtrType>
StorageInfoPtr StorageInfo::Clone() const {
  return New(
      mojo::Clone(local_storage_area),
      mojo::Clone(session_storage_area)
  );
}

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

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


}  // content::mojom

namespace mojo {


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

  static decltype(::content::mojom::DidCommitProvisionalLoadParams::item_sequence_number) item_sequence_number(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->item_sequence_number;
  }

  static decltype(::content::mojom::DidCommitProvisionalLoadParams::document_sequence_number) document_sequence_number(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->document_sequence_number;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::navigation_api_key)& navigation_api_key(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->navigation_api_key;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::url)& url(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->url;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::referrer)& referrer(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->referrer;
  }

  static decltype(::content::mojom::DidCommitProvisionalLoadParams::transition) transition(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->transition;
  }

  static decltype(::content::mojom::DidCommitProvisionalLoadParams::should_update_history) should_update_history(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->should_update_history;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::contents_mime_type)& contents_mime_type(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->contents_mime_type;
  }

  static decltype(::content::mojom::DidCommitProvisionalLoadParams::did_create_new_entry) did_create_new_entry(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->did_create_new_entry;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::method)& method(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->method;
  }

  static decltype(::content::mojom::DidCommitProvisionalLoadParams::post_id) post_id(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->post_id;
  }

  static decltype(::content::mojom::DidCommitProvisionalLoadParams::http_status_code) http_status_code(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->http_status_code;
  }

  static decltype(::content::mojom::DidCommitProvisionalLoadParams::url_is_unreachable) url_is_unreachable(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->url_is_unreachable;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::previous_page_state)& previous_page_state(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->previous_page_state;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::page_state)& page_state(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->page_state;
  }

  static decltype(::content::mojom::DidCommitProvisionalLoadParams::is_overriding_user_agent) is_overriding_user_agent(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->is_overriding_user_agent;
  }

  static decltype(::content::mojom::DidCommitProvisionalLoadParams::history_list_was_cleared) history_list_was_cleared(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->history_list_was_cleared;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::origin)& origin(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->origin;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::initiator_base_url)& initiator_base_url(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->initiator_base_url;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::permissions_policy_header)& permissions_policy_header(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->permissions_policy_header;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::document_policy_header)& document_policy_header(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->document_policy_header;
  }

  static decltype(::content::mojom::DidCommitProvisionalLoadParams::insecure_request_policy) insecure_request_policy(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->insecure_request_policy;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::insecure_navigations_set)& insecure_navigations_set(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->insecure_navigations_set;
  }

  static decltype(::content::mojom::DidCommitProvisionalLoadParams::has_potentially_trustworthy_unique_origin) has_potentially_trustworthy_unique_origin(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->has_potentially_trustworthy_unique_origin;
  }

  static decltype(::content::mojom::DidCommitProvisionalLoadParams::request_id) request_id(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->request_id;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::navigation_token)& navigation_token(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->navigation_token;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::embedding_token)& embedding_token(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->embedding_token;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::unload_start)& unload_start(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->unload_start;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::unload_end)& unload_end(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->unload_end;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::commit_navigation_start)& commit_navigation_start(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->commit_navigation_start;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::commit_navigation_end)& commit_navigation_end(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->commit_navigation_end;
  }

  static const decltype(::content::mojom::DidCommitProvisionalLoadParams::commit_reply_sent)& commit_reply_sent(
      const ::content::mojom::DidCommitProvisionalLoadParamsPtr& input) {
    return input->commit_reply_sent;
  }

  static bool Read(::content::mojom::DidCommitProvisionalLoadParams::DataView input, ::content::mojom::DidCommitProvisionalLoadParamsPtr* output);
};


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

  static decltype(::content::mojom::DidCommitSameDocumentNavigationParams::same_document_navigation_type) same_document_navigation_type(
      const ::content::mojom::DidCommitSameDocumentNavigationParamsPtr& input) {
    return input->same_document_navigation_type;
  }

  static decltype(::content::mojom::DidCommitSameDocumentNavigationParams::is_client_redirect) is_client_redirect(
      const ::content::mojom::DidCommitSameDocumentNavigationParamsPtr& input) {
    return input->is_client_redirect;
  }

  static decltype(::content::mojom::DidCommitSameDocumentNavigationParams::started_with_transient_activation) started_with_transient_activation(
      const ::content::mojom::DidCommitSameDocumentNavigationParamsPtr& input) {
    return input->started_with_transient_activation;
  }

  static decltype(::content::mojom::DidCommitSameDocumentNavigationParams::should_replace_current_entry) should_replace_current_entry(
      const ::content::mojom::DidCommitSameDocumentNavigationParamsPtr& input) {
    return input->should_replace_current_entry;
  }

  static const decltype(::content::mojom::DidCommitSameDocumentNavigationParams::navigation_entry_screenshot_destination)& navigation_entry_screenshot_destination(
      const ::content::mojom::DidCommitSameDocumentNavigationParamsPtr& input) {
    return input->navigation_entry_screenshot_destination;
  }

  static bool Read(::content::mojom::DidCommitSameDocumentNavigationParams::DataView input, ::content::mojom::DidCommitSameDocumentNavigationParamsPtr* output);
};


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

  static const decltype(::content::mojom::CookieManagerInfo::origin)& origin(
      const ::content::mojom::CookieManagerInfoPtr& input) {
    return input->origin;
  }

  static  decltype(::content::mojom::CookieManagerInfo::cookie_manager)& cookie_manager(
       ::content::mojom::CookieManagerInfoPtr& input) {
    return input->cookie_manager;
  }

  static bool Read(::content::mojom::CookieManagerInfo::DataView input, ::content::mojom::CookieManagerInfoPtr* output);
};


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

  static  decltype(::content::mojom::StorageInfo::local_storage_area)& local_storage_area(
       ::content::mojom::StorageInfoPtr& input) {
    return input->local_storage_area;
  }

  static  decltype(::content::mojom::StorageInfo::session_storage_area)& session_storage_area(
       ::content::mojom::StorageInfoPtr& input) {
    return input->session_storage_area;
  }

  static bool Read(::content::mojom::StorageInfo::DataView input, ::content::mojom::StorageInfoPtr* output);
};

}  // namespace mojo

#endif  // CONTENT_COMMON_NAVIGATION_CLIENT_MOJOM_H_

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