// Copyright (c) 2012 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 IPC_IPC_MESSAGE_UTILS_H_ #define IPC_IPC_MESSAGE_UTILS_H_ #include #include #include #include #include #include #include #include #include #include #include "base/check.h" #include "base/compiler_specific.h" #include "base/component_export.h" #include "base/containers/flat_map.h" #include "base/containers/stack_container.h" #include "base/files/file.h" #include "base/memory/platform_shared_memory_region.h" #include "base/memory/read_only_shared_memory_region.h" #include "base/memory/unsafe_shared_memory_region.h" #include "base/memory/writable_shared_memory_region.h" #include "base/numerics/safe_conversions.h" #include "base/pickle.h" #include "base/types/id_type.h" #include "base/values.h" #include "build/build_config.h" #include "ipc/ipc_buildflags.h" #include "ipc/ipc_param_traits.h" #include "third_party/abseil-cpp/absl/types/optional.h" #if BUILDFLAG(IS_ANDROID) #include "base/android/scoped_hardware_buffer_handle.h" #endif #if BUILDFLAG(IS_FUCHSIA) #include #include #endif #if BUILDFLAG(IS_WIN) #include "base/strings/string_util_win.h" #endif #if BUILDFLAG(IPC_MESSAGE_LOG_ENABLED) #include "ipc/ipc_message.h" #endif namespace base { class FilePath; class Time; class TimeDelta; class TimeTicks; class UnguessableToken; struct FileDescriptor; } // namespace base namespace IPC { class Message; struct ChannelHandle; #if BUILDFLAG(IS_WIN) class PlatformFileForTransit; #endif // ----------------------------------------------------------------------------- // How we send IPC message logs across channels. struct COMPONENT_EXPORT(IPC) LogData { LogData(); LogData(const LogData& other); ~LogData(); std::string channel; int32_t routing_id; uint32_t type; // "User-defined" message type, from ipc_message.h. std::string flags; int64_t sent; // Time that the message was sent (i.e. at Send()). int64_t receive; // Time before it was dispatched (i.e. before calling // OnMessageReceived). int64_t dispatch; // Time after it was dispatched (i.e. after calling // OnMessageReceived). std::string message_name; std::string params; }; //----------------------------------------------------------------------------- // A dummy struct to place first just to allow leading commas for all // members in the macro-generated constructor initializer lists. struct NoParams { }; // Specializations are checked by 'IPC checker' part of find-bad-constructs // Clang plugin (see WriteParam() below for the details). template struct CheckedTuple { typedef std::tuple Tuple; }; // This function is checked by 'IPC checker' part of find-bad-constructs // Clang plugin to make it's not called on the following types: // 1. long / unsigned long (but not typedefs to) // 2. intmax_t, uintmax_t, intptr_t, uintptr_t, wint_t, // size_t, rsize_t, ssize_t, ptrdiff_t, dev_t, off_t, clock_t, // time_t, suseconds_t (including typedefs to) // 3. Any template referencing types above (e.g. std::vector) template inline void WriteParam(base::Pickle* m, const P& p) { typedef typename SimilarTypeTraits

