chromium/out/Default/gen/services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom-blink.h

// services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom-blink.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 SERVICES_RESOURCE_COORDINATOR_PUBLIC_MOJOM_MEMORY_INSTRUMENTATION_MEMORY_INSTRUMENTATION_MOJOM_BLINK_H_
#define SERVICES_RESOURCE_COORDINATOR_PUBLIC_MOJOM_MEMORY_INSTRUMENTATION_MEMORY_INSTRUMENTATION_MOJOM_BLINK_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 "services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom-features.h"  // IWYU pragma: export
#include "services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom-shared.h"  // IWYU pragma: export
#include "services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom-blink-forward.h"  // IWYU pragma: export
#include "mojo/public/mojom/base/big_string.mojom-blink.h"
#include "mojo/public/mojom/base/process_id.mojom-blink.h"
#include "mojo/public/mojom/base/time.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/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 "base/component_export.h"




namespace memory_instrumentation::mojom::blink {

class ClientProcessProxy;

template <typename ImplRefTraits>
class ClientProcessStub;

class ClientProcessRequestValidator;
class ClientProcessResponseValidator;


class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) ClientProcess
    : public ClientProcessInterfaceBase { … };

class HeapProfilerProxy;

template <typename ImplRefTraits>
class HeapProfilerStub;

class HeapProfilerRequestValidator;
class HeapProfilerResponseValidator;


class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) HeapProfiler
    : public HeapProfilerInterfaceBase { … };

class HeapProfilerHelperProxy;

template <typename ImplRefTraits>
class HeapProfilerHelperStub;

class HeapProfilerHelperRequestValidator;
class HeapProfilerHelperResponseValidator;


class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) HeapProfilerHelper
    : public HeapProfilerHelperInterfaceBase { … };

class CoordinatorProxy;

template <typename ImplRefTraits>
class CoordinatorStub;

class CoordinatorRequestValidator;
class CoordinatorResponseValidator;


class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) Coordinator
    : public CoordinatorInterfaceBase { … };

class CoordinatorConnectorProxy;

template <typename ImplRefTraits>
class CoordinatorConnectorStub;

class CoordinatorConnectorRequestValidator;


class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) CoordinatorConnector
    : public CoordinatorConnectorInterfaceBase { … };



class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) ClientProcessProxy
    : public ClientProcess { … };



class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) HeapProfilerProxy
    : public HeapProfiler { … };



class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) HeapProfilerHelperProxy
    : public HeapProfilerHelper { … };



class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) CoordinatorProxy
    : public Coordinator { … };



class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) CoordinatorConnectorProxy
    : public CoordinatorConnector { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) ClientProcessStubDispatch { … };

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

  ClientProcessStub() = default;
  ~ClientProcessStub() 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 COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) HeapProfilerStubDispatch { … };

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

  HeapProfilerStub() = default;
  ~HeapProfilerStub() 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 COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) HeapProfilerHelperStubDispatch { … };

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

  HeapProfilerHelperStub() = default;
  ~HeapProfilerHelperStub() 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 COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) CoordinatorStubDispatch { … };

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

  CoordinatorStub() = default;
  ~CoordinatorStub() 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 COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) CoordinatorConnectorStubDispatch { … };

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

  CoordinatorConnectorStub() = default;
  ~CoordinatorConnectorStub() 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 COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) ClientProcessRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) HeapProfilerRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) HeapProfilerHelperRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) CoordinatorRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) CoordinatorConnectorRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) ClientProcessResponseValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) HeapProfilerResponseValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) HeapProfilerHelperResponseValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) CoordinatorResponseValidator : public mojo::MessageReceiver { … };





class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) RequestArgs { … };

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

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

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

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





class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) RawAllocatorDumpEdge { … };

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

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

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

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














class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) AggregatedMetrics { … };

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

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

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

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







class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) RawAllocatorDumpEntryValue { … };







class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) RawAllocatorDumpEntry { … };

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

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

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

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





class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) RawAllocatorDump { … };

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

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

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

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





class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) RawProcessMemoryDump { … };

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

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

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

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





class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) VmRegion { … };

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

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

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

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





class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) PlatformPrivateFootprint { … };

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

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

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

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





class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) RawOSMemDump { … };

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

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

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

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





class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) OSMemDump { … };

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

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

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

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





class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) AllocatorMemDump { … };

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

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

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

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





