chromium/out/Default/gen/content/common/frame.mojom.h

// content/common/frame.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_FRAME_MOJOM_H_
#define CONTENT_COMMON_FRAME_MOJOM_H_

#include <stdint.h>

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

#include "base/types/cxx23_to_underlying.h"
#include "mojo/public/cpp/bindings/clone_traits.h"
#include "mojo/public/cpp/bindings/equals_traits.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/struct_ptr.h"
#include "mojo/public/cpp/bindings/struct_traits.h"
#include "mojo/public/cpp/bindings/union_traits.h"

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

#include "content/common/frame.mojom-features.h"  // IWYU pragma: export
#include "content/common/frame.mojom-shared.h"  // IWYU pragma: export
#include "content/common/frame.mojom-forward.h"  // IWYU pragma: export
#include "cc/mojom/browser_controls_state.mojom-forward.h"
#include "content/common/frame_messages.mojom-forward.h"
#include "content/common/navigation_client.mojom.h"
#include "content/common/web_ui.mojom-forward.h"
#include "content/public/common/extra_mojo_js_features.mojom-forward.h"
#include "content/public/common/window_container_type.mojom-forward.h"
#include "ipc/constants.mojom-forward.h"
#include "mojo/public/mojom/base/file_path.mojom.h"
#include "mojo/public/mojom/base/time.mojom.h"
#include "mojo/public/mojom/base/unguessable_token.mojom.h"
#include "skia/public/mojom/skcolor.mojom.h"
#include "services/network/public/mojom/attribution.mojom-forward.h"
#include "services/network/public/mojom/content_security_policy.mojom-forward.h"
#include "services/network/public/mojom/url_loader.mojom-forward.h"
#include "services/network/public/mojom/url_loader_completion_status.mojom-forward.h"
#include "services/network/public/mojom/url_loader_factory.mojom-forward.h"
#include "services/network/public/mojom/url_request.mojom.h"
#include "services/network/public/mojom/url_response_head.mojom-forward.h"
#include "services/service_manager/public/mojom/interface_provider.mojom-forward.h"
#include "services/viz/public/mojom/compositing/surface_id.mojom-forward.h"
#include "third_party/blink/public/mojom/associated_interfaces/associated_interfaces.mojom-forward.h"
#include "third_party/blink/public/mojom/blob/blob_url_store.mojom-forward.h"
#include "third_party/blink/public/mojom/browser_interface_broker.mojom-forward.h"
#include "third_party/blink/public/mojom/commit_result/commit_result.mojom-forward.h"
#include "third_party/blink/public/mojom/conversions/conversions.mojom.h"
#include "third_party/blink/public/mojom/devtools/console_message.mojom-forward.h"
#include "third_party/blink/public/mojom/fenced_frame/fenced_frame.mojom-forward.h"
#include "third_party/blink/public/mojom/fenced_frame/fenced_frame_config.mojom.h"
#include "third_party/blink/public/mojom/frame/frame_owner_properties.mojom.h"
#include "third_party/blink/public/mojom/frame/frame_policy.mojom.h"
#include "third_party/blink/public/mojom/frame/frame_replication_state.mojom.h"
#include "third_party/blink/public/mojom/frame/lifecycle.mojom-forward.h"
#include "third_party/blink/public/mojom/frame/policy_container.mojom.h"
#include "third_party/blink/public/mojom/frame/remote_frame.mojom.h"
#include "third_party/blink/public/mojom/frame/tree_scope_type.mojom-forward.h"
#include "third_party/blink/public/mojom/loader/referrer.mojom.h"
#include "third_party/blink/public/mojom/navigation/navigation_policy.mojom.h"
#include "third_party/blink/public/mojom/loader/resource_load_info.mojom-forward.h"
#include "third_party/blink/public/mojom/loader/url_loader_factory_bundle.mojom.h"
#include "third_party/blink/public/mojom/messaging/transferable_message.mojom-forward.h"
#include "third_party/blink/public/mojom/navigation/navigation_params.mojom-forward.h"
#include "third_party/blink/public/mojom/navigation/navigation_initiator_activation_and_ad_status.mojom-forward.h"
#include "third_party/blink/public/mojom/page/browsing_context_group_info.mojom.h"
#include "third_party/blink/public/mojom/page/page.mojom.h"
#include "third_party/blink/public/mojom/page/prerender_page_param.mojom.h"
#include "third_party/blink/public/mojom/partitioned_popins/partitioned_popin_params.mojom.h"
#include "third_party/blink/public/mojom/picture_in_picture_window_options/picture_in_picture_window_options.mojom.h"
#include "third_party/blink/public/mojom/widget/platform_widget.mojom-forward.h"
#include "third_party/blink/public/mojom/page/widget.mojom-forward.h"
#include "third_party/blink/public/mojom/renderer_preferences.mojom.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 "third_party/blink/public/mojom/webpreferences/web_preferences.mojom.h"
#include "third_party/blink/public/mojom/widget/visual_properties.mojom.h"
#include "third_party/blink/public/mojom/window_features/window_features.mojom.h"
#include "ui/accessibility/mojom/ax_tree_update.mojom.h"
#include "ui/base/mojom/window_open_disposition.mojom.h"
#include "url/mojom/origin.mojom.h"
#include "url/mojom/scheme_host_port.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/lib/message_size_estimator.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 "net/base/network_change_notifier.h"
#include "third_party/blink/public/common/navigation/impression.h"
#include "third_party/blink/public/common/widget/visual_properties.h"
#include "ui/events/types/scroll_types.h"
#include "ui/native_theme/native_theme.h"
#include "content/common/content_export.h"




