Changeset 64877 in webkit


Ignore:
Timestamp:
Aug 6, 2010 4:04:20 PM (14 years ago)
Author:
andersca@apple.com
Message:

Change all ArgumentEncoder and ArgumentDecoder references to pointers
https://bugs.webkit.org/show_bug.cgi?id=43651

Reviewed by Sam Weinig.

  • Platform/CoreIPC/ArgumentCoder.h:
  • Platform/CoreIPC/ArgumentDecoder.h:
  • Platform/CoreIPC/Arguments.h:
  • Platform/CoreIPC/Attachment.cpp:
  • Platform/CoreIPC/Attachment.h:
  • Platform/CoreIPC/mac/MachPort.h:
  • Platform/SharedMemory.h:
  • Platform/mac/SharedMemoryMac.cpp:
  • Shared/DrawingAreaBase.cpp:
  • Shared/DrawingAreaBase.h:
  • Shared/WebEvent.h:
  • Shared/WebNavigationDataStore.h:
  • Shared/WebPreferencesStore.h:
  • Shared/mac/UpdateChunk.cpp:
  • Shared/mac/UpdateChunk.h:
  • UIProcess/ChunkedUpdateDrawingAreaProxy.cpp:
  • UIProcess/ChunkedUpdateDrawingAreaProxy.h:
  • UIProcess/DrawingAreaProxy.h:
  • UIProcess/LayerBackedDrawingAreaProxy.cpp:
  • UIProcess/LayerBackedDrawingAreaProxy.h:
  • UIProcess/WebContext.cpp:
  • UIProcess/WebContext.h:
  • UIProcess/WebPageProxy.cpp:
  • UIProcess/WebPageProxy.h:
  • UIProcess/WebProcessProxy.cpp:
  • WebProcess/InjectedBundle/InjectedBundle.cpp:
  • WebProcess/InjectedBundle/InjectedBundle.h:
  • WebProcess/WebPage/ChunkedUpdateDrawingArea.cpp:
  • WebProcess/WebPage/ChunkedUpdateDrawingArea.h:
  • WebProcess/WebPage/DrawingArea.h:
  • WebProcess/WebPage/LayerBackedDrawingArea.cpp:
  • WebProcess/WebPage/LayerBackedDrawingArea.h:
  • WebProcess/WebPage/WebPage.cpp:
  • WebProcess/WebPage/WebPage.h:
  • WebProcess/WebProcess.cpp:
Location:
trunk/WebKit2
Files:
36 edited

Legend:

