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

// services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.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 SERVICES_RESOURCE_COORDINATOR_PUBLIC_MOJOM_MEMORY_INSTRUMENTATION_MEMORY_INSTRUMENTATION_MOJOM_H_
#define SERVICES_RESOURCE_COORDINATOR_PUBLIC_MOJOM_MEMORY_INSTRUMENTATION_MEMORY_INSTRUMENTATION_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 "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-forward.h"  // IWYU pragma: export
#include "mojo/public/mojom/base/big_string.mojom.h"
#include "mojo/public/mojom/base/process_id.mojom.h"
#include "mojo/public/mojom/base/time.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 "services/resource_coordinator/public/cpp/memory_instrumentation/memory_instrumentation_mojom_traits.h"
#include "base/component_export.h"




namespace memory_instrumentation::mojom {

class ClientProcessProxy;

template <typename ImplRefTraits>
class ClientProcessStub;

class ClientProcessRequestValidator;
class ClientProcessResponseValidator;


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

class HeapProfilerProxy;

template <typename ImplRefTraits>
class HeapProfilerStub;

class HeapProfilerRequestValidator;
class HeapProfilerResponseValidator;


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

class HeapProfilerHelperProxy;

template <typename ImplRefTraits>
class HeapProfilerHelperStub;

class HeapProfilerHelperRequestValidator;
class HeapProfilerHelperResponseValidator;


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

class CoordinatorProxy;

template <typename ImplRefTraits>
class CoordinatorStub;

class CoordinatorRequestValidator;
class CoordinatorResponseValidator;


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

class CoordinatorConnectorProxy;

template <typename ImplRefTraits>
class CoordinatorConnectorStub;

class CoordinatorConnectorRequestValidator;


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



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



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



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



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



class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) CoordinatorConnectorProxy
    : public CoordinatorConnector { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) 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) 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) 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) 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) 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) ClientProcessRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfilerRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfilerHelperRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) CoordinatorRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) CoordinatorConnectorRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) ClientProcessResponseValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfilerResponseValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfilerHelperResponseValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) CoordinatorResponseValidator : public mojo::MessageReceiver { … };





class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) 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) 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) 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) RawAllocatorDumpEntryValue { … };







class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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

namespace mojo {


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

}  // namespace mojo

#endif  // SERVICES_RESOURCE_COORDINATOR_PUBLIC_MOJOM_MEMORY_INSTRUMENTATION_MEMORY_INSTRUMENTATION_MOJOM_H_