win-Debug/gen/services/network/public/mojom/network_service_test.mojom.h

// services/network/public/mojom/network_service_test.mojom.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef SERVICES_NETWORK_PUBLIC_MOJOM_NETWORK_SERVICE_TEST_MOJOM_H_
#define SERVICES_NETWORK_PUBLIC_MOJOM_NETWORK_SERVICE_TEST_MOJOM_H_

#include <stdint.h>

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

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

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

#include "services/network/public/mojom/network_service_test.mojom-features.h"
#include "services/network/public/mojom/network_service_test.mojom-shared.h"
#include "services/network/public/mojom/network_service_test.mojom-forward.h"
#include "mojo/public/mojom/base/file.mojom-forward.h"
#include "mojo/public/mojom/base/file_path.mojom.h"
#include "mojo/public/mojom/base/memory_pressure_level.mojom.h"
#include "mojo/public/mojom/base/time.mojom.h"
#include "services/network/public/mojom/address_list.mojom.h"
#include "services/network/public/mojom/host_resolver.mojom.h"
#include "services/network/public/mojom/network_change_manager.mojom-forward.h"
#include "services/network/public/mojom/network_interface_change_listener.mojom-forward.h"
#include "services/network/public/mojom/network_param.mojom.h"
#include "services/network/public/mojom/network_types.mojom.h"
#include "services/network/public/mojom/http_cache_backend_file_operations.mojom.h"
#include "services/network/public/mojom/ip_endpoint.mojom.h"
#include "services/network/public/mojom/transferable_socket.mojom.h"
#include <string>
#include <vector>

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



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


namespace network::mojom {

class SimpleCacheEntryProxy;

template <typename ImplRefTraits>
class SimpleCacheEntryStub;

class SimpleCacheEntryRequestValidator;
class SimpleCacheEntryResponseValidator;


// @generated_from: network.mojom.SimpleCacheEntry
class SimpleCacheEntry
    : public SimpleCacheEntryInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();

  static const char Name_[];
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = SimpleCacheEntryInterfaceBase;
  using Proxy_ = SimpleCacheEntryProxy;

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

  using RequestValidator_ = SimpleCacheEntryRequestValidator;
  using ResponseValidator_ = SimpleCacheEntryResponseValidator;
  enum MethodMinVersions : uint32_t {
    kWriteDataMinVersion = 0,
    kReadDataMinVersion = 0,
    kWriteSparseDataMinVersion = 0,
    kReadSparseDataMinVersion = 0,
    kCloseMinVersion = 0,
  };

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


  using WriteDataCallback = base::OnceCallback<void(int32_t)>;
  
// @generated_from: network.mojom.SimpleCacheEntry.WriteData
  virtual void WriteData(int32_t index, int32_t offset, const std::vector<uint8_t>& data, bool truncate, WriteDataCallback callback) = 0;


  using ReadDataCallback = base::OnceCallback<void(const std::vector<uint8_t>&, int32_t)>;
  
// @generated_from: network.mojom.SimpleCacheEntry.ReadData
  virtual void ReadData(int32_t index, int32_t offset, uint32_t length, ReadDataCallback callback) = 0;


  using WriteSparseDataCallback = base::OnceCallback<void(int32_t)>;
  
// @generated_from: network.mojom.SimpleCacheEntry.WriteSparseData
  virtual void WriteSparseData(int32_t offset, const std::vector<uint8_t>& data, WriteSparseDataCallback callback) = 0;


  using ReadSparseDataCallback = base::OnceCallback<void(const std::vector<uint8_t>&, int32_t)>;
  
// @generated_from: network.mojom.SimpleCacheEntry.ReadSparseData
  virtual void ReadSparseData(int32_t offset, uint32_t length, ReadSparseDataCallback callback) = 0;


  using CloseCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.SimpleCacheEntry.Close
  virtual void Close(CloseCallback callback) = 0;
};

class SimpleCacheEntryEnumeratorProxy;

template <typename ImplRefTraits>
class SimpleCacheEntryEnumeratorStub;

class SimpleCacheEntryEnumeratorRequestValidator;
class SimpleCacheEntryEnumeratorResponseValidator;


// @generated_from: network.mojom.SimpleCacheEntryEnumerator
class SimpleCacheEntryEnumerator
    : public SimpleCacheEntryEnumeratorInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();

  static const char Name_[];
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = SimpleCacheEntryEnumeratorInterfaceBase;
  using Proxy_ = SimpleCacheEntryEnumeratorProxy;

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

  using RequestValidator_ = SimpleCacheEntryEnumeratorRequestValidator;
  using ResponseValidator_ = SimpleCacheEntryEnumeratorResponseValidator;
  enum MethodMinVersions : uint32_t {
    kGetNextMinVersion = 0,
  };

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


  using GetNextCallback = base::OnceCallback<void(SimpleCacheOpenEntryResultPtr)>;
  
