tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

MediaIPCUtils.h (25916B)

      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #ifndef mozilla_dom_media_MediaIPCUtils_h
      8 #define mozilla_dom_media_MediaIPCUtils_h
      9 
     10 #include "DecoderDoctorDiagnostics.h"
     11 #include "EncoderConfig.h"
     12 #include "MediaTrackConstraints.h"
     13 #include "PerformanceRecorder.h"
     14 #include "PlatformDecoderModule.h"
     15 #include "PlatformEncoderModule.h"
     16 #include "ipc/EnumSerializer.h"
     17 #include "mozilla/CDMProxy.h"
     18 #include "mozilla/GfxMessageUtils.h"
     19 #include "mozilla/Maybe.h"
     20 #include "mozilla/ParamTraits_TiedFields.h"
     21 #include "mozilla/dom/MFCDMSerializers.h"
     22 #include "mozilla/dom/MediaKeysBinding.h"
     23 #include "mozilla/gfx/Rect.h"
     24 
     25 namespace IPC {
     26 template <>
     27 struct ParamTraits<mozilla::VideoInfo> {
     28  typedef mozilla::VideoInfo paramType;
     29 
     30  static void Write(MessageWriter* aWriter, const paramType& aParam) {
     31    // TrackInfo
     32    WriteParam(aWriter, aParam.mMimeType);
     33 
     34    // VideoInfo
     35    WriteParam(aWriter, aParam.mDisplay);
     36    WriteParam(aWriter, aParam.mStereoMode);
     37    WriteParam(aWriter, aParam.mImage);
     38    WriteParam(aWriter, aParam.mImageRect);
     39    WriteParam(aWriter, *aParam.mCodecSpecificConfig);
     40    WriteParam(aWriter, *aParam.mExtraData);
     41    WriteParam(aWriter, aParam.mRotation);
     42    WriteParam(aWriter, aParam.mColorDepth);
     43    WriteParam(aWriter, aParam.mColorSpace);
     44    WriteParam(aWriter, aParam.mColorPrimaries);
     45    WriteParam(aWriter, aParam.mTransferFunction);
     46    WriteParam(aWriter, aParam.mColorRange);
     47    WriteParam(aWriter, aParam.HasAlpha());
     48    WriteParam(aWriter, aParam.mCrypto);
     49  }
     50 
     51  static bool Read(MessageReader* aReader, paramType* aResult) {
     52    mozilla::gfx::IntRect imageRect;
     53    bool alphaPresent;
     54    if (ReadParam(aReader, &aResult->mMimeType) &&
     55        ReadParam(aReader, &aResult->mDisplay) &&
     56        ReadParam(aReader, &aResult->mStereoMode) &&
     57        ReadParam(aReader, &aResult->mImage) &&
     58        ReadParam(aReader, &aResult->mImageRect) &&
     59        ReadParam(aReader, aResult->mCodecSpecificConfig.get()) &&
     60        ReadParam(aReader, aResult->mExtraData.get()) &&
     61        ReadParam(aReader, &aResult->mRotation) &&
     62        ReadParam(aReader, &aResult->mColorDepth) &&
     63        ReadParam(aReader, &aResult->mColorSpace) &&
     64        ReadParam(aReader, &aResult->mColorPrimaries) &&
     65        ReadParam(aReader, &aResult->mTransferFunction) &&
     66        ReadParam(aReader, &aResult->mColorRange) &&
     67        ReadParam(aReader, &alphaPresent) &&
     68        ReadParam(aReader, &aResult->mCrypto)) {
     69      aResult->SetAlpha(alphaPresent);
     70      return true;
     71    }
     72    return false;
     73  }
     74 };
     75 
     76 template <>
     77 struct ParamTraits<mozilla::TrackInfo::TrackType>
     78    : public ContiguousEnumSerializerInclusive<
     79          mozilla::TrackInfo::TrackType,
     80          mozilla::TrackInfo::TrackType::kUndefinedTrack,
     81          mozilla::TrackInfo::TrackType::kTextTrack> {};
     82 
     83 template <>
     84 struct ParamTraits<mozilla::VideoRotation>
     85    : public ContiguousEnumSerializerInclusive<
     86          mozilla::VideoRotation, mozilla::VideoRotation::kDegree_0,
     87          mozilla::VideoRotation::kDegree_270> {};
     88 
     89 template <>
     90 struct ParamTraits<mozilla::MediaByteBuffer>
     91    : public ParamTraits<nsTArray<uint8_t>> {
     92  typedef mozilla::MediaByteBuffer paramType;
     93 };
     94 
     95 // Traits for AudioCodecSpecificVariant types.
     96 
     97 template <>
     98 struct ParamTraits<mozilla::NoCodecSpecificData>
     99    : public EmptyStructSerializer<mozilla::NoCodecSpecificData> {};
    100 
    101 template <>
    102 struct ParamTraits<mozilla::AudioCodecSpecificBinaryBlob> {
    103  using paramType = mozilla::AudioCodecSpecificBinaryBlob;
    104 
    105  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    106    WriteParam(aWriter, *aParam.mBinaryBlob);
    107  }
    108  static bool Read(MessageReader* aReader, paramType* aResult) {
    109    return ReadParam(aReader, aResult->mBinaryBlob.get());
    110  }
    111 };
    112 
    113 template <>
    114 struct ParamTraits<mozilla::AacCodecSpecificData> {
    115  using paramType = mozilla::AacCodecSpecificData;
    116 
    117  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    118    WriteParam(aWriter, *aParam.mEsDescriptorBinaryBlob);
    119    WriteParam(aWriter, *aParam.mDecoderConfigDescriptorBinaryBlob);
    120    WriteParam(aWriter, aParam.mEncoderDelayFrames);
    121    WriteParam(aWriter, aParam.mMediaFrameCount);
    122  }
    123  static bool Read(MessageReader* aReader, paramType* aResult) {
    124    return ReadParam(aReader, aResult->mEsDescriptorBinaryBlob.get()) &&
    125           ReadParam(aReader,
    126                     aResult->mDecoderConfigDescriptorBinaryBlob.get()) &&
    127           ReadParam(aReader, &aResult->mEncoderDelayFrames) &&
    128           ReadParam(aReader, &aResult->mMediaFrameCount);
    129  }
    130 };
    131 
    132 template <>
    133 struct ParamTraits<mozilla::FlacCodecSpecificData> {
    134  using paramType = mozilla::FlacCodecSpecificData;
    135 
    136  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    137    WriteParam(aWriter, *aParam.mStreamInfoBinaryBlob);
    138  }
    139  static bool Read(MessageReader* aReader, paramType* aResult) {
    140    return ReadParam(aReader, aResult->mStreamInfoBinaryBlob.get());
    141  }
    142 };
    143 
    144 template <>
    145 struct ParamTraits<mozilla::Mp3CodecSpecificData>
    146    : public ParamTraits_TiedFields<mozilla::Mp3CodecSpecificData> {};
    147 
    148 template <>
    149 struct ParamTraits<mozilla::OpusCodecSpecificData> {
    150  using paramType = mozilla::OpusCodecSpecificData;
    151 
    152  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    153    WriteParam(aWriter, aParam.mContainerCodecDelayFrames);
    154    WriteParam(aWriter, *aParam.mHeadersBinaryBlob);
    155  }
    156  static bool Read(MessageReader* aReader, paramType* aResult) {
    157    return ReadParam(aReader, &aResult->mContainerCodecDelayFrames) &&
    158           ReadParam(aReader, aResult->mHeadersBinaryBlob.get());
    159  }
    160 };
    161 
    162 template <>
    163 struct ParamTraits<mozilla::VorbisCodecSpecificData> {
    164  using paramType = mozilla::VorbisCodecSpecificData;
    165 
    166  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    167    WriteParam(aWriter, *aParam.mHeadersBinaryBlob);
    168  }
    169  static bool Read(MessageReader* aReader, paramType* aResult) {
    170    return ReadParam(aReader, aResult->mHeadersBinaryBlob.get());
    171  }
    172 };
    173 
    174 template <>
    175 struct ParamTraits<mozilla::WaveCodecSpecificData>
    176    : public EmptyStructSerializer<mozilla::WaveCodecSpecificData> {};
    177 
    178 // End traits for AudioCodecSpecificVariant types.
    179 
    180 template <>
    181 struct ParamTraits<mozilla::AudioInfo> {
    182  typedef mozilla::AudioInfo paramType;
    183 
    184  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    185    // TrackInfo
    186    WriteParam(aWriter, aParam.mMimeType);
    187 
    188    // AudioInfo
    189    WriteParam(aWriter, aParam.mRate);
    190    WriteParam(aWriter, aParam.mChannels);
    191    WriteParam(aWriter, aParam.mChannelMap);
    192    WriteParam(aWriter, aParam.mBitDepth);
    193    WriteParam(aWriter, aParam.mProfile);
    194    WriteParam(aWriter, aParam.mExtendedProfile);
    195    WriteParam(aWriter, aParam.mCodecSpecificConfig);
    196    WriteParam(aWriter, aParam.mCrypto);
    197  }
    198 
    199  static bool Read(MessageReader* aReader, paramType* aResult) {
    200    if (ReadParam(aReader, &aResult->mMimeType) &&
    201        ReadParam(aReader, &aResult->mRate) &&
    202        ReadParam(aReader, &aResult->mChannels) &&
    203        ReadParam(aReader, &aResult->mChannelMap) &&
    204        ReadParam(aReader, &aResult->mBitDepth) &&
    205        ReadParam(aReader, &aResult->mProfile) &&
    206        ReadParam(aReader, &aResult->mExtendedProfile) &&
    207        ReadParam(aReader, &aResult->mCodecSpecificConfig) &&
    208        ReadParam(aReader, &aResult->mCrypto)) {
    209      return true;
    210    }
    211    return false;
    212  }
    213 };
    214 
    215 template <>
    216 struct ParamTraits<mozilla::MediaDataDecoder::ConversionRequired>
    217    : public ContiguousEnumSerializerInclusive<
    218          mozilla::MediaDataDecoder::ConversionRequired,
    219          mozilla::MediaDataDecoder::ConversionRequired(0),
    220          mozilla::MediaDataDecoder::ConversionRequired(
    221              mozilla::MediaDataDecoder::ConversionRequired::kNeedHVCC)> {};
    222 
    223 template <>
    224 struct ParamTraits<mozilla::MediaDataDecoder::PropertyName>
    225    : public ContiguousEnumSerializerInclusive<
    226          mozilla::MediaDataDecoder::PropertyName,
    227          mozilla::MediaDataDecoder::PropertyName(0),
    228          mozilla::MediaDataDecoder::sHighestPropertyName> {};
    229 
    230 template <>
    231 struct ParamTraits<mozilla::media::TimeUnit> {
    232  using paramType = mozilla::media::TimeUnit;
    233 
    234  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    235    WriteParam(aWriter, aParam.IsValid());
    236    WriteParam(aWriter, aParam.IsValid() ? aParam.mTicks.value() : 0);
    237    WriteParam(aWriter,
    238               aParam.IsValid() ? aParam.mBase : 1);  // base can't be 0
    239  }
    240 
    241  static bool Read(MessageReader* aReader, paramType* aResult) {
    242    bool valid;
    243    int64_t ticks;
    244    int64_t base;
    245    if (ReadParam(aReader, &valid) && ReadParam(aReader, &ticks) &&
    246        ReadParam(aReader, &base)) {
    247      if (valid) {
    248        *aResult = mozilla::media::TimeUnit(ticks, base);
    249      } else {
    250        *aResult = mozilla::media::TimeUnit::Invalid();
    251      }
    252      return true;
    253    }
    254    return false;
    255  };
    256 };
    257 
    258 template <>
    259 struct ParamTraits<mozilla::media::TimeInterval> {
    260  typedef mozilla::media::TimeInterval paramType;
    261 
    262  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    263    WriteParam(aWriter, aParam.mStart);
    264    WriteParam(aWriter, aParam.mEnd);
    265    WriteParam(aWriter, aParam.mFuzz);
    266  }
    267 
    268  static bool Read(MessageReader* aReader, paramType* aResult) {
    269    if (ReadParam(aReader, &aResult->mStart) &&
    270        ReadParam(aReader, &aResult->mEnd) &&
    271        ReadParam(aReader, &aResult->mFuzz)) {
    272      return true;
    273    }
    274    return false;
    275  }
    276 };
    277 
    278 template <>
    279 struct ParamTraits<mozilla::MediaResult> {
    280  typedef mozilla::MediaResult paramType;
    281 
    282  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    283    WriteParam(aWriter, aParam.Code());
    284    WriteParam(aWriter, aParam.Message());
    285    WriteParam(aWriter, aParam.GetPlatformErrorCode());
    286  }
    287 
    288  static bool Read(MessageReader* aReader, paramType* aResult) {
    289    nsresult result;
    290    nsCString message;
    291    mozilla::Maybe<int32_t> platformErrorCode;
    292    if (ReadParam(aReader, &result) && ReadParam(aReader, &message) &&
    293        ReadParam(aReader, &platformErrorCode)) {
    294      *aResult = paramType(result, std::move(message), platformErrorCode);
    295      return true;
    296    }
    297    return false;
    298  };
    299 };
    300 
    301 template <>
    302 struct ParamTraits<mozilla::DecoderDoctorDiagnostics> {
    303  typedef mozilla::DecoderDoctorDiagnostics paramType;
    304 
    305  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    306    WriteParam(aWriter, aParam.mDiagnosticsType);
    307    WriteParam(aWriter, aParam.mFormat);
    308    WriteParam(aWriter, aParam.mFlags);
    309    WriteParam(aWriter, aParam.mEvent);
    310  }
    311 
    312  static bool Read(MessageReader* aReader, paramType* aResult) {
    313    if (ReadParam(aReader, &aResult->mDiagnosticsType) &&
    314        ReadParam(aReader, &aResult->mFormat) &&
    315        ReadParam(aReader, &aResult->mFlags) &&
    316        ReadParam(aReader, &aResult->mEvent)) {
    317      return true;
    318    }
    319    return false;
    320  };
    321 };
    322 
    323 template <>
    324 struct ParamTraits<mozilla::DecoderDoctorDiagnostics::DiagnosticsType>
    325    : public ContiguousEnumSerializerInclusive<
    326          mozilla::DecoderDoctorDiagnostics::DiagnosticsType,
    327          mozilla::DecoderDoctorDiagnostics::DiagnosticsType::eUnsaved,
    328          mozilla::DecoderDoctorDiagnostics::DiagnosticsType::eDecodeWarning> {
    329 };
    330 
    331 template <>
    332 struct ParamTraits<mozilla::DecoderDoctorEvent> {
    333  typedef mozilla::DecoderDoctorEvent paramType;
    334 
    335  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    336    int domain = aParam.mDomain;
    337    WriteParam(aWriter, domain);
    338    WriteParam(aWriter, aParam.mResult);
    339  }
    340 
    341  static bool Read(MessageReader* aReader, paramType* aResult) {
    342    int domain = 0;
    343    if (ReadParam(aReader, &domain) && ReadParam(aReader, &aResult->mResult)) {
    344      aResult->mDomain = paramType::Domain(domain);
    345      return true;
    346    }
    347    return false;
    348  };
    349 };
    350 
    351 template <>
    352 struct ParamTraits<mozilla::TrackingId::Source>
    353    : public ContiguousEnumSerializer<
    354          mozilla::TrackingId::Source,
    355          mozilla::TrackingId::Source::Unimplemented,
    356          mozilla::TrackingId::Source::LAST> {};
    357 
    358 template <>
    359 struct ParamTraits<mozilla::TrackingId> {
    360  typedef mozilla::TrackingId paramType;
    361 
    362  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    363    WriteParam(aWriter, aParam.mSource);
    364    WriteParam(aWriter, aParam.mProcId);
    365    WriteParam(aWriter, aParam.mUniqueInProcId);
    366  }
    367 
    368  static bool Read(MessageReader* aReader, paramType* aResult) {
    369    return ReadParam(aReader, &aResult->mSource) &&
    370           ReadParam(aReader, &aResult->mProcId) &&
    371           ReadParam(aReader, &aResult->mUniqueInProcId);
    372  }
    373 };
    374 
    375 template <>
    376 struct ParamTraits<mozilla::CryptoTrack> {
    377  typedef mozilla::CryptoTrack paramType;
    378 
    379  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    380    WriteParam(aWriter, aParam.mCryptoScheme);
    381  }
    382 
    383  static bool Read(MessageReader* aReader, paramType* aResult) {
    384    return ReadParam(aReader, &aResult->mCryptoScheme);
    385  }
    386 };
    387 
    388 template <>
    389 struct ParamTraits<mozilla::dom::ImageBitmapFormat>
    390    : public ContiguousEnumSerializerInclusive<
    391          mozilla::dom::ImageBitmapFormat,
    392          mozilla::dom::ImageBitmapFormat::RGBA32,
    393          mozilla::dom::ImageBitmapFormat::DEPTH> {};
    394 
    395 template <>
    396 struct ParamTraits<mozilla::CodecType>
    397    : public ContiguousEnumSerializerInclusive<mozilla::CodecType,
    398                                               mozilla::CodecType::_BeginVideo_,
    399                                               mozilla::CodecType::Unknown> {};
    400 
    401 template <>
    402 struct ParamTraits<mozilla::BitrateMode>
    403    : public ContiguousEnumSerializerInclusive<mozilla::BitrateMode,
    404                                               mozilla::BitrateMode::Constant,
    405                                               mozilla::BitrateMode::Variable> {
    406 };
    407 
    408 template <>
    409 struct ParamTraits<mozilla::ScalabilityMode>
    410    : public ContiguousEnumSerializerInclusive<mozilla::ScalabilityMode,
    411                                               mozilla::ScalabilityMode::None,
    412                                               mozilla::ScalabilityMode::L1T3> {
    413 };
    414 
    415 template <>
    416 struct ParamTraits<mozilla::H264BitStreamFormat>
    417    : public ContiguousEnumSerializerInclusive<
    418          mozilla::H264BitStreamFormat, mozilla::H264BitStreamFormat::AVC,
    419          mozilla::H264BitStreamFormat::ANNEXB> {};
    420 
    421 template <>
    422 struct ParamTraits<mozilla::HardwarePreference>
    423    : public ContiguousEnumSerializerInclusive<
    424          mozilla::HardwarePreference, mozilla::HardwarePreference::None,
    425          mozilla::HardwarePreference::RequireSoftware> {};
    426 
    427 template <>
    428 struct ParamTraits<mozilla::Usage>
    429    : public ContiguousEnumSerializerInclusive<
    430          mozilla::Usage, mozilla::Usage::Realtime, mozilla::Usage::Record> {};
    431 
    432 template <>
    433 struct ParamTraits<mozilla::H264_PROFILE>
    434    : public ContiguousEnumSerializerInclusive<
    435          mozilla::H264_PROFILE, mozilla::H264_PROFILE::H264_PROFILE_UNKNOWN,
    436          mozilla::H264_PROFILE::H264_PROFILE_HIGH> {};
    437 
    438 template <>
    439 struct ParamTraits<mozilla::H264_LEVEL>
    440    : public ContiguousEnumSerializerInclusive<
    441          mozilla::H264_LEVEL, mozilla::H264_LEVEL::H264_LEVEL_1,
    442          mozilla::H264_LEVEL::H264_LEVEL_6_2> {};
    443 
    444 template <>
    445 struct ParamTraits<mozilla::OpusBitstreamFormat>
    446    : public ContiguousEnumSerializerInclusive<
    447          mozilla::OpusBitstreamFormat, mozilla::OpusBitstreamFormat::Opus,
    448          mozilla::OpusBitstreamFormat::OGG> {};
    449 
    450 template <>
    451 struct ParamTraits<mozilla::OpusSpecific::Application>
    452    : public ContiguousEnumSerializerInclusive<
    453          mozilla::OpusSpecific::Application,
    454          mozilla::OpusSpecific::Application::Unspecified,
    455          mozilla::OpusSpecific::Application::RestricedLowDelay> {};
    456 
    457 template <>
    458 struct ParamTraits<mozilla::VPXComplexity>
    459    : public ContiguousEnumSerializerInclusive<mozilla::VPXComplexity,
    460                                               mozilla::VPXComplexity::Normal,
    461                                               mozilla::VPXComplexity::Max> {};
    462 
    463 template <>
    464 struct ParamTraits<struct mozilla::H264Specific> {
    465  typedef mozilla::H264Specific paramType;
    466 
    467  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    468    WriteParam(aWriter, aParam.mProfile);
    469    WriteParam(aWriter, aParam.mLevel);
    470    WriteParam(aWriter, aParam.mFormat);
    471  }
    472 
    473  static bool Read(MessageReader* aReader, paramType* aResult) {
    474    return ReadParam(aReader, &aResult->mProfile) &&
    475           ReadParam(aReader, &aResult->mLevel) &&
    476           ReadParam(aReader, &aResult->mFormat);
    477  }
    478 };
    479 
    480 template <>
    481 struct ParamTraits<struct mozilla::OpusSpecific> {
    482  typedef mozilla::OpusSpecific paramType;
    483 
    484  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    485    WriteParam(aWriter, aParam.mApplication);
    486    WriteParam(aWriter, aParam.mFrameDuration);
    487    WriteParam(aWriter, aParam.mComplexity);
    488    WriteParam(aWriter, aParam.mFormat);
    489    WriteParam(aWriter, aParam.mPacketLossPerc);
    490    WriteParam(aWriter, aParam.mUseInBandFEC);
    491    WriteParam(aWriter, aParam.mUseDTX);
    492  }
    493 
    494  static bool Read(MessageReader* aReader, paramType* aResult) {
    495    return ReadParam(aReader, &aResult->mApplication) &&
    496           ReadParam(aReader, &aResult->mFrameDuration) &&
    497           ReadParam(aReader, &aResult->mComplexity) &&
    498           ReadParam(aReader, &aResult->mFormat) &&
    499           ReadParam(aReader, &aResult->mPacketLossPerc) &&
    500           ReadParam(aReader, &aResult->mUseInBandFEC) &&
    501           ReadParam(aReader, &aResult->mUseDTX);
    502  }
    503 };
    504 
    505 template <>
    506 struct ParamTraits<struct mozilla::VP8Specific> {
    507  typedef mozilla::VP8Specific paramType;
    508 
    509  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    510    WriteParam(aWriter, aParam.mComplexity);
    511    WriteParam(aWriter, aParam.mResilience);
    512    WriteParam(aWriter, aParam.mNumTemporalLayers);
    513    WriteParam(aWriter, aParam.mDenoising);
    514    WriteParam(aWriter, aParam.mAutoResize);
    515    WriteParam(aWriter, aParam.mFrameDropping);
    516  }
    517 
    518  static bool Read(MessageReader* aReader, paramType* aResult) {
    519    return ReadParam(aReader, &aResult->mComplexity) &&
    520           ReadParam(aReader, &aResult->mResilience) &&
    521           ReadParam(aReader, &aResult->mNumTemporalLayers) &&
    522           ReadParam(aReader, &aResult->mDenoising) &&
    523           ReadParam(aReader, &aResult->mAutoResize) &&
    524           ReadParam(aReader, &aResult->mFrameDropping);
    525  }
    526 };
    527 
    528 template <>
    529 struct ParamTraits<struct mozilla::VP9Specific> {
    530  typedef mozilla::VP9Specific paramType;
    531 
    532  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    533    ParamTraits<mozilla::VP8Specific>::Write(aWriter, aParam);
    534    WriteParam(aWriter, aParam.mAdaptiveQp);
    535    WriteParam(aWriter, aParam.mNumSpatialLayers);
    536    WriteParam(aWriter, aParam.mFlexible);
    537  }
    538 
    539  static bool Read(MessageReader* aReader, paramType* aResult) {
    540    return ParamTraits<mozilla::VP8Specific>::Read(aReader, aResult) &&
    541           ReadParam(aReader, &aResult->mAdaptiveQp) &&
    542           ReadParam(aReader, &aResult->mNumSpatialLayers) &&
    543           ReadParam(aReader, &aResult->mFlexible);
    544  }
    545 };
    546 
    547 template <>
    548 struct ParamTraits<struct mozilla::EncoderConfig::VideoColorSpace> {
    549  typedef mozilla::EncoderConfig::VideoColorSpace paramType;
    550 
    551  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    552    WriteParam(aWriter, aParam.mRange);
    553    WriteParam(aWriter, aParam.mMatrix);
    554    WriteParam(aWriter, aParam.mPrimaries);
    555    WriteParam(aWriter, aParam.mTransferFunction);
    556  }
    557 
    558  static bool Read(MessageReader* aReader, paramType* aResult) {
    559    return ReadParam(aReader, &aResult->mRange) &&
    560           ReadParam(aReader, &aResult->mMatrix) &&
    561           ReadParam(aReader, &aResult->mPrimaries) &&
    562           ReadParam(aReader, &aResult->mTransferFunction);
    563  }
    564 };
    565 
    566 template <>
    567 struct ParamTraits<struct mozilla::EncoderConfig::SampleFormat> {
    568  typedef mozilla::EncoderConfig::SampleFormat paramType;
    569 
    570  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    571    WriteParam(aWriter, aParam.mPixelFormat);
    572    WriteParam(aWriter, aParam.mColorSpace);
    573  }
    574 
    575  static bool Read(MessageReader* aReader, paramType* aResult) {
    576    return ReadParam(aReader, &aResult->mPixelFormat) &&
    577           ReadParam(aReader, &aResult->mColorSpace);
    578  }
    579 };
    580 
    581 template <>
    582 struct ParamTraits<mozilla::EncoderConfig> {
    583  typedef mozilla::EncoderConfig paramType;
    584 
    585  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    586    WriteParam(aWriter, aParam.mCodec);
    587    WriteParam(aWriter, aParam.mSize);
    588    WriteParam(aWriter, aParam.mBitrateMode);
    589    WriteParam(aWriter, aParam.mBitrate);
    590    WriteParam(aWriter, aParam.mMinBitrate);
    591    WriteParam(aWriter, aParam.mMaxBitrate);
    592    WriteParam(aWriter, aParam.mUsage);
    593    WriteParam(aWriter, aParam.mHardwarePreference);
    594    WriteParam(aWriter, aParam.mFormat);
    595    WriteParam(aWriter, aParam.mScalabilityMode);
    596    WriteParam(aWriter, aParam.mFramerate);
    597    WriteParam(aWriter, aParam.mKeyframeInterval);
    598    WriteParam(aWriter, aParam.mNumberOfChannels);
    599    WriteParam(aWriter, aParam.mSampleRate);
    600    WriteParam(aWriter, aParam.mCodecSpecific);
    601  }
    602 
    603  static bool Read(MessageReader* aReader, paramType* aResult) {
    604    return ReadParam(aReader, &aResult->mCodec) &&
    605           ReadParam(aReader, &aResult->mSize) &&
    606           ReadParam(aReader, &aResult->mBitrateMode) &&
    607           ReadParam(aReader, &aResult->mBitrate) &&
    608           ReadParam(aReader, &aResult->mMinBitrate) &&
    609           ReadParam(aReader, &aResult->mMaxBitrate) &&
    610           ReadParam(aReader, &aResult->mUsage) &&
    611           ReadParam(aReader, &aResult->mHardwarePreference) &&
    612           ReadParam(aReader, &aResult->mFormat) &&
    613           ReadParam(aReader, &aResult->mScalabilityMode) &&
    614           ReadParam(aReader, &aResult->mFramerate) &&
    615           ReadParam(aReader, &aResult->mKeyframeInterval) &&
    616           ReadParam(aReader, &aResult->mNumberOfChannels) &&
    617           ReadParam(aReader, &aResult->mSampleRate) &&
    618           ReadParam(aReader, &aResult->mCodecSpecific);
    619  }
    620 };
    621 
    622 template <typename T, typename Phantom>
    623 struct ParamTraits<struct mozilla::StrongTypedef<T, Phantom>> {
    624  typedef mozilla::StrongTypedef<T, Phantom> paramType;
    625 
    626  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    627    WriteParam(aWriter, aParam.mValue);
    628  }
    629 
    630  static bool Read(MessageReader* aReader, paramType* aResult) {
    631    return ReadParam(aReader, &aResult->mValue);
    632  }
    633 };
    634 
    635 // [RefCounted] typed
    636 template <>
    637 struct ParamTraits<mozilla::EncoderConfigurationChangeList*> {
    638  typedef mozilla::EncoderConfigurationChangeList paramType;
    639 
    640  static void Write(MessageWriter* aWriter, const paramType* aParam) {
    641    WriteParam(aWriter, aParam->mChanges);
    642  }
    643 
    644  static bool Read(MessageReader* aReader, RefPtr<paramType>* aResult) {
    645    auto result = mozilla::MakeRefPtr<paramType>();
    646    if (!ReadParam(aReader, &result->mChanges)) {
    647      return false;
    648    }
    649    *aResult = std::move(result);
    650    return true;
    651  }
    652 };
    653 
    654 template <>
    655 struct ParamTraits<mozilla::dom::MediaKeySessionType>
    656    : public ContiguousEnumSerializerInclusive<
    657          mozilla::dom::MediaKeySessionType,
    658          mozilla::dom::MediaKeySessionType::Temporary,
    659          mozilla::dom::MediaKeySessionType::Persistent_license> {};
    660 
    661 template <>
    662 struct ParamTraits<mozilla::CDMKeyInfo> {
    663  typedef mozilla::CDMKeyInfo paramType;
    664 
    665  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    666    WriteParam(aWriter, aParam.mKeyId);
    667    WriteParam(aWriter, aParam.mStatus);
    668  }
    669 
    670  static bool Read(MessageReader* aReader, paramType* aResult) {
    671    return ReadParam(aReader, &aResult->mKeyId) &&
    672           ReadParam(aReader, &aResult->mStatus);
    673  }
    674 };
    675 
    676 template <typename T>
    677 struct ParamTraits<mozilla::NormalizedConstraintSet::Range<T>> {
    678  using paramType = mozilla::NormalizedConstraintSet::Range<T>;
    679  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    680    WriteParams(aWriter, aParam.mMin, aParam.mMax, aParam.mIdeal);
    681  }
    682 
    683  static bool Read(MessageReader* aReader, paramType* aResult) {
    684    paramType& aParam = *aResult;
    685    return ReadParams(aReader, aParam.mMin, aParam.mMax, aParam.mIdeal);
    686  }
    687 };
    688 DEFINE_IPC_SERIALIZER_WITH_SUPER_CLASS(
    689    mozilla::NormalizedConstraintSet::LongRange,
    690    mozilla::NormalizedConstraintSet::Range<int32_t>);
    691 DEFINE_IPC_SERIALIZER_WITH_SUPER_CLASS(
    692    mozilla::NormalizedConstraintSet::LongLongRange,
    693    mozilla::NormalizedConstraintSet::Range<int64_t>);
    694 DEFINE_IPC_SERIALIZER_WITH_SUPER_CLASS(
    695    mozilla::NormalizedConstraintSet::DoubleRange,
    696    mozilla::NormalizedConstraintSet::Range<double>);
    697 DEFINE_IPC_SERIALIZER_WITH_SUPER_CLASS(
    698    mozilla::NormalizedConstraintSet::BooleanRange,
    699    mozilla::NormalizedConstraintSet::Range<bool>);
    700 DEFINE_IPC_SERIALIZER_WITH_FIELDS(mozilla::NormalizedConstraintSet::StringRange,
    701                                  mExact, mIdeal);
    702 DEFINE_IPC_SERIALIZER_WITH_FIELDS(mozilla::NormalizedConstraintSet, mWidth,
    703                                  mHeight, mFrameRate, mFacingMode, mResizeMode,
    704                                  mMediaSource, mBrowserWindow, mDeviceId,
    705                                  mGroupId, mViewportOffsetX, mViewportOffsetY,
    706                                  mViewportWidth, mViewportHeight,
    707                                  mEchoCancellation, mNoiseSuppression,
    708                                  mAutoGainControl, mChannelCount);
    709 DEFINE_IPC_SERIALIZER_WITH_SUPER_CLASS_AND_FIELDS(
    710    mozilla::NormalizedConstraints, mozilla::NormalizedConstraintSet,
    711    mAdvanced);
    712 
    713 template <>
    714 struct ParamTraits<mozilla::dom::VideoResizeModeEnum>
    715    : public mozilla::dom::WebIDLEnumSerializer<
    716          mozilla::dom::VideoResizeModeEnum> {};
    717 
    718 }  // namespace IPC
    719 
    720 #endif  // mozilla_dom_media_MediaIPCUtils_h