win-Debug/gen/services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom.h

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

#ifndef SERVICES_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 <type_traits>
#include <utility>

#include "base/callback.h"
#include "base/macros.h"
#include "base/optional.h"

#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#if BUILDFLAG(MOJO_TRACE_ENABLED)
#include "base/trace_event/trace_event.h"
#endif
#include "mojo/public/cpp/bindings/clone_traits.h"
#include "mojo/public/cpp/bindings/equals_traits.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/struct_ptr.h"
#include "mojo/public/cpp/bindings/struct_traits.h"
#include "mojo/public/cpp/bindings/union_traits.h"
#include "services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom-shared.h"
#include "services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom-forward.h"
#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/associated_interface_ptr.h"
#include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
#include "mojo/public/cpp/bindings/associated_interface_request.h"
#include "mojo/public/cpp/bindings/interface_ptr.h"
#include "mojo/public/cpp/bindings/interface_request.h"
#include "mojo/public/cpp/bindings/lib/control_message_handler.h"
#include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"
#include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h"


#include "mojo/public/cpp/bindings/lib/native_enum_serialization.h"
#include "mojo/public/cpp/bindings/lib/native_struct_serialization.h"
#include "base/trace_event/memory_allocator_dump.h"
#include "base/trace_event/memory_dump_manager.h"
#include "base/trace_event/memory_dump_request_args.h"
#include "base/trace_event/process_memory_dump.h"
#include "base/component_export.h"

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


namespace memory_instrumentation {
namespace mojom {

class ClientProcessProxy;

template <typename ImplRefTraits>
class ClientProcessStub;

class ClientProcessRequestValidator;
class ClientProcessResponseValidator;


// @generated_from: memory_instrumentation.mojom.ClientProcess
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) ClientProcess
    : public ClientProcessInterfaceBase {
 public:
  static const char Name_[];
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasSyncMethods_ = false;

  using Base_ = ClientProcessInterfaceBase;
  using Proxy_ = ClientProcessProxy;

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

  using RequestValidator_ = ClientProcessRequestValidator;
  using ResponseValidator_ = ClientProcessResponseValidator;
  enum MethodMinVersions : uint32_t {
    kRequestChromeMemoryDumpMinVersion = 0,
    kRequestOSMemoryDumpMinVersion = 0,
  };
  virtual ~ClientProcess() {}


  using RequestChromeMemoryDumpCallback = base::OnceCallback<void(bool, uint64_t, std::unique_ptr<base::trace_event::ProcessMemoryDump>)>;
  
// @generated_from: memory_instrumentation.mojom.ClientProcess.RequestChromeMemoryDump
  virtual void RequestChromeMemoryDump(const base::trace_event::MemoryDumpRequestArgs& args, RequestChromeMemoryDumpCallback callback) = 0;


  using RequestOSMemoryDumpCallback = base::OnceCallback<void(bool, base::flat_map<base::ProcessId, RawOSMemDumpPtr>)>;
  
// @generated_from: memory_instrumentation.mojom.ClientProcess.RequestOSMemoryDump
  virtual void RequestOSMemoryDump(MemoryMapOption option, const std::vector<base::ProcessId>& pids, RequestOSMemoryDumpCallback callback) = 0;
};

class HeapProfilerProxy;

template <typename ImplRefTraits>
class HeapProfilerStub;

class HeapProfilerRequestValidator;
class HeapProfilerResponseValidator;


// @generated_from: memory_instrumentation.mojom.HeapProfiler
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfiler
    : public HeapProfilerInterfaceBase {
 public:
  static const char Name_[];
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasSyncMethods_ = false;

  using Base_ = HeapProfilerInterfaceBase;
  using Proxy_ = HeapProfilerProxy;

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

  using RequestValidator_ = HeapProfilerRequestValidator;
  using ResponseValidator_ = HeapProfilerResponseValidator;
  enum MethodMinVersions : uint32_t {
    kDumpProcessesForTracingMinVersion = 0,
  };
  virtual ~HeapProfiler() {}


  using DumpProcessesForTracingCallback = base::OnceCallback<void(std::vector<HeapProfileResultPtr>)>;
  
// @generated_from: memory_instrumentation.mojom.HeapProfiler.DumpProcessesForTracing
  virtual void DumpProcessesForTracing(bool strip_path_from_mapped_files, DumpProcessesForTracingCallback callback) = 0;
};

class HeapProfilerHelperProxy;

template <typename ImplRefTraits>
class HeapProfilerHelperStub;

class HeapProfilerHelperRequestValidator;
class HeapProfilerHelperResponseValidator;


// @generated_from: memory_instrumentation.mojom.HeapProfilerHelper
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfilerHelper
    : public HeapProfilerHelperInterfaceBase {
 public:
  static const char Name_[];
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasSyncMethods_ = false;

  using Base_ = HeapProfilerHelperInterfaceBase;
  using Proxy_ = HeapProfilerHelperProxy;

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

  using RequestValidator_ = HeapProfilerHelperRequestValidator;
  using ResponseValidator_ = HeapProfilerHelperResponseValidator;
  enum MethodMinVersions : uint32_t {
    kGetVmRegionsForHeapProfilerMinVersion = 0,
  };
  virtual ~HeapProfilerHelper() {}


  using GetVmRegionsForHeapProfilerCallback = base::OnceCallback<void(base::flat_map<base::ProcessId, std::vector<VmRegionPtr>>)>;
  
// @generated_from: memory_instrumentation.mojom.HeapProfilerHelper.GetVmRegionsForHeapProfiler
  virtual void GetVmRegionsForHeapProfiler(const std::vector<base::ProcessId>& pids, GetVmRegionsForHeapProfilerCallback callback) = 0;
};

class CoordinatorProxy;

template <typename ImplRefTraits>
class CoordinatorStub;

class CoordinatorRequestValidator;
class CoordinatorResponseValidator;


// @generated_from: memory_instrumentation.mojom.Coordinator
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) Coordinator
    : public CoordinatorInterfaceBase {
 public:
  static const char Name_[];
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasSyncMethods_ = false;

  using Base_ = CoordinatorInterfaceBase;
  using Proxy_ = CoordinatorProxy;

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

  using RequestValidator_ = CoordinatorRequestValidator;
  using ResponseValidator_ = CoordinatorResponseValidator;
  enum MethodMinVersions : uint32_t {
    kRegisterClientProcessMinVersion = 0,
    kRequestGlobalMemoryDumpMinVersion = 0,
    kRequestGlobalMemoryDumpForPidMinVersion = 0,
    kRequestPrivateMemoryFootprintMinVersion = 0,
    kRequestGlobalMemoryDumpAndAppendToTraceMinVersion = 0,
    kRegisterHeapProfilerMinVersion = 0,
  };
  virtual ~Coordinator() {}

  
// @generated_from: memory_instrumentation.mojom.Coordinator.RegisterClientProcess
  virtual void RegisterClientProcess(ClientProcessPtr client_process, ProcessType process_type) = 0;


  using RequestGlobalMemoryDumpCallback = base::OnceCallback<void(bool, GlobalMemoryDumpPtr)>;
  
// @generated_from: memory_instrumentation.mojom.Coordinator.RequestGlobalMemoryDump
  virtual void RequestGlobalMemoryDump(base::trace_event::MemoryDumpType dump_type, base::trace_event::MemoryDumpLevelOfDetail level_of_detail, const std::vector<std::string>& allocator_dump_names, RequestGlobalMemoryDumpCallback callback) = 0;


  using RequestGlobalMemoryDumpForPidCallback = base::OnceCallback<void(bool, GlobalMemoryDumpPtr)>;
  
// @generated_from: memory_instrumentation.mojom.Coordinator.RequestGlobalMemoryDumpForPid
  virtual void RequestGlobalMemoryDumpForPid(base::ProcessId pid, const std::vector<std::string>& allocator_dump_names, RequestGlobalMemoryDumpForPidCallback callback) = 0;


  using RequestPrivateMemoryFootprintCallback = base::OnceCallback<void(bool, GlobalMemoryDumpPtr)>;
  
// @generated_from: memory_instrumentation.mojom.Coordinator.RequestPrivateMemoryFootprint
  virtual void RequestPrivateMemoryFootprint(base::ProcessId pid, RequestPrivateMemoryFootprintCallback callback) = 0;


  using RequestGlobalMemoryDumpAndAppendToTraceCallback = base::OnceCallback<void(bool, uint64_t)>;
  
// @generated_from: memory_instrumentation.mojom.Coordinator.RequestGlobalMemoryDumpAndAppendToTrace
  virtual void RequestGlobalMemoryDumpAndAppendToTrace(base::trace_event::MemoryDumpType dump_type, base::trace_event::MemoryDumpLevelOfDetail level_of_detail, RequestGlobalMemoryDumpAndAppendToTraceCallback callback) = 0;

  
// @generated_from: memory_instrumentation.mojom.Coordinator.RegisterHeapProfiler
  virtual void RegisterHeapProfiler(HeapProfilerPtr heap_profiler) = 0;
};