namespace content::mojom {

class FrameHTMLSerializerHandlerProxy;

template <typename ImplRefTraits>
class FrameHTMLSerializerHandlerStub;

class FrameHTMLSerializerHandlerRequestValidator;


class CONTENT_EXPORT FrameHTMLSerializerHandler
    : public FrameHTMLSerializerHandlerInterfaceBase { … };

class FrameProxy;

template <typename ImplRefTraits>
class FrameStub;

class FrameRequestValidator;
class FrameResponseValidator;


class CONTENT_EXPORT Frame
    : public FrameInterfaceBase { … };

class FrameBindingsControlProxy;

template <typename ImplRefTraits>
class FrameBindingsControlStub;

class FrameBindingsControlRequestValidator;


class CONTENT_EXPORT FrameBindingsControl
    : public FrameBindingsControlInterfaceBase { … };

class NavigationRendererCancellationListenerProxy;

template <typename ImplRefTraits>
class NavigationRendererCancellationListenerStub;

class NavigationRendererCancellationListenerRequestValidator;


class CONTENT_EXPORT NavigationRendererCancellationListener
    : public NavigationRendererCancellationListenerInterfaceBase { … };

class FrameHostProxy;

template <typename ImplRefTraits>
class FrameHostStub;

class FrameHostRequestValidator;
class FrameHostResponseValidator;


class CONTENT_EXPORT FrameHost
    : public FrameHostInterfaceBase { … };



class CONTENT_EXPORT FrameHTMLSerializerHandlerProxy
    : public FrameHTMLSerializerHandler { … };



class CONTENT_EXPORT FrameProxy
    : public Frame { … };



class CONTENT_EXPORT FrameBindingsControlProxy
    : public FrameBindingsControl { … };



class CONTENT_EXPORT NavigationRendererCancellationListenerProxy
    : public NavigationRendererCancellationListener { … };



class CONTENT_EXPORT FrameHostProxy
    : public FrameHost { … };
class CONTENT_EXPORT FrameHTMLSerializerHandlerStubDispatch { … };

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

  FrameHTMLSerializerHandlerStub() = default;
  ~FrameHTMLSerializerHandlerStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class CONTENT_EXPORT FrameStubDispatch { … };

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

  FrameStub() = default;
  ~FrameStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class CONTENT_EXPORT FrameBindingsControlStubDispatch { … };

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

  FrameBindingsControlStub() = default;
  ~FrameBindingsControlStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class CONTENT_EXPORT NavigationRendererCancellationListenerStubDispatch { … };

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

  NavigationRendererCancellationListenerStub() = default;
  ~NavigationRendererCancellationListenerStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class CONTENT_EXPORT FrameHostStubDispatch { … };

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

