The Tor Browser: ipc/glue/IPCMessageUtils.h@6474c204b198 (annotated)

ipc/glue/IPCMessageUtils.h@6474c204b198 (annotated)

ipc/glue/IPCMessageUtils.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set sw=2 ts=8 et tw=80 : */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef __IPC_GLUE_IPCMESSAGEUTILS_H__
 #define __IPC_GLUE_IPCMESSAGEUTILS_H__
 #include "base/process_util.h"
 #include "chrome/common/ipc_message_utils.h"
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/TimeStamp.h"
 #ifdef XP_WIN
 #include "mozilla/TimeStamp_windows.h"
 #endif
 #include "mozilla/TypedEnum.h"
 #include "mozilla/IntegerTypeTraits.h"
 #include <stdint.h>
 #include "nsID.h"
 #include "nsMemory.h"
 #include "nsString.h"
 #include "nsTArray.h"
 #include "js/StructuredClone.h"
 #include "nsCSSProperty.h"
 #ifdef _MSC_VER
 #pragma warning( disable : 4800 )
 #endif
 #if !defined(OS_POSIX)
 // This condition must be kept in sync with the one in
 // ipc_message_utils.h, but this dummy definition of
 // base::FileDescriptor acts as a static assert that we only get one
 // def or the other (or neither, in which case code using
 // FileDescriptor fails to build)
 namespace base { struct FileDescriptor { }; }
 #endif
 namespace mozilla {
 // This is a cross-platform approximation to HANDLE, which we expect
 // to be typedef'd to void* or thereabouts.
 typedef uintptr_t WindowsHandle;
 // XXX there are out of place and might be generally useful.  Could
 // move to nscore.h or something.
 struct void_t {
   bool operator==(const void_t&) const { return true; }
 };
 struct null_t {
   bool operator==(const null_t&) const { return true; }
 };
 struct SerializedStructuredCloneBuffer
 {
   SerializedStructuredCloneBuffer()
   : data(nullptr), dataLength(0)
   { }
   SerializedStructuredCloneBuffer(const JSAutoStructuredCloneBuffer& aOther)
   {
     *this = aOther;
   }
   bool
   operator==(const SerializedStructuredCloneBuffer& aOther) const
   {
     return this->data == aOther.data &&
            this->dataLength == aOther.dataLength;
   }
   SerializedStructuredCloneBuffer&
   operator=(const JSAutoStructuredCloneBuffer& aOther)
   {
     data = aOther.data();
     dataLength = aOther.nbytes();
     return *this;
   }
   uint64_t* data;
   size_t dataLength;
 };
 } // namespace mozilla
 namespace IPC {
 /**
  * Generic enum serializer.
  *
  * Consider using the specializations below, such as ContiguousEnumSerializer.
  *
  * This is a generic serializer for any enum type used in IPDL.
  * Programmers can define ParamTraits<E> for enum type E by deriving
  * EnumSerializer<E, MyEnumValidator> where MyEnumValidator is a struct
  * that has to define a static IsLegalValue function returning whether
  * a given value is a legal value of the enum type at hand.
  *
  * \sa https://developer.mozilla.org/en/IPDL/Type_Serialization
  */
 template <typename E, typename EnumValidator>
 struct EnumSerializer {
   typedef E paramType;
   typedef typename mozilla::UnsignedStdintTypeForSize<sizeof(paramType)>::Type
           uintParamType;
   static void Write(Message* aMsg, const paramType& aValue) {
     MOZ_ASSERT(EnumValidator::IsLegalValue(aValue));
     WriteParam(aMsg, uintParamType(aValue));
   }
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult) {
     uintParamType value;
     if(!ReadParam(aMsg, aIter, &value) ||
        !EnumValidator::IsLegalValue(paramType(value))) {
       return false;
     }
     *aResult = paramType(value);
     return true;
   }
 };
 template <typename E,
           E MinLegal,
           E HighBound>
 struct ContiguousEnumValidator
 {
   static bool IsLegalValue(E e)
   {
     return MinLegal <= e && e < HighBound;
   }
 };
 template <typename E,
           MOZ_TEMPLATE_ENUM_CLASS_ENUM_TYPE(E) MinLegal,
           MOZ_TEMPLATE_ENUM_CLASS_ENUM_TYPE(E) HighBound>
 class ContiguousTypedEnumValidator
 {
   // Silence overzealous -Wtype-limits bug in GCC fixed in GCC 4.8:
   // "comparison of unsigned expression >= 0 is always true"
   // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=11856
   template <typename T>
   static bool IsLessThanOrEqual(T a, T b) { return a <= b; }
 public:
   static bool IsLegalValue(E e)
   {
     typedef MOZ_TEMPLATE_ENUM_CLASS_ENUM_TYPE(E) ActualEnumType;
     return IsLessThanOrEqual(MinLegal, ActualEnumType(e)) &&
            ActualEnumType(e) < HighBound;
   }
 };
 template <typename E,
           E AllBits>
 struct BitFlagsEnumValidator
 {
   static bool IsLegalValue(E e)
   {
     return (e & AllBits) == e;
   }
 };
 template <typename E,
           MOZ_TEMPLATE_ENUM_CLASS_ENUM_TYPE(E) AllBits>
 struct BitFlagsTypedEnumValidator
 {
   static bool IsLegalValue(E e)
   {
     return (e & AllBits) == e;
   }
 };
 /**
  * Specialization of EnumSerializer for enums with contiguous enum values.
  *
  * Provide two values: MinLegal, HighBound. An enum value x will be
  * considered legal if MinLegal <= x < HighBound.
  *
  * For example, following is definition of serializer for enum type FOO.
  * \code
  * enum FOO { FOO_FIRST, FOO_SECOND, FOO_LAST, NUM_FOO };
  *
  * template <>
  * struct ParamTraits<FOO>:
  *     public ContiguousEnumSerializer<FOO, FOO_FIRST, NUM_FOO> {};
  * \endcode
  * FOO_FIRST, FOO_SECOND, and FOO_LAST are valid value.
  */
 template <typename E,
           E MinLegal,
           E HighBound>
 struct ContiguousEnumSerializer
   : EnumSerializer<E,
                    ContiguousEnumValidator<E, MinLegal, HighBound>>
 {};
 /**
  * Similar to ContiguousEnumSerializer, but for MFBT typed enums
  * as constructed by MOZ_BEGIN_ENUM_CLASS. This can go away when
  * we drop MOZ_BEGIN_ENUM_CLASS and use C++11 enum classes directly.
  */
 template <typename E,
           MOZ_TEMPLATE_ENUM_CLASS_ENUM_TYPE(E) MinLegal,
           MOZ_TEMPLATE_ENUM_CLASS_ENUM_TYPE(E) HighBound>
 struct ContiguousTypedEnumSerializer
   : EnumSerializer<E,
                    ContiguousTypedEnumValidator<E, MinLegal, HighBound>>
 {};
 /**
  * Specialization of EnumSerializer for enums representing bit flags.
  *
  * Provide one value: AllBits. An enum value x will be
  * considered legal if (x & AllBits) == x;
  *
  * Example:
  * \code
  * enum FOO {
  *   FOO_FIRST =  1 << 0,
  *   FOO_SECOND = 1 << 1,
  *   FOO_LAST =   1 << 2,
  *   ALL_BITS =   (1 << 3) - 1
  * };
  *
  * template <>
  * struct ParamTraits<FOO>:
  *     public BitFlagsEnumSerializer<FOO, FOO::ALL_BITS> {};
  * \endcode
  */
 template <typename E,
           E AllBits>
 struct BitFlagsEnumSerializer
   : EnumSerializer<E,
                    BitFlagsEnumValidator<E, AllBits>>
 {};
 /**
  * Similar to BitFlagsEnumSerializer, but for MFBT typed enums
  * as constructed by MOZ_BEGIN_ENUM_CLASS. This can go away when
  * we drop MOZ_BEGIN_ENUM_CLASS and use C++11 enum classes directly.
  */
 template <typename E,
           MOZ_TEMPLATE_ENUM_CLASS_ENUM_TYPE(E) AllBits>
 struct BitFlagsTypedEnumSerializer
   : EnumSerializer<E,
                    BitFlagsTypedEnumValidator<E, AllBits>>
 {};
 template <>
 struct ParamTraits<base::ChildPrivileges>
   : public ContiguousEnumSerializer<base::ChildPrivileges,
                                     base::PRIVILEGES_DEFAULT,
                                     base::PRIVILEGES_LAST>
 { };
 template<>
 struct ParamTraits<int8_t>
 {
   typedef int8_t paramType;
   static void Write(Message* aMsg, const paramType& aParam)
   {
     aMsg->WriteBytes(&aParam, sizeof(aParam));
   }
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     const char* outp;
     if (!aMsg->ReadBytes(aIter, &outp, sizeof(*aResult)))
       return false;
     *aResult = *reinterpret_cast<const paramType*>(outp);
     return true;
   }
 };
 template<>
 struct ParamTraits<uint8_t>
 {
   typedef uint8_t paramType;
   static void Write(Message* aMsg, const paramType& aParam)
   {
     aMsg->WriteBytes(&aParam, sizeof(aParam));
   }
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     const char* outp;
     if (!aMsg->ReadBytes(aIter, &outp, sizeof(*aResult)))
       return false;
     *aResult = *reinterpret_cast<const paramType*>(outp);
     return true;
   }
 };
 #if !defined(OS_POSIX)
 // See above re: keeping definitions in sync
 template<>
 struct ParamTraits<base::FileDescriptor>
 {
   typedef base::FileDescriptor paramType;
   static void Write(Message* aMsg, const paramType& aParam) {
     NS_RUNTIMEABORT("FileDescriptor isn't meaningful on this platform");
   }
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult) {
     NS_RUNTIMEABORT("FileDescriptor isn't meaningful on this platform");
     return false;
   }
 };
 #endif  // !defined(OS_POSIX)
 template <>
 struct ParamTraits<nsACString>
 {
   typedef nsACString paramType;
   static void Write(Message* aMsg, const paramType& aParam)
   {
     bool isVoid = aParam.IsVoid();
     aMsg->WriteBool(isVoid);
     if (isVoid)
       // represents a nullptr pointer
       return;
     uint32_t length = aParam.Length();
     WriteParam(aMsg, length);
     aMsg->WriteBytes(aParam.BeginReading(), length);
   }
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     bool isVoid;
     if (!aMsg->ReadBool(aIter, &isVoid))
       return false;
     if (isVoid) {
       aResult->SetIsVoid(true);
       return true;
     }
     uint32_t length;
     if (ReadParam(aMsg, aIter, &length)) {
       const char* buf;
       if (aMsg->ReadBytes(aIter, &buf, length)) {
         aResult->Assign(buf, length);
         return true;
       }
     }
     return false;
   }
   static void Log(const paramType& aParam, std::wstring* aLog)
   {
     if (aParam.IsVoid())
       aLog->append(L"(NULL)");
     else
       aLog->append(UTF8ToWide(aParam.BeginReading()));
   }
 };
 template <>
 struct ParamTraits<nsAString>
 {
   typedef nsAString paramType;
   static void Write(Message* aMsg, const paramType& aParam)
   {
     bool isVoid = aParam.IsVoid();
     aMsg->WriteBool(isVoid);
     if (isVoid)
       // represents a nullptr pointer
       return;
     uint32_t length = aParam.Length();
     WriteParam(aMsg, length);
     aMsg->WriteBytes(aParam.BeginReading(), length * sizeof(char16_t));
   }
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     bool isVoid;
     if (!aMsg->ReadBool(aIter, &isVoid))
       return false;
     if (isVoid) {
       aResult->SetIsVoid(true);
       return true;
     }
     uint32_t length;
     if (ReadParam(aMsg, aIter, &length)) {
       const char16_t* buf;
       if (aMsg->ReadBytes(aIter, reinterpret_cast<const char**>(&buf),
                        length * sizeof(char16_t))) {
         aResult->Assign(buf, length);
         return true;
       }
     }
     return false;
   }
   static void Log(const paramType& aParam, std::wstring* aLog)
   {
     if (aParam.IsVoid())
       aLog->append(L"(NULL)");
     else {
 #ifdef WCHAR_T_IS_UTF16
       aLog->append(reinterpret_cast<const wchar_t*>(aParam.BeginReading()));
 #else
       uint32_t length = aParam.Length();
       for (uint32_t index = 0; index < length; index++) {
         aLog->push_back(std::wstring::value_type(aParam[index]));
       }
 #endif
     }
   }
 };
 template <>
 struct ParamTraits<nsCString> : ParamTraits<nsACString>
 {
   typedef nsCString paramType;
 };
 template <>
 struct ParamTraits<nsLiteralCString> : ParamTraits<nsACString>
 {
   typedef nsLiteralCString paramType;
 };
 #ifdef MOZILLA_INTERNAL_API
 template<>
 struct ParamTraits<nsAutoCString> : ParamTraits<nsCString>
 {
   typedef nsAutoCString paramType;
 };
 #endif  // MOZILLA_INTERNAL_API
 template <>
 struct ParamTraits<nsString> : ParamTraits<nsAString>
 {
   typedef nsString paramType;
 };
 template <>
 struct ParamTraits<nsLiteralString> : ParamTraits<nsAString>
 {
   typedef nsLiteralString paramType;
 };
 template <typename E>
 struct ParamTraits<FallibleTArray<E> >
 {
   typedef FallibleTArray<E> paramType;
   static void Write(Message* aMsg, const paramType& aParam)
   {
     uint32_t length = aParam.Length();
     WriteParam(aMsg, length);
     for (uint32_t index = 0; index < length; index++) {
       WriteParam(aMsg, aParam[index]);
     }
   }
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     uint32_t length;
     if (!ReadParam(aMsg, aIter, &length)) {
       return false;
     }
     aResult->SetCapacity(length);
     for (uint32_t index = 0; index < length; index++) {
       E* element = aResult->AppendElement();
       if (!(element && ReadParam(aMsg, aIter, element))) {
         return false;
       }
     }
     return true;
   }
   static void Log(const paramType& aParam, std::wstring* aLog)
   {
     for (uint32_t index = 0; index < aParam.Length(); index++) {
       if (index) {
         aLog->append(L" ");
       }
       LogParam(aParam[index], aLog);
     }
   }
 };
 template<typename E>
 struct ParamTraits<InfallibleTArray<E> >
 {
   typedef InfallibleTArray<E> paramType;
   static void Write(Message* aMsg, const paramType& aParam)
   {
     WriteParam(aMsg, static_cast<const FallibleTArray<E>&>(aParam));
   }
   // deserialize the array fallibly, but return an InfallibleTArray
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     FallibleTArray<E> temp;
     if (!ReadParam(aMsg, aIter, &temp))
       return false;
     aResult->SwapElements(temp);
     return true;
   }
   static void Log(const paramType& aParam, std::wstring* aLog)
   {
     LogParam(static_cast<const FallibleTArray<E>&>(aParam), aLog);
   }
 };
 template<>
 struct ParamTraits<float>
 {
   typedef float paramType;
   static void Write(Message* aMsg, const paramType& aParam)
   {
     aMsg->WriteBytes(&aParam, sizeof(paramType));
   }
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     const char* outFloat;
     if (!aMsg->ReadBytes(aIter, &outFloat, sizeof(float)))
       return false;
     *aResult = *reinterpret_cast<const float*>(outFloat);
     return true;
   }
   static void Log(const paramType& aParam, std::wstring* aLog)
   {
     aLog->append(StringPrintf(L"%g", aParam));
   }
 };
 template <>
 struct ParamTraits<nsCSSProperty>
   : public ContiguousEnumSerializer<nsCSSProperty,
                                     eCSSProperty_UNKNOWN,
                                     eCSSProperty_COUNT>
 {};
 template<>
 struct ParamTraits<mozilla::void_t>
 {
   typedef mozilla::void_t paramType;
   static void Write(Message* aMsg, const paramType& aParam) { }
   static bool
   Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     *aResult = paramType();
     return true;
   }
 };
 template<>
 struct ParamTraits<mozilla::null_t>
 {
   typedef mozilla::null_t paramType;
   static void Write(Message* aMsg, const paramType& aParam) { }
   static bool
   Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     *aResult = paramType();
     return true;
   }
 };
 template<>
 struct ParamTraits<nsID>
 {
   typedef nsID paramType;
   static void Write(Message* aMsg, const paramType& aParam)
   {
     WriteParam(aMsg, aParam.m0);
     WriteParam(aMsg, aParam.m1);
     WriteParam(aMsg, aParam.m2);
     for (unsigned int i = 0; i < mozilla::ArrayLength(aParam.m3); i++) {
       WriteParam(aMsg, aParam.m3[i]);
     }
   }
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     if(!ReadParam(aMsg, aIter, &(aResult->m0)) ||
        !ReadParam(aMsg, aIter, &(aResult->m1)) ||
        !ReadParam(aMsg, aIter, &(aResult->m2)))
       return false;
     for (unsigned int i = 0; i < mozilla::ArrayLength(aResult->m3); i++)
       if (!ReadParam(aMsg, aIter, &(aResult->m3[i])))
         return false;
     return true;
   }
   static void Log(const paramType& aParam, std::wstring* aLog)
   {
     aLog->append(L"{");
     aLog->append(StringPrintf(L"%8.8X-%4.4X-%4.4X-",
                               aParam.m0,
                               aParam.m1,
                               aParam.m2));
     for (unsigned int i = 0; i < mozilla::ArrayLength(aParam.m3); i++)
       aLog->append(StringPrintf(L"%2.2X", aParam.m3[i]));
     aLog->append(L"}");
   }
 };
 template<>
 struct ParamTraits<mozilla::TimeDuration>
 {
   typedef mozilla::TimeDuration paramType;
   static void Write(Message* aMsg, const paramType& aParam)
   {
     WriteParam(aMsg, aParam.mValue);
   }
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     return ReadParam(aMsg, aIter, &aResult->mValue);
   };
 };
 template<>
 struct ParamTraits<mozilla::TimeStamp>
 {
   typedef mozilla::TimeStamp paramType;
   static void Write(Message* aMsg, const paramType& aParam)
   {
     WriteParam(aMsg, aParam.mValue);
   }
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     return ReadParam(aMsg, aIter, &aResult->mValue);
   };
 };
 #ifdef XP_WIN
 template<>
 struct ParamTraits<mozilla::TimeStampValue>
 {
   typedef mozilla::TimeStampValue paramType;
   static void Write(Message* aMsg, const paramType& aParam)
   {
     WriteParam(aMsg, aParam.mGTC);
     WriteParam(aMsg, aParam.mQPC);
     WriteParam(aMsg, aParam.mHasQPC);
     WriteParam(aMsg, aParam.mIsNull);
   }
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     return (ReadParam(aMsg, aIter, &aResult->mGTC) &&
             ReadParam(aMsg, aIter, &aResult->mQPC) &&
             ReadParam(aMsg, aIter, &aResult->mHasQPC) &&
             ReadParam(aMsg, aIter, &aResult->mIsNull));
   }
 };
 #endif
 template <>
 struct ParamTraits<mozilla::SerializedStructuredCloneBuffer>
 {
   typedef mozilla::SerializedStructuredCloneBuffer paramType;
   static void Write(Message* aMsg, const paramType& aParam)
   {
     WriteParam(aMsg, aParam.dataLength);
     if (aParam.dataLength) {
       // Structured clone data must be 64-bit aligned.
       aMsg->WriteBytes(aParam.data, aParam.dataLength, sizeof(uint64_t));
     }
   }
   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
   {
     if (!ReadParam(aMsg, aIter, &aResult->dataLength)) {
       return false;
     }
     if (aResult->dataLength) {
       const char** buffer =
         const_cast<const char**>(reinterpret_cast<char**>(&aResult->data));
       // Structured clone data must be 64-bit aligned.
       if (!aMsg->ReadBytes(aIter, buffer, aResult->dataLength,
                            sizeof(uint64_t))) {
         return false;
       }
     } else {
       aResult->data = nullptr;
     }
     return true;
   }
   static void Log(const paramType& aParam, std::wstring* aLog)
   {
     LogParam(aParam.dataLength, aLog);
   }
 };
 } /* namespace IPC */
 #endif /* __IPC_GLUE_IPCMESSAGEUTILS_H__ */

The Tor Browser / annotate

ipc/glue/IPCMessageUtils.h@6474c204b198 (annotated)

ipc/glue/IPCMessageUtils.h