class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) ClientProcessProxy
    : public ClientProcess {
 public:
  using InterfaceType = ClientProcess;

  explicit ClientProcessProxy(mojo::MessageReceiverWithResponder* receiver);
  void RequestChromeMemoryDump(const base::trace_event::MemoryDumpRequestArgs& args, RequestChromeMemoryDumpCallback callback) final;
  void RequestOSMemoryDump(MemoryMapOption option, const std::vector<base::ProcessId>& pids, RequestOSMemoryDumpCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};

class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfilerProxy
    : public HeapProfiler {
 public:
  using InterfaceType = HeapProfiler;

  explicit HeapProfilerProxy(mojo::MessageReceiverWithResponder* receiver);
  void DumpProcessesForTracing(bool strip_path_from_mapped_files, DumpProcessesForTracingCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};

class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfilerHelperProxy
    : public HeapProfilerHelper {
 public:
  using InterfaceType = HeapProfilerHelper;

  explicit HeapProfilerHelperProxy(mojo::MessageReceiverWithResponder* receiver);
  void GetVmRegionsForHeapProfiler(const std::vector<base::ProcessId>& pids, GetVmRegionsForHeapProfilerCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};

class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) CoordinatorProxy
    : public Coordinator {
 public:
  using InterfaceType = Coordinator;

  explicit CoordinatorProxy(mojo::MessageReceiverWithResponder* receiver);
  void RegisterClientProcess(ClientProcessPtr client_process, ProcessType process_type) final;
  void RequestGlobalMemoryDump(base::trace_event::MemoryDumpType dump_type, base::trace_event::MemoryDumpLevelOfDetail level_of_detail, const std::vector<std::string>& allocator_dump_names, RequestGlobalMemoryDumpCallback callback) final;
  void RequestGlobalMemoryDumpForPid(base::ProcessId pid, const std::vector<std::string>& allocator_dump_names, RequestGlobalMemoryDumpForPidCallback callback) final;
  void RequestPrivateMemoryFootprint(base::ProcessId pid, RequestPrivateMemoryFootprintCallback callback) final;
  void RequestGlobalMemoryDumpAndAppendToTrace(base::trace_event::MemoryDumpType dump_type, base::trace_event::MemoryDumpLevelOfDetail level_of_detail, RequestGlobalMemoryDumpAndAppendToTraceCallback callback) final;
  void RegisterHeapProfiler(HeapProfilerPtr heap_profiler) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) ClientProcessStubDispatch {
 public:
  static bool Accept(ClientProcess* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      ClientProcess* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

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

  ClientProcessStub() {}
  ~ClientProcessStub() override {}

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

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

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

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfilerStubDispatch {
 public:
  static bool Accept(HeapProfiler* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      HeapProfiler* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

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

  HeapProfilerStub() {}
  ~HeapProfilerStub() override {}

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

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

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

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfilerHelperStubDispatch {
 public:
  static bool Accept(HeapProfilerHelper* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      HeapProfilerHelper* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

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

  HeapProfilerHelperStub() {}
  ~HeapProfilerHelperStub() override {}

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

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

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

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) CoordinatorStubDispatch {
 public:
  static bool Accept(Coordinator* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      Coordinator* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

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

  CoordinatorStub() {}
  ~CoordinatorStub() override {}

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

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

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

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) ClientProcessRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfilerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfilerHelperRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) CoordinatorRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) ClientProcessResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfilerResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfilerHelperResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) CoordinatorResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};





// @generated_from: memory_instrumentation.mojom.RequestArgs
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) RequestArgs {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<RequestArgs, T>::value>;
  using DataView = RequestArgsDataView;
  using Data_ = internal::RequestArgs_Data;

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

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

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


  RequestArgs();

  RequestArgs(
      uint64_t dump_guid,
      base::trace_event::MemoryDumpType dump_type,
      base::trace_event::MemoryDumpLevelOfDetail level_of_detail);

  ~RequestArgs();

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

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return RequestArgs::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.RequestArgs.dump_guid
  uint64_t dump_guid;
  
// @generated_from: memory_instrumentation.mojom.RequestArgs.dump_type
  base::trace_event::MemoryDumpType dump_type;
  
// @generated_from: memory_instrumentation.mojom.RequestArgs.level_of_detail
  base::trace_event::MemoryDumpLevelOfDetail level_of_detail;

 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, 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) {
  return !(rhs < lhs);
}

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

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





// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEdge
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) RawAllocatorDumpEdge {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<RawAllocatorDumpEdge, T>::value>;
  using DataView = RawAllocatorDumpEdgeDataView;
  using Data_ = internal::RawAllocatorDumpEdge_Data;

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

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

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


  RawAllocatorDumpEdge();

  RawAllocatorDumpEdge(
      uint64_t source_id,
      uint64_t target_id,
      int32_t importance,
      bool overridable);

  ~RawAllocatorDumpEdge();

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

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return RawAllocatorDumpEdge::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEdge.source_id
  uint64_t source_id;
  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEdge.target_id
  uint64_t target_id;
  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEdge.importance
  int32_t importance;
  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEdge.overridable
  bool overridable;

 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, 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) {
  return !(rhs < lhs);
}

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

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














// @generated_from: memory_instrumentation.mojom.AggregatedMetrics
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) AggregatedMetrics {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<AggregatedMetrics, T>::value>;
  using DataView = AggregatedMetricsDataView;
  using Data_ = internal::AggregatedMetrics_Data;

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

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

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


  AggregatedMetrics();

  AggregatedMetrics(
      int32_t native_library_resident_kb,
      int32_t native_library_resident_not_ordered_kb,
      int32_t native_library_not_resident_ordered_kb);

  ~AggregatedMetrics();

  // 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 = AggregatedMetricsPtr>
  AggregatedMetricsPtr 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, AggregatedMetrics::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;
  size_t Hash(size_t seed) const;

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return AggregatedMetrics::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.AggregatedMetrics.native_library_resident_kb
  int32_t native_library_resident_kb;
  
// @generated_from: memory_instrumentation.mojom.AggregatedMetrics.native_library_resident_not_ordered_kb
  int32_t native_library_resident_not_ordered_kb;
  
// @generated_from: memory_instrumentation.mojom.AggregatedMetrics.native_library_not_resident_ordered_kb
  int32_t native_library_not_resident_ordered_kb;

 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, 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) {
  return !(rhs < lhs);
}

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

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







// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEntryValue
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) RawAllocatorDumpEntryValue {
 public:
  using DataView = RawAllocatorDumpEntryValueDataView;
  using Data_ = internal::RawAllocatorDumpEntryValue_Data;
  using Tag = Data_::RawAllocatorDumpEntryValue_Tag;

  static RawAllocatorDumpEntryValuePtr New() {
    return RawAllocatorDumpEntryValuePtr(base::in_place);
  }
  // Construct an instance holding |value_uint64|.
  static RawAllocatorDumpEntryValuePtr
  NewValueUint64(
      uint64_t value_uint64) {
    auto result = RawAllocatorDumpEntryValuePtr(base::in_place);
    result->set_value_uint64(std::move(value_uint64));
    return result;
  }
  // Construct an instance holding |value_string|.
  static RawAllocatorDumpEntryValuePtr
  NewValueString(
      const std::string& value_string) {
    auto result = RawAllocatorDumpEntryValuePtr(base::in_place);
    result->set_value_string(std::move(value_string));
    return result;
  }

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

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

  RawAllocatorDumpEntryValue();
  ~RawAllocatorDumpEntryValue();

  // 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 UnionPtrType = RawAllocatorDumpEntryValuePtr>
  RawAllocatorDumpEntryValuePtr 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,
            typename std::enable_if<std::is_same<
                T, RawAllocatorDumpEntryValue>::value>::type* = nullptr>
  bool Equals(const T& other) const;
  size_t Hash(size_t seed) const;

  Tag which() const {
    return tag_;
  }


  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEntryValue.value_uint64
  bool is_value_uint64() const { return tag_ == Tag::VALUE_UINT64; }

  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEntryValue.value_uint64
  uint64_t get_value_uint64() const {
    DCHECK(tag_ == Tag::VALUE_UINT64);
    return data_.value_uint64;
  }

  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEntryValue.value_uint64
  void set_value_uint64(
      uint64_t value_uint64);
  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEntryValue.value_string
  bool is_value_string() const { return tag_ == Tag::VALUE_STRING; }

  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEntryValue.value_string
  std::string& get_value_string() const {
    DCHECK(tag_ == Tag::VALUE_STRING);
    return *(data_.value_string);
  }

  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEntryValue.value_string
  void set_value_string(
      const std::string& value_string);

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        RawAllocatorDumpEntryValue::DataView>(input);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<RawAllocatorDumpEntryValue::DataView>(
        input.payload(), input.payload_num_bytes(),
        std::move(*input.mutable_handles()), output, Validate);
  }

 private:
  union Union_ {
    Union_() {}
    ~Union_() {}
    uint64_t value_uint64;
    std::string* value_string;
  };

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

  void DestroyActive();
  Tag tag_;
  Union_ data_;
};







// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEntry
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) RawAllocatorDumpEntry {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<RawAllocatorDumpEntry, T>::value>;
  using DataView = RawAllocatorDumpEntryDataView;
  using Data_ = internal::RawAllocatorDumpEntry_Data;

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

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

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


  RawAllocatorDumpEntry();

  RawAllocatorDumpEntry(
      const std::string& name,
      const std::string& units,
      RawAllocatorDumpEntryValuePtr value);

  ~RawAllocatorDumpEntry();

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

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return RawAllocatorDumpEntry::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEntry.name
  std::string name;
  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEntry.units
  std::string units;
  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDumpEntry.value
  RawAllocatorDumpEntryValuePtr value;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
  DISALLOW_COPY_AND_ASSIGN(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) {
  return !(rhs < lhs);
}

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

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





// @generated_from: memory_instrumentation.mojom.RawAllocatorDump
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) RawAllocatorDump {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<RawAllocatorDump, T>::value>;
  using DataView = RawAllocatorDumpDataView;
  using Data_ = internal::RawAllocatorDump_Data;

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

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

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


  RawAllocatorDump();

  RawAllocatorDump(
      uint64_t id,
      const std::string& absolute_name,
      bool weak,
      base::trace_event::MemoryDumpLevelOfDetail level_of_detail,
      std::vector<base::trace_event::MemoryAllocatorDump::Entry> entries);

  ~RawAllocatorDump();

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

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return RawAllocatorDump::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDump.id
  uint64_t id;
  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDump.absolute_name
  std::string absolute_name;
  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDump.weak
  bool weak;
  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDump.level_of_detail
  base::trace_event::MemoryDumpLevelOfDetail level_of_detail;
  
// @generated_from: memory_instrumentation.mojom.RawAllocatorDump.entries
  std::vector<base::trace_event::MemoryAllocatorDump::Entry> entries;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
  DISALLOW_COPY_AND_ASSIGN(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) {
  return !(rhs < lhs);
}

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

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





// @generated_from: memory_instrumentation.mojom.RawProcessMemoryDump
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) RawProcessMemoryDump {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<RawProcessMemoryDump, T>::value>;
  using DataView = RawProcessMemoryDumpDataView;
  using Data_ = internal::RawProcessMemoryDump_Data;

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

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

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


  RawProcessMemoryDump();

  RawProcessMemoryDump(
      base::trace_event::MemoryDumpLevelOfDetail level_of_detail,
      const std::vector<base::trace_event::ProcessMemoryDump::MemoryAllocatorDumpEdge>& allocator_dump_edges,
      std::vector<std::unique_ptr<base::trace_event::MemoryAllocatorDump>> allocator_dumps);

  ~RawProcessMemoryDump();

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

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return RawProcessMemoryDump::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.RawProcessMemoryDump.level_of_detail
  base::trace_event::MemoryDumpLevelOfDetail level_of_detail;
  
// @generated_from: memory_instrumentation.mojom.RawProcessMemoryDump.allocator_dump_edges
  std::vector<base::trace_event::ProcessMemoryDump::MemoryAllocatorDumpEdge> allocator_dump_edges;
  
// @generated_from: memory_instrumentation.mojom.RawProcessMemoryDump.allocator_dumps
  std::vector<std::unique_ptr<base::trace_event::MemoryAllocatorDump>> allocator_dumps;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
  DISALLOW_COPY_AND_ASSIGN(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) {
  return !(rhs < lhs);
}

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

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





// @generated_from: memory_instrumentation.mojom.VmRegion
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) VmRegion {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<VmRegion, T>::value>;
  using DataView = VmRegionDataView;
  using Data_ = internal::VmRegion_Data;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.kProtectionFlagsRead
  static constexpr uint32_t kProtectionFlagsRead = 4U;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.kProtectionFlagsWrite
  static constexpr uint32_t kProtectionFlagsWrite = 2U;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.kProtectionFlagsExec
  static constexpr uint32_t kProtectionFlagsExec = 1U;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.kProtectionFlagsMayshare
  static constexpr uint32_t kProtectionFlagsMayshare = 128U;

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

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

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


  VmRegion();

  VmRegion(
      uint64_t start_address,
      uint64_t size_in_bytes,
      uint64_t module_timestamp,
      const std::string& module_debugid,
      const std::string& module_debug_path,
      uint32_t protection_flags,
      const std::string& mapped_file,
      uint64_t byte_stats_private_dirty_resident,
      uint64_t byte_stats_private_clean_resident,
      uint64_t byte_stats_shared_dirty_resident,
      uint64_t byte_stats_shared_clean_resident,
      uint64_t byte_stats_swapped,
      uint64_t byte_stats_proportional_resident);

  ~VmRegion();

  // 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 = VmRegionPtr>
  VmRegionPtr 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, VmRegion::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;
  size_t Hash(size_t seed) const;

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return VmRegion::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.VmRegion.start_address
  uint64_t start_address;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.size_in_bytes
  uint64_t size_in_bytes;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.module_timestamp
  uint64_t module_timestamp;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.module_debugid
  std::string module_debugid;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.module_debug_path
  std::string module_debug_path;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.protection_flags
  uint32_t protection_flags;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.mapped_file
  std::string mapped_file;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.byte_stats_private_dirty_resident
  uint64_t byte_stats_private_dirty_resident;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.byte_stats_private_clean_resident
  uint64_t byte_stats_private_clean_resident;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.byte_stats_shared_dirty_resident
  uint64_t byte_stats_shared_dirty_resident;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.byte_stats_shared_clean_resident
  uint64_t byte_stats_shared_clean_resident;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.byte_stats_swapped
  uint64_t byte_stats_swapped;
  
// @generated_from: memory_instrumentation.mojom.VmRegion.byte_stats_proportional_resident
  uint64_t byte_stats_proportional_resident;

 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, 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) {
  return !(rhs < lhs);
}

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

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





// @generated_from: memory_instrumentation.mojom.PlatformPrivateFootprint
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) PlatformPrivateFootprint {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<PlatformPrivateFootprint, T>::value>;
  using DataView = PlatformPrivateFootprintDataView;
  using Data_ = internal::PlatformPrivateFootprint_Data;

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

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

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


  PlatformPrivateFootprint();

  PlatformPrivateFootprint(
      uint64_t phys_footprint_bytes,
      uint64_t internal_bytes,
      uint64_t compressed_bytes,
      uint64_t rss_anon_bytes,
      uint64_t vm_swap_bytes,
      uint64_t private_bytes);

  ~PlatformPrivateFootprint();

  // 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 = PlatformPrivateFootprintPtr>
  PlatformPrivateFootprintPtr 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, PlatformPrivateFootprint::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;
  size_t Hash(size_t seed) const;

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return PlatformPrivateFootprint::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.PlatformPrivateFootprint.phys_footprint_bytes
  uint64_t phys_footprint_bytes;
  
// @generated_from: memory_instrumentation.mojom.PlatformPrivateFootprint.internal_bytes
  uint64_t internal_bytes;
  
// @generated_from: memory_instrumentation.mojom.PlatformPrivateFootprint.compressed_bytes
  uint64_t compressed_bytes;
  
// @generated_from: memory_instrumentation.mojom.PlatformPrivateFootprint.rss_anon_bytes
  uint64_t rss_anon_bytes;
  
// @generated_from: memory_instrumentation.mojom.PlatformPrivateFootprint.vm_swap_bytes
  uint64_t vm_swap_bytes;
  
// @generated_from: memory_instrumentation.mojom.PlatformPrivateFootprint.private_bytes
  uint64_t private_bytes;

 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, 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) {
  return !(rhs < lhs);
}

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

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





// @generated_from: memory_instrumentation.mojom.RawOSMemDump
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) RawOSMemDump {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<RawOSMemDump, T>::value>;
  using DataView = RawOSMemDumpDataView;
  using Data_ = internal::RawOSMemDump_Data;

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

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

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


  RawOSMemDump();

  RawOSMemDump(
      uint32_t resident_set_kb,
      uint32_t peak_resident_set_kb,
      bool is_peak_rss_resettable,
      PlatformPrivateFootprintPtr platform_private_footprint,
      std::vector<VmRegionPtr> memory_maps,
      const std::vector<uint8_t>& native_library_pages_bitmap);

  ~RawOSMemDump();

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

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return RawOSMemDump::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.RawOSMemDump.resident_set_kb
  uint32_t resident_set_kb;
  
// @generated_from: memory_instrumentation.mojom.RawOSMemDump.peak_resident_set_kb
  uint32_t peak_resident_set_kb;
  
// @generated_from: memory_instrumentation.mojom.RawOSMemDump.is_peak_rss_resettable
  bool is_peak_rss_resettable;
  
// @generated_from: memory_instrumentation.mojom.RawOSMemDump.platform_private_footprint
  PlatformPrivateFootprintPtr platform_private_footprint;
  
// @generated_from: memory_instrumentation.mojom.RawOSMemDump.memory_maps
  std::vector<VmRegionPtr> memory_maps;
  
// @generated_from: memory_instrumentation.mojom.RawOSMemDump.native_library_pages_bitmap
  std::vector<uint8_t> native_library_pages_bitmap;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
  DISALLOW_COPY_AND_ASSIGN(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) {
  return !(rhs < lhs);
}

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

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





// @generated_from: memory_instrumentation.mojom.OSMemDump
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) OSMemDump {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<OSMemDump, T>::value>;
  using DataView = OSMemDumpDataView;
  using Data_ = internal::OSMemDump_Data;

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

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

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


  OSMemDump();

  OSMemDump(
      uint32_t resident_set_kb,
      uint32_t peak_resident_set_kb,
      bool is_peak_rss_resettable,
      uint32_t private_footprint_kb,
      uint32_t shared_footprint_kb);

  ~OSMemDump();

  // 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 = OSMemDumpPtr>
  OSMemDumpPtr 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, OSMemDump::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;
  size_t Hash(size_t seed) const;

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return OSMemDump::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.OSMemDump.resident_set_kb
  uint32_t resident_set_kb;
  
// @generated_from: memory_instrumentation.mojom.OSMemDump.peak_resident_set_kb
  uint32_t peak_resident_set_kb;
  
// @generated_from: memory_instrumentation.mojom.OSMemDump.is_peak_rss_resettable
  bool is_peak_rss_resettable;
  
// @generated_from: memory_instrumentation.mojom.OSMemDump.private_footprint_kb
  uint32_t private_footprint_kb;
  
// @generated_from: memory_instrumentation.mojom.OSMemDump.shared_footprint_kb
  uint32_t shared_footprint_kb;

 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, 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) {
  return !(rhs < lhs);
}

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

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





