tor-browser

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

WebRenderMessageUtils.h (14453B)

      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 GFX_WEBRENDERMESSAGEUTILS_H
      8 #define GFX_WEBRENDERMESSAGEUTILS_H
      9 
     10 #include "chrome/common/ipc_message_utils.h"
     11 
     12 #include "ipc/EnumSerializer.h"
     13 #include "ipc/IPCMessageUtils.h"
     14 #include "mozilla/IsEnumCase.h"
     15 #include "mozilla/ParamTraits_IsEnumCase.h"
     16 #include "mozilla/ParamTraits_TiedFields.h"
     17 #include "mozilla/webrender/webrender_ffi.h"
     18 #include "mozilla/webrender/WebRenderTypes.h"
     19 #include "mozilla/dom/MediaIPCUtils.h"
     20 
     21 namespace IPC {
     22 
     23 template <>
     24 struct ParamTraits<mozilla::wr::ByteBuffer> {
     25  typedef mozilla::wr::ByteBuffer paramType;
     26 
     27  static void Write(MessageWriter* aWriter, const paramType& aParam) {
     28    WriteParam(aWriter, aParam.mLength);
     29    aWriter->WriteBytes(aParam.mData, aParam.mLength);
     30  }
     31 
     32  static bool Read(MessageReader* aReader, paramType* aResult) {
     33    size_t length;
     34    return ReadParam(aReader, &length) && aResult->Allocate(length) &&
     35           aReader->ReadBytesInto(aResult->mData, length);
     36  }
     37 };
     38 
     39 template <>
     40 struct ParamTraits<mozilla::wr::ImageDescriptor> {
     41  typedef mozilla::wr::ImageDescriptor paramType;
     42 
     43  static void Write(MessageWriter* aWriter, const paramType& aParam) {
     44    WriteParam(aWriter, aParam.format);
     45    WriteParam(aWriter, aParam.width);
     46    WriteParam(aWriter, aParam.height);
     47    WriteParam(aWriter, aParam.stride);
     48    WriteParam(aWriter, aParam.opacity);
     49  }
     50 
     51  static bool Read(MessageReader* aReader, paramType* aResult) {
     52    return ReadParam(aReader, &aResult->format) &&
     53           ReadParam(aReader, &aResult->width) &&
     54           ReadParam(aReader, &aResult->height) &&
     55           ReadParam(aReader, &aResult->stride) &&
     56           ReadParam(aReader, &aResult->opacity);
     57  }
     58 };
     59 
     60 template <>
     61 struct ParamTraits<mozilla::wr::GeckoDisplayListType::Tag>
     62    : public ContiguousEnumSerializer<
     63          mozilla::wr::GeckoDisplayListType::Tag,
     64          mozilla::wr::GeckoDisplayListType::Tag::None,
     65          mozilla::wr::GeckoDisplayListType::Tag::Sentinel> {};
     66 
     67 template <>
     68 struct ParamTraits<mozilla::wr::GeckoDisplayListType> {
     69  typedef mozilla::wr::GeckoDisplayListType paramType;
     70 
     71  static void Write(MessageWriter* aWriter, const paramType& aParam) {
     72    WriteParam(aWriter, aParam.tag);
     73    switch (aParam.tag) {
     74      case mozilla::wr::GeckoDisplayListType::Tag::None:
     75        break;
     76      case mozilla::wr::GeckoDisplayListType::Tag::Partial:
     77        WriteParam(aWriter, aParam.partial._0);
     78        break;
     79      case mozilla::wr::GeckoDisplayListType::Tag::Full:
     80        WriteParam(aWriter, aParam.full._0);
     81        break;
     82      default:
     83        MOZ_RELEASE_ASSERT(false, "bad enum variant");
     84    }
     85  }
     86 
     87  static bool Read(MessageReader* aReader, paramType* aResult) {
     88    if (!ReadParam(aReader, &aResult->tag)) {
     89      return false;
     90    }
     91    switch (aResult->tag) {
     92      case mozilla::wr::GeckoDisplayListType::Tag::None:
     93        return true;
     94      case mozilla::wr::GeckoDisplayListType::Tag::Partial:
     95        return ReadParam(aReader, &aResult->partial._0);
     96      case mozilla::wr::GeckoDisplayListType::Tag::Full:
     97        return ReadParam(aReader, &aResult->full._0);
     98      default:
     99        MOZ_RELEASE_ASSERT(false, "bad enum variant");
    100    }
    101  }
    102 };
    103 
    104 template <>
    105 struct ParamTraits<mozilla::wr::BuiltDisplayListDescriptor> {
    106  typedef mozilla::wr::BuiltDisplayListDescriptor paramType;
    107 
    108  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    109    WriteParam(aWriter, aParam.gecko_display_list_type);
    110    WriteParam(aWriter, aParam.builder_start_time);
    111    WriteParam(aWriter, aParam.builder_finish_time);
    112    WriteParam(aWriter, aParam.send_start_time);
    113    WriteParam(aWriter, aParam.total_clip_nodes);
    114    WriteParam(aWriter, aParam.total_spatial_nodes);
    115    WriteParam(aWriter, aParam.cache_size);
    116  }
    117 
    118  static bool Read(MessageReader* aReader, paramType* aResult) {
    119    return ReadParam(aReader, &aResult->gecko_display_list_type) &&
    120           ReadParam(aReader, &aResult->builder_start_time) &&
    121           ReadParam(aReader, &aResult->builder_finish_time) &&
    122           ReadParam(aReader, &aResult->send_start_time) &&
    123           ReadParam(aReader, &aResult->total_clip_nodes) &&
    124           ReadParam(aReader, &aResult->total_spatial_nodes) &&
    125           ReadParam(aReader, &aResult->cache_size);
    126  }
    127 };
    128 
    129 }  // namespace IPC
    130 namespace mozilla {
    131 template <>
    132 inline auto TiedFields<mozilla::wr::IdNamespace>(mozilla::wr::IdNamespace& a) {
    133  return std::tie(a.mHandle);
    134 }
    135 
    136 template <>
    137 inline auto TiedFields<mozilla::wr::ImageKey>(mozilla::wr::ImageKey& a) {
    138  return std::tie(a.mNamespace, a.mHandle);
    139 }
    140 
    141 template <>
    142 inline auto TiedFields<mozilla::wr::BlobImageKey>(
    143    mozilla::wr::BlobImageKey& a) {
    144  return std::tie(a._0);
    145 }
    146 
    147 template <>
    148 inline auto TiedFields<mozilla::wr::SnapshotImageKey>(
    149    mozilla::wr::SnapshotImageKey& a) {
    150  return std::tie(a._0);
    151 }
    152 
    153 template <>
    154 inline auto TiedFields<mozilla::wr::FontKey>(mozilla::wr::FontKey& a) {
    155  return std::tie(a.mNamespace, a.mHandle);
    156 }
    157 template <>
    158 inline auto TiedFields<mozilla::wr::FontInstanceKey>(
    159    mozilla::wr::FontInstanceKey& a) {
    160  return std::tie(a.mNamespace, a.mHandle);
    161 }
    162 
    163 template <>
    164 inline auto TiedFields<mozilla::wr::FontInstanceFlags>(
    165    mozilla::wr::FontInstanceFlags& a) {
    166  return std::tie(a._0);
    167 }
    168 
    169 template <>
    170 inline auto TiedFields<mozilla::wr::SyntheticItalics>(
    171    mozilla::wr::SyntheticItalics& a) {
    172  return std::tie(a.angle);
    173 }
    174 
    175 template <>
    176 inline auto TiedFields<mozilla::wr::FontInstanceOptions>(
    177    mozilla::wr::FontInstanceOptions& a) {
    178  return std::tie(a.flags, a.synthetic_italics, a.render_mode, a._padding);
    179 }
    180 
    181 // -
    182 
    183 #if !(defined(XP_MACOSX) || defined(XP_WIN))
    184 
    185 template <>
    186 inline constexpr bool IsEnumCase<wr::FontLCDFilter>(
    187    const wr::FontLCDFilter raw) {
    188  switch (raw) {
    189    case wr::FontLCDFilter::None:
    190    case wr::FontLCDFilter::Default:
    191    case wr::FontLCDFilter::Light:
    192    case wr::FontLCDFilter::Legacy:
    193    case wr::FontLCDFilter::Sentinel:
    194      return true;
    195  }
    196  return false;
    197 }
    198 
    199 template <>
    200 inline constexpr bool IsEnumCase<wr::FontHinting>(const wr::FontHinting raw) {
    201  switch (raw) {
    202    case wr::FontHinting::None:
    203    case wr::FontHinting::Mono:
    204    case wr::FontHinting::Light:
    205    case wr::FontHinting::Normal:
    206    case wr::FontHinting::LCD:
    207    case wr::FontHinting::Sentinel:
    208      return true;
    209  }
    210  return false;
    211 }
    212 
    213 #endif  // !(defined(XP_MACOSX) || defined(XP_WIN))
    214 
    215 // -
    216 
    217 template <>
    218 inline auto TiedFields<mozilla::wr::FontInstancePlatformOptions>(
    219    mozilla::wr::FontInstancePlatformOptions& a) {
    220 #if defined(XP_WIN)
    221  return std::tie(a.gamma, a.contrast, a.cleartype_level);
    222 #elif defined(XP_MACOSX)
    223  return std::tie(a.unused);
    224 #else
    225  return std::tie(a.lcd_filter, a.hinting);
    226 #endif
    227 }
    228 
    229 template <>
    230 inline auto TiedFields<mozilla::wr::ExternalImageId>(
    231    mozilla::wr::ExternalImageId& a) {
    232  return std::tie(a._0);
    233 }
    234 
    235 template <>
    236 inline auto TiedFields<mozilla::wr::PipelineId>(mozilla::wr::PipelineId& a) {
    237  return std::tie(a.mNamespace, a.mHandle);
    238 }
    239 
    240 template <>
    241 inline auto TiedFields<mozilla::wr::LayoutSize>(mozilla::wr::LayoutSize& a) {
    242  return std::tie(a.width, a.height);
    243 }
    244 template <>
    245 inline auto TiedFields<mozilla::wr::LayoutRect>(mozilla::wr::LayoutRect& a) {
    246  return std::tie(a.min, a.max);
    247 }
    248 template <>
    249 inline auto TiedFields<mozilla::wr::LayoutPoint>(mozilla::wr::LayoutPoint& a) {
    250  return std::tie(a.x, a.y);
    251 }
    252 
    253 template <>
    254 inline constexpr bool IsEnumCase<wr::OpacityType>(const wr::OpacityType raw) {
    255  switch (raw) {
    256    case wr::OpacityType::Opaque:
    257    case wr::OpacityType::HasAlphaChannel:
    258    case wr::OpacityType::Sentinel:
    259      return true;
    260  }
    261  return false;
    262 }
    263 
    264 template <>
    265 inline constexpr bool IsEnumCase<wr::FontRenderMode>(
    266    const wr::FontRenderMode raw) {
    267  switch (raw) {
    268    case wr::FontRenderMode::Mono:
    269    case wr::FontRenderMode::Alpha:
    270    case wr::FontRenderMode::Subpixel:
    271    case wr::FontRenderMode::Sentinel:
    272      return true;
    273  }
    274  return false;
    275 }
    276 
    277 template <>
    278 inline auto TiedFields<mozilla::wr::InternerSubReport>(
    279    mozilla::wr::InternerSubReport& a) {
    280 #define _COMMA ,
    281 #define _(X) a.X
    282  return std::tie(WEBRENDER_FOR_EACH_INTERNER(_, _COMMA));
    283 #undef _
    284 #undef _COMMA
    285 }
    286 
    287 template <>
    288 inline auto TiedFields<mozilla::wr::InterningMemoryReport>(
    289    mozilla::wr::InterningMemoryReport& a) {
    290  return std::tie(a.interners, a.data_stores);
    291 }
    292 
    293 template <>
    294 inline auto TiedFields<mozilla::wr::MemoryReport>(
    295    mozilla::wr::MemoryReport& a) {
    296  // clang-format off
    297  return std::tie(
    298    a.clip_stores,
    299    a.hit_testers,
    300    a.fonts,
    301    a.weak_fonts,
    302    a.images,
    303    a.rasterized_blobs,
    304    a.shader_cache,
    305    a.interning,
    306    a.display_list,
    307    a.upload_staging_memory,
    308    a.swgl,
    309    a.frame_allocator,
    310    a.render_tasks,
    311    a.vertex_data_textures,
    312    a.render_target_textures,
    313    a.picture_tile_textures,
    314    a.atlas_textures,
    315    a.standalone_textures,
    316    a.texture_cache_structures,
    317    a.depth_target_textures,
    318    a.texture_upload_pbos,
    319    a.swap_chain,
    320    a.render_texture_hosts,
    321    a.upload_staging_textures
    322  );
    323  // clang-format on
    324 }
    325 
    326 template <>
    327 inline auto TiedFields<mozilla::wr::RenderReasons>(
    328    mozilla::wr::RenderReasons& a) {
    329  return std::tie(a._0);
    330 }
    331 
    332 }  // namespace mozilla
    333 namespace IPC {
    334 template <>
    335 struct ParamTraits<mozilla::wr::IdNamespace>
    336    : public ParamTraits_TiedFields<mozilla::wr::IdNamespace> {};
    337 
    338 template <>
    339 struct ParamTraits<mozilla::wr::ImageKey>
    340    : public ParamTraits_TiedFields<mozilla::wr::ImageKey> {};
    341 
    342 template <>
    343 struct ParamTraits<mozilla::wr::BlobImageKey>
    344    : public ParamTraits_TiedFields<mozilla::wr::BlobImageKey> {};
    345 
    346 template <>
    347 struct ParamTraits<mozilla::wr::SnapshotImageKey>
    348    : public ParamTraits_TiedFields<mozilla::wr::SnapshotImageKey> {};
    349 
    350 template <>
    351 struct ParamTraits<mozilla::wr::FontKey>
    352    : public ParamTraits_TiedFields<mozilla::wr::FontKey> {};
    353 
    354 template <>
    355 struct ParamTraits<mozilla::wr::FontInstanceKey>
    356    : public ParamTraits_TiedFields<mozilla::wr::FontInstanceKey> {};
    357 
    358 template <>
    359 struct ParamTraits<mozilla::wr::FontInstanceFlags>
    360    : public ParamTraits_TiedFields<mozilla::wr::FontInstanceFlags> {};
    361 
    362 template <>
    363 struct ParamTraits<mozilla::wr::SyntheticItalics>
    364    : public ParamTraits_TiedFields<mozilla::wr::SyntheticItalics> {};
    365 
    366 template <>
    367 struct ParamTraits<mozilla::wr::FontInstanceOptions>
    368    : public ParamTraits_TiedFields<mozilla::wr::FontInstanceOptions> {};
    369 
    370 #if !(defined(XP_MACOSX) || defined(XP_WIN))
    371 
    372 template <>
    373 struct ParamTraits<mozilla::wr::FontLCDFilter>
    374    : public ParamTraits_IsEnumCase<mozilla::wr::FontLCDFilter> {};
    375 
    376 template <>
    377 struct ParamTraits<mozilla::wr::FontHinting>
    378    : public ParamTraits_IsEnumCase<mozilla::wr::FontHinting> {};
    379 
    380 #endif  // !(defined(XP_MACOSX) || defined(XP_WIN))
    381 
    382 template <>
    383 struct ParamTraits<mozilla::wr::FontInstancePlatformOptions>
    384    : public ParamTraits_TiedFields<mozilla::wr::FontInstancePlatformOptions> {
    385 };
    386 
    387 template <>
    388 struct ParamTraits<mozilla::wr::ExternalImageId>
    389    : public ParamTraits_TiedFields<mozilla::wr::ExternalImageId> {};
    390 
    391 template <>
    392 struct ParamTraits<mozilla::wr::PipelineId>
    393    : public ParamTraits_TiedFields<mozilla::wr::PipelineId> {};
    394 
    395 template <>
    396 struct ParamTraits<mozilla::wr::ImageFormat>
    397    : public ContiguousEnumSerializer<mozilla::wr::ImageFormat,
    398                                      mozilla::wr::ImageFormat::R8,
    399                                      mozilla::wr::ImageFormat::Sentinel> {};
    400 
    401 template <>
    402 struct ParamTraits<mozilla::wr::LayoutSize>
    403    : public ParamTraits_TiedFields<mozilla::wr::LayoutSize> {};
    404 
    405 template <>
    406 struct ParamTraits<mozilla::wr::LayoutRect>
    407    : public ParamTraits_TiedFields<mozilla::wr::LayoutRect> {};
    408 
    409 template <>
    410 struct ParamTraits<mozilla::wr::LayoutPoint>
    411    : public ParamTraits_TiedFields<mozilla::wr::LayoutPoint> {};
    412 
    413 template <>
    414 struct ParamTraits<mozilla::wr::ImageRendering>
    415    : public ContiguousEnumSerializer<mozilla::wr::ImageRendering,
    416                                      mozilla::wr::ImageRendering::Auto,
    417                                      mozilla::wr::ImageRendering::Sentinel> {};
    418 
    419 template <>
    420 struct ParamTraits<mozilla::wr::MixBlendMode>
    421    : public ContiguousEnumSerializer<mozilla::wr::MixBlendMode,
    422                                      mozilla::wr::MixBlendMode::Normal,
    423                                      mozilla::wr::MixBlendMode::Sentinel> {};
    424 
    425 template <>
    426 struct ParamTraits<mozilla::wr::WebRenderError>
    427    : public ContiguousEnumSerializer<mozilla::wr::WebRenderError,
    428                                      mozilla::wr::WebRenderError::INITIALIZE,
    429                                      mozilla::wr::WebRenderError::Sentinel> {};
    430 
    431 template <>
    432 struct ParamTraits<mozilla::wr::WrRotation>
    433    : public ContiguousEnumSerializer<mozilla::wr::WrRotation,
    434                                      mozilla::wr::WrRotation::Degree0,
    435                                      mozilla::wr::WrRotation::Sentinel> {};
    436 
    437 template <>
    438 struct ParamTraits<mozilla::wr::InternerSubReport>
    439    : public ParamTraits_TiedFields<mozilla::wr::InternerSubReport> {};
    440 
    441 template <>
    442 struct ParamTraits<mozilla::wr::InterningMemoryReport>
    443    : public ParamTraits_TiedFields<mozilla::wr::InterningMemoryReport> {};
    444 
    445 template <>
    446 struct ParamTraits<mozilla::wr::MemoryReport>
    447    : public ParamTraits_TiedFields<mozilla::wr::MemoryReport> {};
    448 
    449 template <>
    450 struct ParamTraits<mozilla::wr::OpacityType>
    451    : public ParamTraits_IsEnumCase<mozilla::wr::OpacityType> {};
    452 
    453 template <>
    454 struct ParamTraits<mozilla::wr::FontRenderMode>
    455    : public ParamTraits_IsEnumCase<mozilla::wr::FontRenderMode> {};
    456 
    457 template <>
    458 struct ParamTraits<mozilla::wr::ExternalImageKeyPair>
    459    : public ParamTraits_TiedFields<mozilla::wr::ExternalImageKeyPair> {};
    460 
    461 template <>
    462 struct ParamTraits<mozilla::wr::RenderReasons>
    463    : public ParamTraits_TiedFields<mozilla::wr::RenderReasons> {};
    464 
    465 template <>
    466 struct ParamTraits<mozilla::wr::ExternalImageSource>
    467    : public ContiguousEnumSerializer<mozilla::wr::ExternalImageSource,
    468                                      mozilla::wr::ExternalImageSource::Unknown,
    469                                      mozilla::wr::ExternalImageSource::Last> {
    470 };
    471 
    472 }  // namespace IPC
    473 
    474 #endif  // GFX_WEBRENDERMESSAGEUTILS_H