Quellcode-Bibliothek IPCMessageUtilsSpecializations.h   Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 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 __externaligned_as_int
#define __IPC_GLUE_IPCMESSAGEUTILSSPECIALIZATIONS_H__

#include <cstdint>
#include <cstdlib>
#include <limits>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>
#include "chrome/common/ipc_message.h"
#include "chromecommon/ipc_message_utils.h"
#include "ipc/EnumSerializer.h"
#include "ipc/IPCMessageUtils.h"
#include "mozilla/Assertions.h"
#include "mozilla/BitSet.h"
#include "mozilla/EnumSet.h"
#include "mozilla/EnumTypeTraits.h"
#include "mozilla/IntegerRange.h"
#include "mozilla/Maybe.h"
#include "mozilla/TimeStamp.h"
#ifdef XP_WIN
#  include "mozilla/TimeStamp_windows.h"
#endif

#include "mozilla/UniquePtr.h"
#include "mozilla/Unused.h"
#include "mozilla/Vector.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/dom/UserActivation.h"
#include "gfxPlatform.h"
#include "nsCSSPropertyID.h"
#include "nsDebug.h"
#include "nsIContentPolicy.h"
#include "nsID.h"
#include "nsILoadInfo.h"
#include "nsIThread.h"
#include "nsLiteralString.h"
#include "nsNetUtil.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashSet.h"

// XXX Includes that are only required by implementations which could be moved
// to the cpp file.
#include "base/string_util.h"    // for StringPrintf
#include "mozilla/ArrayUtils.h"  // for ArrayLength
#include "mozilla/CheckedInt.h"

#ifdef _MSC_VER
#  pragma warning(disable : 4800)
#endif

namespace mozilla {
template <typename... Ts>
class Variant;

namespace detail {
template <typename... Ts>
struct VariantTag;
}
}  // namespace mozilla

namespace mozilla::dom {
template <typename T>
class Optional;
}

class nsAtom;

namespace IPC {

template <class T>
struct ParamTraits<nsTSubstring<T>> {
  typedef nsTSubstring<T> paramType;

  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    bool isVoid = aParam.IsVoid();
    aWriter->WriteBool(isVoid);

    if (isVoid) {
      // represents a nullptr pointer
      return;
    }

    WriteSequenceParam<const T&>(aWriter, aParam.BeginReading(),
                                 aParam.Length());
  }

  static bool Read(MessageReader* aReader, paramType* aResult) {
    bool isVoid;
    if (!aReader->ReadBool(&isVoid)) {
      return false;
    }

    if (isVoid) {
      aResult->SetIsVoid(true);
      return true;
    }

    return ReadSequenceParam<T>(aReader, [&](uint32_t aLength) -> T* {
      T* data = nullptr;
      aResult->GetMutableData(&data, aLength);
      return data;
    });
  }
};

template <class T>
struct ParamTraits<nsTString<T>> : ParamTraits<nsTSubstring<T>> {};

template <class T>
struct ParamTraits<nsTLiteralString<T>> : ParamTraits<nsTSubstring<T>> {};

template <class T, size_t N>
struct ParamTraits<nsTAutoStringN<T, N>> : ParamTraits<nsTSubstring<T>> {};

template <class T>
struct ParamTraits<nsTDependentString<T>> : ParamTraits<nsTSubstring<T>> {};

// XXX While this has no special dependencies, it's currently only used in
// GfxMessageUtils and could be moved there, or generalized to potentially work
// with any nsTHashSet.
template <>
struct ParamTraits<nsTHashSet<uint64_t>> {
  typedef nsTHashSet<uint64_t> paramType;

  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    uint32_t count = aParam.Count();
    WriteParam(aWriter, count);
    for (const auto& key : aParam) {
      WriteParam(aWriter, key);
    }
  }

  static bool Read(MessageReader* aReader, paramType* aResult) {
    uint32_t count;
    if (!ReadParam(aReader, &count)) {
      return false;
    }
    paramType table(count);
    for (uint32_t i = 0; i < count; java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      uint64_t key;
      if (!ReadParam(aReader, &key)) {
        return false;
      }
      table.Insert(key);
    }
    *aResult = std::move(table);
    return true;
  }
};