::Type Type; ParamTraits::Write(m, static_cast(p)); } template [[nodiscard]] inline bool ReadParam(const base::Pickle* m, base::PickleIterator* iter, P* p) { typedef typename SimilarTypeTraits

::Type Type; return ParamTraits::Read(m, iter, reinterpret_cast(p)); } template inline void LogParam(const P& p, std::string* l) { typedef typename SimilarTypeTraits

::Type Type; ParamTraits::Log(static_cast(p), l); } // Primitive ParamTraits ------------------------------------------------------- template <> struct ParamTraits { typedef bool param_type; static void Write(base::Pickle* m, const param_type& p) { m->WriteBool(p); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return iter->ReadBool(r); } COMPONENT_EXPORT(IPC) static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef signed char param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef unsigned char param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef unsigned short param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct ParamTraits { typedef int param_type; static void Write(base::Pickle* m, const param_type& p) { m->WriteInt(p); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return iter->ReadInt(r); } COMPONENT_EXPORT(IPC) static void Log(const param_type& p, std::string* l); }; template <> struct ParamTraits { typedef unsigned int param_type; static void Write(base::Pickle* m, const param_type& p) { m->WriteInt(static_cast(p)); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return iter->ReadInt(reinterpret_cast(r)); } COMPONENT_EXPORT(IPC) static void Log(const param_type& p, std::string* l); }; // long isn't safe to send over IPC because it's 4 bytes on 32 bit builds but // 8 bytes on 64 bit builds. So if a 32 bit and 64 bit process have a channel // that would cause problem. // We need to keep this on for a few configs: // 1) Windows because DWORD is typedef'd to it, which is fine because we have // very few IPCs that cross this boundary. // 2) We also need to keep it for Linux for two reasons: int64_t is typedef'd // to long, and gfx::PluginWindow is long and is used in one GPU IPC. // 3) Android 64 bit and Fuchsia also have int64_t typedef'd to long. // Since we want to support Android 32<>64 bit IPC, as long as we don't have // these traits for 32 bit ARM then that'll catch any errors. #if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || \ BUILDFLAG(IS_FUCHSIA) || \ (BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_64_BITS)) template <> struct ParamTraits { typedef long param_type; static void Write(base::Pickle* m, const param_type& p) { m->WriteLong(p); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return iter->ReadLong(r); } COMPONENT_EXPORT(IPC) static void Log(const param_type& p, std::string* l); }; template <> struct ParamTraits { typedef unsigned long param_type; static void Write(base::Pickle* m, const param_type& p) { m->WriteLong(p); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return iter->ReadLong(reinterpret_cast(r)); } COMPONENT_EXPORT(IPC) static void Log(const param_type& p, std::string* l); }; #endif template <> struct ParamTraits { typedef long long param_type; static void Write(base::Pickle* m, const param_type& p) { m->WriteInt64(static_cast(p)); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return iter->ReadInt64(reinterpret_cast(r)); } COMPONENT_EXPORT(IPC) static void Log(const param_type& p, std::string* l); }; template <> struct ParamTraits { typedef unsigned long long param_type; static void Write(base::Pickle* m, const param_type& p) { m->WriteInt64(static_cast(p)); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return iter->ReadInt64(reinterpret_cast(r)); } COMPONENT_EXPORT(IPC) static void Log(const param_type& p, std::string* l); }; // Note that the IPC layer doesn't sanitize NaNs and +/- INF values. Clients // should be sure to check the sanity of these values after receiving them over // IPC. template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef float param_type; static void Write(base::Pickle* m, const param_type& p) { m->WriteFloat(p); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return iter->ReadFloat(r); } static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef double param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template struct ParamTraits { using param_type = P[Size]; static void Write(base::Pickle* m, const param_type& p) { for (const P& element : p) WriteParam(m, element); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { for (P& element : *r) { if (!ReadParam(m, iter, &element)) return false; } return true; } static void Log(const param_type& p, std::string* l) { l->append("["); for (const P& element : p) { if (&element != &p[0]) l->append(" "); LogParam(element, l); } l->append("]"); } }; // STL ParamTraits ------------------------------------------------------------- template <> struct ParamTraits { typedef std::string param_type; static void Write(base::Pickle* m, const param_type& p) { m->WriteString(p); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return iter->ReadString(r); } COMPONENT_EXPORT(IPC) static void Log(const param_type& p, std::string* l); }; template <> struct ParamTraits { typedef std::u16string param_type; static void Write(base::Pickle* m, const param_type& p) { m->WriteString16(p); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return iter->ReadString16(r); } COMPONENT_EXPORT(IPC) static void Log(const param_type& p, std::string* l); }; #if BUILDFLAG(IS_WIN) template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef std::wstring param_type; static void Write(base::Pickle* m, const param_type& p) { m->WriteString16(base::AsStringPiece16(p)); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; #endif template <> struct COMPONENT_EXPORT(IPC) ParamTraits> { typedef std::vector param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle*, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits> { typedef std::vector param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits> { typedef std::vector param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template struct ParamTraits> { typedef std::vector