class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) ProcessMemoryDump { … };

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

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

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

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






class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) GlobalMemoryDump { … };

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

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

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

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





class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) HeapProfileResult { … };

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

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

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

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

template <typename UnionPtrType>
RawAllocatorDumpEntryValuePtr RawAllocatorDumpEntryValue::Clone() const { … }

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

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

template <typename T, RequestArgs::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
RawAllocatorDumpEdgePtr RawAllocatorDumpEdge::Clone() const { … }

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

template <typename T, RawAllocatorDumpEdge::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
RawAllocatorDumpEntryPtr RawAllocatorDumpEntry::Clone() const { … }

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

template <typename T, RawAllocatorDumpEntry::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
RawAllocatorDumpPtr RawAllocatorDump::Clone() const { … }

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

template <typename T, RawAllocatorDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
RawProcessMemoryDumpPtr RawProcessMemoryDump::Clone() const { … }

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

template <typename T, RawProcessMemoryDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VmRegionPtr VmRegion::Clone() const { … }

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

template <typename T, VmRegion::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
PlatformPrivateFootprintPtr PlatformPrivateFootprint::Clone() const { … }

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

template <typename T, PlatformPrivateFootprint::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
RawOSMemDumpPtr RawOSMemDump::Clone() const { … }

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

template <typename T, RawOSMemDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
OSMemDumpPtr OSMemDump::Clone() const { … }

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

template <typename T, OSMemDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
AllocatorMemDumpPtr AllocatorMemDump::Clone() const { … }

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

template <typename T, AllocatorMemDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
ProcessMemoryDumpPtr ProcessMemoryDump::Clone() const { … }

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

template <typename T, ProcessMemoryDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
AggregatedMetricsPtr AggregatedMetrics::Clone() const { … }

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

template <typename T, AggregatedMetrics::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
GlobalMemoryDumpPtr GlobalMemoryDump::Clone() const { … }

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

template <typename T, GlobalMemoryDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
HeapProfileResultPtr HeapProfileResult::Clone() const { … }

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

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


}  // memory_instrumentation::mojom::blink

namespace mojo {


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::RequestArgs::DataView,
                                         ::memory_instrumentation::mojom::blink::RequestArgsPtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::RawAllocatorDumpEdge::DataView,
                                         ::memory_instrumentation::mojom::blink::RawAllocatorDumpEdgePtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::RawAllocatorDumpEntry::DataView,
                                         ::memory_instrumentation::mojom::blink::RawAllocatorDumpEntryPtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::RawAllocatorDump::DataView,
                                         ::memory_instrumentation::mojom::blink::RawAllocatorDumpPtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::RawProcessMemoryDump::DataView,
                                         ::memory_instrumentation::mojom::blink::RawProcessMemoryDumpPtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::VmRegion::DataView,
                                         ::memory_instrumentation::mojom::blink::VmRegionPtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::PlatformPrivateFootprint::DataView,
                                         ::memory_instrumentation::mojom::blink::PlatformPrivateFootprintPtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::RawOSMemDump::DataView,
                                         ::memory_instrumentation::mojom::blink::RawOSMemDumpPtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::OSMemDump::DataView,
                                         ::memory_instrumentation::mojom::blink::OSMemDumpPtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::AllocatorMemDump::DataView,
                                         ::memory_instrumentation::mojom::blink::AllocatorMemDumpPtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::ProcessMemoryDump::DataView,
                                         ::memory_instrumentation::mojom::blink::ProcessMemoryDumpPtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::AggregatedMetrics::DataView,
                                         ::memory_instrumentation::mojom::blink::AggregatedMetricsPtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::GlobalMemoryDump::DataView,
                                         ::memory_instrumentation::mojom::blink::GlobalMemoryDumpPtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) StructTraits<::memory_instrumentation::mojom::blink::HeapProfileResult::DataView,
                                         ::memory_instrumentation::mojom::blink::HeapProfileResultPtr> { … };


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM_BLINK) UnionTraits<::memory_instrumentation::mojom::blink::RawAllocatorDumpEntryValue::DataView,
                                        ::memory_instrumentation::mojom::blink::RawAllocatorDumpEntryValuePtr> { … };

}  // namespace mojo

#endif  // SERVICES_RESOURCE_COORDINATOR_PUBLIC_MOJOM_MEMORY_INSTRUMENTATION_MEMORY_INSTRUMENTATION_MOJOM_BLINK_H_