// @generated_from: network.mojom.SimpleCacheEntryEnumerator.GetNext
  virtual void GetNext(GetNextCallback callback) = 0;
};

class SimpleCacheProxy;

template <typename ImplRefTraits>
class SimpleCacheStub;

class SimpleCacheRequestValidator;
class SimpleCacheResponseValidator;


// @generated_from: network.mojom.SimpleCache
class SimpleCache
    : public SimpleCacheInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();

  static const char Name_[];
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = SimpleCacheInterfaceBase;
  using Proxy_ = SimpleCacheProxy;

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

  using RequestValidator_ = SimpleCacheRequestValidator;
  using ResponseValidator_ = SimpleCacheResponseValidator;
  enum MethodMinVersions : uint32_t {
    kCreateEntryMinVersion = 0,
    kOpenEntryMinVersion = 0,
    kDoomEntryMinVersion = 0,
    kDoomAllEntriesMinVersion = 0,
    kEnumerateEntriesMinVersion = 0,
    kDetachMinVersion = 0,
  };

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


  using CreateEntryCallback = base::OnceCallback<void(::mojo::PendingRemote<SimpleCacheEntry>, int32_t)>;
  
// @generated_from: network.mojom.SimpleCache.CreateEntry
  virtual void CreateEntry(const std::string& key, CreateEntryCallback callback) = 0;


  using OpenEntryCallback = base::OnceCallback<void(::mojo::PendingRemote<SimpleCacheEntry>, int32_t)>;
  
// @generated_from: network.mojom.SimpleCache.OpenEntry
  virtual void OpenEntry(const std::string& key, OpenEntryCallback callback) = 0;


  using DoomEntryCallback = base::OnceCallback<void(int32_t)>;
  
// @generated_from: network.mojom.SimpleCache.DoomEntry
  virtual void DoomEntry(const std::string& key, DoomEntryCallback callback) = 0;


  using DoomAllEntriesCallback = base::OnceCallback<void(int32_t)>;
  
// @generated_from: network.mojom.SimpleCache.DoomAllEntries
  virtual void DoomAllEntries(DoomAllEntriesCallback callback) = 0;

  
// @generated_from: network.mojom.SimpleCache.EnumerateEntries
  virtual void EnumerateEntries(::mojo::PendingReceiver<SimpleCacheEntryEnumerator> receiver) = 0;


  using DetachCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.SimpleCache.Detach
  virtual void Detach(DetachCallback callback) = 0;
};

class NetworkServiceTestProxy;

template <typename ImplRefTraits>
class NetworkServiceTestStub;

class NetworkServiceTestRequestValidator;
class NetworkServiceTestResponseValidator;