// @generated_from: memory_instrumentation.mojom.AllocatorMemDump
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) AllocatorMemDump {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<AllocatorMemDump, T>::value>;
  using DataView = AllocatorMemDumpDataView;
  using Data_ = internal::AllocatorMemDump_Data;

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

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

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


  AllocatorMemDump();

  explicit AllocatorMemDump(
      const base::flat_map<std::string, uint64_t>& numeric_entries);

  ~AllocatorMemDump();

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

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return AllocatorMemDump::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.AllocatorMemDump.numeric_entries
  base::flat_map<std::string, uint64_t> numeric_entries;

 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, 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) {
  return !(rhs < lhs);
}

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

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





// @generated_from: memory_instrumentation.mojom.ProcessMemoryDump
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) ProcessMemoryDump {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ProcessMemoryDump, T>::value>;
  using DataView = ProcessMemoryDumpDataView;
  using Data_ = internal::ProcessMemoryDump_Data;

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

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

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


  ProcessMemoryDump();

  ProcessMemoryDump(
      ProcessType process_type,
      OSMemDumpPtr os_dump,
      base::flat_map<std::string, AllocatorMemDumpPtr> chrome_allocator_dumps,
      base::ProcessId pid,
      const std::vector<std::string>& service_names);

  ~ProcessMemoryDump();

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

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return ProcessMemoryDump::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.ProcessMemoryDump.process_type
  ProcessType process_type;
  
// @generated_from: memory_instrumentation.mojom.ProcessMemoryDump.os_dump
  OSMemDumpPtr os_dump;
  
// @generated_from: memory_instrumentation.mojom.ProcessMemoryDump.chrome_allocator_dumps
  base::flat_map<std::string, AllocatorMemDumpPtr> chrome_allocator_dumps;
  
// @generated_from: memory_instrumentation.mojom.ProcessMemoryDump.pid
  base::ProcessId pid;
  
// @generated_from: memory_instrumentation.mojom.ProcessMemoryDump.service_names
  std::vector<std::string> service_names;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
  DISALLOW_COPY_AND_ASSIGN(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) {
  return !(rhs < lhs);
}

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

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






// @generated_from: memory_instrumentation.mojom.GlobalMemoryDump
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) GlobalMemoryDump {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GlobalMemoryDump, T>::value>;
  using DataView = GlobalMemoryDumpDataView;
  using Data_ = internal::GlobalMemoryDump_Data;

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

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

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


  GlobalMemoryDump();

  GlobalMemoryDump(
      base::TimeTicks start_time,
      std::vector<ProcessMemoryDumpPtr> process_dumps,
      AggregatedMetricsPtr aggregated_metrics);

  ~GlobalMemoryDump();

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

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return GlobalMemoryDump::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.GlobalMemoryDump.start_time
  base::TimeTicks start_time;
  
// @generated_from: memory_instrumentation.mojom.GlobalMemoryDump.process_dumps
  std::vector<ProcessMemoryDumpPtr> process_dumps;
  
// @generated_from: memory_instrumentation.mojom.GlobalMemoryDump.aggregated_metrics
  AggregatedMetricsPtr aggregated_metrics;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
  DISALLOW_COPY_AND_ASSIGN(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) {
  return !(rhs < lhs);
}

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

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





// @generated_from: memory_instrumentation.mojom.HeapProfileResult
class COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) HeapProfileResult {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<HeapProfileResult, T>::value>;
  using DataView = HeapProfileResultDataView;
  using Data_ = internal::HeapProfileResult_Data;

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

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

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


  HeapProfileResult();

  HeapProfileResult(
      base::ProcessId pid,
      const std::string& json);

  ~HeapProfileResult();

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

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return HeapProfileResult::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

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

  
// @generated_from: memory_instrumentation.mojom.HeapProfileResult.pid
  base::ProcessId pid;
  
// @generated_from: memory_instrumentation.mojom.HeapProfileResult.json
  std::string json;

 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, 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) {
  return !(rhs < lhs);
}

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

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

template <typename UnionPtrType>
RawAllocatorDumpEntryValuePtr RawAllocatorDumpEntryValue::Clone() const {
  // Use UnionPtrType to prevent the compiler from trying to compile this
  // without being asked.
  UnionPtrType rv(New());
  switch (tag_) {
    case Tag::VALUE_UINT64:
      rv->set_value_uint64(mojo::Clone(data_.value_uint64));
      break;
    case Tag::VALUE_STRING:
      rv->set_value_string(mojo::Clone(*data_.value_string));
      break;
  }
  return rv;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, RawAllocatorDumpEntryValue>::value>::type*>
bool RawAllocatorDumpEntryValue::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::VALUE_UINT64:
      return mojo::Equals(data_.value_uint64, other.data_.value_uint64);
    case Tag::VALUE_STRING:
      return mojo::Equals(*(data_.value_string), *(other.data_.value_string));
  }

  return false;
}
template <typename StructPtrType>
RequestArgsPtr RequestArgs::Clone() const {
  return New(
      mojo::Clone(dump_guid),
      mojo::Clone(dump_type),
      mojo::Clone(level_of_detail)
  );
}

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

template <typename T, RequestArgs::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.dump_guid < rhs.dump_guid)
    return true;
  if (rhs.dump_guid < lhs.dump_guid)
    return false;
  if (lhs.dump_type < rhs.dump_type)
    return true;
  if (rhs.dump_type < lhs.dump_type)
    return false;
  if (lhs.level_of_detail < rhs.level_of_detail)
    return true;
  if (rhs.level_of_detail < lhs.level_of_detail)
    return false;
  return false;
}
template <typename StructPtrType>
RawAllocatorDumpEdgePtr RawAllocatorDumpEdge::Clone() const {
  return New(
      mojo::Clone(source_id),
      mojo::Clone(target_id),
      mojo::Clone(importance),
      mojo::Clone(overridable)
  );
}

template <typename T, RawAllocatorDumpEdge::EnableIfSame<T>*>
bool RawAllocatorDumpEdge::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->source_id, other_struct.source_id))
    return false;
  if (!mojo::Equals(this->target_id, other_struct.target_id))
    return false;
  if (!mojo::Equals(this->importance, other_struct.importance))
    return false;
  if (!mojo::Equals(this->overridable, other_struct.overridable))
    return false;
  return true;
}

template <typename T, RawAllocatorDumpEdge::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.source_id < rhs.source_id)
    return true;
  if (rhs.source_id < lhs.source_id)
    return false;
  if (lhs.target_id < rhs.target_id)
    return true;
  if (rhs.target_id < lhs.target_id)
    return false;
  if (lhs.importance < rhs.importance)
    return true;
  if (rhs.importance < lhs.importance)
    return false;
  if (lhs.overridable < rhs.overridable)
    return true;
  if (rhs.overridable < lhs.overridable)
    return false;
  return false;
}
template <typename StructPtrType>
RawAllocatorDumpEntryPtr RawAllocatorDumpEntry::Clone() const {
  return New(
      mojo::Clone(name),
      mojo::Clone(units),
      mojo::Clone(value)
  );
}

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

template <typename T, RawAllocatorDumpEntry::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.name < rhs.name)
    return true;
  if (rhs.name < lhs.name)
    return false;
  if (lhs.units < rhs.units)
    return true;
  if (rhs.units < lhs.units)
    return false;
  if (lhs.value < rhs.value)
    return true;
  if (rhs.value < lhs.value)
    return false;
  return false;
}
template <typename StructPtrType>
RawAllocatorDumpPtr RawAllocatorDump::Clone() const {
  return New(
      mojo::Clone(id),
      mojo::Clone(absolute_name),
      mojo::Clone(weak),
      mojo::Clone(level_of_detail),
      mojo::Clone(entries)
  );
}

template <typename T, RawAllocatorDump::EnableIfSame<T>*>
bool RawAllocatorDump::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->id, other_struct.id))
    return false;
  if (!mojo::Equals(this->absolute_name, other_struct.absolute_name))
    return false;
  if (!mojo::Equals(this->weak, other_struct.weak))
    return false;
  if (!mojo::Equals(this->level_of_detail, other_struct.level_of_detail))
    return false;
  if (!mojo::Equals(this->entries, other_struct.entries))
    return false;
  return true;
}

template <typename T, RawAllocatorDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.id < rhs.id)
    return true;
  if (rhs.id < lhs.id)
    return false;
  if (lhs.absolute_name < rhs.absolute_name)
    return true;
  if (rhs.absolute_name < lhs.absolute_name)
    return false;
  if (lhs.weak < rhs.weak)
    return true;
  if (rhs.weak < lhs.weak)
    return false;
  if (lhs.level_of_detail < rhs.level_of_detail)
    return true;
  if (rhs.level_of_detail < lhs.level_of_detail)
    return false;
  if (lhs.entries < rhs.entries)
    return true;
  if (rhs.entries < lhs.entries)
    return false;
  return false;
}
template <typename StructPtrType>
RawProcessMemoryDumpPtr RawProcessMemoryDump::Clone() const {
  return New(
      mojo::Clone(level_of_detail),
      mojo::Clone(allocator_dump_edges),
      mojo::Clone(allocator_dumps)
  );
}

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

