net_ipc_param_traits.cc | Explore in Territory

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

#include "services/network/public/cpp/net_ipc_param_traits.h"

#include <string_view>

#include "ipc/ipc_message_utils.h"
#include "ipc/ipc_mojo_param_traits.h"
#include "ipc/ipc_platform_file.h"
#include "net/cert/cert_verify_result.h"
#include "net/http/http_util.h"

namespace IPC {

void ParamTraits<net::AuthCredentials>::Write(base::Pickle* m,
                                              const param_type& p) { … }

bool ParamTraits<net::AuthCredentials>::Read(const base::Pickle* m,
                                             base::PickleIterator* iter,
                                             param_type* r) { … }

void ParamTraits<net::AuthCredentials>::Log(const param_type& p,
                                            std::string* l) { … }

void ParamTraits<net::CertVerifyResult>::Write(base::Pickle* m,
                                               const param_type& p) { … }

bool ParamTraits<net::CertVerifyResult>::Read(const base::Pickle* m,
                                              base::PickleIterator* iter,
                                              param_type* r) { … }

void ParamTraits<net::CertVerifyResult>::Log(const param_type& p,
                                             std::string* l) { … }

void ParamTraits<net::HashValue>::Write(base::Pickle* m, const param_type& p) { … }

bool ParamTraits<net::HashValue>::Read(const base::Pickle* m,
                                       base::PickleIterator* iter,
                                       param_type* r) { … }

void ParamTraits<net::HashValue>::Log(const param_type& p, std::string* l) { … }

void ParamTraits<net::IPEndPoint>::Write(base::Pickle* m, const param_type& p) { … }

bool ParamTraits<net::IPEndPoint>::Read(const base::Pickle* m,
                                        base::PickleIterator* iter,
                                        param_type* p) { … }

void ParamTraits<net::IPEndPoint>::Log(const param_type& p, std::string* l) { … }

void ParamTraits<net::IPAddress>::Write(base::Pickle* m, const param_type& p) { … }

bool ParamTraits<net::IPAddress>::Read(const base::Pickle* m,
                                       base::PickleIterator* iter,
                                       param_type* p) { … }

void ParamTraits<net::IPAddress>::Log(const param_type& p, std::string* l) { … }

void ParamTraits<net::HttpRequestHeaders>::Write(base::Pickle* m,
                                                 const param_type& p) { … }

bool ParamTraits<net::HttpRequestHeaders>::Read(const base::Pickle* m,
                                                base::PickleIterator* iter,
                                                param_type* r) { … }

void ParamTraits<net::HttpRequestHeaders>::Log(const param_type& p,
                                               std::string* l) { … }

void ParamTraits<scoped_refptr<net::HttpResponseHeaders>>::Write(
    base::Pickle* m,
    const param_type& p) { … }

bool ParamTraits<scoped_refptr<net::HttpResponseHeaders>>::Read(
    const base::Pickle* m,
    base::PickleIterator* iter,
    param_type* r) { … }

void ParamTraits<scoped_refptr<net::HttpResponseHeaders>>::Log(
    const param_type& p,
    std::string* l) { … }

void ParamTraits<bssl::OCSPVerifyResult>::Write(base::Pickle* m,
                                                const param_type& p) { … }

bool ParamTraits<bssl::OCSPVerifyResult>::Read(const base::Pickle* m,
                                               base::PickleIterator* iter,
                                               param_type* r) { … }

void ParamTraits<bssl::OCSPVerifyResult>::Log(const param_type& p,
                                              std::string* l) { … }

void ParamTraits<net::ResolveErrorInfo>::Write(base::Pickle* m,
                                               const param_type& p) { … }
bool ParamTraits<net::ResolveErrorInfo>::Read(const base::Pickle* m,
                                              base::PickleIterator* iter,
                                              param_type* r) { … }
void ParamTraits<net::ResolveErrorInfo>::Log(const param_type& p,
                                             std::string* l) { … }

void ParamTraits<net::SSLInfo>::Write(base::Pickle* m, const param_type& p) { … }

bool ParamTraits<net::SSLInfo>::Read(const base::Pickle* m,
                                     base::PickleIterator* iter,
                                     param_type* r) { … }

void ParamTraits<net::SSLInfo>::Log(const param_type& p, std::string* l) { … }

void ParamTraits<scoped_refptr<net::ct::SignedCertificateTimestamp>>::Write(
    base::Pickle* m,
    const param_type& p) { … }

bool ParamTraits<scoped_refptr<net::ct::SignedCertificateTimestamp>>::Read(
    const base::Pickle* m,
    base::PickleIterator* iter,
    param_type* r) { … }

void ParamTraits<scoped_refptr<net::ct::SignedCertificateTimestamp>>::Log(
    const param_type& p,
    std::string* l) { … }

void ParamTraits<scoped_refptr<net::X509Certificate>>::Write(
    base::Pickle* m,
    const param_type& p) { … }

bool ParamTraits<scoped_refptr<net::X509Certificate>>::Read(
    const base::Pickle* m,
    base::PickleIterator* iter,
    param_type* r) { … }

void ParamTraits<scoped_refptr<net::X509Certificate>>::Log(const param_type& p,
                                                           std::string* l) { … }

void ParamTraits<net::LoadTimingInfo>::Write(base::Pickle* m,
                                             const param_type& p) { … }

bool ParamTraits<net::LoadTimingInfo>::Read(const base::Pickle* m,
                                            base::PickleIterator* iter,
                                            param_type* r) { … }

void ParamTraits<net::LoadTimingInfo>::Log(const param_type& p,
                                           std::string* l) { … }

void ParamTraits<net::SiteForCookies>::Write(base::Pickle* m,
                                             const param_type& p) { … }

bool ParamTraits<net::SiteForCookies>::Read(const base::Pickle* m,
                                            base::PickleIterator* iter,
                                            param_type* r) { … }

void ParamTraits<net::SiteForCookies>::Log(const param_type& p,
                                           std::string* l) { … }

void ParamTraits<url::Origin>::Write(base::Pickle* m, const url::Origin& p) { … }

bool ParamTraits<url::Origin>::Read(const base::Pickle* m,
                                    base::PickleIterator* iter,
                                    url::Origin* p) { … }

void ParamTraits<url::Origin>::Log(const url::Origin& p, std::string* l) { … }

void ParamTraits<net::SchemefulSite>::Write(base::Pickle* m,
                                            const net::SchemefulSite& p) { … }

bool ParamTraits<net::SchemefulSite>::Read(const base::Pickle* m,
                                           base::PickleIterator* iter,
                                           net::SchemefulSite* p) { … }

void ParamTraits<net::SchemefulSite>::Log(const net::SchemefulSite& p,
                                          std::string* l) { … }

}  // namespace IPC

// Generation of IPC definitions.

// Generate constructors.
#undef SERVICES_NETWORK_PUBLIC_CPP_NET_IPC_PARAM_TRAITS_H_
#include "ipc/struct_constructor_macros.h"
#include "net_ipc_param_traits.h"

// Generate param traits write methods.
#undef SERVICES_NETWORK_PUBLIC_CPP_NET_IPC_PARAM_TRAITS_H_
#include "ipc/param_traits_write_macros.h"
namespace IPC {
#include "net_ipc_param_traits.h"
}  // namespace IPC

// Generate param traits read methods.
#undef SERVICES_NETWORK_PUBLIC_CPP_NET_IPC_PARAM_TRAITS_H_
#include "ipc/param_traits_read_macros.h"
namespace IPC {
#include "net_ipc_param_traits.h"
}  // namespace IPC

// Generate param traits log methods.
#undef SERVICES_NETWORK_PUBLIC_CPP_NET_IPC_PARAM_TRAITS_H_
#include "ipc/param_traits_log_macros.h"
namespace IPC {
#include "net_ipc_param_traits.h"
}  // namespace IPC
chromium/services/network/public/cpp/net_ipc_param_traits.cc
