Changeset 262032 in webkit


Ignore:
Timestamp:
May 21, 2020 3:30:01 PM (4 years ago)
Author:
achristensen@apple.com
Message:

Use an OptionSet instead of uint8_t for MessageFlags
​https://bugs.webkit.org/show_bug.cgi?id=212230
<rdar://problem/63496543>

Reviewed by Darin Adler.

I also reduce the encoding size of OptionSet.

  • Platform/IPC/ArgumentCoders.h:

(IPC::ArgumentCoder<OptionSet<T>>::encode):
(IPC::ArgumentCoder<OptionSet<T>>::decode):

  • Platform/IPC/Decoder.cpp:

(IPC::Decoder::isSyncMessage const):
(IPC::Decoder::shouldDispatchMessageWhenWaitingForSyncReply const):
(IPC::Decoder::shouldUseFullySynchronousModeForTesting const):

  • Platform/IPC/Decoder.h:
  • Platform/IPC/Encoder.cpp:

(IPC::Encoder::isSyncMessage const):
(IPC::Encoder::shouldDispatchMessageWhenWaitingForSyncReply const):
(IPC::Encoder::setIsSyncMessage):
(IPC::Encoder::setShouldDispatchMessageWhenWaitingForSyncReply):
(IPC::Encoder::setFullySynchronousModeForTesting):
(IPC::Encoder::messageFlags):
(IPC::Encoder::messageFlags const):

  • Platform/IPC/Encoder.h:
  • Platform/IPC/MessageFlags.h:

(): Deleted.