param_type; static void Write(base::Pickle* m, const param_type& p) { WriteParam(m, base::checked_cast(p.size())); for (size_t i = 0; i < p.size(); i++) WriteParam(m, p[i]); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { size_t size; // ReadLength() checks for < 0 itself. if (!iter->ReadLength(&size)) return false; // Resizing beforehand is not safe, see BUG 1006367 for details. if (size > INT_MAX / sizeof(P)) return false; r->resize(size); for (size_t i = 0; i < size; i++) { if (!ReadParam(m, iter, &(*r)[i])) return false; } return true; } static void Log(const param_type& p, std::string* l) { for (size_t i = 0; i < p.size(); ++i) { if (i != 0) l->append(" "); LogParam((p[i]), l); } } }; template struct ParamTraits > { typedef std::set

param_type; static void Write(base::Pickle* m, const param_type& p) { WriteParam(m, base::checked_cast(p.size())); typename param_type::const_iterator iter; for (iter = p.begin(); iter != p.end(); ++iter) WriteParam(m, *iter); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { size_t size; if (!iter->ReadLength(&size)) return false; for (size_t i = 0; i < size; ++i) { P item; if (!ReadParam(m, iter, &item)) return false; r->insert(item); } return true; } static void Log(const param_type& p, std::string* l) { l->append(""); } }; template struct ParamTraits > { typedef std::map param_type; static void Write(base::Pickle* m, const param_type& p) { WriteParam(m, base::checked_cast(p.size())); for (const auto& iter : p) { WriteParam(m, iter.first); WriteParam(m, iter.second); } } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { int size; if (!ReadParam(m, iter, &size) || size < 0) return false; for (int i = 0; i < size; ++i) { K k; if (!ReadParam(m, iter, &k)) return false; V& value = (*r)[k]; if (!ReadParam(m, iter, &value)) return false; } return true; } static void Log(const param_type& p, std::string* l) { l->append(""); } }; template struct ParamTraits> { typedef std::unordered_map param_type; static void Write(base::Pickle* m, const param_type& p) { WriteParam(m, base::checked_cast(p.size())); for (const auto& iter : p) { WriteParam(m, iter.first); WriteParam(m, iter.second); } } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { int size; if (!ReadParam(m, iter, &size) || size < 0) return false; for (int i = 0; i < size; ++i) { K k; if (!ReadParam(m, iter, &k)) return false; V& value = (*r)[k]; if (!ReadParam(m, iter, &value)) return false; } return true; } static void Log(const param_type& p, std::string* l) { l->append(""); } }; template struct ParamTraits > { typedef std::pair param_type; static void Write(base::Pickle* m, const param_type& p) { WriteParam(m, p.first); WriteParam(m, p.second); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return ReadParam(m, iter, &r->first) && ReadParam(m, iter, &r->second); } static void Log(const param_type& p, std::string* l) { l->append("("); LogParam(p.first, l); l->append(", "); LogParam(p.second, l); l->append(")"); } }; // Base ParamTraits ------------------------------------------------------------ template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::DictionaryValue param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::Value::Dict param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; #if BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA) // FileDescriptors may be serialised over IPC channels on POSIX. On the // receiving side, the FileDescriptor is a valid duplicate of the file // descriptor which was transmitted: *it is not just a copy of the integer like // HANDLEs on Windows*. The only exception is if the file descriptor is < 0. In // this case, the receiving end will see a value of -1. *Zero is a valid file // descriptor*. // // The received file descriptor will have the |auto_close| flag set to true. The // code which handles the message is responsible for taking ownership of it. // File descriptors are OS resources and must be closed when no longer needed. // // When sending a file descriptor, the file descriptor must be valid at the time // of transmission. Since transmission is not synchronous, one should consider // dup()ing any file descriptors to be transmitted and setting the |auto_close| // flag, which causes the file descriptor to be closed after writing. template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::FileDescriptor param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::ScopedFD param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; #endif // BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA) #if BUILDFLAG(IS_WIN) template <> struct COMPONENT_EXPORT(IPC) ParamTraits { using param_type = base::win::ScopedHandle; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; #endif #if BUILDFLAG(IS_FUCHSIA) template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef zx::vmo param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef zx::channel param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; #endif // BUILDFLAG(IS_FUCHSIA) #if BUILDFLAG(IS_ANDROID) template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::android::ScopedHardwareBufferHandle param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; #endif template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::ReadOnlySharedMemoryRegion param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::WritableSharedMemoryRegion param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::UnsafeSharedMemoryRegion param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::subtle::PlatformSharedMemoryRegion param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::subtle::PlatformSharedMemoryRegion::Mode param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; #if BUILDFLAG(IS_WIN) template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef PlatformFileForTransit param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; #endif // BUILDFLAG(IS_WIN) template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::FilePath param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::ListValue param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::Value::List param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::Value param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::File::Info param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct SimilarTypeTraits { typedef int Type; }; #if BUILDFLAG(IS_WIN) template <> struct SimilarTypeTraits { typedef HANDLE Type; }; #endif // BUILDFLAG(IS_WIN) template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::Time param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::TimeDelta param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::TimeTicks param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef base::UnguessableToken param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct ParamTraits> { typedef std::tuple<> param_type; static void Write(base::Pickle* m, const param_type& p) {} static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return true; } static void Log(const param_type& p, std::string* l) { } }; template struct TupleParamTraitsHelper { using Next = TupleParamTraitsHelper; static void Write(base::Pickle* m, const T& p) { WriteParam(m, std::get(p)); Next::Write(m, p); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, T* r) { return ReadParam(m, iter, &std::get(*r)) && Next::Read(m, iter, r); } static void Log(const T& p, std::string* l) { LogParam(std::get(p), l); if (index < count - 1) l->append(", "); Next::Log(p, l); } }; template struct TupleParamTraitsHelper { static void Write(base::Pickle* m, const T& p) {} static bool Read(const base::Pickle* m, base::PickleIterator* iter, T* r) { return true; } static void Log(const T& p, std::string* l) {} }; template struct ParamTraits> { using param_type = std::tuple; using Helper = TupleParamTraitsHelper::value>; static void Write(base::Pickle* m, const param_type& p) { Helper::Write(m, p); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return Helper::Read(m, iter, r); } static void Log(const param_type& p, std::string* l) { Helper::Log(p, l); } }; template struct ParamTraits > { typedef base::StackVector param_type; static void Write(base::Pickle* m, const param_type& p) { WriteParam(m, base::checked_cast(p->size())); for (size_t i = 0; i < p->size(); i++) WriteParam(m, p[i]); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { size_t size; if (!iter->ReadLength(&size)) return false; // Sanity check for the vector size. if (size > INT_MAX / sizeof(P)) return false; P value; for (size_t i = 0; i < size; i++) { if (!ReadParam(m, iter, &value)) return false; (*r)->push_back(value); } return true; } static void Log(const param_type& p, std::string* l) { for (size_t i = 0; i < p->size(); ++i) { if (i != 0) l->append(" "); LogParam((p[i]), l); } } }; template struct ParamTraits> { using param_type = base::flat_map; static void Write(base::Pickle* m, const param_type& p) { DCHECK(base::IsValueInRangeForNumericType(p.size())); WriteParam(m, base::checked_cast(p.size())); for (const auto& iter : p) { WriteParam(m, iter.first); WriteParam(m, iter.second); } } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { size_t size; if (!iter->ReadLength(&size)) return false; // Construct by creating in a vector and moving into the flat_map. Properly // serialized flat_maps will be in-order so this will be O(n). Incorrectly // serialized ones will still be handled properly. std::vector vect; vect.resize(size); for (size_t i = 0; i < size; ++i) { if (!ReadParam(m, iter, &vect[i].first)) return false; if (!ReadParam(m, iter, &vect[i].second)) return false; } *r = param_type(std::move(vect)); return true; } static void Log(const param_type& p, std::string* l) { l->append(""); } }; template struct ParamTraits> { typedef std::unique_ptr

param_type; static void Write(base::Pickle* m, const param_type& p) { bool valid = !!p; WriteParam(m, valid); if (valid) WriteParam(m, *p); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { bool valid = false; if (!ReadParam(m, iter, &valid)) return false; if (!valid) { r->reset(); return true; } param_type temp(new P()); if (!ReadParam(m, iter, temp.get())) return false; r->swap(temp); return true; } static void Log(const param_type& p, std::string* l) { if (p) LogParam(*p, l); else l->append("NULL"); } }; // absl types ParamTraits template struct ParamTraits> { typedef absl::optional

param_type; static void Write(base::Pickle* m, const param_type& p) { const bool is_set = static_cast(p); WriteParam(m, is_set); if (is_set) WriteParam(m, p.value()); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { bool is_set = false; if (!iter->ReadBool(&is_set)) return false; if (is_set) { P value; if (!ReadParam(m, iter, &value)) return false; *r = std::move(value); } return true; } static void Log(const param_type& p, std::string* l) { if (p) LogParam(p.value(), l); else l->append("(unset)"); } }; template <> struct ParamTraits { typedef absl::monostate param_type; static void Write(base::Pickle* m, const param_type& p) {} static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { return true; } static void Log(const param_type& p, std::string* l) { l->append("()"); } }; // base/util types ParamTraits template struct ParamTraits> { using param_type = base::IdType; static void Write(base::Pickle* m, const param_type& p) { WriteParam(m, p.GetUnsafeValue()); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { WrappedType value; if (!ReadParam(m, iter, &value)) return false; *r = param_type::FromUnsafeValue(value); return true; } static void Log(const param_type& p, std::string* l) { LogParam(p.GetUnsafeValue(), l); } }; template struct ParamTraits> { using param_type = base::StrongAlias; static void Write(base::Pickle* m, const param_type& p) { WriteParam(m, p.value()); } static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r) { UnderlyingType value; if (!ReadParam(m, iter, &value)) return false; *r = param_type(value); return true; } static void Log(const param_type& p, std::string* l) { LogParam(p.value(), l); } }; // IPC types ParamTraits ------------------------------------------------------- // A ChannelHandle is basically a platform-inspecific wrapper around the // fact that IPC endpoints are handled specially on POSIX. See above comments // on FileDescriptor for more background. template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef ChannelHandle param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef LogData param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { static void Write(base::Pickle* m, const Message& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, Message* r); static void Log(const Message& p, std::string* l); }; // Windows ParamTraits --------------------------------------------------------- #if BUILDFLAG(IS_WIN) template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef HANDLE param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; template <> struct COMPONENT_EXPORT(IPC) ParamTraits { typedef MSG param_type; static void Write(base::Pickle* m, const param_type& p); static bool Read(const base::Pickle* m, base::PickleIterator* iter, param_type* r); static void Log(const param_type& p, std::string* l); }; #endif // BUILDFLAG(IS_WIN) //----------------------------------------------------------------------------- // Generic message subclasses // defined in ipc_logging.cc COMPONENT_EXPORT(IPC) void GenerateLogData(const Message& message, LogData* data, bool get_params); #if BUILDFLAG(IPC_MESSAGE_LOG_ENABLED) inline void AddOutputParamsToLog(const Message* msg, std::string* l) { const std::string& output_params = msg->output_params(); if (!l->empty() && !output_params.empty()) l->append(", "); l->append(output_params); } template inline void LogReplyParamsToMessage(const ReplyParamType& reply_params, const Message* msg) { if (msg->received_time() != 0) { std::string output_params; LogParam(reply_params, &output_params); msg->set_output_params(output_params); } } inline void ConnectMessageAndReply(const Message* msg, Message* reply) { if (msg->sent_time()) { // Don't log the sync message after dispatch, as we don't have the // output parameters at that point. Instead, save its data and log it // with the outgoing reply message when it's sent. LogData* data = new LogData; GenerateLogData(*msg, data, true); msg->set_dont_log(); reply->set_sync_log_data(data); } } #else inline void AddOutputParamsToLog(const Message* msg, std::string* l) {} template inline void LogReplyParamsToMessage(const ReplyParamType& reply_params, const Message* msg) {} inline void ConnectMessageAndReply(const Message* msg, Message* reply) {} #endif } // namespace IPC #endif // IPC_IPC_MESSAGE_UTILS_H_