Changeset 176452 in webkit


Ignore:
Timestamp:
Nov 21, 2014 9:40:50 AM (9 years ago)
Author:
Antti Koivisto
Message:

Remove alignment code from IPC coders
​https://bugs.webkit.org/show_bug.cgi?id=138963

Reviewed by Anders Carlsson.

Alignment code achieves nothing except making the messages somewhat bigger.

  • Platform/IPC/ArgumentCoders.cpp:

(IPC::ArgumentCoder<CString>::encode):
(IPC::ArgumentCoder<CString>::decode):
(IPC::ArgumentCoder<String>::encode):
(IPC::decodeStringText):

  • Platform/IPC/ArgumentCoders.h:

(IPC::SimpleArgumentCoder::encode):
(IPC::SimpleArgumentCoder::decode):

  • Platform/IPC/ArgumentDecoder.cpp:

(IPC::ArgumentDecoder::initialize):
(IPC::ArgumentDecoder::bufferIsLargeEnoughToContain):
(IPC::ArgumentDecoder::decodeFixedLengthData):
(IPC::ArgumentDecoder::decodeVariableLengthByteArray):
(IPC::ArgumentDecoder::decodeNumber):
(IPC::ArgumentDecoder::decode):
(IPC::roundUpToAlignment): Deleted.
(IPC::alignedBufferIsLargeEnoughToContain): Deleted.
(IPC::ArgumentDecoder::alignBufferPosition): Deleted.
(IPC::decodeValueFromBuffer): Deleted.

  • Platform/IPC/ArgumentDecoder.h:

(IPC::ArgumentDecoder::isInvalid):
(IPC::ArgumentDecoder::markInvalid):
(IPC::ArgumentDecoder::bufferIsLargeEnoughToContain):

  • Platform/IPC/ArgumentEncoder.cpp:

(IPC::ArgumentEncoder::ArgumentEncoder):
(IPC::ArgumentEncoder::grow):
(IPC::ArgumentEncoder::encodeFixedLengthData):
(IPC::ArgumentEncoder::encodeVariableLengthByteArray):
(IPC::ArgumentEncoder::encode):

  • Platform/IPC/ArgumentEncoder.h:

(IPC::ArgumentEncoder::buffer):
(IPC::ArgumentEncoder::mutableBuffer):

  • Platform/IPC/DataReference.cpp:

(IPC::SharedBufferDataReference::encode):

  • Platform/IPC/MessageEncoder.cpp:

(IPC::MessageEncoder::setIsSyncMessage):
(IPC::MessageEncoder::setShouldDispatchMessageWhenWaitingForSyncReply):

  • Platform/IPC/mac/ConnectionMac.mm:

(IPC::Connection::sendOutgoingMessage):