Unmodified
Added
Removed
  • trunk/WebKit2/ChangeLog

    r64875 r64877  
     12010-08-06  Anders Carlsson  <andersca@apple.com>
     2
     3        Reviewed by Sam Weinig.
     4
     5        Change all ArgumentEncoder and ArgumentDecoder references to pointers
     6        https://bugs.webkit.org/show_bug.cgi?id=43651
     7
     8        * Platform/CoreIPC/ArgumentCoder.h:
     9        * Platform/CoreIPC/ArgumentDecoder.h:
     10        * Platform/CoreIPC/Arguments.h:
     11        * Platform/CoreIPC/Attachment.cpp:
     12        * Platform/CoreIPC/Attachment.h:
     13        * Platform/CoreIPC/mac/MachPort.h:
     14        * Platform/SharedMemory.h:
     15        * Platform/mac/SharedMemoryMac.cpp:
     16        * Shared/DrawingAreaBase.cpp:
     17        * Shared/DrawingAreaBase.h:
     18        * Shared/WebEvent.h:
     19        * Shared/WebNavigationDataStore.h:
     20        * Shared/WebPreferencesStore.h:
     21        * Shared/mac/UpdateChunk.cpp:
     22        * Shared/mac/UpdateChunk.h:
     23        * UIProcess/ChunkedUpdateDrawingAreaProxy.cpp:
     24        * UIProcess/ChunkedUpdateDrawingAreaProxy.h:
     25        * UIProcess/DrawingAreaProxy.h:
     26        * UIProcess/LayerBackedDrawingAreaProxy.cpp:
     27        * UIProcess/LayerBackedDrawingAreaProxy.h:
     28        * UIProcess/WebContext.cpp:
     29        * UIProcess/WebContext.h:
     30        * UIProcess/WebPageProxy.cpp:
     31        * UIProcess/WebPageProxy.h:
     32        * UIProcess/WebProcessProxy.cpp:
     33        * WebProcess/InjectedBundle/InjectedBundle.cpp:
     34        * WebProcess/InjectedBundle/InjectedBundle.h:
     35        * WebProcess/WebPage/ChunkedUpdateDrawingArea.cpp:
     36        * WebProcess/WebPage/ChunkedUpdateDrawingArea.h:
     37        * WebProcess/WebPage/DrawingArea.h:
     38        * WebProcess/WebPage/LayerBackedDrawingArea.cpp:
     39        * WebProcess/WebPage/LayerBackedDrawingArea.h:
     40        * WebProcess/WebPage/WebPage.cpp:
     41        * WebProcess/WebPage/WebPage.h:
     42        * WebProcess/WebProcess.cpp:
     43
    1442010-08-06  Anders Carlsson  <andersca@apple.com>
    245
  • trunk/WebKit2/Platform/CoreIPC/ArgumentCoder.h

    r61635 r64877  
    3737    static void encode(ArgumentEncoder* encoder, const T& t)
    3838    {
    39         t.encode(*encoder);
     39        t.encode(encoder);
    4040    }
    4141
    4242    static bool decode(ArgumentDecoder* decoder, T& t)
    4343    {
    44         return T::decode(*decoder, t);
     44        return T::decode(decoder, t);
    4545    }
    4646};
  • trunk/WebKit2/Platform/CoreIPC/ArgumentDecoder.h

    r64875 r64877  
    8080
    8181private:
    82     ArgumentDecoder(const ArgumentDecoder&);
    83     ArgumentDecoder& operator=(const ArgumentDecoder&);
     82    ArgumentDecoder(const ArgumentDecoder*);
     83    ArgumentDecoder* operator=(const ArgumentDecoder*);
    8484
    8585    void initialize(const uint8_t* buffer, size_t bufferSize);
  • trunk/WebKit2/Platform/CoreIPC/Arguments.h

    r57307 r64877  
    3434class Arguments0 {
    3535public:
    36     void encode(ArgumentEncoder&) const
    37     {
    38     }
    39 
    40     static bool decode(ArgumentDecoder&, Arguments0&)
     36    void encode(ArgumentEncoder*) const
     37    {
     38    }
     39
     40    static bool decode(ArgumentDecoder*, Arguments0&)
    4141    {
    4242        return true;
     
    6161    }
    6262
    63     void encode(ArgumentEncoder& encoder) const
    64     {
    65         encoder.encode(m_value);
    66     }
    67 
    68     static bool decode(ArgumentDecoder& decoder, Arguments1<T1>& result)
    69     {
    70         return decoder.decode(result.m_value);
     63    void encode(ArgumentEncoder* encoder) const
     64    {
     65        encoder->encode(m_value);
     66    }
     67
     68    static bool decode(ArgumentDecoder* decoder, Arguments1<T1>& result)
     69    {
     70        return decoder->decode(result.m_value);
    7171    }
    7272   
     
    9393    }
    9494
    95     void encode(ArgumentEncoder& encoder) const
     95    void encode(ArgumentEncoder* encoder) const
    9696    {
    9797        Arguments1<T1>::encode(encoder);
    98         encoder.encode(m_value);
    99     }
    100 
    101     static bool decode(ArgumentDecoder& decoder, Arguments2<T1, T2>& result)
     98        encoder->encode(m_value);
     99    }
     100
     101    static bool decode(ArgumentDecoder* decoder, Arguments2<T1, T2>& result)
    102102    {
    103103        if (!Arguments1<T1>::decode(decoder, result))
    104104            return false;
    105105       
    106         return decoder.decode(result.m_value);
     106        return decoder->decode(result.m_value);
    107107    }
    108108
     
    129129    }
    130130
    131     void encode(ArgumentEncoder& encoder) const
     131    void encode(ArgumentEncoder* encoder) const
    132132    {
    133133        Arguments2<T1, T2>::encode(encoder);
    134         encoder.encode(m_value);
    135     }
    136 
    137     static bool decode(ArgumentDecoder& decoder, Arguments3<T1, T2, T3>& result)
     134        encoder->encode(m_value);
     135    }
     136
     137    static bool decode(ArgumentDecoder* decoder, Arguments3<T1, T2, T3>& result)
    138138    {
    139139        if (!Arguments2<T1, T2>::decode(decoder, result))
    140140            return false;
    141141       
    142         return decoder.decode(result.m_value);
     142        return decoder->decode(result.m_value);
    143143    }
    144144
     
    165165    }
    166166
    167     void encode(ArgumentEncoder& encoder) const
     167    void encode(ArgumentEncoder* encoder) const
    168168    {
    169169        Arguments3<T1, T2, T3>::encode(encoder);
    170         encoder.encode(m_value);
    171     }
    172    
    173     static bool decode(ArgumentDecoder& decoder, Arguments4<T1, T2, T3, T4>& result)
     170        encoder->encode(m_value);
     171    }
     172   
     173    static bool decode(ArgumentDecoder* decoder, Arguments4<T1, T2, T3, T4>& result)
    174174    {
    175175        if (!Arguments3<T1, T2, T3>::decode(decoder, result))
    176176            return false;
    177177       
    178         return decoder.decode(result.m_value);
     178        return decoder->decode(result.m_value);
    179179    }
    180180
     
    201201    }
    202202
    203     void encode(ArgumentEncoder& encoder) const
     203    void encode(ArgumentEncoder* encoder) const
    204204    {
    205205        Arguments4<T1, T2, T3, T4>::encode(encoder);
    206         encoder.encode(m_value);
    207     }
    208    
    209     static bool decode(ArgumentDecoder& decoder, Arguments5<T1, T2, T3, T4, T5>& result)
     206        encoder->encode(m_value);
     207    }
     208   
     209    static bool decode(ArgumentDecoder* decoder, Arguments5<T1, T2, T3, T4, T5>& result)
    210210    {
    211211        if (!Arguments4<T1, T2, T3, T4>::decode(decoder, result))
    212212            return false;
    213213       
    214         return decoder.decode(result.m_value);
     214        return decoder->decode(result.m_value);
    215215    }
    216216
  • trunk/WebKit2/Platform/CoreIPC/Attachment.cpp

    r57359 r64877  
    5959#endif
    6060
    61 void Attachment::encode(ArgumentEncoder& encoder) const
     61void Attachment::encode(ArgumentEncoder* encoder) const
    6262{
    63     encoder.addAttachment(*this);
     63    encoder->addAttachment(*this);
    6464}
    6565
    66 bool Attachment::decode(ArgumentDecoder& decoder, Attachment& attachment)
     66bool Attachment::decode(ArgumentDecoder* decoder, Attachment& attachment)
    6767{
    68     if (!decoder.removeAttachment(attachment))
     68    if (!decoder->removeAttachment(attachment))
    6969        return false;
    7070    return true;
  • trunk/WebKit2/Platform/CoreIPC/Attachment.h

    r57307 r64877  
    6565#endif
    6666
    67     void encode(ArgumentEncoder&) const;
    68     static bool decode(ArgumentDecoder&, Attachment&);
     67    void encode(ArgumentEncoder*) const;
     68    static bool decode(ArgumentDecoder*, Attachment&);
    6969   
    7070private:
  • trunk/WebKit2/Platform/CoreIPC/mac/MachPort.h

    r57307 r64877  
    4545    }
    4646
    47     void encode(ArgumentEncoder& encoder) const
     47    void encode(ArgumentEncoder* encoder) const
    4848    {
    49         encoder.encode(Attachment(m_port, m_disposition));
     49        encoder->encode(Attachment(m_port, m_disposition));
    5050    }
    5151
    52     static bool decode(ArgumentDecoder& decoder, MachPort& p)
     52    static bool decode(ArgumentDecoder* decoder, MachPort& p)
    5353    {
    5454        Attachment attachment;
    55         if (!decoder.decode(attachment))
     55        if (!decoder->decode(attachment))
    5656            return false;
    5757       
  • trunk/WebKit2/Platform/SharedMemory.h

    r64765 r64877  
    5050        ~Handle();
    5151
    52         void encode(CoreIPC::ArgumentEncoder&) const;
    53         static bool decode(CoreIPC::ArgumentDecoder&, Handle&);
     52        void encode(CoreIPC::ArgumentEncoder*) const;
     53        static bool decode(CoreIPC::ArgumentDecoder*, Handle&);
    5454
    5555    private:
  • trunk/WebKit2/Platform/mac/SharedMemoryMac.cpp

    r64776 r64877  
    4949}
    5050
    51 void SharedMemory::Handle::encode(CoreIPC::ArgumentEncoder& encoder) const
     51void SharedMemory::Handle::encode(CoreIPC::ArgumentEncoder* encoder) const
    5252{
    5353    ASSERT(m_port);
    5454    ASSERT(m_size);
    5555   
    56     encoder.encodeUInt64(m_size);
    57     encoder.encode(CoreIPC::MachPort(m_port, MACH_MSG_TYPE_COPY_SEND));
     56    encoder->encodeUInt64(m_size);
     57    encoder->encode(CoreIPC::MachPort(m_port, MACH_MSG_TYPE_COPY_SEND));
    5858    m_port = MACH_PORT_NULL;
    5959}
    6060
    61 bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder& decoder, Handle& handle)
     61bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder* decoder, Handle& handle)
    6262{
    6363    ASSERT(!handle.m_port);
     
    6565
    6666    uint64_t size;
    67     if (!decoder.decodeUInt64(size))
     67    if (!decoder->decodeUInt64(size))
    6868        return false;
    6969
    7070    CoreIPC::MachPort machPort;
    71     if (!decoder.decode(CoreIPC::Out(machPort)))
     71    if (!decoder->decode(CoreIPC::Out(machPort)))
    7272        return false;
    7373   
  • trunk/WebKit2/Shared/DrawingAreaBase.cpp

    r64594 r64877  
    2828namespace WebKit {
    2929
    30 void DrawingAreaBase::encode(CoreIPC::ArgumentEncoder& encoder) const
     30void DrawingAreaBase::encode(CoreIPC::ArgumentEncoder* encoder) const
    3131{
    3232    DrawingAreaInfo info(type(), id());
    33     encoder.encode(info);
     33    encoder->encode(info);
    3434}
    3535
    36 bool DrawingAreaBase::decode(CoreIPC::ArgumentDecoder& decoder, DrawingAreaInfo& info)
     36bool DrawingAreaBase::decode(CoreIPC::ArgumentDecoder* decoder, DrawingAreaInfo& info)
    3737{
    3838    uint32_t drawingAreaType;
    39     if (!decoder.decode(drawingAreaType))
     39    if (!decoder->decode(drawingAreaType))
    4040        return false;
    4141
    4242    DrawingAreaID drawingAreaID;
    43     if (!decoder.decode(drawingAreaID))
     43    if (!decoder->decode(drawingAreaID))
    4444        return false;
    4545
  • trunk/WebKit2/Shared/DrawingAreaBase.h

    r64867 r64877  
    6666   
    6767    // The DrawingAreaProxy should never be decoded itself. Instead, the DrawingArea should be decoded.
    68     void encode(CoreIPC::ArgumentEncoder& encoder) const;
    69     static bool decode(CoreIPC::ArgumentDecoder&, DrawingAreaInfo&);
     68    void encode(CoreIPC::ArgumentEncoder* encoder) const;
     69    static bool decode(CoreIPC::ArgumentDecoder*, DrawingAreaInfo&);
    7070
    7171protected:
  • trunk/WebKit2/Shared/WebEvent.h

    r64063 r64877  
    8383    }
    8484
    85     void encode(CoreIPC::ArgumentEncoder& encoder) const
    86     {
    87         encoder.encode(m_type);
    88         encoder.encode(m_modifiers);
    89         encoder.encode(m_timestamp);
    90     }
    91 
    92     static bool decode(CoreIPC::ArgumentDecoder& decoder, WebEvent& t)
    93     {
    94         if (!decoder.decode(t.m_type))
    95             return false;
    96         if (!decoder.decode(t.m_modifiers))
    97             return false;
    98         if (!decoder.decode(t.m_timestamp))
     85    void encode(CoreIPC::ArgumentEncoder* encoder) const
     86    {
     87        encoder->encode(m_type);
     88        encoder->encode(m_modifiers);
     89        encoder->encode(m_timestamp);
     90    }
     91
     92    static bool decode(CoreIPC::ArgumentDecoder* decoder, WebEvent& t)
     93    {
     94        if (!decoder->decode(t.m_type))
     95            return false;
     96        if (!decoder->decode(t.m_modifiers))
     97            return false;
     98        if (!decoder->decode(t.m_timestamp))
    9999            return false;
    100100
     
    146146    int clickCount() const { return m_clickCount; }
    147147
    148     void encode(CoreIPC::ArgumentEncoder& encoder) const
    149     {
    150         encoder.encodeBytes(reinterpret_cast<const uint8_t*>(this), sizeof(*this));
    151     }
    152 
    153     static bool decode(CoreIPC::ArgumentDecoder& decoder, WebMouseEvent& t)
    154     {
    155         return decoder.decodeBytes(reinterpret_cast<uint8_t*>(&t), sizeof(t));
     148    void encode(CoreIPC::ArgumentEncoder* encoder) const
     149    {
     150        encoder->encodeBytes(reinterpret_cast<const uint8_t*>(this), sizeof(*this));
     151    }
     152
     153    static bool decode(CoreIPC::ArgumentDecoder* decoder, WebMouseEvent& t)
     154    {
     155        return decoder->decodeBytes(reinterpret_cast<uint8_t*>(&t), sizeof(t));
    156156    }
    157157
     
    209209    Granularity granularity() const { return (Granularity)m_granularity; }
    210210
    211     void encode(CoreIPC::ArgumentEncoder& encoder) const
    212     {
    213         encoder.encodeBytes(reinterpret_cast<const uint8_t*>(this), sizeof(*this));
    214     }
    215 
    216     static bool decode(CoreIPC::ArgumentDecoder& decoder, WebWheelEvent& t)
    217     {
    218         return decoder.decodeBytes(reinterpret_cast<uint8_t*>(&t), sizeof(t));
     211    void encode(CoreIPC::ArgumentEncoder* encoder) const
     212    {
     213        encoder->encodeBytes(reinterpret_cast<const uint8_t*>(this), sizeof(*this));
     214    }
     215
     216    static bool decode(CoreIPC::ArgumentDecoder* decoder, WebWheelEvent& t)
     217    {
     218        return decoder->decodeBytes(reinterpret_cast<uint8_t*>(&t), sizeof(t));
    219219    }
    220220
     
    265265    bool isSystemKey() const { return m_isSystemKey; }
    266266
    267     void encode(CoreIPC::ArgumentEncoder& encoder) const
     267    void encode(CoreIPC::ArgumentEncoder* encoder) const
    268268    {
    269269        WebEvent::encode(encoder);
    270270
    271         encoder.encode(m_text);
    272         encoder.encode(m_unmodifiedText);
    273         encoder.encode(m_keyIdentifier);
    274         encoder.encode(m_windowsVirtualKeyCode);
    275         encoder.encode(m_nativeVirtualKeyCode);
    276         encoder.encode(m_isAutoRepeat);
    277         encoder.encode(m_isKeypad);
    278         encoder.encode(m_isSystemKey);
    279     }
    280 
    281     static bool decode(CoreIPC::ArgumentDecoder& decoder, WebKeyboardEvent& t)
     271        encoder->encode(m_text);
     272        encoder->encode(m_unmodifiedText);
     273        encoder->encode(m_keyIdentifier);
     274        encoder->encode(m_windowsVirtualKeyCode);
     275        encoder->encode(m_nativeVirtualKeyCode);
     276        encoder->encode(m_isAutoRepeat);
     277        encoder->encode(m_isKeypad);
     278        encoder->encode(m_isSystemKey);
     279    }
     280
     281    static bool decode(CoreIPC::ArgumentDecoder* decoder, WebKeyboardEvent& t)
    282282    {
    283283        if (!WebEvent::decode(decoder, t))
     
    285285
    286286        WebCore::String text;
    287         if (!decoder.decode(text))
     287        if (!decoder->decode(text))
    288288            return false;
    289289        t.m_text = text;
    290290
    291291        WebCore::String unmodifiedText;
    292         if (!decoder.decode(unmodifiedText))
     292        if (!decoder->decode(unmodifiedText))
    293293            return false;
    294294        t.m_unmodifiedText = unmodifiedText;
    295295
    296296        WebCore::String keyIdentifier;
    297         if (!decoder.decode(keyIdentifier))
     297        if (!decoder->decode(keyIdentifier))
    298298            return false;
    299299        t.m_keyIdentifier = keyIdentifier;
    300300
    301         if (!decoder.decode(t.m_windowsVirtualKeyCode))
    302             return false;
    303         if (!decoder.decode(t.m_nativeVirtualKeyCode))
    304             return false;
    305         if (!decoder.decode(t.m_isAutoRepeat))
    306             return false;
    307         if (!decoder.decode(t.m_isKeypad))
    308             return false;
    309         if (!decoder.decode(t.m_isSystemKey))
     301        if (!decoder->decode(t.m_windowsVirtualKeyCode))
     302            return false;
     303        if (!decoder->decode(t.m_nativeVirtualKeyCode))
     304            return false;
     305        if (!decoder->decode(t.m_isAutoRepeat))
     306            return false;
     307        if (!decoder->decode(t.m_isKeypad))
     308            return false;
     309        if (!decoder->decode(t.m_isSystemKey))
    310310            return false;
    311311        return true;
  • trunk/WebKit2/Shared/WebNavigationDataStore.h

    r61719 r64877  
    3535
    3636struct WebNavigationDataStore {
    37     void encode(CoreIPC::ArgumentEncoder& encoder) const
     37    void encode(CoreIPC::ArgumentEncoder* encoder) const
    3838    {
    39         encoder.encode(url);
    40         encoder.encode(title);
     39        encoder->encode(url);
     40        encoder->encode(title);
    4141    }
    4242
    43     static bool decode(CoreIPC::ArgumentDecoder& decoder, WebNavigationDataStore& store)
     43    static bool decode(CoreIPC::ArgumentDecoder* decoder, WebNavigationDataStore& store)
    4444    {
    45         if (!decoder.decode(store.url))
     45        if (!decoder->decode(store.url))
    4646            return false;
    47         if (!decoder.decode(store.title))
     47        if (!decoder->decode(store.title))
    4848            return false;
    4949        return true;
  • trunk/WebKit2/Shared/WebPreferencesStore.h

    r63682 r64877  
    4040    void swap(WebPreferencesStore&);
    4141
    42     void encode(CoreIPC::ArgumentEncoder& encoder) const
     42    void encode(CoreIPC::ArgumentEncoder* encoder) const
    4343    {
    44         encoder.encode(javaScriptEnabled);
    45         encoder.encode(loadsImagesAutomatically);
    46         encoder.encode(pluginsEnabled);
    47         encoder.encode(offlineWebApplicationCacheEnabled);
    48         encoder.encode(localStorageEnabled);
    49         encoder.encode(minimumFontSize);
    50         encoder.encode(minimumLogicalFontSize);
    51         encoder.encode(defaultFontSize);
    52         encoder.encode(defaultFixedFontSize);
    53         encoder.encode(standardFontFamily);
    54         encoder.encode(cursiveFontFamily);
    55         encoder.encode(fantasyFontFamily);
    56         encoder.encode(fixedFontFamily);
    57         encoder.encode(sansSerifFontFamily);
    58         encoder.encode(serifFontFamily);
     44        encoder->encode(javaScriptEnabled);
     45        encoder->encode(loadsImagesAutomatically);
     46        encoder->encode(pluginsEnabled);
     47        encoder->encode(offlineWebApplicationCacheEnabled);
     48        encoder->encode(localStorageEnabled);
     49        encoder->encode(minimumFontSize);
     50        encoder->encode(minimumLogicalFontSize);
     51        encoder->encode(defaultFontSize);
     52        encoder->encode(defaultFixedFontSize);
     53        encoder->encode(standardFontFamily);
     54        encoder->encode(cursiveFontFamily);
     55        encoder->encode(fantasyFontFamily);
     56        encoder->encode(fixedFontFamily);
     57        encoder->encode(sansSerifFontFamily);
     58        encoder->encode(serifFontFamily);
    5959    }
    6060
    61     static bool decode(CoreIPC::ArgumentDecoder& decoder, WebPreferencesStore& s)
     61    static bool decode(CoreIPC::ArgumentDecoder* decoder, WebPreferencesStore& s)
    6262    {
    63         if (!decoder.decode(s.javaScriptEnabled))
     63        if (!decoder->decode(s.javaScriptEnabled))
    6464            return false;
    65         if (!decoder.decode(s.loadsImagesAutomatically))
     65        if (!decoder->decode(s.loadsImagesAutomatically))
    6666            return false;
    67         if (!decoder.decode(s.pluginsEnabled))
     67        if (!decoder->decode(s.pluginsEnabled))
    6868            return false;
    69         if (!decoder.decode(s.offlineWebApplicationCacheEnabled))
     69        if (!decoder->decode(s.offlineWebApplicationCacheEnabled))
    7070            return false;
    71         if (!decoder.decode(s.localStorageEnabled))
     71        if (!decoder->decode(s.localStorageEnabled))
    7272            return false;
    73         if (!decoder.decode(s.minimumFontSize))
     73        if (!decoder->decode(s.minimumFontSize))
    7474            return false;
    75         if (!decoder.decode(s.minimumLogicalFontSize))
     75        if (!decoder->decode(s.minimumLogicalFontSize))
    7676            return false;
    77         if (!decoder.decode(s.defaultFontSize))
     77        if (!decoder->decode(s.defaultFontSize))
    7878            return false;
    79         if (!decoder.decode(s.defaultFixedFontSize))
     79        if (!decoder->decode(s.defaultFixedFontSize))
    8080            return false;
    81         if (!decoder.decode(s.standardFontFamily))
     81        if (!decoder->decode(s.standardFontFamily))
    8282            return false;
    83         if (!decoder.decode(s.cursiveFontFamily))
     83        if (!decoder->decode(s.cursiveFontFamily))
    8484            return false;
    85         if (!decoder.decode(s.fantasyFontFamily))
     85        if (!decoder->decode(s.fantasyFontFamily))
    8686            return false;
    87         if (!decoder.decode(s.fixedFontFamily))
     87        if (!decoder->decode(s.fixedFontFamily))
    8888            return false;
    89         if (!decoder.decode(s.sansSerifFontFamily))
     89        if (!decoder->decode(s.sansSerifFontFamily))
    9090            return false;
    91         if (!decoder.decode(s.serifFontFamily))
     91        if (!decoder->decode(s.serifFontFamily))
    9292            return false;
    9393        return true;
  • trunk/WebKit2/Shared/mac/UpdateChunk.cpp

    r63400 r64877  
    6666}
    6767
    68 void UpdateChunk::encode(CoreIPC::ArgumentEncoder& encoder) const
     68void UpdateChunk::encode(CoreIPC::ArgumentEncoder* encoder) const
    6969{
    70     encoder.encode(m_rect);
    71     encoder.encode(CoreIPC::Attachment(m_data, size(), MACH_MSG_VIRTUAL_COPY, true));
     70    encoder->encode(m_rect);
     71    encoder->encode(CoreIPC::Attachment(m_data, size(), MACH_MSG_VIRTUAL_COPY, true));
    7272   
    7373    m_data = 0;
    7474}
    7575
    76 bool UpdateChunk::decode(CoreIPC::ArgumentDecoder& decoder, UpdateChunk& chunk)
     76bool UpdateChunk::decode(CoreIPC::ArgumentDecoder* decoder, UpdateChunk& chunk)
    7777{
    7878    IntRect rect;
    79     if (!decoder.decode(rect))
     79    if (!decoder->decode(rect))
    8080        return false;
    8181    chunk.m_rect = rect;
    8282   
    8383    CoreIPC::Attachment attachment;
    84     if (!decoder.decode(attachment))
     84    if (!decoder->decode(attachment))
    8585        return false;
    8686
  • trunk/WebKit2/Shared/mac/UpdateChunk.h

    r63821 r64877  
    4747    bool isEmpty() const { return m_rect.isEmpty(); }
    4848
    49     void encode(CoreIPC::ArgumentEncoder&) const;
    50     static bool decode(CoreIPC::ArgumentDecoder&, UpdateChunk&);
     49    void encode(CoreIPC::ArgumentEncoder*) const;
     50    static bool decode(CoreIPC::ArgumentDecoder*, UpdateChunk&);
    5151
    5252    RetainPtr<CGImageRef> createImage();
  • trunk/WebKit2/UIProcess/ChunkedUpdateDrawingAreaProxy.cpp

    r64867 r64877  
    6363        OwnPtr<CoreIPC::ArgumentDecoder> arguments = page->process()->connection()->waitFor(DrawingAreaProxyMessage::DidSetSize, page->pageID(), 0.04);
    6464        if (arguments)
    65             didReceiveMessage(page->process()->connection(), CoreIPC::MessageID(DrawingAreaProxyMessage::DidSetSize), *arguments.get());
     65            didReceiveMessage(page->process()->connection(), CoreIPC::MessageID(DrawingAreaProxyMessage::DidSetSize), arguments.get());
    6666    }
    6767
     
    145145}
    146146
    147 void ChunkedUpdateDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments)
     147void ChunkedUpdateDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
    148148{
    149149    switch (messageID.get<DrawingAreaProxyMessage::Kind>()) {
    150150        case DrawingAreaProxyMessage::Update: {
    151151            UpdateChunk updateChunk;
    152             if (!arguments.decode(updateChunk))
     152            if (!arguments->decode(updateChunk))
    153153                return;
    154154
     
    158158        case DrawingAreaProxyMessage::DidSetSize: {
    159159            UpdateChunk updateChunk;
    160             if (!arguments.decode(CoreIPC::Out(updateChunk)))
     160            if (!arguments->decode(CoreIPC::Out(updateChunk)))
    161161                return;
    162162
  • trunk/WebKit2/UIProcess/ChunkedUpdateDrawingAreaProxy.h

    r64867 r64877  
    6262
    6363    // The DrawingAreaProxy should never be decoded itself. Instead, the DrawingArea should be decoded.
    64     virtual void encode(CoreIPC::ArgumentEncoder& encoder) const
     64    virtual void encode(CoreIPC::ArgumentEncoder* encoder) const
    6565    {
    6666        DrawingAreaProxy::encode(encoder);
     
    7171
    7272    // DrawingAreaProxy
    73     virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder&);
     73    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
    7474    virtual void paint(const WebCore::IntRect&, PlatformDrawingContext);
    7575    virtual void setSize(const WebCore::IntSize&);
  • trunk/WebKit2/UIProcess/DrawingAreaProxy.h

    r64867 r64877  
    4949    virtual ~DrawingAreaProxy();
    5050
    51     virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder&) = 0;
    52     virtual void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder&, CoreIPC::ArgumentEncoder&) { ASSERT_NOT_REACHED(); }
     51    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*) = 0;
     52    virtual void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*, CoreIPC::ArgumentEncoder*) { ASSERT_NOT_REACHED(); }
    5353
    5454    virtual void paint(const WebCore::IntRect&, PlatformDrawingContext) = 0;
  • trunk/WebKit2/UIProcess/LayerBackedDrawingAreaProxy.cpp

    r64594 r64877  
    119119}
    120120
    121 void LayerBackedDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments)
     121void LayerBackedDrawingAreaProxy::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
    122122{
    123123    switch (messageID.get<DrawingAreaProxyMessage::Kind>()) {
     
    135135}
    136136
    137 void LayerBackedDrawingAreaProxy::didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments, CoreIPC::ArgumentEncoder&)
     137void LayerBackedDrawingAreaProxy::didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments, CoreIPC::ArgumentEncoder*)
    138138{
    139139    switch (messageID.get<DrawingAreaProxyMessage::Kind>()) {
     
    141141        case DrawingAreaProxyMessage::AttachCompositingContext: {
    142142            uint32_t contextID;
    143             if (!arguments.decode(CoreIPC::Out(contextID)))
     143            if (!arguments->decode(CoreIPC::Out(contextID)))
    144144                return;
    145145            attachCompositingContext(contextID);
  • trunk/WebKit2/UIProcess/LayerBackedDrawingAreaProxy.h

    r64594 r64877  
    6363
    6464    // DrawingAreaProxy
    65     virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder&);
    66     virtual void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder&, CoreIPC::ArgumentEncoder&);
     65    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
     66    virtual void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*, CoreIPC::ArgumentEncoder*);
    6767
    6868    virtual void paint(const WebCore::IntRect&, PlatformDrawingContext);
  • trunk/WebKit2/UIProcess/WebContext.cpp

    r64797 r64877  
    6969    }
    7070
    71     void encode(CoreIPC::ArgumentEncoder& encoder) const
     71    void encode(CoreIPC::ArgumentEncoder* encoder) const
    7272    {
    7373        APIObject::Type type = m_root->type();
    74         encoder.encode(static_cast<uint32_t>(type));
     74        encoder->encode(static_cast<uint32_t>(type));
    7575        switch (type) {
    7676        case APIObject::TypeArray: {
    7777            ImmutableArray* array = static_cast<ImmutableArray*>(m_root);
    78             encoder.encode(static_cast<uint64_t>(array->size()));
     78            encoder->encode(static_cast<uint64_t>(array->size()));
    7979            for (size_t i = 0; i < array->size(); ++i)
    80                 encoder.encode(PostMessageEncoder(array->at(i)));
     80                encoder->encode(PostMessageEncoder(array->at(i)));
    8181            break;
    8282        }
    8383        case APIObject::TypeString: {
    8484            WebString* string = static_cast<WebString*>(m_root);
    85             encoder.encode(string->string());
     85            encoder->encode(string->string());
    8686            break;
    8787        }
    8888        case APIObject::TypePage: {
    8989            WebPageProxy* page = static_cast<WebPageProxy*>(m_root);
    90             encoder.encode(page->pageID());
     90            encoder->encode(page->pageID());
    9191            break;
    9292        }
     
    115115    }
    116116
    117     static bool decode(CoreIPC::ArgumentDecoder& decoder, PostMessageDecoder& coder)
     117    static bool decode(CoreIPC::ArgumentDecoder* decoder, PostMessageDecoder& coder)
    118118    {
    119119        uint32_t type;
    120         if (!decoder.decode(type))
     120        if (!decoder->decode(type))
    121121            return false;
    122122
     
    124124        case APIObject::TypeArray: {
    125125            uint64_t size;
    126             if (!decoder.decode(size))
     126            if (!decoder->decode(size))
    127127                return false;
    128128           
     
    133133                APIObject* element;
    134134                PostMessageDecoder messageCoder(&element, coder.m_context);
    135                 if (!decoder.decode(messageCoder))
     135                if (!decoder->decode(messageCoder))
    136136                    return false;
    137137                array[i] = element;
     
    143143        case APIObject::TypeString: {
    144144            String string;
    145             if (!decoder.decode(string))
     145            if (!decoder->decode(string))
    146146                return false;
    147147            *(coder.m_root) = WebString::create(string).leakRef();
     
    150150        case APIObject::TypeBundlePage: {
    151151            uint64_t pageID;
    152             if (!decoder.decode(pageID))
     152            if (!decoder->decode(pageID))
    153153                return false;
    154154            *(coder.m_root) = coder.m_context->process()->webPage(pageID);
     
    398398}
    399399       
    400 void WebContext::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments)
     400void WebContext::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
    401401{
    402402    switch (messageID.get<WebContextMessage::Kind>()) {
     
    406406            APIObject* messageBody = 0;
    407407            PostMessageDecoder messageCoder(&messageBody, this);
    408             if (!arguments.decode(CoreIPC::Out(messageName, messageCoder)))
     408            if (!arguments->decode(CoreIPC::Out(messageName, messageCoder)))
    409409                return;
    410410
  • trunk/WebKit2/UIProcess/WebContext.h

    r64797 r64877  
    105105    void addVisitedLink(WebCore::LinkHash);
    106106
    107     void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder&);
     107    void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
    108108
    109109private:
  • trunk/WebKit2/UIProcess/WebPageProxy.cpp

    r64662 r64877  
    389389}
    390390
    391 void WebPageProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments)
     391void WebPageProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
    392392{
    393393    if (messageID.is<CoreIPC::MessageClassDrawingAreaProxy>()) {
     
    399399        case WebPageProxyMessage::DidCreateMainFrame: {
    400400            uint64_t frameID;
    401             if (!arguments.decode(frameID))
     401            if (!arguments->decode(frameID))
    402402                return;
    403403            didCreateMainFrame(frameID);
     
    406406        case WebPageProxyMessage::DidCreateSubFrame: {
    407407            uint64_t frameID;
    408             if (!arguments.decode(frameID))
     408            if (!arguments->decode(frameID))
    409409                return;
    410410            didCreateSubFrame(frameID);
     
    414414            uint64_t frameID;
    415415            String url;
    416             if (!arguments.decode(CoreIPC::Out(frameID, url)))
     416            if (!arguments->decode(CoreIPC::Out(frameID, url)))
    417417                return;
    418418            didStartProvisionalLoadForFrame(webFrame(frameID), url);
     
    421421        case WebPageProxyMessage::DidReceiveServerRedirectForProvisionalLoadForFrame: {
    422422            uint64_t frameID;
    423             if (!arguments.decode(frameID))
     423            if (!arguments->decode(frameID))
    424424                return;
    425425            didReceiveServerRedirectForProvisionalLoadForFrame(webFrame(frameID));
     
    428428        case WebPageProxyMessage::DidFailProvisionalLoadForFrame: {
    429429            uint64_t frameID;
    430             if (!arguments.decode(frameID))
     430            if (!arguments->decode(frameID))
    431431                return;
    432432            didFailProvisionalLoadForFrame(webFrame(frameID));
     
    435435        case WebPageProxyMessage::DidCommitLoadForFrame: {
    436436            uint64_t frameID;
    437             if (!arguments.decode(frameID))
     437            if (!arguments->decode(frameID))
    438438                return;
    439439            didCommitLoadForFrame(webFrame(frameID));
     
    442442        case WebPageProxyMessage::DidFinishLoadForFrame: {
    443443            uint64_t frameID;
    444             if (!arguments.decode(frameID))
     444            if (!arguments->decode(frameID))
    445445                return;
    446446            didFinishLoadForFrame(webFrame(frameID));
     
    449449        case WebPageProxyMessage::DidFailLoadForFrame: {
    450450            uint64_t frameID;
    451             if (!arguments.decode(frameID))
     451            if (!arguments->decode(frameID))
    452452                return;
    453453            didFailLoadForFrame(webFrame(frameID));
     
    457457            uint64_t frameID;
    458458            String title;
    459             if (!arguments.decode(CoreIPC::Out(frameID, title)))
     459            if (!arguments->decode(CoreIPC::Out(frameID, title)))
    460460                return;
    461461            didReceiveTitleForFrame(webFrame(frameID), title);
     
    464464        case WebPageProxyMessage::DidFirstLayoutForFrame: {
    465465            uint64_t frameID;
    466             if (!arguments.decode(frameID))
     466            if (!arguments->decode(frameID))
    467467                return;
    468468            didFirstLayoutForFrame(webFrame(frameID));
     
    471471        case WebPageProxyMessage::DidFirstVisuallyNonEmptyLayoutForFrame: {
    472472            uint64_t frameID;
    473             if (!arguments.decode(frameID))
     473            if (!arguments->decode(frameID))
    474474                return;
    475475            didFirstVisuallyNonEmptyLayoutForFrame(webFrame(frameID));
     
    481481        case WebPageProxyMessage::DidChangeProgress: {
    482482            double value;
    483             if (!arguments.decode(value))
     483            if (!arguments->decode(value))
    484484                return;
    485485            didChangeProgress(value);
     
    491491        case WebPageProxyMessage::DidReceiveEvent: {
    492492            uint32_t type;
    493             if (!arguments.decode(type))
     493            if (!arguments->decode(type))
    494494                return;
    495495            didReceiveEvent((WebEvent::Type)type);
     
    499499            // FIXME: Use enum here.
    500500            bool direction;
    501             if (!arguments.decode(direction))
     501            if (!arguments->decode(direction))
    502502                return;
    503503            takeFocus(direction);
     
    509509            String url;
    510510            uint64_t listenerID;
    511             if (!arguments.decode(CoreIPC::Out(frameID, navigationType, url, listenerID)))
     511            if (!arguments->decode(CoreIPC::Out(frameID, navigationType, url, listenerID)))
    512512                return;
    513513            decidePolicyForNavigationAction(webFrame(frameID), static_cast<NavigationType>(navigationType), url, listenerID);
     
    519519            String url;
    520520            uint64_t listenerID;
    521             if (!arguments.decode(CoreIPC::Out(frameID, navigationType, url, listenerID)))
     521            if (!arguments->decode(CoreIPC::Out(frameID, navigationType, url, listenerID)))
    522522                return;
    523523            decidePolicyForNewWindowAction(webFrame(frameID), static_cast<NavigationType>(navigationType), url, listenerID);
     
    529529            String url;
    530530            uint64_t listenerID;
    531             if (!arguments.decode(CoreIPC::Out(frameID, MIMEType, url, listenerID)))
     531            if (!arguments->decode(CoreIPC::Out(frameID, MIMEType, url, listenerID)))
    532532                return;
    533533            decidePolicyForMIMEType(webFrame(frameID), MIMEType, url, listenerID);
     
    537537            String resultString;
    538538            uint64_t callbackID;
    539             if (!arguments.decode(CoreIPC::Out(resultString, callbackID)))
     539            if (!arguments->decode(CoreIPC::Out(resultString, callbackID)))
    540540                return;
    541541            didRunJavaScriptInMainFrame(resultString, callbackID);
     
    545545            String resultString;
    546546            uint64_t callbackID;
    547             if (!arguments.decode(CoreIPC::Out(resultString, callbackID)))
     547            if (!arguments->decode(CoreIPC::Out(resultString, callbackID)))
    548548                return;
    549549            didGetRenderTreeExternalRepresentation(resultString, callbackID);
     
    552552        case WebPageProxyMessage::SetToolTip: {
    553553            String toolTip;
    554             if (!arguments.decode(toolTip))
     554            if (!arguments->decode(toolTip))
    555555                return;
    556556            setToolTip(toolTip);
     
    560560#if USE(LAZY_NATIVE_CURSOR)
    561561            Cursor cursor;
    562             if (!arguments.decode(cursor))
     562            if (!arguments->decode(cursor))
    563563                return;
    564564            setCursor(cursor);
     
    576576        case WebPageProxyMessage::BackForwardAddItem: {
    577577            uint64_t itemID;
    578             if (!arguments.decode(CoreIPC::Out(itemID)))
     578            if (!arguments->decode(CoreIPC::Out(itemID)))
    579579                return;
    580580            addItemToBackForwardList(process()->webBackForwardItem(itemID));
     
    583583        case WebPageProxyMessage::BackForwardGoToItem: {
    584584            uint64_t itemID;
    585             if (!arguments.decode(CoreIPC::Out(itemID)))
     585            if (!arguments->decode(CoreIPC::Out(itemID)))
    586586                return;
    587587            goToItemInBackForwardList(process()->webBackForwardItem(itemID));
     
    594594}
    595595
    596 void WebPageProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments, CoreIPC::ArgumentEncoder& reply)
     596void WebPageProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments, CoreIPC::ArgumentEncoder* reply)
    597597{
    598598    if (messageID.is<CoreIPC::MessageClassDrawingAreaProxy>()) {
     
    606606            if (newPage) {
    607607                // FIXME: Pass the real size.
    608                 reply.encode(CoreIPC::In(newPage->pageID(), IntSize(100, 100),
    609                                          newPage->pageNamespace()->context()->preferences()->store(),
    610                                          *(newPage->drawingArea())));
     608                reply->encode(CoreIPC::In(newPage->pageID(), IntSize(100, 100),
     609                                          newPage->pageNamespace()->context()->preferences()->store(),
     610                                          *(newPage->drawingArea())));
    611611            } else {
    612                 reply.encode(CoreIPC::In(static_cast<uint64_t>(0), IntSize(), WebPreferencesStore(), DrawingAreaBase::DrawingAreaInfo()));
     612                reply->encode(CoreIPC::In(static_cast<uint64_t>(0), IntSize(), WebPreferencesStore(), DrawingAreaBase::DrawingAreaInfo()));
    613613            }
    614614            break;
     
    617617            uint64_t frameID;
    618618            String message;
    619             if (!arguments.decode(CoreIPC::Out(frameID, message)))
     619            if (!arguments->decode(CoreIPC::Out(frameID, message)))
    620620                return;
    621621            runJavaScriptAlert(webFrame(frameID), message);
     
    626626            uint64_t frameID;
    627627            String message;
    628             if (!arguments.decode(CoreIPC::Out(frameID, message)))
     628            if (!arguments->decode(CoreIPC::Out(frameID, message)))
    629629                return;
    630630
    631631            bool result = runJavaScriptConfirm(webFrame(frameID), message);
    632             reply.encode(CoreIPC::In(result));
     632            reply->encode(CoreIPC::In(result));
    633633            break;
    634634        }
     
    638638            String message;
    639639            String defaultValue;
    640             if (!arguments.decode(CoreIPC::Out(frameID, message, defaultValue)))
     640            if (!arguments->decode(CoreIPC::Out(frameID, message, defaultValue)))
    641641                return;
    642642
    643643            String result = runJavaScriptPrompt(webFrame(frameID), message, defaultValue);
    644             reply.encode(CoreIPC::In(result));
     644            reply->encode(CoreIPC::In(result));
    645645            break;
    646646        }
     
    648648            WebBackForwardListItem* currentItem = m_backForwardList->currentItem();
    649649            uint64_t currentItemID = currentItem ? currentItem->itemID() : 0;
    650             reply.encode(CoreIPC::In(currentItemID));
     650            reply->encode(CoreIPC::In(currentItemID));
    651651            break;
    652652        }
    653653        case WebPageProxyMessage::BackForwardItemAtIndex: {
    654654            int itemIndex;
    655             if (!arguments.decode(CoreIPC::Out(itemIndex)))
     655            if (!arguments->decode(CoreIPC::Out(itemIndex)))
    656656                return;
    657657
    658658            WebBackForwardListItem* item = m_backForwardList->itemAtIndex(itemIndex);
    659659            uint64_t itemID = item ? item->itemID() : 0;
    660             reply.encode(CoreIPC::In(itemID));
     660            reply->encode(CoreIPC::In(itemID));
    661661            break;
    662662        }
    663663        case WebPageProxyMessage::BackForwardBackListCount: {
    664664            int backListCount = m_backForwardList->backListCount();
    665             reply.encode(CoreIPC::In(backListCount));
     665            reply->encode(CoreIPC::In(backListCount));
    666666            break;
    667667        }
    668668        case WebPageProxyMessage::BackForwardForwardListCount: {
    669669            int forwardListCount = m_backForwardList->forwardListCount();
    670             reply.encode(CoreIPC::In(forwardListCount));
     670            reply->encode(CoreIPC::In(forwardListCount));
    671671            break;
    672672        }
     
    674674        case WebPageProxyMessage::DidChangeAcceleratedCompositing: {
    675675            bool compositing;
    676             if (!arguments.decode(CoreIPC::Out(compositing)))
     676            if (!arguments->decode(CoreIPC::Out(compositing)))
    677677                return;
    678678
    679679            didChangeAcceleratedCompositing(compositing);
    680             reply.encode(*(drawingArea()));
     680            reply->encode(*(drawingArea()));
    681681            break;
    682682        }
  • trunk/WebKit2/UIProcess/WebPageProxy.h

    r64662 r64877  
    141141    void receivedPolicyDecision(WebCore::PolicyAction, WebFrameProxy*, uint64_t listenerID);
    142142
    143     void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder&);
    144     void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder&, CoreIPC::ArgumentEncoder&);
     143    void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
     144    void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*, CoreIPC::ArgumentEncoder*);
    145145
    146146    void processDidBecomeUnresponsive();
  • trunk/WebKit2/UIProcess/WebProcessProxy.cpp

    r64871 r64877  
    316316
    317317    if (messageID.is<CoreIPC::MessageClassWebContext>()) {
    318         m_context->didReceiveMessage(connection, messageID, *arguments);   
     318        m_context->didReceiveMessage(connection, messageID, arguments);   
    319319        return;
    320320    }
     
    328328        return;
    329329   
    330     pageProxy->didReceiveMessage(connection, messageID, *arguments);   
     330    pageProxy->didReceiveMessage(connection, messageID, arguments);   
    331331}
    332332
     
    381381        return;
    382382   
    383     pageProxy->didReceiveSyncMessage(connection, messageID, *arguments, *reply);
     383    pageProxy->didReceiveSyncMessage(connection, messageID, arguments, reply);
    384384}
    385385
  • trunk/WebKit2/WebProcess/InjectedBundle/InjectedBundle.cpp

    r64396 r64877  
    6161    }
    6262
    63     void encode(CoreIPC::ArgumentEncoder& encoder) const
     63    void encode(CoreIPC::ArgumentEncoder* encoder) const
    6464    {
    6565        APIObject::Type type = m_root->type();
    66         encoder.encode(static_cast<uint32_t>(type));
     66        encoder->encode(static_cast<uint32_t>(type));
    6767        switch (type) {
    6868        case APIObject::TypeArray: {
    6969            ImmutableArray* array = static_cast<ImmutableArray*>(m_root);
    70             encoder.encode(static_cast<uint64_t>(array->size()));
     70            encoder->encode(static_cast<uint64_t>(array->size()));
    7171            for (size_t i = 0; i < array->size(); ++i)
    72                 encoder.encode(PostMessageEncoder(array->at(i)));
     72                encoder->encode(PostMessageEncoder(array->at(i)));
    7373            break;
    7474        }
    7575        case APIObject::TypeString: {
    7676            WebString* string = static_cast<WebString*>(m_root);
    77             encoder.encode(string->string());
     77            encoder->encode(string->string());
    7878            break;
    7979        }
    8080        case APIObject::TypeBundlePage: {
    8181            WebPage* page = static_cast<WebPage*>(m_root);
    82             encoder.encode(page->pageID());
     82            encoder->encode(page->pageID());
    8383            break;
    8484        }
     
    107107    }
    108108
    109     static bool decode(CoreIPC::ArgumentDecoder& decoder, PostMessageDecoder& coder)
     109    static bool decode(CoreIPC::ArgumentDecoder* decoder, PostMessageDecoder& coder)
    110110    {
    111111        uint32_t type;
    112         if (!decoder.decode(type))
     112        if (!decoder->decode(type))
    113113            return false;
    114114
     
    116116        case APIObject::TypeArray: {
    117117            uint64_t size;
    118             if (!decoder.decode(size))
     118            if (!decoder->decode(size))
    119119                return false;
    120120           
     
    125125                APIObject* element;
    126126                PostMessageDecoder messageCoder(&element);
    127                 if (!decoder.decode(messageCoder))
     127                if (!decoder->decode(messageCoder))
    128128                    return false;
    129129                array[i] = element;
     
    135135        case APIObject::TypeString: {
    136136            String string;
    137             if (!decoder.decode(string))
     137            if (!decoder->decode(string))
    138138                return false;
    139139            *(coder.m_root) = WebString::create(string).leakRef();
     
    142142        case APIObject::TypePage: {
    143143            uint64_t pageID;
    144             if (!decoder.decode(pageID))
     144            if (!decoder->decode(pageID))
    145145                return false;
    146146            *(coder.m_root) = WebProcess::shared().webPage(pageID);
     
    212212}
    213213
    214 void InjectedBundle::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments)
     214void InjectedBundle::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
    215215{
    216216    switch (messageID.get<InjectedBundleMessage::Kind>()) {
     
    220220            APIObject* messageBody = 0;
    221221            PostMessageDecoder messageCoder(&messageBody);
    222             if (!arguments.decode(CoreIPC::Out(messageName, messageCoder)))
     222            if (!arguments->decode(CoreIPC::Out(messageName, messageCoder)))
    223223                return;
    224224
  • trunk/WebKit2/WebProcess/InjectedBundle/InjectedBundle.h

    r64603 r64877  
    7878    void didReceiveMessage(const WebCore::String&, APIObject*);
    7979
    80     void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder&);
     80    void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
    8181
    8282private:
  • trunk/WebKit2/WebProcess/WebPage/ChunkedUpdateDrawingArea.cpp

    r64594 r64877  
    181181}
    182182
    183 void ChunkedUpdateDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments)
     183void ChunkedUpdateDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
    184184{
    185185    DrawingAreaID targetDrawingAreaID;
    186     if (!arguments.decode(CoreIPC::Out(targetDrawingAreaID)))
     186    if (!arguments->decode(CoreIPC::Out(targetDrawingAreaID)))
    187187        return;
    188188
     
    194194        case DrawingAreaMessage::SetSize: {
    195195            IntSize size;
    196             if (!arguments.decode(CoreIPC::Out(size)))
     196            if (!arguments->decode(CoreIPC::Out(size)))
    197197                return;
    198198
     
    207207        case DrawingAreaMessage::ResumePainting: {
    208208            bool forceRepaint;
    209             if (!arguments.decode(CoreIPC::Out(forceRepaint)))
     209            if (!arguments->decode(CoreIPC::Out(forceRepaint)))
    210210                return;
    211211           
  • trunk/WebKit2/WebProcess/WebPage/ChunkedUpdateDrawingArea.h

    r64594 r64877  
    5555#endif
    5656
    57     virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder&);
     57    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
    5858
    5959private:
  • trunk/WebKit2/WebProcess/WebPage/DrawingArea.h

    r64594 r64877  
    6565#endif
    6666
    67     virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder&) = 0;
     67    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*) = 0;
    6868
    6969protected:
  • trunk/WebKit2/WebProcess/WebPage/LayerBackedDrawingArea.cpp

    r64594 r64877  
    147147}
    148148
    149 void LayerBackedDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments)
     149void LayerBackedDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
    150150{
    151151    DrawingAreaID targetDrawingAreaID;
    152     if (!arguments.decode(CoreIPC::Out(targetDrawingAreaID)))
     152    if (!arguments->decode(CoreIPC::Out(targetDrawingAreaID)))
    153153        return;
    154154
     
    160160        case DrawingAreaMessage::SetSize: {
    161161            IntSize size;
    162             if (!arguments.decode(CoreIPC::Out(size)))
     162            if (!arguments->decode(CoreIPC::Out(size)))
    163163                return;
    164164
  • trunk/WebKit2/WebProcess/WebPage/LayerBackedDrawingArea.h

    r64594 r64877  
    6969    virtual void syncCompositingLayers();
    7070
    71     virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder&);
     71    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
    7272
    7373private:
  • trunk/WebKit2/WebProcess/WebPage/WebPage.cpp

    r64862 r64877  
    543543}
    544544
    545 void WebPage::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder& arguments)
     545void WebPage::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
    546546{
    547547    if (messageID.is<CoreIPC::MessageClassDrawingArea>()) {
     
    554554        case WebPageMessage::SetActive: {
    555555            bool active;
    556             if (!arguments.decode(active))
     556            if (!arguments->decode(active))
    557557                return;
    558558         
     
    562562        case WebPageMessage::SetFocused: {
    563563            bool focused;
    564             if (!arguments.decode(focused))
     564            if (!arguments->decode(focused))
    565565                return;
    566566           
     
    570570        case WebPageMessage::SetIsInWindow: {
    571571            bool isInWindow;
    572             if (!arguments.decode(isInWindow))
     572            if (!arguments->decode(isInWindow))
    573573                return;
    574574           
     
    578578        case WebPageMessage::MouseEvent: {
    579579            WebMouseEvent event;
    580             if (!arguments.decode(event))
     580            if (!arguments->decode(event))
    581581                return;
    582582            mouseEvent(event);
     
    585585        case WebPageMessage::PreferencesDidChange: {
    586586            WebPreferencesStore store;
    587             if (!arguments.decode(store))
     587            if (!arguments->decode(store))
    588588                return;
    589589           
     
    593593        case WebPageMessage::WheelEvent: {
    594594            WebWheelEvent event;
    595             if (!arguments.decode(event))
     595            if (!arguments->decode(event))
    596596                return;
    597597
     
    601601        case WebPageMessage::KeyEvent: {
    602602            WebKeyboardEvent event;
    603             if (!arguments.decode(event))
     603            if (!arguments->decode(event))
    604604                return;
    605605
     
    609609        case WebPageMessage::LoadURL: {
    610610            String url;
    611             if (!arguments.decode(url))
     611            if (!arguments->decode(url))
    612612                return;
    613613           
     
    620620        case WebPageMessage::Reload: {
    621621            bool reloadFromOrigin;
    622             if (!arguments.decode(CoreIPC::Out(reloadFromOrigin)))
     622            if (!arguments->decode(CoreIPC::Out(reloadFromOrigin)))
    623623                return;
    624624
     
    628628        case WebPageMessage::GoForward: {
    629629            uint64_t backForwardItemID;
    630             if (!arguments.decode(CoreIPC::Out(backForwardItemID)))
     630            if (!arguments->decode(CoreIPC::Out(backForwardItemID)))
    631631                return;
    632632            goForward(backForwardItemID);
     
    635635        case WebPageMessage::GoBack: {
    636636            uint64_t backForwardItemID;
    637             if (!arguments.decode(CoreIPC::Out(backForwardItemID)))
     637            if (!arguments->decode(CoreIPC::Out(backForwardItemID)))
    638638                return;
    639639            goBack(backForwardItemID);
     
    642642       case WebPageMessage::GoToBackForwardItem: {
    643643            uint64_t backForwardItemID;
    644             if (!arguments.decode(CoreIPC::Out(backForwardItemID)))
     644            if (!arguments->decode(CoreIPC::Out(backForwardItemID)))
    645645                return;
    646646            goToBackForwardItem(backForwardItemID);
     
    651651            uint64_t listenerID;
    652652            uint32_t policyAction;
    653             if (!arguments.decode(CoreIPC::Out(frameID, listenerID, policyAction)))
     653            if (!arguments->decode(CoreIPC::Out(frameID, listenerID, policyAction)))
    654654                return;
    655655            didReceivePolicyDecision(webFrame(frameID), listenerID, (WebCore::PolicyAction)policyAction);
     
    659659            String script;
    660660            uint64_t callbackID;
    661             if (!arguments.decode(CoreIPC::Out(script, callbackID)))
     661            if (!arguments->decode(CoreIPC::Out(script, callbackID)))
    662662                return;
    663663            runJavaScriptInMainFrame(script, callbackID);
     
    666666        case WebPageMessage::GetRenderTreeExternalRepresentation: {
    667667            uint64_t callbackID;
    668             if (!arguments.decode(callbackID))
     668            if (!arguments->decode(callbackID))
    669669                return;
    670670            getRenderTreeExternalRepresentation(callbackID);
  • trunk/WebKit2/WebProcess/WebPage/WebPage.h

    r64862 r64877  
    9494
    9595    // -- Called from WebProcess.
    96     void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder&);
     96    void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
    9797
    9898    // -- InjectedBundle methods
  • trunk/WebKit2/WebProcess/WebProcess.cpp

    r64871 r64877  
    295295        if (!m_injectedBundle)
    296296            return;
    297         m_injectedBundle->didReceiveMessage(connection, messageID, *arguments);   
     297        m_injectedBundle->didReceiveMessage(connection, messageID, arguments);   
    298298        return;
    299299    }
     
    307307        return;
    308308   
    309     page->didReceiveMessage(connection, messageID, *arguments);   
     309    page->didReceiveMessage(connection, messageID, arguments);
    310310}
    311311
Note: See TracChangeset for help on using the changeset viewer.