content_param_traits.cc | Explore in Territory

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

#include "content/common/content_param_traits.h"

#include <stddef.h>

#include "base/strings/string_number_conversions.h"
#include "base/unguessable_token.h"
#include "components/viz/common/surfaces/frame_sink_id.h"
#include "components/viz/common/surfaces/local_surface_id.h"
#include "components/viz/common/surfaces/surface_id.h"
#include "components/viz/common/surfaces/surface_info.h"
#include "ipc/ipc_mojo_message_helper.h"
#include "ipc/ipc_mojo_param_traits.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "net/base/ip_endpoint.h"
#include "services/network/public/cpp/net_ipc_param_traits.h"
#include "third_party/blink/public/common/messaging/message_port_channel.h"
#include "third_party/blink/public/common/messaging/message_port_descriptor.h"
#include "third_party/blink/public/common/messaging/transferable_message.h"
#include "third_party/blink/public/common/permissions_policy/permissions_policy.h"
#include "third_party/blink/public/mojom/blob/blob.mojom.h"
#include "third_party/blink/public/mojom/permissions_policy/policy_value.mojom.h"
#include "ui/accessibility/ax_mode.h"
#include "ui/gfx/ipc/geometry/gfx_param_traits.h"

namespace IPC {

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

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

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

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

void ParamTraits<blink::MessagePortDescriptor>::Write(
    base::Pickle* m,
    const param_type& pconst) { … }

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

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

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

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

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

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

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

template <>
struct ParamTraits<blink::mojom::SerializedBlobPtr> { … };

template <>
struct ParamTraits<
    mojo::PendingRemote<blink::mojom::FileSystemAccessTransferToken>> { … };

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

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

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

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

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

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

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

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

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

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

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

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

}  // namespace IPC

// Generate param traits write methods.
#include "ipc/param_traits_write_macros.h"
namespace IPC {
#undef CONTENT_COMMON_CONTENT_PARAM_TRAITS_MACROS_H_
#include "content/common/content_param_traits_macros.h"
}  // namespace IPC

// Generate param traits read methods.
#include "ipc/param_traits_read_macros.h"
namespace IPC {
#undef CONTENT_COMMON_CONTENT_PARAM_TRAITS_MACROS_H_
#include "content/common/content_param_traits_macros.h"
}  // namespace IPC

// Generate param traits log methods.
#include "ipc/param_traits_log_macros.h"
namespace IPC {
#undef CONTENT_COMMON_CONTENT_PARAM_TRAITS_MACROS_H_
#include "content/common/content_param_traits_macros.h"
}  // namespace IPC
chromium/content/common/content_param_traits.cc