template <typename T, RawProcessMemoryDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.level_of_detail < rhs.level_of_detail)
    return true;
  if (rhs.level_of_detail < lhs.level_of_detail)
    return false;
  if (lhs.allocator_dump_edges < rhs.allocator_dump_edges)
    return true;
  if (rhs.allocator_dump_edges < lhs.allocator_dump_edges)
    return false;
  if (lhs.allocator_dumps < rhs.allocator_dumps)
    return true;
  if (rhs.allocator_dumps < lhs.allocator_dumps)
    return false;
  return false;
}
template <typename StructPtrType>
VmRegionPtr VmRegion::Clone() const {
  return New(
      mojo::Clone(start_address),
      mojo::Clone(size_in_bytes),
      mojo::Clone(module_timestamp),
      mojo::Clone(module_debugid),
      mojo::Clone(module_debug_path),
      mojo::Clone(protection_flags),
      mojo::Clone(mapped_file),
      mojo::Clone(byte_stats_private_dirty_resident),
      mojo::Clone(byte_stats_private_clean_resident),
      mojo::Clone(byte_stats_shared_dirty_resident),
      mojo::Clone(byte_stats_shared_clean_resident),
      mojo::Clone(byte_stats_swapped),
      mojo::Clone(byte_stats_proportional_resident)
  );
}

template <typename T, VmRegion::EnableIfSame<T>*>
bool VmRegion::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->start_address, other_struct.start_address))
    return false;
  if (!mojo::Equals(this->size_in_bytes, other_struct.size_in_bytes))
    return false;
  if (!mojo::Equals(this->module_timestamp, other_struct.module_timestamp))
    return false;
  if (!mojo::Equals(this->module_debugid, other_struct.module_debugid))
    return false;
  if (!mojo::Equals(this->module_debug_path, other_struct.module_debug_path))
    return false;
  if (!mojo::Equals(this->protection_flags, other_struct.protection_flags))
    return false;
  if (!mojo::Equals(this->mapped_file, other_struct.mapped_file))
    return false;
  if (!mojo::Equals(this->byte_stats_private_dirty_resident, other_struct.byte_stats_private_dirty_resident))
    return false;
  if (!mojo::Equals(this->byte_stats_private_clean_resident, other_struct.byte_stats_private_clean_resident))
    return false;
  if (!mojo::Equals(this->byte_stats_shared_dirty_resident, other_struct.byte_stats_shared_dirty_resident))
    return false;
  if (!mojo::Equals(this->byte_stats_shared_clean_resident, other_struct.byte_stats_shared_clean_resident))
    return false;
  if (!mojo::Equals(this->byte_stats_swapped, other_struct.byte_stats_swapped))
    return false;
  if (!mojo::Equals(this->byte_stats_proportional_resident, other_struct.byte_stats_proportional_resident))
    return false;
  return true;
}

template <typename T, VmRegion::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.start_address < rhs.start_address)
    return true;
  if (rhs.start_address < lhs.start_address)
    return false;
  if (lhs.size_in_bytes < rhs.size_in_bytes)
    return true;
  if (rhs.size_in_bytes < lhs.size_in_bytes)
    return false;
  if (lhs.module_timestamp < rhs.module_timestamp)
    return true;
  if (rhs.module_timestamp < lhs.module_timestamp)
    return false;
  if (lhs.module_debugid < rhs.module_debugid)
    return true;
  if (rhs.module_debugid < lhs.module_debugid)
    return false;
  if (lhs.module_debug_path < rhs.module_debug_path)
    return true;
  if (rhs.module_debug_path < lhs.module_debug_path)
    return false;
  if (lhs.protection_flags < rhs.protection_flags)
    return true;
  if (rhs.protection_flags < lhs.protection_flags)
    return false;
  if (lhs.mapped_file < rhs.mapped_file)
    return true;
  if (rhs.mapped_file < lhs.mapped_file)
    return false;
  if (lhs.byte_stats_private_dirty_resident < rhs.byte_stats_private_dirty_resident)
    return true;
  if (rhs.byte_stats_private_dirty_resident < lhs.byte_stats_private_dirty_resident)
    return false;
  if (lhs.byte_stats_private_clean_resident < rhs.byte_stats_private_clean_resident)
    return true;
  if (rhs.byte_stats_private_clean_resident < lhs.byte_stats_private_clean_resident)
    return false;
  if (lhs.byte_stats_shared_dirty_resident < rhs.byte_stats_shared_dirty_resident)
    return true;
  if (rhs.byte_stats_shared_dirty_resident < lhs.byte_stats_shared_dirty_resident)
    return false;
  if (lhs.byte_stats_shared_clean_resident < rhs.byte_stats_shared_clean_resident)
    return true;
  if (rhs.byte_stats_shared_clean_resident < lhs.byte_stats_shared_clean_resident)
    return false;
  if (lhs.byte_stats_swapped < rhs.byte_stats_swapped)
    return true;
  if (rhs.byte_stats_swapped < lhs.byte_stats_swapped)
    return false;
  if (lhs.byte_stats_proportional_resident < rhs.byte_stats_proportional_resident)
    return true;
  if (rhs.byte_stats_proportional_resident < lhs.byte_stats_proportional_resident)
    return false;
  return false;
}
template <typename StructPtrType>
PlatformPrivateFootprintPtr PlatformPrivateFootprint::Clone() const {
  return New(
      mojo::Clone(phys_footprint_bytes),
      mojo::Clone(internal_bytes),
      mojo::Clone(compressed_bytes),
      mojo::Clone(rss_anon_bytes),
      mojo::Clone(vm_swap_bytes),
      mojo::Clone(private_bytes)
  );
}

template <typename T, PlatformPrivateFootprint::EnableIfSame<T>*>
bool PlatformPrivateFootprint::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->phys_footprint_bytes, other_struct.phys_footprint_bytes))
    return false;
  if (!mojo::Equals(this->internal_bytes, other_struct.internal_bytes))
    return false;
  if (!mojo::Equals(this->compressed_bytes, other_struct.compressed_bytes))
    return false;
  if (!mojo::Equals(this->rss_anon_bytes, other_struct.rss_anon_bytes))
    return false;
  if (!mojo::Equals(this->vm_swap_bytes, other_struct.vm_swap_bytes))
    return false;
  if (!mojo::Equals(this->private_bytes, other_struct.private_bytes))
    return false;
  return true;
}

template <typename T, PlatformPrivateFootprint::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.phys_footprint_bytes < rhs.phys_footprint_bytes)
    return true;
  if (rhs.phys_footprint_bytes < lhs.phys_footprint_bytes)
    return false;
  if (lhs.internal_bytes < rhs.internal_bytes)
    return true;
  if (rhs.internal_bytes < lhs.internal_bytes)
    return false;
  if (lhs.compressed_bytes < rhs.compressed_bytes)
    return true;
  if (rhs.compressed_bytes < lhs.compressed_bytes)
    return false;
  if (lhs.rss_anon_bytes < rhs.rss_anon_bytes)
    return true;
  if (rhs.rss_anon_bytes < lhs.rss_anon_bytes)
    return false;
  if (lhs.vm_swap_bytes < rhs.vm_swap_bytes)
    return true;
  if (rhs.vm_swap_bytes < lhs.vm_swap_bytes)
    return false;
  if (lhs.private_bytes < rhs.private_bytes)
    return true;
  if (rhs.private_bytes < lhs.private_bytes)
    return false;
  return false;
}
template <typename StructPtrType>
RawOSMemDumpPtr RawOSMemDump::Clone() const {
  return New(
      mojo::Clone(resident_set_kb),
      mojo::Clone(peak_resident_set_kb),
      mojo::Clone(is_peak_rss_resettable),
      mojo::Clone(platform_private_footprint),
      mojo::Clone(memory_maps),
      mojo::Clone(native_library_pages_bitmap)
  );
}

template <typename T, RawOSMemDump::EnableIfSame<T>*>
bool RawOSMemDump::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->resident_set_kb, other_struct.resident_set_kb))
    return false;
  if (!mojo::Equals(this->peak_resident_set_kb, other_struct.peak_resident_set_kb))
    return false;
  if (!mojo::Equals(this->is_peak_rss_resettable, other_struct.is_peak_rss_resettable))
    return false;
  if (!mojo::Equals(this->platform_private_footprint, other_struct.platform_private_footprint))
    return false;
  if (!mojo::Equals(this->memory_maps, other_struct.memory_maps))
    return false;
  if (!mojo::Equals(this->native_library_pages_bitmap, other_struct.native_library_pages_bitmap))
    return false;
  return true;
}