Location:
trunk/Source/WebKit2
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r176450 r176452  
     12014-11-21  Antti Koivisto  <antti@apple.com>
     2
     3        Remove alignment code from IPC coders
     4        https://bugs.webkit.org/show_bug.cgi?id=138963
     5
     6        Reviewed by Anders Carlsson.
     7
     8        Alignment code achieves nothing except making the messages somewhat bigger.
     9
     10        * Platform/IPC/ArgumentCoders.cpp:
     11        (IPC::ArgumentCoder<CString>::encode):
     12        (IPC::ArgumentCoder<CString>::decode):
     13        (IPC::ArgumentCoder<String>::encode):
     14        (IPC::decodeStringText):
     15        * Platform/IPC/ArgumentCoders.h:
     16        (IPC::SimpleArgumentCoder::encode):
     17        (IPC::SimpleArgumentCoder::decode):
     18        * Platform/IPC/ArgumentDecoder.cpp:
     19        (IPC::ArgumentDecoder::initialize):
     20        (IPC::ArgumentDecoder::bufferIsLargeEnoughToContain):
     21        (IPC::ArgumentDecoder::decodeFixedLengthData):
     22        (IPC::ArgumentDecoder::decodeVariableLengthByteArray):
     23        (IPC::ArgumentDecoder::decodeNumber):
     24        (IPC::ArgumentDecoder::decode):
     25        (IPC::roundUpToAlignment): Deleted.
     26        (IPC::alignedBufferIsLargeEnoughToContain): Deleted.
     27        (IPC::ArgumentDecoder::alignBufferPosition): Deleted.
     28        (IPC::decodeValueFromBuffer): Deleted.
     29        * Platform/IPC/ArgumentDecoder.h:
     30        (IPC::ArgumentDecoder::isInvalid):
     31        (IPC::ArgumentDecoder::markInvalid):
     32        (IPC::ArgumentDecoder::bufferIsLargeEnoughToContain):
     33        * Platform/IPC/ArgumentEncoder.cpp:
     34        (IPC::ArgumentEncoder::ArgumentEncoder):
     35        (IPC::ArgumentEncoder::grow):
     36        (IPC::ArgumentEncoder::encodeFixedLengthData):
     37        (IPC::ArgumentEncoder::encodeVariableLengthByteArray):
     38        (IPC::ArgumentEncoder::encode):
     39        * Platform/IPC/ArgumentEncoder.h:
     40        (IPC::ArgumentEncoder::buffer):
     41        (IPC::ArgumentEncoder::mutableBuffer):
     42        * Platform/IPC/DataReference.cpp:
     43        (IPC::SharedBufferDataReference::encode):
     44        * Platform/IPC/MessageEncoder.cpp:
     45        (IPC::MessageEncoder::setIsSyncMessage):
     46        (IPC::MessageEncoder::setShouldDispatchMessageWhenWaitingForSyncReply):
     47        * Platform/IPC/mac/ConnectionMac.mm:
     48        (IPC::Connection::sendOutgoingMessage):
     49
    1502014-11-21  Anders Carlsson  <andersca@apple.com>
    251

  • trunk/Source/WebKit2/Platform/IPC/ArgumentCoders.cpp

    r161148 r176452  
    5858    uint32_t length = string.length();
    5959    encoder << length;
    60     encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.data()), length, 1);
     60    encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.data()), length);
    6161}
    6262
    … …  
    8181    char* buffer;
    8282    CString string = CString::newUninitialized(length, buffer);
    83     if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length, 1))
     83    if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length))
    8484        return false;
    8585
    … …  
    103103
    104104    if (is8Bit)
    105         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters8()), length * sizeof(LChar), alignof(LChar));
     105        encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters8()), length * sizeof(LChar));
    106106    else
    107         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters16()), length * sizeof(UChar), alignof(UChar));
     107        encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters16()), length * sizeof(UChar));
    108108}
    109109
    … …  
    119119    CharacterType* buffer;
    120120    String string = String::createUninitialized(length, buffer);
    121     if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length * sizeof(CharacterType), alignof(CharacterType)))
     121    if (!decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(buffer), length * sizeof(CharacterType)))
    122122        return false;
    123123   

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

    r176275 r176452  
    4242    static void encode(ArgumentEncoder& encoder, const T& t)
    4343    {
    44         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(&t), sizeof(T), alignof(T));
     44        encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(&t), sizeof(T));
    4545    }
    4646
    4747    static bool decode(ArgumentDecoder& decoder, T& t)
    4848    {
    49         return decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(&t), sizeof(T), alignof(T));
     49        return decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(&t), sizeof(T));
    5050    }
    5151};
    … …  
    179179    {
    180180        encoder << static_cast<uint64_t>(vector.size());
    181         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(vector.data()), vector.size() * sizeof(T), alignof(T));
     181        encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(vector.data()), vector.size() * sizeof(T));
    182182    }
    183183   
    … …  
    199199        temp.resize(size);
    200200
    201         decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(temp.data()), size * sizeof(T), alignof(T));
     201        decoder.decodeFixedLengthData(reinterpret_cast<uint8_t*>(temp.data()), size * sizeof(T));
    202202
    203203        vector.swap(temp);

  • trunk/Source/WebKit2/Platform/IPC/ArgumentDecoder.cpp

    r170799 r176452  
    5757}
    5858
    59 static inline uint8_t* roundUpToAlignment(uint8_t* ptr, unsigned alignment)
    60 {
    61     // Assert that the alignment is a power of 2.
    62     ASSERT(alignment && !(alignment & (alignment - 1)));
    63 
    64     uintptr_t alignmentMask = alignment - 1;
    65     return reinterpret_cast<uint8_t*>((reinterpret_cast<uintptr_t>(ptr) + alignmentMask) & ~alignmentMask);
    66 }
    67 
    6859void ArgumentDecoder::initialize(const uint8_t* buffer, size_t bufferSize)
    6960{
    … …  
    7263    ASSERT(!(reinterpret_cast<uintptr_t>(m_buffer) % alignof(uint64_t)));
    7364
    74     m_bufferPos = m_buffer;
     65    m_bufferPosition = m_buffer;
    7566    m_bufferEnd = m_buffer + bufferSize;
    7667    memcpy(m_buffer, buffer, bufferSize);
    7768}
    7869
    79 static inline bool alignedBufferIsLargeEnoughToContain(const uint8_t* alignedPosition, const uint8_t* bufferEnd, size_t size)
     70bool ArgumentDecoder::bufferIsLargeEnoughToContain(size_t size) const
    8071{
    81     return bufferEnd >= alignedPosition && static_cast<size_t>(bufferEnd - alignedPosition) >= size;
     72    return m_buffer + size <= m_bufferEnd;
    8273}
    8374
    84 bool ArgumentDecoder::alignBufferPosition(unsigned alignment, size_t size)
     75bool ArgumentDecoder::decodeFixedLengthData(uint8_t* data, size_t size)
    8576{
    86     uint8_t* alignedPosition = roundUpToAlignment(m_bufferPos, alignment);
    87     if (!alignedBufferIsLargeEnoughToContain(alignedPosition, m_bufferEnd, size)) {
    88         // We've walked off the end of this buffer.
    89         markInvalid();
    90         return false;
    91     }
    92    
    93     m_bufferPos = alignedPosition;
    94     return true;
    95 }
    96 
    97 bool ArgumentDecoder::bufferIsLargeEnoughToContain(unsigned alignment, size_t size) const
    98 {
    99     return alignedBufferIsLargeEnoughToContain(roundUpToAlignment(m_bufferPos, alignment), m_bufferEnd, size);
    100 }
    101 
    102 bool ArgumentDecoder::decodeFixedLengthData(uint8_t* data, size_t size, unsigned alignment)
    103 {
    104     if (!alignBufferPosition(alignment, size))
     77    if (!bufferIsLargeEnoughToContain(size))
    10578        return false;
    10679
    107     memcpy(data, m_bufferPos, size);
    108     m_bufferPos += size;
     80    memcpy(data, m_bufferPosition, size);
     81    m_bufferPosition += size;
    10982
    11083    return true;
    … …  
    11790        return false;
    11891   
    119     if (!alignBufferPosition(1, size))
     92    if (!bufferIsLargeEnoughToContain(size))
    12093        return false;
    12194
    122     uint8_t* data = m_bufferPos;
    123     m_bufferPos += size;
     95    uint8_t* data = m_bufferPosition;
     96    m_bufferPosition += size;
    12497
    12598    dataReference = DataReference(data, size);
    … …  
    128101
    129102template<typename Type>
    130 static void decodeValueFromBuffer(Type& value, uint8_t*& bufferPosition)
     103bool ArgumentDecoder::decodeNumber(Type& value)
    131104{
    132     memcpy(&value, bufferPosition, sizeof(value));
    133     bufferPosition += sizeof(Type);
     105    if (!bufferIsLargeEnoughToContain(sizeof(Type)))
     106        return false;
     107
     108    memcpy(&value, m_bufferPosition, sizeof(Type));
     109    m_bufferPosition += sizeof(Type);
     110
     111    return true;
    134112}
    135113
    136114bool ArgumentDecoder::decode(bool& result)
    137115{
    138     if (!alignBufferPosition(sizeof(result), sizeof(result)))
    139         return false;
    140    
    141     decodeValueFromBuffer(result, m_bufferPos);
    142     return true;
     116    return decodeNumber(result);
    143117}
    144118
    145119bool ArgumentDecoder::decode(uint8_t& result)
    146120{
    147     if (!alignBufferPosition(sizeof(result), sizeof(result)))
    148         return false;
    149 
    150     decodeValueFromBuffer(result, m_bufferPos);
    151     return true;
     121    return decodeNumber(result);
    152122}
    153123
    154124bool ArgumentDecoder::decode(uint16_t& result)
    155125{
    156     if (!alignBufferPosition(sizeof(result), sizeof(result)))
    157         return false;
    158 
    159     decodeValueFromBuffer(result, m_bufferPos);
    160     return true;
     126    return decodeNumber(result);
    161127}
    162128
    163129bool ArgumentDecoder::decode(uint32_t& result)
    164130{
    165     if (!alignBufferPosition(sizeof(result), sizeof(result)))
    166         return false;
    167 
    168     decodeValueFromBuffer(result, m_bufferPos);
    169     return true;
     131    return decodeNumber(result);
    170132}
    171133
    172134bool ArgumentDecoder::decode(uint64_t& result)
    173135{
    174     if (!alignBufferPosition(sizeof(result), sizeof(result)))
    175         return false;
    176    
    177     decodeValueFromBuffer(result, m_bufferPos);
    178     return true;
     136    return decodeNumber(result);
    179137}
    180138
    181139bool ArgumentDecoder::decode(int32_t& result)
    182140{
    183     if (!alignBufferPosition(sizeof(result), sizeof(result)))
    184         return false;
    185    
    186     decodeValueFromBuffer(result, m_bufferPos);
    187     return true;
     141    return decodeNumber(result);
    188142}
    189143
    190144bool ArgumentDecoder::decode(int64_t& result)
    191145{
    192     if (!alignBufferPosition(sizeof(result), sizeof(result)))
    193         return false;
    194 
    195     decodeValueFromBuffer(result, m_bufferPos);
    196     return true;
     146    return decodeNumber(result);
    197147}
    198148
    199149bool ArgumentDecoder::decode(float& result)
    200150{
    201     if (!alignBufferPosition(sizeof(result), sizeof(result)))
    202         return false;
    203 
    204     decodeValueFromBuffer(result, m_bufferPos);
    205     return true;
     151    return decodeNumber(result);
    206152}
    207153
    208154bool ArgumentDecoder::decode(double& result)
    209155{
    210     if (!alignBufferPosition(sizeof(result), sizeof(result)))
    211         return false;
    212    
    213     decodeValueFromBuffer(result, m_bufferPos);
    214     return true;
     156    return decodeNumber(result);
    215157}
    216158

  • trunk/Source/WebKit2/Platform/IPC/ArgumentDecoder.h

    r170799 r176452  
    4343    size_t length() const { return m_bufferEnd - m_buffer; }
    4444
    45     bool isInvalid() const { return m_bufferPos > m_bufferEnd; }
    46     void markInvalid() { m_bufferPos = m_bufferEnd + 1; }
     45    bool isInvalid() const { return m_bufferPosition > m_bufferEnd; }
     46    void markInvalid() { m_bufferPosition = m_bufferEnd + 1; }
    4747
    48     bool decodeFixedLengthData(uint8_t*, size_t, unsigned alignment);
     48    bool decodeFixedLengthData(uint8_t*, size_t);
    4949
    5050    // The data in the data reference here will only be valid for the lifetime of the ArgumentDecoder object.
    … …  
    8181            return false;
    8282
    83         return bufferIsLargeEnoughToContain(alignof(T), numElements * sizeof(T));
     83        return bufferIsLargeEnoughToContain(numElements * sizeof(T));
    8484    }
    8585
    … …  
    9797    void initialize(const uint8_t* buffer, size_t bufferSize);
    9898
    99     bool alignBufferPosition(unsigned alignment, size_t size);
    100     bool bufferIsLargeEnoughToContain(unsigned alignment, size_t size) const;
     99    bool bufferIsLargeEnoughToContain(size_t) const;
     100    template <typename Type> bool decodeNumber(Type& value);
    101101
    102102private:
    103103    uint8_t* m_buffer;
    104     uint8_t* m_bufferPos;
     104    uint8_t* m_bufferPosition;
    105105    uint8_t* m_bufferEnd;
    106106

  • trunk/Source/WebKit2/Platform/IPC/ArgumentEncoder.cpp

    r170799 r176452  
    5858ArgumentEncoder::ArgumentEncoder()
    5959    : m_buffer(m_inlineBuffer)
    60     , m_bufferPointer(m_inlineBuffer)
    6160    , m_bufferSize(0)
    6261    , m_bufferCapacity(sizeof(m_inlineBuffer))
    … …  
    104103}
    105104
    106 uint8_t* ArgumentEncoder::grow(unsigned alignment, size_t size)
     105uint8_t* ArgumentEncoder::grow(size_t size)
    107106{
    108     size_t alignedSize = roundUpToAlignment(m_bufferSize, alignment);
    109     reserve(alignedSize + size);
     107    size_t position = m_bufferSize;
     108    reserve(m_bufferSize + size);
    110109
    111     m_bufferSize = alignedSize + size;
    112     m_bufferPointer = m_buffer + alignedSize + size;
    113    
    114     return m_buffer + alignedSize;
     110    m_bufferSize += size;
     111
     112    return m_buffer + position;
    115113}
    116114
    117 void ArgumentEncoder::encodeFixedLengthData(const uint8_t* data, size_t size, unsigned alignment)
     115void ArgumentEncoder::encodeFixedLengthData(const uint8_t* data, size_t size)
    118116{
    119     ASSERT(!(reinterpret_cast<uintptr_t>(data) % alignment));
    120 
    121     uint8_t* buffer = grow(alignment, size);
     117    uint8_t* buffer = grow(size);
    122118    memcpy(buffer, data, size);
    123119}
    … …  
    126122{
    127123    encode(static_cast<uint64_t>(dataReference.size()));
    128     encodeFixedLengthData(dataReference.data(), dataReference.size(), 1);
     124    encodeFixedLengthData(dataReference.data(), dataReference.size());
    129125}
    130126
    131127template<typename Type>
    132 static void copyValueToBuffer(Type value, uint8_t* bufferPosition)
     128void ArgumentEncoder::encodeNumber(Type value)
    133129{
     130    uint8_t* bufferPosition = grow(sizeof(Type));
    134131    memcpy(bufferPosition, &value, sizeof(Type));
    135132}
    136133
    137 void ArgumentEncoder::encode(bool n)
     134void ArgumentEncoder::encode(bool value)
    138135{
    139     uint8_t* buffer = grow(sizeof(n), sizeof(n));
    140     copyValueToBuffer(n, buffer);
     136    encodeNumber(value);
    141137}
    142138
    143 void ArgumentEncoder::encode(uint8_t n)
     139void ArgumentEncoder::encode(uint8_t value)
    144140{
    145     uint8_t* buffer = grow(sizeof(n), sizeof(n));
    146     copyValueToBuffer(n, buffer);
     141    encodeNumber(value);
    147142}
    148143
    149 void ArgumentEncoder::encode(uint16_t n)
     144void ArgumentEncoder::encode(uint16_t value)
    150145{
    151     uint8_t* buffer = grow(sizeof(n), sizeof(n));
    152     copyValueToBuffer(n, buffer);
     146    encodeNumber(value);
    153147}
    154148
    155 void ArgumentEncoder::encode(uint32_t n)
     149void ArgumentEncoder::encode(uint32_t value)
    156150{
    157     uint8_t* buffer = grow(sizeof(n), sizeof(n));
    158     copyValueToBuffer(n, buffer);
     151    encodeNumber(value);
    159152}
    160153
    161 void ArgumentEncoder::encode(uint64_t n)
     154void ArgumentEncoder::encode(uint64_t value)
    162155{
    163     uint8_t* buffer = grow(sizeof(n), sizeof(n));
    164     copyValueToBuffer(n, buffer);
     156    encodeNumber(value);
    165157}
    166158
    167 void ArgumentEncoder::encode(int32_t n)
     159void ArgumentEncoder::encode(int32_t value)
    168160{
    169     uint8_t* buffer = grow(sizeof(n), sizeof(n));
    170     copyValueToBuffer(n, buffer);
     161    encodeNumber(value);
    171162}
    172163
    173 void ArgumentEncoder::encode(int64_t n)
     164void ArgumentEncoder::encode(int64_t value)
    174165{
    175     uint8_t* buffer = grow(sizeof(n), sizeof(n));
    176     copyValueToBuffer(n, buffer);
     166    encodeNumber(value);
    177167}
    178168
    179 void ArgumentEncoder::encode(float n)
     169void ArgumentEncoder::encode(float value)
    180170{
    181     uint8_t* buffer = grow(sizeof(n), sizeof(n));
    182     copyValueToBuffer(n, buffer);
     171    encodeNumber(value);
    183172}
    184173
    185 void ArgumentEncoder::encode(double n)
     174void ArgumentEncoder::encode(double value)
    186175{
    187     uint8_t* buffer = grow(sizeof(n), sizeof(n));
    188     copyValueToBuffer(n, buffer);
     176    encodeNumber(value);
    189177}
    190178

  • trunk/Source/WebKit2/Platform/IPC/ArgumentEncoder.h

    r170799 r176452  
    4242    virtual ~ArgumentEncoder();
    4343
    44     void encodeFixedLengthData(const uint8_t*, size_t, unsigned alignment);
     44    void encodeFixedLengthData(const uint8_t*, size_t);
    4545    void encodeVariableLengthByteArray(const DataReference&);
    4646
    … …  
    6363    }
    6464
    65     uint8_t* buffer() const { return m_buffer; }
     65    const uint8_t* buffer() const { return m_buffer; }
    6666    size_t bufferSize() const { return m_bufferSize; }
    6767
    … …  
    6969    Vector<Attachment> releaseAttachments();
    7070    void reserve(size_t);
     71
     72protected:
     73    uint8_t* mutableBuffer() { return m_buffer; }
    7174
    7275private:
    … …  
    8083    void encode(float);
    8184    void encode(double);
     85    template<typename Type> void encodeNumber(Type);
    8286
    83     uint8_t* grow(unsigned alignment, size_t size);
     87    uint8_t* grow(size_t);
    8488
    8589    uint8_t m_inlineBuffer[512];
     90    uint8_t* m_buffer;
    8691
    87     uint8_t* m_buffer;
    88     uint8_t* m_bufferPointer;
    89    
    9092    size_t m_bufferSize;
    9193    size_t m_bufferCapacity;

  • trunk/Source/WebKit2/Platform/IPC/DataReference.cpp

    r170154 r176452  
    5252    while (position < bufferSize) {
    5353        unsigned bytesToWrite = m_buffer->getSomeData(partialData, position);
    54         encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(partialData), bytesToWrite, 1);
     54        encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(partialData), bytesToWrite);
    5555        position += bytesToWrite;
    5656    }

  • trunk/Source/WebKit2/Platform/IPC/MessageEncoder.cpp

    r161148 r176452  
    5252{
    5353    if (isSyncMessage)
    54         *buffer() |= SyncMessage;
     54        *mutableBuffer() |= SyncMessage;
    5555    else
    56         *buffer() &= ~SyncMessage;
     56        *mutableBuffer() &= ~SyncMessage;
    5757}
    5858
    … …  
    6060{
    6161    if (shouldDispatchMessageWhenWaitingForSyncReply)
    62         *buffer() |= DispatchMessageWhenWaitingForSyncReply;
     62        *mutableBuffer() |= DispatchMessageWhenWaitingForSyncReply;
    6363    else
    64         *buffer() &= ~DispatchMessageWhenWaitingForSyncReply;
     64        *mutableBuffer() &= ~DispatchMessageWhenWaitingForSyncReply;
    6565}
    6666

  • trunk/Source/WebKit2/Platform/IPC/mac/ConnectionMac.mm

    r176036 r176452  
    328328            mach_msg_descriptor_t* descriptor = reinterpret_cast<mach_msg_descriptor_t*>(descriptorData);
    329329
    330             descriptor->out_of_line.address = encoder->buffer();
     330            descriptor->out_of_line.address = const_cast<uint8_t*>(encoder->buffer());
    331331            descriptor->out_of_line.size = encoder->bufferSize();
    332332            descriptor->out_of_line.copy = MACH_MSG_VIRTUAL_COPY;

  • trunk/Source/WebKit2/Platform/IPC/unix/ConnectionUnix.cpp

    r176036 r176452  
    515515
    516516    if (!messageInfo.isMessageBodyIsOutOfLine() && encoder->bufferSize()) {
    517         iov[iovLength].iov_base = reinterpret_cast<void*>(encoder->buffer());
     517        iov[iovLength].iov_base = reinterpret_cast<void*>(const_cast<uint8_t*>(encoder->buffer()));
    518518        iov[iovLength].iov_len = encoder->bufferSize();
    519519        ++iovLength;
Note: See TracChangeset for help on using the changeset viewer.