// @generated_from: network.mojom.NetworkServiceTest
class NetworkServiceTest
    : public NetworkServiceTestInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();

  static const char Name_[];
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static inline constexpr uint32_t kSyncMethodOrdinals[] = {
    0, 
    5, 
    6, 
    7, 
    8, 
    9, 
    10, 
    13, 
    14, 
    15, 
    16, 
    18, 
    25
  };
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = NetworkServiceTestInterfaceBase;
  using Proxy_ = NetworkServiceTestProxy;

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

  using RequestValidator_ = NetworkServiceTestRequestValidator;
  using ResponseValidator_ = NetworkServiceTestResponseValidator;
  enum MethodMinVersions : uint32_t {
    kAddRulesMinVersion = 0,
    kSimulateNetworkChangeMinVersion = 0,
    kSimulateNetworkQualityChangeMinVersion = 0,
    kForceNetworkQualityEstimatorReportWifiAsSlow2GMinVersion = 0,
    kSimulateCrashMinVersion = 0,
    kMockCertVerifierSetDefaultResultMinVersion = 0,
    kMockCertVerifierAddResultForCertAndHostMinVersion = 0,
    kSetTransportSecurityStateSourceMinVersion = 0,
    kSetAllowNetworkAccessToHostResolutionsMinVersion = 0,
    kReplaceSystemDnsConfigMinVersion = 0,
    kSetTestDohConfigMinVersion = 0,
    kCrashOnResolveHostMinVersion = 0,
    kCrashOnGetCookieListMinVersion = 0,
    kGetLatestMemoryPressureLevelMinVersion = 0,
    kGetPeerToPeerConnectionsCountChangeMinVersion = 0,
    kGetEnvironmentVariableValueMinVersion = 0,
    kLogMinVersion = 0,
    kActivateFieldTrialMinVersion = 0,
    kSetSCTAuditingRetryDelayMinVersion = 0,
    kOpenFileMinVersion = 0,
    kEnumerateFilesMinVersion = 0,
    kCreateSimpleCacheMinVersion = 0,
    kMakeRequestToServerMinVersion = 0,
    kResolveOwnHostnameWithSystemDnsMinVersion = 0,
    kSetIPv6ProbeResultMinVersion = 0,
    kAllowsGSSAPILibraryLoadMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct AddRules_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SimulateNetworkChange_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SimulateNetworkQualityChange_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ForceNetworkQualityEstimatorReportWifiAsSlow2G_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SimulateCrash_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct MockCertVerifierSetDefaultResult_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct MockCertVerifierAddResultForCertAndHost_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetTransportSecurityStateSource_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetAllowNetworkAccessToHostResolutions_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ReplaceSystemDnsConfig_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetTestDohConfig_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CrashOnResolveHost_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CrashOnGetCookieList_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetLatestMemoryPressureLevel_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetPeerToPeerConnectionsCountChange_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetEnvironmentVariableValue_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct Log_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ActivateFieldTrial_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetSCTAuditingRetryDelay_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OpenFile_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct EnumerateFiles_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CreateSimpleCache_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct MakeRequestToServer_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ResolveOwnHostnameWithSystemDns_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetIPv6ProbeResult_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct AllowsGSSAPILibraryLoad_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~NetworkServiceTest() = default;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: network.mojom.NetworkServiceTest.AddRules
  virtual bool AddRules(std::vector<RulePtr> rules);

  using AddRulesCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.NetworkServiceTest.AddRules
  virtual void AddRules(std::vector<RulePtr> rules, AddRulesCallback callback) = 0;


  using SimulateNetworkChangeCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.NetworkServiceTest.SimulateNetworkChange
  virtual void SimulateNetworkChange(::network::mojom::ConnectionType type, SimulateNetworkChangeCallback callback) = 0;


  using SimulateNetworkQualityChangeCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.NetworkServiceTest.SimulateNetworkQualityChange
  virtual void SimulateNetworkQualityChange(::net::EffectiveConnectionType type, SimulateNetworkQualityChangeCallback callback) = 0;


  using ForceNetworkQualityEstimatorReportWifiAsSlow2GCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.NetworkServiceTest.ForceNetworkQualityEstimatorReportWifiAsSlow2G
  virtual void ForceNetworkQualityEstimatorReportWifiAsSlow2G(ForceNetworkQualityEstimatorReportWifiAsSlow2GCallback callback) = 0;

  
// @generated_from: network.mojom.NetworkServiceTest.SimulateCrash
  virtual void SimulateCrash() = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: network.mojom.NetworkServiceTest.MockCertVerifierSetDefaultResult
  virtual bool MockCertVerifierSetDefaultResult(int32_t default_result);

  using MockCertVerifierSetDefaultResultCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.NetworkServiceTest.MockCertVerifierSetDefaultResult
  virtual void MockCertVerifierSetDefaultResult(int32_t default_result, MockCertVerifierSetDefaultResultCallback callback) = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: network.mojom.NetworkServiceTest.MockCertVerifierAddResultForCertAndHost
  virtual bool MockCertVerifierAddResultForCertAndHost(const ::scoped_refptr<::net::X509Certificate>& cert, const std::string& host_pattern, const ::net::CertVerifyResult& verify_result, int32_t rv);

  using MockCertVerifierAddResultForCertAndHostCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.NetworkServiceTest.MockCertVerifierAddResultForCertAndHost
  virtual void MockCertVerifierAddResultForCertAndHost(const ::scoped_refptr<::net::X509Certificate>& cert, const std::string& host_pattern, const ::net::CertVerifyResult& verify_result, int32_t rv, MockCertVerifierAddResultForCertAndHostCallback callback) = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: network.mojom.NetworkServiceTest.SetTransportSecurityStateSource
  virtual bool SetTransportSecurityStateSource(uint16_t reporting_port);

  using SetTransportSecurityStateSourceCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.NetworkServiceTest.SetTransportSecurityStateSource
  virtual void SetTransportSecurityStateSource(uint16_t reporting_port, SetTransportSecurityStateSourceCallback callback) = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: network.mojom.NetworkServiceTest.SetAllowNetworkAccessToHostResolutions
  virtual bool SetAllowNetworkAccessToHostResolutions();

  using SetAllowNetworkAccessToHostResolutionsCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.NetworkServiceTest.SetAllowNetworkAccessToHostResolutions
  virtual void SetAllowNetworkAccessToHostResolutions(SetAllowNetworkAccessToHostResolutionsCallback callback) = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: network.mojom.NetworkServiceTest.ReplaceSystemDnsConfig
  virtual bool ReplaceSystemDnsConfig();

  using ReplaceSystemDnsConfigCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.NetworkServiceTest.ReplaceSystemDnsConfig
  virtual void ReplaceSystemDnsConfig(ReplaceSystemDnsConfigCallback callback) = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: network.mojom.NetworkServiceTest.SetTestDohConfig
  virtual bool SetTestDohConfig(::net::SecureDnsMode secure_dns_mode, const ::net::DnsOverHttpsConfig& doh_config);

  using SetTestDohConfigCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.NetworkServiceTest.SetTestDohConfig
  virtual void SetTestDohConfig(::net::SecureDnsMode secure_dns_mode, const ::net::DnsOverHttpsConfig& doh_config, SetTestDohConfigCallback callback) = 0;

  
// @generated_from: network.mojom.NetworkServiceTest.CrashOnResolveHost
  virtual void CrashOnResolveHost(const std::string& host) = 0;

  
// @generated_from: network.mojom.NetworkServiceTest.CrashOnGetCookieList
  virtual void CrashOnGetCookieList() = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: network.mojom.NetworkServiceTest.GetLatestMemoryPressureLevel
  virtual bool GetLatestMemoryPressureLevel(::base::MemoryPressureListener::MemoryPressureLevel* out_memory_pressure_level);

  using GetLatestMemoryPressureLevelCallback = base::OnceCallback<void(::base::MemoryPressureListener::MemoryPressureLevel)>;
  
// @generated_from: network.mojom.NetworkServiceTest.GetLatestMemoryPressureLevel
  virtual void GetLatestMemoryPressureLevel(GetLatestMemoryPressureLevelCallback callback) = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: network.mojom.NetworkServiceTest.GetPeerToPeerConnectionsCountChange
  virtual bool GetPeerToPeerConnectionsCountChange(uint32_t* out_connection_count);

  using GetPeerToPeerConnectionsCountChangeCallback = base::OnceCallback<void(uint32_t)>;
  
// @generated_from: network.mojom.NetworkServiceTest.GetPeerToPeerConnectionsCountChange
  virtual void GetPeerToPeerConnectionsCountChange(GetPeerToPeerConnectionsCountChangeCallback callback) = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: network.mojom.NetworkServiceTest.GetEnvironmentVariableValue
  virtual bool GetEnvironmentVariableValue(const std::string& name, std::string* out_value);

  using GetEnvironmentVariableValueCallback = base::OnceCallback<void(const std::string&)>;
  
// @generated_from: network.mojom.NetworkServiceTest.GetEnvironmentVariableValue
  virtual void GetEnvironmentVariableValue(const std::string& name, GetEnvironmentVariableValueCallback callback) = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: network.mojom.NetworkServiceTest.Log
  virtual bool Log(const std::string& message);

  using LogCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.NetworkServiceTest.Log
  virtual void Log(const std::string& message, LogCallback callback) = 0;

  
// @generated_from: network.mojom.NetworkServiceTest.ActivateFieldTrial
  virtual void ActivateFieldTrial(const std::string& field_trial_name) = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: network.mojom.NetworkServiceTest.SetSCTAuditingRetryDelay
  virtual bool SetSCTAuditingRetryDelay(std::optional<::base::TimeDelta> delay);

  using SetSCTAuditingRetryDelayCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.NetworkServiceTest.SetSCTAuditingRetryDelay
  virtual void SetSCTAuditingRetryDelay(std::optional<::base::TimeDelta> delay, SetSCTAuditingRetryDelayCallback callback) = 0;


  using OpenFileCallback = base::OnceCallback<void(bool)>;
  
// @generated_from: network.mojom.NetworkServiceTest.OpenFile
  virtual void OpenFile(const ::base::FilePath& path, OpenFileCallback callback) = 0;


  using EnumerateFilesCallback = base::OnceCallback<void(const std::vector<::disk_cache::BackendFileOperations::FileEnumerationEntry>&, bool)>;
  
// @generated_from: network.mojom.NetworkServiceTest.EnumerateFiles
  virtual void EnumerateFiles(const ::base::FilePath& path, ::mojo::PendingRemote<::network::mojom::HttpCacheBackendFileOperationsFactory> factory, EnumerateFilesCallback callback) = 0;


  using CreateSimpleCacheCallback = base::OnceCallback<void(::mojo::PendingRemote<SimpleCache>)>;
  
// @generated_from: network.mojom.NetworkServiceTest.CreateSimpleCache
  virtual void CreateSimpleCache(::mojo::PendingRemote<::network::mojom::HttpCacheBackendFileOperationsFactory> factory, const ::base::FilePath& path, bool reset, CreateSimpleCacheCallback callback) = 0;


  using MakeRequestToServerCallback = base::OnceCallback<void(bool)>;
  
// @generated_from: network.mojom.NetworkServiceTest.MakeRequestToServer
  virtual void MakeRequestToServer(::network::TransferableSocket s, const ::net::IPEndPoint& endpoint, MakeRequestToServerCallback callback) = 0;


  using ResolveOwnHostnameWithSystemDnsCallback = base::OnceCallback<void(const ::net::AddressList&, int32_t, int32_t)>;
  
// @generated_from: network.mojom.NetworkServiceTest.ResolveOwnHostnameWithSystemDns
  virtual void ResolveOwnHostnameWithSystemDns(ResolveOwnHostnameWithSystemDnsCallback callback) = 0;


  using SetIPv6ProbeResultCallback = base::OnceCallback<void()>;
  
// @generated_from: network.mojom.NetworkServiceTest.SetIPv6ProbeResult
  virtual void SetIPv6ProbeResult(bool success, SetIPv6ProbeResultCallback callback) = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: network.mojom.NetworkServiceTest.AllowsGSSAPILibraryLoad
  virtual bool AllowsGSSAPILibraryLoad(bool* out_allow_gssapi_library_load);

  using AllowsGSSAPILibraryLoadCallback = base::OnceCallback<void(bool)>;
  
// @generated_from: network.mojom.NetworkServiceTest.AllowsGSSAPILibraryLoad
  virtual void AllowsGSSAPILibraryLoad(AllowsGSSAPILibraryLoadCallback callback) = 0;
};