template <typename T, RawOSMemDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.resident_set_kb < rhs.resident_set_kb)
    return true;
  if (rhs.resident_set_kb < lhs.resident_set_kb)
    return false;
  if (lhs.peak_resident_set_kb < rhs.peak_resident_set_kb)
    return true;
  if (rhs.peak_resident_set_kb < lhs.peak_resident_set_kb)
    return false;
  if (lhs.is_peak_rss_resettable < rhs.is_peak_rss_resettable)
    return true;
  if (rhs.is_peak_rss_resettable < lhs.is_peak_rss_resettable)
    return false;
  if (lhs.platform_private_footprint < rhs.platform_private_footprint)
    return true;
  if (rhs.platform_private_footprint < lhs.platform_private_footprint)
    return false;
  if (lhs.memory_maps < rhs.memory_maps)
    return true;
  if (rhs.memory_maps < lhs.memory_maps)
    return false;
  if (lhs.native_library_pages_bitmap < rhs.native_library_pages_bitmap)
    return true;
  if (rhs.native_library_pages_bitmap < lhs.native_library_pages_bitmap)
    return false;
  return false;
}
template <typename StructPtrType>
OSMemDumpPtr OSMemDump::Clone() const {
  return New(
      mojo::Clone(resident_set_kb),
      mojo::Clone(peak_resident_set_kb),
      mojo::Clone(is_peak_rss_resettable),
      mojo::Clone(private_footprint_kb),
      mojo::Clone(shared_footprint_kb)
  );
}

template <typename T, OSMemDump::EnableIfSame<T>*>
bool OSMemDump::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->resident_set_kb, other_struct.resident_set_kb))
    return false;
  if (!mojo::Equals(this->peak_resident_set_kb, other_struct.peak_resident_set_kb))
    return false;
  if (!mojo::Equals(this->is_peak_rss_resettable, other_struct.is_peak_rss_resettable))
    return false;
  if (!mojo::Equals(this->private_footprint_kb, other_struct.private_footprint_kb))
    return false;
  if (!mojo::Equals(this->shared_footprint_kb, other_struct.shared_footprint_kb))
    return false;
  return true;
}

template <typename T, OSMemDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.resident_set_kb < rhs.resident_set_kb)
    return true;
  if (rhs.resident_set_kb < lhs.resident_set_kb)
    return false;
  if (lhs.peak_resident_set_kb < rhs.peak_resident_set_kb)
    return true;
  if (rhs.peak_resident_set_kb < lhs.peak_resident_set_kb)
    return false;
  if (lhs.is_peak_rss_resettable < rhs.is_peak_rss_resettable)
    return true;
  if (rhs.is_peak_rss_resettable < lhs.is_peak_rss_resettable)
    return false;
  if (lhs.private_footprint_kb < rhs.private_footprint_kb)
    return true;
  if (rhs.private_footprint_kb < lhs.private_footprint_kb)
    return false;
  if (lhs.shared_footprint_kb < rhs.shared_footprint_kb)
    return true;
  if (rhs.shared_footprint_kb < lhs.shared_footprint_kb)
    return false;
  return false;
}
template <typename StructPtrType>
AllocatorMemDumpPtr AllocatorMemDump::Clone() const {
  return New(
      mojo::Clone(numeric_entries)
  );
}

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

template <typename T, AllocatorMemDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.numeric_entries < rhs.numeric_entries)
    return true;
  if (rhs.numeric_entries < lhs.numeric_entries)
    return false;
  return false;
}
template <typename StructPtrType>
ProcessMemoryDumpPtr ProcessMemoryDump::Clone() const {
  return New(
      mojo::Clone(process_type),
      mojo::Clone(os_dump),
      mojo::Clone(chrome_allocator_dumps),
      mojo::Clone(pid),
      mojo::Clone(service_names)
  );
}

template <typename T, ProcessMemoryDump::EnableIfSame<T>*>
bool ProcessMemoryDump::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->process_type, other_struct.process_type))
    return false;
  if (!mojo::Equals(this->os_dump, other_struct.os_dump))
    return false;
  if (!mojo::Equals(this->chrome_allocator_dumps, other_struct.chrome_allocator_dumps))
    return false;
  if (!mojo::Equals(this->pid, other_struct.pid))
    return false;
  if (!mojo::Equals(this->service_names, other_struct.service_names))
    return false;
  return true;
}

template <typename T, ProcessMemoryDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.process_type < rhs.process_type)
    return true;
  if (rhs.process_type < lhs.process_type)
    return false;
  if (lhs.os_dump < rhs.os_dump)
    return true;
  if (rhs.os_dump < lhs.os_dump)
    return false;
  if (lhs.chrome_allocator_dumps < rhs.chrome_allocator_dumps)
    return true;
  if (rhs.chrome_allocator_dumps < lhs.chrome_allocator_dumps)
    return false;
  if (lhs.pid < rhs.pid)
    return true;
  if (rhs.pid < lhs.pid)
    return false;
  if (lhs.service_names < rhs.service_names)
    return true;
  if (rhs.service_names < lhs.service_names)
    return false;
  return false;
}
template <typename StructPtrType>
AggregatedMetricsPtr AggregatedMetrics::Clone() const {
  return New(
      mojo::Clone(native_library_resident_kb),
      mojo::Clone(native_library_resident_not_ordered_kb),
      mojo::Clone(native_library_not_resident_ordered_kb)
  );
}

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

template <typename T, AggregatedMetrics::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.native_library_resident_kb < rhs.native_library_resident_kb)
    return true;
  if (rhs.native_library_resident_kb < lhs.native_library_resident_kb)
    return false;
  if (lhs.native_library_resident_not_ordered_kb < rhs.native_library_resident_not_ordered_kb)
    return true;
  if (rhs.native_library_resident_not_ordered_kb < lhs.native_library_resident_not_ordered_kb)
    return false;
  if (lhs.native_library_not_resident_ordered_kb < rhs.native_library_not_resident_ordered_kb)
    return true;
  if (rhs.native_library_not_resident_ordered_kb < lhs.native_library_not_resident_ordered_kb)
    return false;
  return false;
}
template <typename StructPtrType>
GlobalMemoryDumpPtr GlobalMemoryDump::Clone() const {
  return New(
      mojo::Clone(start_time),
      mojo::Clone(process_dumps),
      mojo::Clone(aggregated_metrics)
  );
}

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

template <typename T, GlobalMemoryDump::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.start_time < rhs.start_time)
    return true;
  if (rhs.start_time < lhs.start_time)
    return false;
  if (lhs.process_dumps < rhs.process_dumps)
    return true;
  if (rhs.process_dumps < lhs.process_dumps)
    return false;
  if (lhs.aggregated_metrics < rhs.aggregated_metrics)
    return true;
  if (rhs.aggregated_metrics < lhs.aggregated_metrics)
    return false;
  return false;
}
template <typename StructPtrType>
HeapProfileResultPtr HeapProfileResult::Clone() const {
  return New(
      mojo::Clone(pid),
      mojo::Clone(json)
  );
}

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

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


}  // namespace mojom
}  // namespace memory_instrumentation