Location:
trunk/Source/WebKit
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r262024 r262032  
     12020-05-21  Alex Christensen  <achristensen@webkit.org>
     2
     3        Use an OptionSet instead of uint8_t for MessageFlags
     4        https://bugs.webkit.org/show_bug.cgi?id=212230
     5        <rdar://problem/63496543>
     6
     7        Reviewed by Darin Adler.
     8
     9        I also reduce the encoding size of OptionSet.
     10
     11        * Platform/IPC/ArgumentCoders.h:
     12        (IPC::ArgumentCoder<OptionSet<T>>::encode):
     13        (IPC::ArgumentCoder<OptionSet<T>>::decode):
     14        * Platform/IPC/Decoder.cpp:
     15        (IPC::Decoder::isSyncMessage const):
     16        (IPC::Decoder::shouldDispatchMessageWhenWaitingForSyncReply const):
     17        (IPC::Decoder::shouldUseFullySynchronousModeForTesting const):
     18        * Platform/IPC/Decoder.h:
     19        * Platform/IPC/Encoder.cpp:
     20        (IPC::Encoder::isSyncMessage const):
     21        (IPC::Encoder::shouldDispatchMessageWhenWaitingForSyncReply const):
     22        (IPC::Encoder::setIsSyncMessage):
     23        (IPC::Encoder::setShouldDispatchMessageWhenWaitingForSyncReply):
     24        (IPC::Encoder::setFullySynchronousModeForTesting):
     25        (IPC::Encoder::messageFlags):
     26        (IPC::Encoder::messageFlags const):
     27        * Platform/IPC/Encoder.h:
     28        * Platform/IPC/MessageFlags.h:
     29        (): Deleted.
     30
    1312020-05-21  John Wilander  <wilander@apple.com>
    232

  • trunk/Source/WebKit/Platform/IPC/ArgumentCoders.h

    r259940 r262032  
    5656    static void encode(Encoder& encoder, const OptionSet<T>& optionSet)
    5757    {
    58         encoder << (static_cast<uint64_t>(optionSet.toRaw()));
     58        encoder << optionSet.toRaw();
    5959    }
    6060
    6161    static WARN_UNUSED_RETURN bool decode(Decoder& decoder, OptionSet<T>& optionSet)
    6262    {
    63         uint64_t value;
     63        typename OptionSet<T>::StorageType value;
    6464        if (!decoder.decode(value))
    6565            return false;
    … …  
    7171    static Optional<OptionSet<T>> decode(Decoder& decoder)
    7272    {
    73         Optional<uint64_t> value;
     73        Optional<typename OptionSet<T>::StorageType> value;
    7474        decoder >> value;
    7575        if (!value)

  • trunk/Source/WebKit/Platform/IPC/Decoder.cpp

    r261672 r262032  
    2727#include "Decoder.h"
    2828
     29#include "ArgumentCoders.h"
    2930#include "DataReference.h"
    3031#include "MessageFlags.h"
    … …  
    9394bool Decoder::isSyncMessage() const
    9495{
    95     return m_messageFlags & SyncMessage;
     96    return m_messageFlags.contains(MessageFlags::SyncMessage);
    9697}
    9798
    9899ShouldDispatchWhenWaitingForSyncReply Decoder::shouldDispatchMessageWhenWaitingForSyncReply() const
    99100{
    100     if (m_messageFlags & DispatchMessageWhenWaitingForSyncReply)
     101    if (m_messageFlags.contains(MessageFlags::DispatchMessageWhenWaitingForSyncReply))
    101102        return ShouldDispatchWhenWaitingForSyncReply::Yes;
    102     if (m_messageFlags & DispatchMessageWhenWaitingForUnboundedSyncReply)
     103    if (m_messageFlags.contains(MessageFlags::DispatchMessageWhenWaitingForUnboundedSyncReply))
    103104        return ShouldDispatchWhenWaitingForSyncReply::YesDuringUnboundedIPC;
    104105    return ShouldDispatchWhenWaitingForSyncReply::No;
    … …  
    107108bool Decoder::shouldUseFullySynchronousModeForTesting() const
    108109{
    109     return m_messageFlags & UseFullySynchronousModeForTesting;
     110    return m_messageFlags.contains(MessageFlags::UseFullySynchronousModeForTesting);
    110111}
    111112

  • trunk/Source/WebKit/Platform/IPC/Decoder.h

    r261672 r262032  
    3131#include "StringReference.h"
    3232#include <wtf/EnumTraits.h>
     33#include <wtf/OptionSet.h>
    3334#include <wtf/Vector.h>
    3435
    … …  
    4142class DataReference;
    4243class ImportanceAssertion;
    43 enum class ShouldDispatchWhenWaitingForSyncReply;
     44enum class MessageFlags : uint8_t;
     45enum class ShouldDispatchWhenWaitingForSyncReply : uint8_t;
    4446
    4547class Decoder {
    … …  
    192194    Vector<Attachment> m_attachments;
    193195
    194     uint8_t m_messageFlags;
     196    OptionSet<MessageFlags> m_messageFlags;
    195197    MessageName m_messageName;
    196198

  • trunk/Source/WebKit/Platform/IPC/Encoder.cpp

    r261672 r262032  
    3030#include "MessageFlags.h"
    3131#include <algorithm>
    32 #include <stdio.h>
     32#include <wtf/OptionSet.h>
    3333
    3434#if OS(DARWIN)
    … …  
    8282bool Encoder::isSyncMessage() const
    8383{
    84     return *buffer() & SyncMessage;
     84    return messageFlags().contains(MessageFlags::SyncMessage);
    8585}
    8686
    8787ShouldDispatchWhenWaitingForSyncReply Encoder::shouldDispatchMessageWhenWaitingForSyncReply() const
    8888{
    89     if (*buffer() & DispatchMessageWhenWaitingForSyncReply)
     89    if (messageFlags().contains(MessageFlags::DispatchMessageWhenWaitingForSyncReply))
    9090        return ShouldDispatchWhenWaitingForSyncReply::Yes;
    91     if (*buffer() & DispatchMessageWhenWaitingForUnboundedSyncReply)
     91    if (messageFlags().contains(MessageFlags::DispatchMessageWhenWaitingForUnboundedSyncReply))
    9292        return ShouldDispatchWhenWaitingForSyncReply::YesDuringUnboundedIPC;
    9393    return ShouldDispatchWhenWaitingForSyncReply::No;
    … …  
    9797{
    9898    if (isSyncMessage)
    99         *buffer() |= SyncMessage;
     99        messageFlags().add(MessageFlags::SyncMessage);
    100100    else
    101         *buffer() &= ~SyncMessage;
     101        messageFlags().remove(MessageFlags::SyncMessage);
    102102}
    103103
    … …  
    106106    switch (shouldDispatchWhenWaitingForSyncReply) {
    107107    case ShouldDispatchWhenWaitingForSyncReply::No:
    108         *buffer() &= ~(DispatchMessageWhenWaitingForSyncReply | DispatchMessageWhenWaitingForUnboundedSyncReply);
     108        messageFlags().remove(MessageFlags::DispatchMessageWhenWaitingForSyncReply);
     109        messageFlags().remove(MessageFlags::DispatchMessageWhenWaitingForUnboundedSyncReply);
    109110        break;
    110111    case ShouldDispatchWhenWaitingForSyncReply::Yes:
    111         *buffer() |= DispatchMessageWhenWaitingForSyncReply;
    112         *buffer() &= ~DispatchMessageWhenWaitingForUnboundedSyncReply;
     112        messageFlags().add(MessageFlags::DispatchMessageWhenWaitingForSyncReply);
     113        messageFlags().remove(MessageFlags::DispatchMessageWhenWaitingForUnboundedSyncReply);
    113114        break;
    114115    case ShouldDispatchWhenWaitingForSyncReply::YesDuringUnboundedIPC:
    115         *buffer() |= DispatchMessageWhenWaitingForUnboundedSyncReply;
    116         *buffer() &= ~DispatchMessageWhenWaitingForSyncReply;
     116        messageFlags().remove(MessageFlags::DispatchMessageWhenWaitingForSyncReply);
     117        messageFlags().add(MessageFlags::DispatchMessageWhenWaitingForUnboundedSyncReply);
    117118        break;
    118119    }
    … …  
    121122void Encoder::setFullySynchronousModeForTesting()
    122123{
    123     *buffer() |= UseFullySynchronousModeForTesting;
     124    messageFlags().add(MessageFlags::UseFullySynchronousModeForTesting);
    124125}
    125126
    … …  
    173174}
    174175
     176OptionSet<MessageFlags>& Encoder::messageFlags()
     177{
     178    // FIXME: We should probably pass an OptionSet<MessageFlags> into the Encoder constructor instead of encoding defaultMessageFlags then using this to change it later.
     179    static_assert(sizeof(OptionSet<MessageFlags>::StorageType) == 1, "Encoder uses the first byte of the buffer for message flags.");
     180    return *reinterpret_cast<OptionSet<MessageFlags>*>(buffer());
     181}
     182
     183const OptionSet<MessageFlags>& Encoder::messageFlags() const
     184{
     185    return *reinterpret_cast<OptionSet<MessageFlags>*>(buffer());
     186}
     187
    175188uint8_t* Encoder::grow(size_t alignment, size_t size)
    176189{

  • trunk/Source/WebKit/Platform/IPC/Encoder.h

    r261672 r262032  
    3636
    3737class DataReference;
    38 enum class ShouldDispatchWhenWaitingForSyncReply;
     38enum class MessageFlags : uint8_t;
    3939enum class MessageName : uint16_t;
     40enum class ShouldDispatchWhenWaitingForSyncReply : uint8_t;
    4041
    4142class Encoder final {
    … …  
    117118
    118119    void encodeHeader();
     120    const OptionSet<MessageFlags>& messageFlags() const;
     121    OptionSet<MessageFlags>& messageFlags();
    119122
    120123    MessageName m_messageName;

  • trunk/Source/WebKit/Platform/IPC/MessageFlags.h

    r247868 r262032  
    2424 */
    2525
    26 #ifndef MessageFlags_h
    27 #define MessageFlags_h
     26#pragma once
    2827
    2928namespace IPC {
    3029
    31 enum MessageFlags {
     30enum class MessageFlags : uint8_t {
    3231    SyncMessage = 1 << 0,
    3332    DispatchMessageWhenWaitingForSyncReply = 1 << 1,
    … …  
    3635};
    3736
    38 enum class ShouldDispatchWhenWaitingForSyncReply { No, Yes, YesDuringUnboundedIPC };
     37enum class ShouldDispatchWhenWaitingForSyncReply : uint8_t {
     38    No,
     39    Yes,
     40    YesDuringUnboundedIPC,
     41};
    3942
    4043} // namespace IPC
    41 
    42 #endif // MessageFlags_h
Note: See TracChangeset for help on using the changeset viewer.