Changeset 88960 in webkit


Ignore:
Timestamp:
Jun 15, 2011 11:14:35 AM (13 years ago)
Author:
andersca@apple.com
Message:

2011-06-15 Anders Carlsson <​andersca@apple.com>

Reviewed by Alexey Proskuryakov.

Move some argument coders to WebCoreArgumentCoders.cpp
​https://bugs.webkit.org/show_bug.cgi?id=62739

  • GNUmakefile.am:
  • Shared/WebCoreArgumentCoders.cpp: (CoreIPC::::encode): (CoreIPC::::decode):
  • Shared/WebCoreArgumentCoders.h:
  • WebKit2.pro:
Location:
trunk/Source/WebKit2
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r88956 r88960  
     12011-06-15  Anders Carlsson  <andersca@apple.com>
     2
     3        Reviewed by Alexey Proskuryakov.
     4
     5        Move some argument coders to WebCoreArgumentCoders.cpp
     6        https://bugs.webkit.org/show_bug.cgi?id=62739
     7
     8        * GNUmakefile.am:
     9        * Shared/WebCoreArgumentCoders.cpp:
     10        (CoreIPC::::encode):
     11        (CoreIPC::::decode):
     12        * Shared/WebCoreArgumentCoders.h:
     13        * WebKit2.pro:
     14
    1152011-06-15  Anders Carlsson  <andersca@apple.com>
    216

  • trunk/Source/WebKit2/GNUmakefile.am

    r88846 r88960  
    257257        Source/WebKit2/Shared/WebContextMenuItemData.h \
    258258        Source/WebKit2/Shared/WebContextMenuItem.h \
     259        Source/WebKit2/Shared/WebCoreArgumentCoders.cpp \
    259260        Source/WebKit2/Shared/WebCoreArgumentCoders.h \
    260261        Source/WebKit2/Shared/WebData.h \

  • trunk/Source/WebKit2/Shared/WebCoreArgumentCoders.cpp

    r84101 r88960  
    2727#include "WebCoreArgumentCoders.h"
    2828
     29#include <WebCore/PluginData.h>
     30
    2931using namespace WebCore;
    3032using namespace WebKit;
    3133
    3234namespace CoreIPC {
     35   
     36void ArgumentCoder<MimeClassInfo>::encode(ArgumentEncoder* encoder, const MimeClassInfo& mimeClassInfo)
     37{
     38    encoder->encode(mimeClassInfo.type);
     39    encoder->encode(mimeClassInfo.desc);
     40    encoder->encode(mimeClassInfo.extensions);
     41}
     42
     43bool ArgumentCoder<MimeClassInfo>::decode(ArgumentDecoder* decoder, MimeClassInfo& mimeClassInfo)
     44{
     45    if (!decoder->decode(mimeClassInfo.type))
     46        return false;
     47    if (!decoder->decode(mimeClassInfo.desc))
     48        return false;
     49    if (!decoder->decode(mimeClassInfo.extensions))
     50        return false;
     51
     52    return true;
     53}
     54
     55
     56void ArgumentCoder<PluginInfo>::encode(ArgumentEncoder* encoder, const PluginInfo& pluginInfo)
     57{
     58    encoder->encode(pluginInfo.name);
     59    encoder->encode(pluginInfo.file);
     60    encoder->encode(pluginInfo.desc);
     61    encoder->encode(pluginInfo.mimes);
     62}
     63   
     64bool ArgumentCoder<PluginInfo>::decode(ArgumentDecoder* decoder, PluginInfo& pluginInfo)
     65{
     66    if (!decoder->decode(pluginInfo.name))
     67        return false;
     68    if (!decoder->decode(pluginInfo.file))
     69        return false;
     70    if (!decoder->decode(pluginInfo.desc))
     71        return false;
     72    if (!decoder->decode(pluginInfo.mimes))
     73        return false;
     74
     75    return true;
     76}
     77
     78
     79void ArgumentCoder<HTTPHeaderMap>::encode(ArgumentEncoder* encoder, const HTTPHeaderMap& headerMap)
     80{
     81    encoder->encode(static_cast<const HashMap<AtomicString, String, CaseFoldingHash>&>(headerMap));
     82}
     83
     84bool ArgumentCoder<HTTPHeaderMap>::decode(ArgumentDecoder* decoder, HTTPHeaderMap& headerMap)
     85{
     86    return decoder->decode(static_cast<HashMap<AtomicString, String, CaseFoldingHash>&>(headerMap));
     87}
     88
     89
     90void ArgumentCoder<AuthenticationChallenge>::encode(ArgumentEncoder* encoder, const AuthenticationChallenge& challenge)
     91{
     92    encoder->encode(challenge.protectionSpace());
     93    encoder->encode(challenge.proposedCredential());
     94    encoder->encode(challenge.previousFailureCount());
     95    encoder->encode(challenge.failureResponse());
     96    encoder->encode(challenge.error());
     97}
     98
     99bool ArgumentCoder<AuthenticationChallenge>::decode(ArgumentDecoder* decoder, AuthenticationChallenge& challenge)
     100{   
     101    ProtectionSpace protectionSpace;
     102    if (!decoder->decode(protectionSpace))
     103        return false;
     104
     105    Credential proposedCredential;
     106    if (!decoder->decode(proposedCredential))
     107        return false;
     108
     109    unsigned previousFailureCount;   
     110    if (!decoder->decode(previousFailureCount))
     111        return false;
     112
     113    ResourceResponse failureResponse;
     114    if (!decoder->decode(failureResponse))
     115        return false;
     116
     117    ResourceError error;
     118    if (!decoder->decode(error))
     119        return false;
     120   
     121    challenge = WebCore::AuthenticationChallenge(protectionSpace, proposedCredential, previousFailureCount, failureResponse, error);
     122    return true;
     123}
     124
     125
     126void ArgumentCoder<ProtectionSpace>::encode(ArgumentEncoder* encoder, const ProtectionSpace& space)
     127{
     128    encoder->encode(space.host());
     129    encoder->encode(space.port());
     130    encoder->encodeEnum(space.serverType());
     131    encoder->encode(space.realm());
     132    encoder->encodeEnum(space.authenticationScheme());
     133}
     134
     135bool ArgumentCoder<ProtectionSpace>::decode(ArgumentDecoder* decoder, ProtectionSpace& space)
     136{
     137    String host;
     138    if (!decoder->decode(host))
     139        return false;
     140
     141    int port;
     142    if (!decoder->decode(port))
     143        return false;
     144
     145    ProtectionSpaceServerType serverType;
     146    if (!decoder->decodeEnum(serverType))
     147        return false;
     148
     149    String realm;
     150    if (!decoder->decode(realm))
     151        return false;
     152   
     153    ProtectionSpaceAuthenticationScheme authenticationScheme;
     154    if (!decoder->decodeEnum(authenticationScheme))
     155        return false;
     156
     157    space = WebCore::ProtectionSpace(host, port, serverType, realm, authenticationScheme);
     158    return true;
     159}
    33160
    34161// For now, these are CG-only. Once other platforms have createImage functions,

  • trunk/Source/WebKit2/Shared/WebCoreArgumentCoders.h

    r88392 r88960  
    5050#include <WebCore/MatrixTransformOperation.h>
    5151#include <WebCore/PerspectiveTransformOperation.h>
    52 #include <WebCore/PluginData.h>
    5352#include <WebCore/ProtectionSpace.h>
    5453#include <WebCore/ResourceError.h>
    … …  
    6766#include <limits>
    6867
     68namespace WebCore {
     69    class HTTPHeaderMap;
     70    struct MimeClassInfo;
     71    struct PluginInfo;
     72}
    6973
    7074namespace CoreIPC {
    … …  
    9195
    9296template<> struct ArgumentCoder<WebCore::MimeClassInfo> {
    93     static void encode(ArgumentEncoder* encoder, const WebCore::MimeClassInfo& mimeClassInfo)
    94     {
    95         encoder->encode(mimeClassInfo.type);
    96         encoder->encode(mimeClassInfo.desc);
    97         encoder->encode(mimeClassInfo.extensions);
    98     }
    99 
    100     static bool decode(ArgumentDecoder* decoder, WebCore::MimeClassInfo& mimeClassInfo)
    101     {
    102         if (!decoder->decode(mimeClassInfo.type))
    103             return false;
    104         if (!decoder->decode(mimeClassInfo.desc))
    105             return false;
    106         if (!decoder->decode(mimeClassInfo.extensions))
    107             return false;
    108 
    109         return true;
    110     }
    111 };
    112    
     97    static void encode(ArgumentEncoder*, const WebCore::MimeClassInfo&);
     98    static bool decode(ArgumentDecoder*, WebCore::MimeClassInfo&);
     99};
     100
    113101template<> struct ArgumentCoder<WebCore::PluginInfo> {
    114     static void encode(ArgumentEncoder* encoder, const WebCore::PluginInfo& pluginInfo)
    115     {
    116         encoder->encode(pluginInfo.name);
    117         encoder->encode(pluginInfo.file);
    118         encoder->encode(pluginInfo.desc);
    119         encoder->encode(pluginInfo.mimes);
    120     }
    121    
    122     static bool decode(ArgumentDecoder* decoder, WebCore::PluginInfo& pluginInfo)
    123     {
    124         if (!decoder->decode(pluginInfo.name))
    125             return false;
    126         if (!decoder->decode(pluginInfo.file))
    127             return false;
    128         if (!decoder->decode(pluginInfo.desc))
    129             return false;
    130         if (!decoder->decode(pluginInfo.mimes))
    131             return false;
    132 
    133         return true;
    134     }
     102    static void encode(ArgumentEncoder*, const WebCore::PluginInfo&);
     103    static bool decode(ArgumentDecoder*, WebCore::PluginInfo&);
    135104};
    136105
    137106template<> struct ArgumentCoder<WebCore::HTTPHeaderMap> {
    138     static void encode(ArgumentEncoder* encoder, const WebCore::HTTPHeaderMap& headerMap)
    139     {
    140         encoder->encode(static_cast<const HashMap<AtomicString, String, CaseFoldingHash>&>(headerMap));
    141     }
    142 
    143     static bool decode(ArgumentDecoder* decoder, WebCore::HTTPHeaderMap& headerMap)
    144     {
    145         return decoder->decode(static_cast<HashMap<AtomicString, String, CaseFoldingHash>&>(headerMap));
    146     }
     107    static void encode(ArgumentEncoder*, const WebCore::HTTPHeaderMap&);
     108    static bool decode(ArgumentDecoder*, WebCore::HTTPHeaderMap&);
    147109};
    148110
    149111template<> struct ArgumentCoder<WebCore::AuthenticationChallenge> {
    150     static void encode(ArgumentEncoder* encoder, const WebCore::AuthenticationChallenge& challenge)
    151     {
    152         encoder->encode(CoreIPC::In(challenge.protectionSpace(), challenge.proposedCredential(), challenge.previousFailureCount(), challenge.failureResponse(), challenge.error()));
    153     }
    154 
    155     static bool decode(ArgumentDecoder* decoder, WebCore::AuthenticationChallenge& challenge)
    156     {   
    157         WebCore::ProtectionSpace protectionSpace;
    158         WebCore::Credential proposedCredential;
    159         unsigned previousFailureCount;
    160         WebCore::ResourceResponse failureResponse;
    161         WebCore::ResourceError error;
    162 
    163         if (!decoder->decode(CoreIPC::Out(protectionSpace, proposedCredential, previousFailureCount, failureResponse, error)))
    164             return false;
    165        
    166         challenge = WebCore::AuthenticationChallenge(protectionSpace, proposedCredential, previousFailureCount, failureResponse, error);
    167 
    168         return true;
    169     }
     112    static void encode(ArgumentEncoder*, const WebCore::AuthenticationChallenge&);
     113    static bool decode(ArgumentDecoder*, WebCore::AuthenticationChallenge&);
    170114};
    171115
    172116template<> struct ArgumentCoder<WebCore::ProtectionSpace> {
    173     static void encode(ArgumentEncoder* encoder, const WebCore::ProtectionSpace& space)
    174     {
    175         encoder->encode(CoreIPC::In(space.host(), space.port(), static_cast<uint32_t>(space.serverType()), space.realm(), static_cast<uint32_t>(space.authenticationScheme())));
    176     }
    177 
    178     static bool decode(ArgumentDecoder* decoder, WebCore::ProtectionSpace& space)
    179     {
    180         String host;
    181         int port;
    182         uint32_t serverType;
    183         String realm;
    184         uint32_t authenticationScheme;
    185 
    186         if (!decoder->decode(CoreIPC::Out(host, port, serverType, realm, authenticationScheme)))
    187             return false;
    188    
    189         space = WebCore::ProtectionSpace(host, port, static_cast<WebCore::ProtectionSpaceServerType>(serverType), realm, static_cast<WebCore::ProtectionSpaceAuthenticationScheme>(authenticationScheme));
    190 
    191         return true;
    192     }
     117    static void encode(ArgumentEncoder*, const WebCore::ProtectionSpace&);
     118    static bool decode(ArgumentDecoder*, WebCore::ProtectionSpace&);
    193119};
    194120

  • trunk/Source/WebKit2/WebKit2.pro

    r88926 r88960  
    354354    Shared/WebContextMenuItem.cpp \
    355355    Shared/WebContextMenuItemData.cpp \
     356    Shared/WebCoreArgumentCoders.cpp \
    356357    Shared/WebError.cpp \
    357358    Shared/WebEvent.cpp \
Note: See TracChangeset for help on using the changeset viewer.