namespace mojo {


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::RequestArgs::DataView,
                                         ::memory_instrumentation::mojom::RequestArgsPtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::RequestArgsPtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::RequestArgsPtr* output) { output->reset(); }

  static decltype(::memory_instrumentation::mojom::RequestArgs::dump_guid) dump_guid(
      const ::memory_instrumentation::mojom::RequestArgsPtr& input) {
    return input->dump_guid;
  }

  static decltype(::memory_instrumentation::mojom::RequestArgs::dump_type) dump_type(
      const ::memory_instrumentation::mojom::RequestArgsPtr& input) {
    return input->dump_type;
  }

  static decltype(::memory_instrumentation::mojom::RequestArgs::level_of_detail) level_of_detail(
      const ::memory_instrumentation::mojom::RequestArgsPtr& input) {
    return input->level_of_detail;
  }

  static bool Read(::memory_instrumentation::mojom::RequestArgs::DataView input, ::memory_instrumentation::mojom::RequestArgsPtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::RawAllocatorDumpEdge::DataView,
                                         ::memory_instrumentation::mojom::RawAllocatorDumpEdgePtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::RawAllocatorDumpEdgePtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::RawAllocatorDumpEdgePtr* output) { output->reset(); }

  static decltype(::memory_instrumentation::mojom::RawAllocatorDumpEdge::source_id) source_id(
      const ::memory_instrumentation::mojom::RawAllocatorDumpEdgePtr& input) {
    return input->source_id;
  }

  static decltype(::memory_instrumentation::mojom::RawAllocatorDumpEdge::target_id) target_id(
      const ::memory_instrumentation::mojom::RawAllocatorDumpEdgePtr& input) {
    return input->target_id;
  }

  static decltype(::memory_instrumentation::mojom::RawAllocatorDumpEdge::importance) importance(
      const ::memory_instrumentation::mojom::RawAllocatorDumpEdgePtr& input) {
    return input->importance;
  }

  static decltype(::memory_instrumentation::mojom::RawAllocatorDumpEdge::overridable) overridable(
      const ::memory_instrumentation::mojom::RawAllocatorDumpEdgePtr& input) {
    return input->overridable;
  }

  static bool Read(::memory_instrumentation::mojom::RawAllocatorDumpEdge::DataView input, ::memory_instrumentation::mojom::RawAllocatorDumpEdgePtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::RawAllocatorDumpEntry::DataView,
                                         ::memory_instrumentation::mojom::RawAllocatorDumpEntryPtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::RawAllocatorDumpEntryPtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::RawAllocatorDumpEntryPtr* output) { output->reset(); }

  static const decltype(::memory_instrumentation::mojom::RawAllocatorDumpEntry::name)& name(
      const ::memory_instrumentation::mojom::RawAllocatorDumpEntryPtr& input) {
    return input->name;
  }

  static const decltype(::memory_instrumentation::mojom::RawAllocatorDumpEntry::units)& units(
      const ::memory_instrumentation::mojom::RawAllocatorDumpEntryPtr& input) {
    return input->units;
  }

  static const decltype(::memory_instrumentation::mojom::RawAllocatorDumpEntry::value)& value(
      const ::memory_instrumentation::mojom::RawAllocatorDumpEntryPtr& input) {
    return input->value;
  }

  static bool Read(::memory_instrumentation::mojom::RawAllocatorDumpEntry::DataView input, ::memory_instrumentation::mojom::RawAllocatorDumpEntryPtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::RawAllocatorDump::DataView,
                                         ::memory_instrumentation::mojom::RawAllocatorDumpPtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::RawAllocatorDumpPtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::RawAllocatorDumpPtr* output) { output->reset(); }

  static decltype(::memory_instrumentation::mojom::RawAllocatorDump::id) id(
      const ::memory_instrumentation::mojom::RawAllocatorDumpPtr& input) {
    return input->id;
  }

  static const decltype(::memory_instrumentation::mojom::RawAllocatorDump::absolute_name)& absolute_name(
      const ::memory_instrumentation::mojom::RawAllocatorDumpPtr& input) {
    return input->absolute_name;
  }

  static decltype(::memory_instrumentation::mojom::RawAllocatorDump::weak) weak(
      const ::memory_instrumentation::mojom::RawAllocatorDumpPtr& input) {
    return input->weak;
  }

  static decltype(::memory_instrumentation::mojom::RawAllocatorDump::level_of_detail) level_of_detail(
      const ::memory_instrumentation::mojom::RawAllocatorDumpPtr& input) {
    return input->level_of_detail;
  }

  static const decltype(::memory_instrumentation::mojom::RawAllocatorDump::entries)& entries(
      const ::memory_instrumentation::mojom::RawAllocatorDumpPtr& input) {
    return input->entries;
  }

  static bool Read(::memory_instrumentation::mojom::RawAllocatorDump::DataView input, ::memory_instrumentation::mojom::RawAllocatorDumpPtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::RawProcessMemoryDump::DataView,
                                         ::memory_instrumentation::mojom::RawProcessMemoryDumpPtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::RawProcessMemoryDumpPtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::RawProcessMemoryDumpPtr* output) { output->reset(); }

  static decltype(::memory_instrumentation::mojom::RawProcessMemoryDump::level_of_detail) level_of_detail(
      const ::memory_instrumentation::mojom::RawProcessMemoryDumpPtr& input) {
    return input->level_of_detail;
  }

  static const decltype(::memory_instrumentation::mojom::RawProcessMemoryDump::allocator_dump_edges)& allocator_dump_edges(
      const ::memory_instrumentation::mojom::RawProcessMemoryDumpPtr& input) {
    return input->allocator_dump_edges;
  }

  static const decltype(::memory_instrumentation::mojom::RawProcessMemoryDump::allocator_dumps)& allocator_dumps(
      const ::memory_instrumentation::mojom::RawProcessMemoryDumpPtr& input) {
    return input->allocator_dumps;
  }

  static bool Read(::memory_instrumentation::mojom::RawProcessMemoryDump::DataView input, ::memory_instrumentation::mojom::RawProcessMemoryDumpPtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::VmRegion::DataView,
                                         ::memory_instrumentation::mojom::VmRegionPtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::VmRegionPtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::VmRegionPtr* output) { output->reset(); }

  static decltype(::memory_instrumentation::mojom::VmRegion::start_address) start_address(
      const ::memory_instrumentation::mojom::VmRegionPtr& input) {
    return input->start_address;
  }

  static decltype(::memory_instrumentation::mojom::VmRegion::size_in_bytes) size_in_bytes(
      const ::memory_instrumentation::mojom::VmRegionPtr& input) {
    return input->size_in_bytes;
  }

  static decltype(::memory_instrumentation::mojom::VmRegion::module_timestamp) module_timestamp(
      const ::memory_instrumentation::mojom::VmRegionPtr& input) {
    return input->module_timestamp;
  }

  static const decltype(::memory_instrumentation::mojom::VmRegion::module_debugid)& module_debugid(
      const ::memory_instrumentation::mojom::VmRegionPtr& input) {
    return input->module_debugid;
  }

  static const decltype(::memory_instrumentation::mojom::VmRegion::module_debug_path)& module_debug_path(
      const ::memory_instrumentation::mojom::VmRegionPtr& input) {
    return input->module_debug_path;
  }

  static decltype(::memory_instrumentation::mojom::VmRegion::protection_flags) protection_flags(
      const ::memory_instrumentation::mojom::VmRegionPtr& input) {
    return input->protection_flags;
  }

  static const decltype(::memory_instrumentation::mojom::VmRegion::mapped_file)& mapped_file(
      const ::memory_instrumentation::mojom::VmRegionPtr& input) {
    return input->mapped_file;
  }

  static decltype(::memory_instrumentation::mojom::VmRegion::byte_stats_private_dirty_resident) byte_stats_private_dirty_resident(
      const ::memory_instrumentation::mojom::VmRegionPtr& input) {
    return input->byte_stats_private_dirty_resident;
  }

  static decltype(::memory_instrumentation::mojom::VmRegion::byte_stats_private_clean_resident) byte_stats_private_clean_resident(
      const ::memory_instrumentation::mojom::VmRegionPtr& input) {
    return input->byte_stats_private_clean_resident;
  }

  static decltype(::memory_instrumentation::mojom::VmRegion::byte_stats_shared_dirty_resident) byte_stats_shared_dirty_resident(
      const ::memory_instrumentation::mojom::VmRegionPtr& input) {
    return input->byte_stats_shared_dirty_resident;
  }

  static decltype(::memory_instrumentation::mojom::VmRegion::byte_stats_shared_clean_resident) byte_stats_shared_clean_resident(
      const ::memory_instrumentation::mojom::VmRegionPtr& input) {
    return input->byte_stats_shared_clean_resident;
  }

  static decltype(::memory_instrumentation::mojom::VmRegion::byte_stats_swapped) byte_stats_swapped(
      const ::memory_instrumentation::mojom::VmRegionPtr& input) {
    return input->byte_stats_swapped;
  }

  static decltype(::memory_instrumentation::mojom::VmRegion::byte_stats_proportional_resident) byte_stats_proportional_resident(
      const ::memory_instrumentation::mojom::VmRegionPtr& input) {
    return input->byte_stats_proportional_resident;
  }

  static bool Read(::memory_instrumentation::mojom::VmRegion::DataView input, ::memory_instrumentation::mojom::VmRegionPtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::PlatformPrivateFootprint::DataView,
                                         ::memory_instrumentation::mojom::PlatformPrivateFootprintPtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::PlatformPrivateFootprintPtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::PlatformPrivateFootprintPtr* output) { output->reset(); }

  static decltype(::memory_instrumentation::mojom::PlatformPrivateFootprint::phys_footprint_bytes) phys_footprint_bytes(
      const ::memory_instrumentation::mojom::PlatformPrivateFootprintPtr& input) {
    return input->phys_footprint_bytes;
  }

  static decltype(::memory_instrumentation::mojom::PlatformPrivateFootprint::internal_bytes) internal_bytes(
      const ::memory_instrumentation::mojom::PlatformPrivateFootprintPtr& input) {
    return input->internal_bytes;
  }

  static decltype(::memory_instrumentation::mojom::PlatformPrivateFootprint::compressed_bytes) compressed_bytes(
      const ::memory_instrumentation::mojom::PlatformPrivateFootprintPtr& input) {
    return input->compressed_bytes;
  }

  static decltype(::memory_instrumentation::mojom::PlatformPrivateFootprint::rss_anon_bytes) rss_anon_bytes(
      const ::memory_instrumentation::mojom::PlatformPrivateFootprintPtr& input) {
    return input->rss_anon_bytes;
  }

  static decltype(::memory_instrumentation::mojom::PlatformPrivateFootprint::vm_swap_bytes) vm_swap_bytes(
      const ::memory_instrumentation::mojom::PlatformPrivateFootprintPtr& input) {
    return input->vm_swap_bytes;
  }

  static decltype(::memory_instrumentation::mojom::PlatformPrivateFootprint::private_bytes) private_bytes(
      const ::memory_instrumentation::mojom::PlatformPrivateFootprintPtr& input) {
    return input->private_bytes;
  }

  static bool Read(::memory_instrumentation::mojom::PlatformPrivateFootprint::DataView input, ::memory_instrumentation::mojom::PlatformPrivateFootprintPtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::RawOSMemDump::DataView,
                                         ::memory_instrumentation::mojom::RawOSMemDumpPtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::RawOSMemDumpPtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::RawOSMemDumpPtr* output) { output->reset(); }

  static decltype(::memory_instrumentation::mojom::RawOSMemDump::resident_set_kb) resident_set_kb(
      const ::memory_instrumentation::mojom::RawOSMemDumpPtr& input) {
    return input->resident_set_kb;
  }

  static decltype(::memory_instrumentation::mojom::RawOSMemDump::peak_resident_set_kb) peak_resident_set_kb(
      const ::memory_instrumentation::mojom::RawOSMemDumpPtr& input) {
    return input->peak_resident_set_kb;
  }

  static decltype(::memory_instrumentation::mojom::RawOSMemDump::is_peak_rss_resettable) is_peak_rss_resettable(
      const ::memory_instrumentation::mojom::RawOSMemDumpPtr& input) {
    return input->is_peak_rss_resettable;
  }

  static const decltype(::memory_instrumentation::mojom::RawOSMemDump::platform_private_footprint)& platform_private_footprint(
      const ::memory_instrumentation::mojom::RawOSMemDumpPtr& input) {
    return input->platform_private_footprint;
  }

  static const decltype(::memory_instrumentation::mojom::RawOSMemDump::memory_maps)& memory_maps(
      const ::memory_instrumentation::mojom::RawOSMemDumpPtr& input) {
    return input->memory_maps;
  }

  static const decltype(::memory_instrumentation::mojom::RawOSMemDump::native_library_pages_bitmap)& native_library_pages_bitmap(
      const ::memory_instrumentation::mojom::RawOSMemDumpPtr& input) {
    return input->native_library_pages_bitmap;
  }

  static bool Read(::memory_instrumentation::mojom::RawOSMemDump::DataView input, ::memory_instrumentation::mojom::RawOSMemDumpPtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::OSMemDump::DataView,
                                         ::memory_instrumentation::mojom::OSMemDumpPtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::OSMemDumpPtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::OSMemDumpPtr* output) { output->reset(); }

  static decltype(::memory_instrumentation::mojom::OSMemDump::resident_set_kb) resident_set_kb(
      const ::memory_instrumentation::mojom::OSMemDumpPtr& input) {
    return input->resident_set_kb;
  }

  static decltype(::memory_instrumentation::mojom::OSMemDump::peak_resident_set_kb) peak_resident_set_kb(
      const ::memory_instrumentation::mojom::OSMemDumpPtr& input) {
    return input->peak_resident_set_kb;
  }

  static decltype(::memory_instrumentation::mojom::OSMemDump::is_peak_rss_resettable) is_peak_rss_resettable(
      const ::memory_instrumentation::mojom::OSMemDumpPtr& input) {
    return input->is_peak_rss_resettable;
  }

  static decltype(::memory_instrumentation::mojom::OSMemDump::private_footprint_kb) private_footprint_kb(
      const ::memory_instrumentation::mojom::OSMemDumpPtr& input) {
    return input->private_footprint_kb;
  }

  static decltype(::memory_instrumentation::mojom::OSMemDump::shared_footprint_kb) shared_footprint_kb(
      const ::memory_instrumentation::mojom::OSMemDumpPtr& input) {
    return input->shared_footprint_kb;
  }

  static bool Read(::memory_instrumentation::mojom::OSMemDump::DataView input, ::memory_instrumentation::mojom::OSMemDumpPtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::AllocatorMemDump::DataView,
                                         ::memory_instrumentation::mojom::AllocatorMemDumpPtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::AllocatorMemDumpPtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::AllocatorMemDumpPtr* output) { output->reset(); }

  static const decltype(::memory_instrumentation::mojom::AllocatorMemDump::numeric_entries)& numeric_entries(
      const ::memory_instrumentation::mojom::AllocatorMemDumpPtr& input) {
    return input->numeric_entries;
  }

  static bool Read(::memory_instrumentation::mojom::AllocatorMemDump::DataView input, ::memory_instrumentation::mojom::AllocatorMemDumpPtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::ProcessMemoryDump::DataView,
                                         ::memory_instrumentation::mojom::ProcessMemoryDumpPtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::ProcessMemoryDumpPtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::ProcessMemoryDumpPtr* output) { output->reset(); }

  static decltype(::memory_instrumentation::mojom::ProcessMemoryDump::process_type) process_type(
      const ::memory_instrumentation::mojom::ProcessMemoryDumpPtr& input) {
    return input->process_type;
  }

  static const decltype(::memory_instrumentation::mojom::ProcessMemoryDump::os_dump)& os_dump(
      const ::memory_instrumentation::mojom::ProcessMemoryDumpPtr& input) {
    return input->os_dump;
  }

  static const decltype(::memory_instrumentation::mojom::ProcessMemoryDump::chrome_allocator_dumps)& chrome_allocator_dumps(
      const ::memory_instrumentation::mojom::ProcessMemoryDumpPtr& input) {
    return input->chrome_allocator_dumps;
  }

  static const decltype(::memory_instrumentation::mojom::ProcessMemoryDump::pid)& pid(
      const ::memory_instrumentation::mojom::ProcessMemoryDumpPtr& input) {
    return input->pid;
  }

  static const decltype(::memory_instrumentation::mojom::ProcessMemoryDump::service_names)& service_names(
      const ::memory_instrumentation::mojom::ProcessMemoryDumpPtr& input) {
    return input->service_names;
  }

  static bool Read(::memory_instrumentation::mojom::ProcessMemoryDump::DataView input, ::memory_instrumentation::mojom::ProcessMemoryDumpPtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::AggregatedMetrics::DataView,
                                         ::memory_instrumentation::mojom::AggregatedMetricsPtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::AggregatedMetricsPtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::AggregatedMetricsPtr* output) { output->reset(); }

  static decltype(::memory_instrumentation::mojom::AggregatedMetrics::native_library_resident_kb) native_library_resident_kb(
      const ::memory_instrumentation::mojom::AggregatedMetricsPtr& input) {
    return input->native_library_resident_kb;
  }

  static decltype(::memory_instrumentation::mojom::AggregatedMetrics::native_library_resident_not_ordered_kb) native_library_resident_not_ordered_kb(
      const ::memory_instrumentation::mojom::AggregatedMetricsPtr& input) {
    return input->native_library_resident_not_ordered_kb;
  }

  static decltype(::memory_instrumentation::mojom::AggregatedMetrics::native_library_not_resident_ordered_kb) native_library_not_resident_ordered_kb(
      const ::memory_instrumentation::mojom::AggregatedMetricsPtr& input) {
    return input->native_library_not_resident_ordered_kb;
  }

  static bool Read(::memory_instrumentation::mojom::AggregatedMetrics::DataView input, ::memory_instrumentation::mojom::AggregatedMetricsPtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::GlobalMemoryDump::DataView,
                                         ::memory_instrumentation::mojom::GlobalMemoryDumpPtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::GlobalMemoryDumpPtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::GlobalMemoryDumpPtr* output) { output->reset(); }

  static const decltype(::memory_instrumentation::mojom::GlobalMemoryDump::start_time)& start_time(
      const ::memory_instrumentation::mojom::GlobalMemoryDumpPtr& input) {
    return input->start_time;
  }

  static const decltype(::memory_instrumentation::mojom::GlobalMemoryDump::process_dumps)& process_dumps(
      const ::memory_instrumentation::mojom::GlobalMemoryDumpPtr& input) {
    return input->process_dumps;
  }

  static const decltype(::memory_instrumentation::mojom::GlobalMemoryDump::aggregated_metrics)& aggregated_metrics(
      const ::memory_instrumentation::mojom::GlobalMemoryDumpPtr& input) {
    return input->aggregated_metrics;
  }

  static bool Read(::memory_instrumentation::mojom::GlobalMemoryDump::DataView input, ::memory_instrumentation::mojom::GlobalMemoryDumpPtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) StructTraits<::memory_instrumentation::mojom::HeapProfileResult::DataView,
                                         ::memory_instrumentation::mojom::HeapProfileResultPtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::HeapProfileResultPtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::HeapProfileResultPtr* output) { output->reset(); }

  static const decltype(::memory_instrumentation::mojom::HeapProfileResult::pid)& pid(
      const ::memory_instrumentation::mojom::HeapProfileResultPtr& input) {
    return input->pid;
  }

  static  decltype(::memory_instrumentation::mojom::HeapProfileResult::json)& json(
       ::memory_instrumentation::mojom::HeapProfileResultPtr& input) {
    return input->json;
  }

  static bool Read(::memory_instrumentation::mojom::HeapProfileResult::DataView input, ::memory_instrumentation::mojom::HeapProfileResultPtr* output);
};