  FrameHostStub() = default;
  ~FrameHostStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class CONTENT_EXPORT FrameHTMLSerializerHandlerRequestValidator : public mojo::MessageReceiver { … };
class CONTENT_EXPORT FrameRequestValidator : public mojo::MessageReceiver { … };
class CONTENT_EXPORT FrameBindingsControlRequestValidator : public mojo::MessageReceiver { … };
class CONTENT_EXPORT NavigationRendererCancellationListenerRequestValidator : public mojo::MessageReceiver { … };
class CONTENT_EXPORT FrameHostRequestValidator : public mojo::MessageReceiver { … };
class CONTENT_EXPORT FrameResponseValidator : public mojo::MessageReceiver { … };
class CONTENT_EXPORT FrameHostResponseValidator : public mojo::MessageReceiver { … };













class CONTENT_EXPORT CreateMainFrameUnion { … };





class CONTENT_EXPORT CreateViewParams { … };

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

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

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

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





class CONTENT_EXPORT CreateLocalMainFrameParams { … };

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

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

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

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





class CONTENT_EXPORT CreateRemoteMainFrameParams { … };

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

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

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

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





class CONTENT_EXPORT CreateFrameWidgetParams { … };

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

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

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

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





class CONTENT_EXPORT CreateFrameParams { … };

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

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

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

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





class CONTENT_EXPORT SnapshotAccessibilityTreeParams { … };

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

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

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

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





class CONTENT_EXPORT CreateNewWindowParams { … };

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

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

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

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





class CONTENT_EXPORT CreateNewWindowReply { … };

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

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

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

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

template <typename UnionPtrType>
CreateMainFrameUnionPtr CreateMainFrameUnion::Clone() const { … }

template <typename T,
          typename std::enable_if<std::is_same<
              T, CreateMainFrameUnion>::value>::type*>
bool CreateMainFrameUnion::Equals(const T& other) const { … }
template <typename StructPtrType>
CreateViewParamsPtr CreateViewParams::Clone() const { … }

template <typename T, CreateViewParams::EnableIfSame<T>*>
bool CreateViewParams::Equals(const T& other_struct) const { … }

template <typename T, CreateViewParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
CreateLocalMainFrameParamsPtr CreateLocalMainFrameParams::Clone() const { … }

template <typename T, CreateLocalMainFrameParams::EnableIfSame<T>*>
bool CreateLocalMainFrameParams::Equals(const T& other_struct) const { … }

template <typename T, CreateLocalMainFrameParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
CreateRemoteMainFrameParamsPtr CreateRemoteMainFrameParams::Clone() const { … }

template <typename T, CreateRemoteMainFrameParams::EnableIfSame<T>*>
bool CreateRemoteMainFrameParams::Equals(const T& other_struct) const { … }

template <typename T, CreateRemoteMainFrameParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
CreateFrameWidgetParamsPtr CreateFrameWidgetParams::Clone() const { … }

template <typename T, CreateFrameWidgetParams::EnableIfSame<T>*>
bool CreateFrameWidgetParams::Equals(const T& other_struct) const { … }

template <typename T, CreateFrameWidgetParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
CreateFrameParamsPtr CreateFrameParams::Clone() const { … }

template <typename T, CreateFrameParams::EnableIfSame<T>*>
bool CreateFrameParams::Equals(const T& other_struct) const { … }

template <typename T, CreateFrameParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
SnapshotAccessibilityTreeParamsPtr SnapshotAccessibilityTreeParams::Clone() const { … }

template <typename T, SnapshotAccessibilityTreeParams::EnableIfSame<T>*>
bool SnapshotAccessibilityTreeParams::Equals(const T& other_struct) const { … }

template <typename T, SnapshotAccessibilityTreeParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
CreateNewWindowParamsPtr CreateNewWindowParams::Clone() const { … }

template <typename T, CreateNewWindowParams::EnableIfSame<T>*>
bool CreateNewWindowParams::Equals(const T& other_struct) const { … }

template <typename T, CreateNewWindowParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
CreateNewWindowReplyPtr CreateNewWindowReply::Clone() const { … }

template <typename T, CreateNewWindowReply::EnableIfSame<T>*>
bool CreateNewWindowReply::Equals(const T& other_struct) const { … }

template <typename T, CreateNewWindowReply::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }


}  // content::mojom

namespace mojo {


template <>
struct CONTENT_EXPORT StructTraits<::content::mojom::CreateViewParams::DataView,
                                         ::content::mojom::CreateViewParamsPtr> { … };


template <>
struct CONTENT_EXPORT StructTraits<::content::mojom::CreateLocalMainFrameParams::DataView,
                                         ::content::mojom::CreateLocalMainFrameParamsPtr> { … };


template <>
struct CONTENT_EXPORT StructTraits<::content::mojom::CreateRemoteMainFrameParams::DataView,
                                         ::content::mojom::CreateRemoteMainFrameParamsPtr> { … };


template <>
struct CONTENT_EXPORT StructTraits<::content::mojom::CreateFrameWidgetParams::DataView,
                                         ::content::mojom::CreateFrameWidgetParamsPtr> { … };


template <>
struct CONTENT_EXPORT StructTraits<::content::mojom::CreateFrameParams::DataView,
                                         ::content::mojom::CreateFrameParamsPtr> { … };


template <>
struct CONTENT_EXPORT StructTraits<::content::mojom::SnapshotAccessibilityTreeParams::DataView,
                                         ::content::mojom::SnapshotAccessibilityTreeParamsPtr> { … };


template <>
struct CONTENT_EXPORT StructTraits<::content::mojom::CreateNewWindowParams::DataView,
                                         ::content::mojom::CreateNewWindowParamsPtr> { … };


template <>
struct CONTENT_EXPORT StructTraits<::content::mojom::CreateNewWindowReply::DataView,
                                         ::content::mojom::CreateNewWindowReplyPtr> { … };


template <>
struct CONTENT_EXPORT UnionTraits<::content::mojom::CreateMainFrameUnion::DataView,
                                        ::content::mojom::CreateMainFrameUnionPtr> { … };

}  // namespace mojo

#endif  // CONTENT_COMMON_FRAME_MOJOM_H_