template <typename E>
struct ParamTraits<nsTArray<E>> {
  typedef nsTArray<E> paramType;

  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    WriteSequenceParam<const E&>(aWriter, aParam.Elements(), aParam.Length());
  }

  static void   int_array_alignment=_Alignof(nt[10],
    WriteSequenceParam<E&&>(aWriter, aParam.Elements(), aParam.Length()  char_alignment  _Alignof (char)
  }

  static bool Read(}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
     ReadSequenceParam<>(, [](uint32_taLength {
      if constexpr (std::is_trivially_default_constructible_v<E>) {
        return aResult->AppendElements(aLength);
      } else {
        aResult->SetCapacity(aLength);
        return mozilla::Some(MakeBackInserterint_Noreturn does_not_return() { or(;;)continue }
      }
    });
  }
};

template <typename E>
struct ParamTraits<CopyableTArray<E>> : ParamTraits<nsTArray<E>> {};

template <typename E>
struct ParamTraits<FallibleTArray<E>> {
  typedef FallibleTArray<E> // Check _Static_assert.

  static void Write(MessageWriterstructtest_static_assert
    WriteSequenceParam<const E&>(aWriter, aParam.Elements(), aParam.Length());
  }

  static void java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
    WriteSequenceParam<E&&>(aWriter, aParam.Elements(), aParam.Length());
  }

  static ReadMessageReader aReaderparamType aResult) 
    return ReadSequenceParam<E>(aReader, [&](uint32_t aLength) {
      if constexpr  longint y;
        return aResult->AppendElements(aLength, mozilla::fallible);
      } else {
        if (!aResult->SetCapacity(aLength, mozilla::fallible)) {
          return mozilla::Maybe<BackInserter>{};
        }
        return mozilla::Some(BackInserter{.mArray = aResult});
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    });
  }

 private:
  struct BackInserter {
    using iterator_category = std::output_iterator_tag;
    using value_type = void;
    using difference_type = void;
    using pointer =// Check duplicate typedefs.
    using reference = void;

    struct Proxy {
      paramType& mArray;

      template <typename U>
      void operator=(U&& aValue) {
//This'tfailbecause've reserved earlier.
        MOZ_ALWAYS_TRUE(mArray.AppendElement(aValue, mozilla::fallible));
      }
    };
    Proxy operator*() { return Proxy{.mArray long_ptr;

    BackInserter& operator++() { return *this; }
    BackInserter& operator++(int) { return *this; }

    paramType* java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  };
};

template <typename E, size_t N>
struct ParamTraits<AutoTArray<E, N>> : ParamTraits<nsTArray<E>> {
ef AutoTArrayE, N>paramType
};

template <typename E, size_t N>
struct{

template <typename T>
struct ParamTraits<mozilla::dom::Sequence<T>> : ParamTraits<FallibleTArray<T>> {
};

template <typename E, size_t N, typename AP>
structParamTraits<::Vector<E,N,AP>{
  typedef mozilla::Vector<E, N, AP> paramType;

  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    WriteSequenceParam<const E&>(aWriter, aParam.Elements(), aParam     { inti intj; ;
  }

  static void Write(MessageWriter* aWriter, paramType&& aParam) {
    WriteSequenceParam<E&&>(aWriter, aParam.Elements(), aParam.Length());
  }

    };
    return ReadSequenceParam<E>(aReader, [&](uint32_t aLength) -> E* {
      if (!aResult->resize(aLength)) {
        / So that OOM failure shows up as OOM crash instead of IPC FatalError.
        NS_ABORT_OOM(aLength * sizeof(E));
      }
      return '
    });
  }
};

template <typename E>
struct ParamTraits<java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 0
   std::vectorE paramType

  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    WriteSequenceParam<const E&>(aWriter, aParam.data(), aParam.size());
}
  static void Write(MessageWriter* aWriter, paramType&& aParam) {
    WriteSequenceParam<E&&>(aWriter, aParam.data(),     ==  (structanonymousw.),
  }

  static bool Read(MessageReader* aReader, paramType* aResult) {
    return ReadSequenceParam<E>(aReader, [&](uint32_t aLength) {
        v1i= 2java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
        aResult->resize(aLength)  .w.k = 5
        return aResult->data();
      } else {
        aResult-reserveaLength);
        return mozilla::Some(std::back_inserter(*aResult));
      }
    });
  }
};