// @generated_from: network.mojom.SimpleCacheEntry
class  SimpleCacheEntryProxy
    : public SimpleCacheEntry {
 public:
  using InterfaceType = SimpleCacheEntry;

  explicit SimpleCacheEntryProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: network.mojom.SimpleCacheEntry.WriteData
  void WriteData(int32_t index, int32_t offset, const std::vector<uint8_t>& data, bool truncate, WriteDataCallback callback) final;
  
// @generated_from: network.mojom.SimpleCacheEntry.ReadData
  void ReadData(int32_t index, int32_t offset, uint32_t length, ReadDataCallback callback) final;
  
// @generated_from: network.mojom.SimpleCacheEntry.WriteSparseData
  void WriteSparseData(int32_t offset, const std::vector<uint8_t>& data, WriteSparseDataCallback callback) final;
  
// @generated_from: network.mojom.SimpleCacheEntry.ReadSparseData
  void ReadSparseData(int32_t offset, uint32_t length, ReadSparseDataCallback callback) final;
  
// @generated_from: network.mojom.SimpleCacheEntry.Close
  void Close(CloseCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



// @generated_from: network.mojom.SimpleCacheEntryEnumerator
class  SimpleCacheEntryEnumeratorProxy
    : public SimpleCacheEntryEnumerator {
 public:
  using InterfaceType = SimpleCacheEntryEnumerator;

  explicit SimpleCacheEntryEnumeratorProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: network.mojom.SimpleCacheEntryEnumerator.GetNext
  void GetNext(GetNextCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



// @generated_from: network.mojom.SimpleCache
class  SimpleCacheProxy
    : public SimpleCache {
 public:
  using InterfaceType = SimpleCache;

  explicit SimpleCacheProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: network.mojom.SimpleCache.CreateEntry
  void CreateEntry(const std::string& key, CreateEntryCallback callback) final;
  
// @generated_from: network.mojom.SimpleCache.OpenEntry
  void OpenEntry(const std::string& key, OpenEntryCallback callback) final;
  
// @generated_from: network.mojom.SimpleCache.DoomEntry
  void DoomEntry(const std::string& key, DoomEntryCallback callback) final;
  
// @generated_from: network.mojom.SimpleCache.DoomAllEntries
  void DoomAllEntries(DoomAllEntriesCallback callback) final;
  
// @generated_from: network.mojom.SimpleCache.EnumerateEntries
  void EnumerateEntries(::mojo::PendingReceiver<SimpleCacheEntryEnumerator> receiver) final;
  
// @generated_from: network.mojom.SimpleCache.Detach
  void Detach(DetachCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



// @generated_from: network.mojom.NetworkServiceTest
class  NetworkServiceTestProxy
    : public NetworkServiceTest {
 public:
  using InterfaceType = NetworkServiceTest;

  explicit NetworkServiceTestProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: network.mojom.NetworkServiceTest.AddRules
  bool AddRules(std::vector<RulePtr> rules) final;
  
// @generated_from: network.mojom.NetworkServiceTest.AddRules
  void AddRules(std::vector<RulePtr> rules, AddRulesCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.SimulateNetworkChange
  void SimulateNetworkChange(::network::mojom::ConnectionType type, SimulateNetworkChangeCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.SimulateNetworkQualityChange
  void SimulateNetworkQualityChange(::net::EffectiveConnectionType type, SimulateNetworkQualityChangeCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.ForceNetworkQualityEstimatorReportWifiAsSlow2G
  void ForceNetworkQualityEstimatorReportWifiAsSlow2G(ForceNetworkQualityEstimatorReportWifiAsSlow2GCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.SimulateCrash
  void SimulateCrash() final;
  
// @generated_from: network.mojom.NetworkServiceTest.MockCertVerifierSetDefaultResult
  bool MockCertVerifierSetDefaultResult(int32_t default_result) final;
  
// @generated_from: network.mojom.NetworkServiceTest.MockCertVerifierSetDefaultResult
  void MockCertVerifierSetDefaultResult(int32_t default_result, MockCertVerifierSetDefaultResultCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.MockCertVerifierAddResultForCertAndHost
  bool MockCertVerifierAddResultForCertAndHost(const ::scoped_refptr<::net::X509Certificate>& cert, const std::string& host_pattern, const ::net::CertVerifyResult& verify_result, int32_t rv) final;
  
// @generated_from: network.mojom.NetworkServiceTest.MockCertVerifierAddResultForCertAndHost
  void MockCertVerifierAddResultForCertAndHost(const ::scoped_refptr<::net::X509Certificate>& cert, const std::string& host_pattern, const ::net::CertVerifyResult& verify_result, int32_t rv, MockCertVerifierAddResultForCertAndHostCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.SetTransportSecurityStateSource
  bool SetTransportSecurityStateSource(uint16_t reporting_port) final;
  
// @generated_from: network.mojom.NetworkServiceTest.SetTransportSecurityStateSource
  void SetTransportSecurityStateSource(uint16_t reporting_port, SetTransportSecurityStateSourceCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.SetAllowNetworkAccessToHostResolutions
  bool SetAllowNetworkAccessToHostResolutions() final;
  
// @generated_from: network.mojom.NetworkServiceTest.SetAllowNetworkAccessToHostResolutions
  void SetAllowNetworkAccessToHostResolutions(SetAllowNetworkAccessToHostResolutionsCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.ReplaceSystemDnsConfig
  bool ReplaceSystemDnsConfig() final;
  
// @generated_from: network.mojom.NetworkServiceTest.ReplaceSystemDnsConfig
  void ReplaceSystemDnsConfig(ReplaceSystemDnsConfigCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.SetTestDohConfig
  bool SetTestDohConfig(::net::SecureDnsMode secure_dns_mode, const ::net::DnsOverHttpsConfig& doh_config) final;
  
// @generated_from: network.mojom.NetworkServiceTest.SetTestDohConfig
  void SetTestDohConfig(::net::SecureDnsMode secure_dns_mode, const ::net::DnsOverHttpsConfig& doh_config, SetTestDohConfigCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.CrashOnResolveHost
  void CrashOnResolveHost(const std::string& host) final;
  
// @generated_from: network.mojom.NetworkServiceTest.CrashOnGetCookieList
  void CrashOnGetCookieList() final;
  
// @generated_from: network.mojom.NetworkServiceTest.GetLatestMemoryPressureLevel
  bool GetLatestMemoryPressureLevel(::base::MemoryPressureListener::MemoryPressureLevel* out_memory_pressure_level) final;
  
// @generated_from: network.mojom.NetworkServiceTest.GetLatestMemoryPressureLevel
  void GetLatestMemoryPressureLevel(GetLatestMemoryPressureLevelCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.GetPeerToPeerConnectionsCountChange
  bool GetPeerToPeerConnectionsCountChange(uint32_t* out_connection_count) final;
  
// @generated_from: network.mojom.NetworkServiceTest.GetPeerToPeerConnectionsCountChange
  void GetPeerToPeerConnectionsCountChange(GetPeerToPeerConnectionsCountChangeCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.GetEnvironmentVariableValue
  bool GetEnvironmentVariableValue(const std::string& name, std::string* out_value) final;
  
// @generated_from: network.mojom.NetworkServiceTest.GetEnvironmentVariableValue
  void GetEnvironmentVariableValue(const std::string& name, GetEnvironmentVariableValueCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.Log
  bool Log(const std::string& message) final;
  
// @generated_from: network.mojom.NetworkServiceTest.Log
  void Log(const std::string& message, LogCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.ActivateFieldTrial
  void ActivateFieldTrial(const std::string& field_trial_name) final;
  
// @generated_from: network.mojom.NetworkServiceTest.SetSCTAuditingRetryDelay
  bool SetSCTAuditingRetryDelay(std::optional<::base::TimeDelta> delay) final;
  
// @generated_from: network.mojom.NetworkServiceTest.SetSCTAuditingRetryDelay
  void SetSCTAuditingRetryDelay(std::optional<::base::TimeDelta> delay, SetSCTAuditingRetryDelayCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.OpenFile
  void OpenFile(const ::base::FilePath& path, OpenFileCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.EnumerateFiles
  void EnumerateFiles(const ::base::FilePath& path, ::mojo::PendingRemote<::network::mojom::HttpCacheBackendFileOperationsFactory> factory, EnumerateFilesCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.CreateSimpleCache
  void CreateSimpleCache(::mojo::PendingRemote<::network::mojom::HttpCacheBackendFileOperationsFactory> factory, const ::base::FilePath& path, bool reset, CreateSimpleCacheCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.MakeRequestToServer
  void MakeRequestToServer(::network::TransferableSocket s, const ::net::IPEndPoint& endpoint, MakeRequestToServerCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.ResolveOwnHostnameWithSystemDns
  void ResolveOwnHostnameWithSystemDns(ResolveOwnHostnameWithSystemDnsCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.SetIPv6ProbeResult
  void SetIPv6ProbeResult(bool success, SetIPv6ProbeResultCallback callback) final;
  
// @generated_from: network.mojom.NetworkServiceTest.AllowsGSSAPILibraryLoad
  bool AllowsGSSAPILibraryLoad(bool* out_allow_gssapi_library_load) final;
  
// @generated_from: network.mojom.NetworkServiceTest.AllowsGSSAPILibraryLoad
  void AllowsGSSAPILibraryLoad(AllowsGSSAPILibraryLoadCallback callback) final;

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

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

  SimpleCacheEntryStub() = default;
  ~SimpleCacheEntryStub() override = default;

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

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

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

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

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

  SimpleCacheEntryEnumeratorStub() = default;
  ~SimpleCacheEntryEnumeratorStub() override = default;

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

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

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

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

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

  SimpleCacheStub() = default;
  ~SimpleCacheStub() override = default;

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

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

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

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

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

  NetworkServiceTestStub() = default;
  ~NetworkServiceTestStub() override = default;

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

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

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

 private:
  ImplPointerType sink_;
};
class  SimpleCacheEntryRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  SimpleCacheEntryEnumeratorRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  SimpleCacheRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  NetworkServiceTestRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  SimpleCacheEntryResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  SimpleCacheEntryEnumeratorResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  SimpleCacheResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  NetworkServiceTestResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};









// @generated_from: network.mojom.Rule
class  Rule {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Rule, T>::value>;
  using DataView = RuleDataView;
  using Data_ = internal::Rule_Data;

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

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

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


  Rule();

  Rule(
      ResolverType resolver_type,
      const std::string& host_pattern,
      const std::string& replacement,
      int32_t host_resolver_flags,
      std::vector<std::string> dns_aliases);


  ~Rule();

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

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

  template <typename T, Rule::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Rule::DataView, std::vector<uint8_t>>(input);
  }

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return Rule::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::Rule_UnserializedMessageContext<
            UserType, Rule::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<Rule::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: network.mojom.Rule.resolver_type
  ResolverType resolver_type;
  
// @generated_from: network.mojom.Rule.host_pattern
  std::string host_pattern;
  
// @generated_from: network.mojom.Rule.replacement
  std::string replacement;
  
// @generated_from: network.mojom.Rule.host_resolver_flags
  int32_t host_resolver_flags;
  
// @generated_from: network.mojom.Rule.dns_aliases
  std::vector<std::string> dns_aliases;

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

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

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

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

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

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





// @generated_from: network.mojom.SimpleCacheOpenEntryResult
class  SimpleCacheOpenEntryResult {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<SimpleCacheOpenEntryResult, T>::value>;
  using DataView = SimpleCacheOpenEntryResultDataView;
  using Data_ = internal::SimpleCacheOpenEntryResult_Data;

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

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

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


  SimpleCacheOpenEntryResult();

  SimpleCacheOpenEntryResult(
      int32_t error,
      const std::string& key,
      ::mojo::PendingRemote<SimpleCacheEntry> entry);

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

  ~SimpleCacheOpenEntryResult();

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

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

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

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

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

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return SimpleCacheOpenEntryResult::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::SimpleCacheOpenEntryResult_UnserializedMessageContext<
            UserType, SimpleCacheOpenEntryResult::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<SimpleCacheOpenEntryResult::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: network.mojom.SimpleCacheOpenEntryResult.error
  int32_t error;
  
// @generated_from: network.mojom.SimpleCacheOpenEntryResult.key
  std::string key;
  
// @generated_from: network.mojom.SimpleCacheOpenEntryResult.entry
  ::mojo::PendingRemote<SimpleCacheEntry> entry;

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

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

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

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

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

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

template <typename StructPtrType>
RulePtr Rule::Clone() const {
  return New(
      mojo::Clone(resolver_type),
      mojo::Clone(host_pattern),
      mojo::Clone(replacement),
      mojo::Clone(host_resolver_flags),
      mojo::Clone(dns_aliases)
  );
}

template <typename T, Rule::EnableIfSame<T>*>
bool Rule::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->resolver_type, other_struct.resolver_type))
    return false;
  if (!mojo::Equals(this->host_pattern, other_struct.host_pattern))
    return false;
  if (!mojo::Equals(this->replacement, other_struct.replacement))
    return false;
  if (!mojo::Equals(this->host_resolver_flags, other_struct.host_resolver_flags))
    return false;
  if (!mojo::Equals(this->dns_aliases, other_struct.dns_aliases))
    return false;
  return true;
}

template <typename T, Rule::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.resolver_type < rhs.resolver_type)
    return true;
  if (rhs.resolver_type < lhs.resolver_type)
    return false;
  if (lhs.host_pattern < rhs.host_pattern)
    return true;
  if (rhs.host_pattern < lhs.host_pattern)
    return false;
  if (lhs.replacement < rhs.replacement)
    return true;
  if (rhs.replacement < lhs.replacement)
    return false;
  if (lhs.host_resolver_flags < rhs.host_resolver_flags)
    return true;
  if (rhs.host_resolver_flags < lhs.host_resolver_flags)
    return false;
  if (lhs.dns_aliases < rhs.dns_aliases)
    return true;
  if (rhs.dns_aliases < lhs.dns_aliases)
    return false;
  return false;
}
template <typename StructPtrType>
SimpleCacheOpenEntryResultPtr SimpleCacheOpenEntryResult::Clone() const {
  return New(
      mojo::Clone(error),
      mojo::Clone(key),
      mojo::Clone(entry)
  );
}

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

template <typename T, SimpleCacheOpenEntryResult::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.error < rhs.error)
    return true;
  if (rhs.error < lhs.error)
    return false;
  if (lhs.key < rhs.key)
    return true;
  if (rhs.key < lhs.key)
    return false;
  if (lhs.entry < rhs.entry)
    return true;
  if (rhs.entry < lhs.entry)
    return false;
  return false;
}


}  // network::mojom

namespace mojo {


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

  static decltype(::network::mojom::Rule::resolver_type) resolver_type(
      const ::network::mojom::RulePtr& input) {
    return input->resolver_type;
  }

  static const decltype(::network::mojom::Rule::host_pattern)& host_pattern(
      const ::network::mojom::RulePtr& input) {
    return input->host_pattern;
  }

  static const decltype(::network::mojom::Rule::replacement)& replacement(
      const ::network::mojom::RulePtr& input) {
    return input->replacement;
  }

  static decltype(::network::mojom::Rule::host_resolver_flags) host_resolver_flags(
      const ::network::mojom::RulePtr& input) {
    return input->host_resolver_flags;
  }

  static const decltype(::network::mojom::Rule::dns_aliases)& dns_aliases(
      const ::network::mojom::RulePtr& input) {
    return input->dns_aliases;
  }

  static bool Read(::network::mojom::Rule::DataView input, ::network::mojom::RulePtr* output);
};


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

  static decltype(::network::mojom::SimpleCacheOpenEntryResult::error) error(
      const ::network::mojom::SimpleCacheOpenEntryResultPtr& input) {
    return input->error;
  }

  static const decltype(::network::mojom::SimpleCacheOpenEntryResult::key)& key(
      const ::network::mojom::SimpleCacheOpenEntryResultPtr& input) {
    return input->key;
  }

  static  decltype(::network::mojom::SimpleCacheOpenEntryResult::entry)& entry(
       ::network::mojom::SimpleCacheOpenEntryResultPtr& input) {
    return input->entry;
  }

  static bool Read(::network::mojom::SimpleCacheOpenEntryResult::DataView input, ::network::mojom::SimpleCacheOpenEntryResultPtr* output);
};

}  // namespace mojo

#endif  // SERVICES_NETWORK_PUBLIC_MOJOM_NETWORK_SERVICE_TEST_MOJOM_H_

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