template <>
struct COMPONENT_EXPORT(RESOURCE_COORDINATOR_PUBLIC_MOJOM) UnionTraits<::memory_instrumentation::mojom::RawAllocatorDumpEntryValue::DataView,
                                        ::memory_instrumentation::mojom::RawAllocatorDumpEntryValuePtr> {
  static bool IsNull(const ::memory_instrumentation::mojom::RawAllocatorDumpEntryValuePtr& input) { return !input; }
  static void SetToNull(::memory_instrumentation::mojom::RawAllocatorDumpEntryValuePtr* output) { output->reset(); }

  static ::memory_instrumentation::mojom::RawAllocatorDumpEntryValue::Tag GetTag(const ::memory_instrumentation::mojom::RawAllocatorDumpEntryValuePtr& input) {
    return input->which();
  }

  static  uint64_t value_uint64(const ::memory_instrumentation::mojom::RawAllocatorDumpEntryValuePtr& input) {
    return input->get_value_uint64();
  }

  static const std::string& value_string(const ::memory_instrumentation::mojom::RawAllocatorDumpEntryValuePtr& input) {
    return input->get_value_string();
  }

  static bool Read(::memory_instrumentation::mojom::RawAllocatorDumpEntryValue::DataView input, ::memory_instrumentation::mojom::RawAllocatorDumpEntryValuePtr* output);
};

}  // namespace mojo

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