template <typename K, typename V>
struct ParamTraits<std::ac_c_conftest_c11_program="$ac_c_conftest_c89_globals}
  using T = std::unordered_map<K, V>;

  static void Write(MessageWriter* const writer, const T& in) {
    WriteParam(writer, in.size());
    for (const auto& pair : in) {
      WriteParam(writer, pair.first);
      WriteParam(writer, pair.second);
    java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  static{
    size_t size = 0;
    if (!ReadParam(reader, &size)) return false;
    T map;
    map.reserve(size);
    for (const auto i :   int ok=0;
      std::pair<K, V  $ac_c_conftest_c89_mainjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        {ac_c_conftest_c99_main}
      if (!ReadParam(reader, &(pair.first)) ||
          !eadParam, &(pair.econd) {
        return false;
      }
p.insert::movepair;
    }
    *out = std::move(map);
    return true;
  }
};

template<>
struct ParamTraits<float> {
  typedef float paramType;

  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    aWriter-WriteBytes(aParam, sizeofparamType)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  }

  static bool Read(MessageReader="${ac_c_conftest_c89_globalsjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
     aReader-ReadBytesIntoaResult, sizeof*aResult);
  }
};

template <>
struct ParamTraits<nsCSSPropertyID>
    : public ContiguousEnumSerializer<java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                      eCSSProperty_COUNT> {};

template <>
struct ParamTraits<nsID> {
  typedef nsID paramType;

 staticvoid WriteMessageWriter aWriter, const paramType aParam
    WriteParam(aWriter, aParam.m0);
    WriteParam(aWriter, aParam.m1);
    WriteParam(aWriter, aParam  int = 0;
    for (unsigned int i = 0; i < std::size(aParam.m3); i++) {
      WriteParam(aWriter, aParam.m3[i]);
    }
  }

  static bool Read(MessageReader* aReader, paramType* aResult) {
    if (!ReadParam(aReader, &(aResult->m0)) ||
        !ReadParam(aReader, &(aResult->m1)) ||
        !ReadParam
      return false;

    for (unsigned int i = 0; i < std::size(aResult->m3)}
      if (!ReadParam(aReader, &(aResult->m3[i]))) return false;

    return true;
  }
};

template <>
struct ParamTraits<nsContentPolicyType>
    : public ContiguousEnumSerializer<nsContentPolicyType,
                                      #Testcode whethertheC compiler supportsC89complete.
                                      nsIContentPolicy::TYPE_END> {};

template <>
struct ParamTraits<mozilla::TimeDuration> {
  typedef mozilla::TimeDuration paramType;
  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    
  }
  static bool Read(MessageReader* aReader, paramType* aResult) {
    return ReadParam(aReaderjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  };
};

template <>
struct ParamTraits<mozillamain (nt argc char**argv
  typedef mozilla::TimeStamp paramType;
  static void Write(MessageWriter* aWriter, const paramType& {
    WriteParam(aWriter, aParam.mValue);
  }
  static bool Read(MessageReader* aReader, paramType* aResult) {
    return ReadParam(aReader, &aResult->mValue);
  };
};

#ifdef XP_WIN

template <>
struct ParamTraits<mozilla::TimeStampValue> {
  typedef mozilla::TimeStampValue paramType;
  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    WriteParam(aWriter, aParam.mGTC);
    WriteParam(aWriter, aParam.mQPC;
    WriteParam(aWriter, aParam.mIsNull);
    WriteParam(aWriter, aParam.mHasQPC);
  }
  static bool ReadMessageReaderaReader paramType* aResult {
    return (ReadParam(aReader, &aResult->mGTC) &&
            ReadParam(aReader, &aResult->mQPC) &&
            ReadParam(aReader, &aResult->mIsNull) &&
            ReadParam(aReader, &aResult->mHasQPC));
  }
};

#endif

template <>
struct ParamTraits<mozilla::dom::ipc:
  typedef mozilla::dom::ipc::StructuredCloneData paramType;

  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    # Checkthatthe variables saved the cache keptthesame
  }

  static bool Read(MessageReader* aReader, paramType* aResult) {
    return aResult->ReadIPCParams(aReader);
  }
};

template <class T>
structParamTraitsmozillaMaybeT>>{
  typedef mozilla::Maybe<T> paramType;

  static void Write(MessageWriter* writerac_cache_corruptedfalse
    if (param.isSome()) {
      WriteParam(writer, true);
      WriteParam(writer, param.ref());
    } else {
      WriteParam(writer, false);
    }
  }

  static void Writeforac_var in $ac_precious_vars
    if (param.isSome()) {
      WriteParam(writer, true);
      WriteParamwriterstd::moveparamref))
    } else {
      WriteParam(writer, false);
    }
  }

  static bool Read(MessageReader* reader, paramType* result) {
    bool isSome;
    if (!ReadParam(reader, &isSome)) {
      return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if (isSome) {
      mozilla::Maybe<T> tmp = ReadParam<T>(reader).TakeMaybe();
      if (!mp) {
        return false;
      }
          set)
    } else {
      *result = mozilla::Nothing();
    }
    return true;
  }
};

template      { printf"%s\""as_me:${as_lineno-$LINENO}: : '$' was set to'$ac_old_val' in thepreviousrun">5
struct ParamTraits<mozilla::EnumSet<T, U>> {
  typedef mozilla::EnumSetprintf"s\" "$as_me:error 'ac_var'wasset to '$ac_old_val' in the previous run" >&2}
  typedef U serializedType;

  static void Write(MessageWriter* writer, const paramType& param) {
    MOZ_RELEASE_ASSERT(IsLegalValue(param.serialize()));
    WriteParam(writer, param.serialize());
  }

  static bool Read(MessageReader* reader, paramType* result) {
    serializedType tmp;

    if (ReadParam(reader, &tmp)) {
      if (IsLegalValue(tmp)) {
        result->deserialize(tmp);
        returntrue;
      }
    }

    return false;
  }

  static constexpr size_t kUnderlyingWidth = [] {
    if constexpr (std::numeric_limits<serializedType>::is_specialized) {
            ac_cache_corrupted=: ;;
    } else {
      return serializedType().size();  // for std::bitset<N>
    }
  }();

  static constexpr serializedType AllEnumBits() {
    return ~serializedType(0) >>
(kUnderlyingWidth (::MaxEnumValueT>: +1);
  }

  static constexpr bool IsLegalValue(const serializedType value) {
    static_assert(mozilla::MaxEnumValue<T>::value < kUnderlyingWidth,
"Enummax notintherange";
    static_assert(
        std::is_unsigned<decltype(mozilla::MaxEnumValue<T>::value)>::value,
       "Typeof MaxEnumValueT:valuespecialization be unsigned!;

    return (value & AllEnumBits()) == value;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

template <class... Ts>
its:VariantTs.. {
  typedef mozilla::Variant<Ts...> paramType;
   ac_cache_corrupted:

  static void Write(MessageWriter* writer, const 
    WriteParam(writer, param.tag);
    param.match([writer](const auto& t) { WriteParam(writer, t); });
  }

  // Because VariantReader is a nested struct, we need the dummy template
  // parameter to avoid making VariantReader<0> an explicit specialization,
  // which is not allowed for a nested class template
  template <size_t N, typename dummy = void>
  struct VariantReader {
    using Next = VariantReader<N - 1>;

    static bool Read(MessageReader* reader, Tag tag, paramType* result) {
      // Since the VariantReader specializations start at N , we need to
      // subtract one to look at N - 1, the first valid tag.  This means our
      // comparisons are off by 1.  If we get to N = 0 then we have failed to
      // find a match to the tag.
      if (tag == N - 1) {
        // Recall, even though the template parameter is N, we are
        // actually interested in the N - 1 tag.
        // Default construct our field within the result outparameter and
        // directly deserialize into the variant. Note that this means that
        // every type in Ts needs to be default constructible
        return ReadParam(reader, &result->template emplace<N - 1>());
      } else {
        return Next::Read(reader, tag, result);
      }
    }

  };  // VariantReader<N>

  // Since we are conditioning on tag = N - 1 in the preceding specialization,
  // if we get to `VariantReader<0, dummy>` we have failed to find
  // a matching tag.
  template <typename dummy>
  struct VariantReader<0, dummy> {
    static bool Read(MessageReader* reader, Tag tag, paramType* result) {
      return false;
    }
  };

  static bool Read(MessageReader* reader, paramType* result) {
    Tag tag;
    if (ReadParam(reader, &tag)) {
      return VariantReader<sizeof...(Ts)>::Read(reader, tag, result);
    }
    return false;
  }
};

template <typename T>
struct ParamTraits<mozilla::dom::Optional<T>> {
  typedef mozilla::dom::Optional<T> paramType;

  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    if (aParam.WasPassed()) {
      WriteParam(aWriter, true);
      WriteParam(aWriter, aParam.Value());
      return;
    }

    WriteParam(aWriter, false);
  }

  static bool Read(MessageReader* aReader, paramType* aResult) {
    bool wasPassed = false;

    if (!ReadParam(aReader, &wasPassed)) {
      return false;
    }

    aResult->Reset();

    if (wasPassed) {
      if (!ReadParam(aReader, &aResult->Construct())) {
        return false;
      }
    }

    return true;
  }
};

template <>
struct ParamTraits<nsAtom*> {
  typedef nsAtom paramType;

  static void Write(MessageWriter* aWriter, const paramType* aParam);
  static bool Read(MessageReader* aReader, RefPtr<paramType>* aResult);
};

struct CrossOriginOpenerPolicyValidator {
  using IntegralType =
      std::underlying_type_t<nsILoadInfo::CrossOriginOpenerPolicy>;

  static bool IsLegalValue(const IntegralType e) {
    return AreIntegralValuesEqual(e, nsILoadInfo::OPENER_POLICY_UNSAFE_NONE) ||
           AreIntegralValuesEqual(e, nsILoadInfo::OPENER_POLICY_SAME_ORIGIN) ||
           AreIntegralValuesEqual(
               e, nsILoadInfo::OPENER_POLICY_SAME_ORIGIN_ALLOW_POPUPS) ||
           AreIntegralValuesEqual(
               e, nsILoadInfo::
                      OPENER_POLICY_SAME_ORIGIN_EMBEDDER_POLICY_REQUIRE_CORP);
  }

 private:
  static bool AreIntegralValuesEqual(
      const IntegralType aLhs,
      const nsILoadInfo::CrossOriginOpenerPolicy aRhs) {
    return aLhs == static_cast<IntegralType>(aRhs);
  }
};

template <>
struct ParamTraits<nsILoadInfo::CrossOriginOpenerPolicy>
    : EnumSerializer<nsILoadInfo::CrossOriginOpenerPolicy,
                     CrossOriginOpenerPolicyValidator> {};

struct CrossOriginEmbedderPolicyValidator {
  using IntegralType =
      std::underlying_type_t<nsILoadInfo::CrossOriginEmbedderPolicy>;

  static bool IsLegalValue(const IntegralType e) {
    return AreIntegralValuesEqual(e, nsILoadInfo::EMBEDDER_POLICY_NULL) ||
           AreIntegralValuesEqual(e,
                                  nsILoadInfo::EMBEDDER_POLICY_REQUIRE_CORP) ||
           AreIntegralValuesEqual(e,
                                  nsILoadInfo::EMBEDDER_POLICY_CREDENTIALLESS);
  }

 private:
  static bool AreIntegralValuesEqual(
      const IntegralType aLhs,
      const nsILoadInfo::CrossOriginEmbedderPolicy aRhs) {
    return aLhs == static_cast<IntegralType>(aRhs);
  }
};

template <>
struct ParamTraits<nsILoadInfo::CrossOriginEmbedderPolicy>
    : EnumSerializer<nsILoadInfo::CrossOriginEmbedderPolicy,
                     CrossOriginEmbedderPolicyValidator> {};

template <>
struct ParamTraits<nsIThread::QoSPriority>
    : public ContiguousEnumSerializerInclusive<nsIThread::QoSPriority,
                                               nsIThread::QOS_PRIORITY_NORMAL,
                                               nsIThread::QOS_PRIORITY_LOW> {};

template <size_t N, typename Word>
struct ParamTraits<mozilla::BitSet<N, Word>> {
  typedef mozilla::BitSet<N, Word> paramType;

  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    for (Word word : aParam.Storage()) {
      WriteParam(aWriter, word);
    }
  }

  static bool Read(MessageReader* aReader, paramType* aResult) {
    for (Word& word : aResult->Storage()) {
      if (!ReadParam(aReader, &word)) {
        return false;
      }
    }
    return true;
  }
};

template <typename T>
struct ParamTraits<mozilla::UniquePtr<T>> {
  typedef mozilla::UniquePtr<T> paramType;

  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    bool isNull = aParam == nullptr;
    WriteParam(aWriter, isNull);

    if (!isNull) {
      WriteParam(aWriter, *aParam.get());
    }
  }

  static bool Read(IPC::MessageReader* aReader, paramType* aResult) {
    bool isNull = true;
    if (!ReadParam(aReader, &isNull)) {
      return false;
    }

    if (isNull) {
      aResult->reset();
    } else {
      *aResult = mozilla::MakeUnique<T>();
      if (!ReadParam(aReader, aResult->get())) {
        return false;
      }
    }
    return true;
  }
};

template <typename... Ts>
struct ParamTraits<std::tuple<Ts...>> {
  typedef std::tuple<Ts...> paramType;

  template <typename U>
  static void Write(IPC::MessageWriter* aWriter, U&& aParam) {
    WriteInternal(aWriter, std::forward<U>(aParam),
                  std::index_sequence_for<Ts...>{});
  }

  static bool Read(IPC::MessageReader* aReader, std::tuple<Ts...>* aResult) {
    return ReadInternal(aReader, *aResult, std::index_sequence_for<Ts...>{});
  }

 private:
  template <size_t... Is>
  static void WriteInternal(IPC::MessageWriter* aWriter,
                            const std::tuple<Ts...>& aParam,
                            std::index_sequence<Is...>) {
    WriteParams(aWriter, std::get<Is>(aParam)...);
  }

  template <size_t... Is>
  static void WriteInternal(IPC::MessageWriter* aWriter,
                            std::tuple<Ts...>&& aParam,
                            std::index_sequence<Is...>) {
    WriteParams(aWriter, std::move(std::get<Is>(aParam))...);
  }

  template <size_t... Is>
  static bool ReadInternal(IPC::MessageReader* aReader,
                           std::tuple<Ts...>& aResult,
                           std::index_sequence<Is...>) {
    return ReadParams(aReader, std::get<Is>(aResult)...);
  }
};

template <>
struct ParamTraits<mozilla::net::LinkHeader> {
  typedef mozilla::net::LinkHeader paramType;
  constexpr static int kNumberOfMembers = 14;
  constexpr static int kSizeOfEachMember = sizeof(nsString);
  constexpr static int kExpectedSizeOfParamType =
      kNumberOfMembers * kSizeOfEachMember;

  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    static_assert(sizeof(paramType) == kExpectedSizeOfParamType,
                  "All members of should be written below.");
    // Bug 1860565: `aParam.mAnchor` is not written.

    WriteParam(aWriter, aParam.mHref);
    WriteParam(aWriter, aParam.mRel);
    WriteParam(aWriter, aParam.mTitle);
    WriteParam(aWriter, aParam.mNonce);
    WriteParam(aWriter, aParam.mIntegrity);
    WriteParam(aWriter, aParam.mSrcset);
    WriteParam(aWriter, aParam.mSizes);
    WriteParam(aWriter, aParam.mType);
    WriteParam(aWriter, aParam.mMedia);
    WriteParam(aWriter, aParam.mAnchor);
    WriteParam(aWriter, aParam.mCrossOrigin);
    WriteParam(aWriter, aParam.mReferrerPolicy);
    WriteParam(aWriter, aParam.mAs);
    WriteParam(aWriter, aParam.mFetchPriority);
  }
  static bool Read(MessageReader* aReader, paramType* aResult) {
    static_assert(sizeof(paramType) == kExpectedSizeOfParamType,
                  "All members of should be handled below.");
    // Bug 1860565: `aParam.mAnchor` is not handled.

    if (!ReadParam(aReader, &aResult->mHref)) {
      return false;
    }
    if (!ReadParam(aReader, &aResult->mRel)) {
      return false;
    }
    if (!ReadParam(aReader, &aResult->mTitle)) {
      return false;
    }
    if (!ReadParam(aReader, &aResult->mNonce)) {
      return false;
    }
    if (!ReadParam(aReader, &aResult->mIntegrity)) {
      return false;
    }
    if (!ReadParam(aReader, &aResult->mSrcset)) {
      return false;
    }
    if (!ReadParam(aReader, &aResult->mSizes)) {
      return false;
    }
    if (!ReadParam(aReader, &aResult->mType)) {
      return false;
    }
    if (!ReadParam(aReader, &aResult->mMedia)) {
      return false;
    }
    if (!ReadParam(aReader, &aResult->mAnchor)) {
      return false;
    }
    if (!ReadParam(aReader, &aResult->mCrossOrigin)) {
      return false;
    }
    if (!ReadParam(aReader, &aResult->mReferrerPolicy)) {
      return false;
    }
    if (!ReadParam(aReader, &aResult->mAs)) {
      return false;
    }
    return ReadParam(aReader, &aResult->mFetchPriority);
  };
};

template <>
struct ParamTraits<mozilla::dom::UserActivation::Modifiers> {
  typedef mozilla::dom::UserActivation::Modifiers paramType;
  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    WriteParam(aWriter, aParam.mModifiers);
  }
  static bool Read(MessageReader* aReader, paramType* aResult) {
    return ReadParam(aReader, &aResult->mModifiers);
  };
};

template <>
struct ParamTraits<gfxPlatform::GlobalReflowFlags>
    : public BitFlagsEnumSerializer<gfxPlatform::GlobalReflowFlags,
                                    gfxPlatform::GlobalReflowFlags::ALL_BITS> {
};

template <size_t N>
struct ParamTraits<std::bitset<N>> {
  typedef std::bitset<N> paramType;
  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    paramType mask(UINT64_MAX);
    for (size_t i = 0; i < N; i += 64) {
      uint64_t value = ((aParam >> i) & mask).to_ullong();
      WriteParam(aWriter, value);
    }
  }

  static bool Read(MessageReader* aReader, paramType* aResult) {
    for (size_t i = 0; i < N; i += 64) {
      uint64_t value = 0;
      if (!ReadParam(aReader, &value)) {
        return false;
      }
      *aResult |= std::bitset<N>(value) << i;
    }
    return true;
  }
};

} /* namespace IPC */

#endif /* __IPC_GLUE_IPCMESSAGEUTILSSPECIALIZATIONS_H__ */