Changeset 225826 in webkit


Ignore:
Timestamp:
Dec 12, 2017, 5:18:20 PM (7 years ago)
Author:
achristensen@apple.com
Message:

Modernize WebsiteDataStoreParameters and SandboxExtension::Handle decoding
​https://bugs.webkit.org/show_bug.cgi?id=180621

Reviewed by Youenn Fablet.

  • NetworkProcess/NetworkProcessCreationParameters.cpp:

(WebKit::NetworkProcessCreationParameters::decode):

  • NetworkProcess/NetworkResourceLoadParameters.cpp:

(WebKit::NetworkResourceLoadParameters::decode):

  • Shared/LoadParameters.cpp:

(WebKit::LoadParameters::decode):

  • Shared/SandboxExtension.h:

(WebKit::decode):
(WebKit::SandboxExtension::Handle::decode): Deleted.

  • Shared/Storage/StorageProcessCreationParameters.cpp:

(WebKit::StorageProcessCreationParameters::decode):

  • Shared/WebProcessCreationParameters.cpp:

(WebKit::WebProcessCreationParameters::decode):

  • Shared/WebsiteDataStoreParameters.cpp:

(WebKit::WebsiteDataStoreParameters::decode):

  • Shared/WebsiteDataStoreParameters.h:
  • Shared/mac/SandboxExtensionMac.mm:

(WebKit::SandboxExtension::Handle::decode):
(WebKit::SandboxExtension::HandleArray::HandleArray):
(WebKit::SandboxExtension::HandleArray::encode const):
(WebKit::SandboxExtension::HandleArray::decode):
(WebKit::SandboxExtension::SandboxExtension):

Location:
trunk/Source/WebKit
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r225818 r225826  
     12017-12-12  Alex Christensen  <achristensen@webkit.org>
     2
     3        Modernize WebsiteDataStoreParameters and SandboxExtension::Handle decoding
     4        https://bugs.webkit.org/show_bug.cgi?id=180621
     5
     6        Reviewed by Youenn Fablet.
     7
     8        * NetworkProcess/NetworkProcessCreationParameters.cpp:
     9        (WebKit::NetworkProcessCreationParameters::decode):
     10        * NetworkProcess/NetworkResourceLoadParameters.cpp:
     11        (WebKit::NetworkResourceLoadParameters::decode):
     12        * Shared/LoadParameters.cpp:
     13        (WebKit::LoadParameters::decode):
     14        * Shared/SandboxExtension.h:
     15        (WebKit::decode):
     16        (WebKit::SandboxExtension::Handle::decode): Deleted.
     17        * Shared/Storage/StorageProcessCreationParameters.cpp:
     18        (WebKit::StorageProcessCreationParameters::decode):
     19        * Shared/WebProcessCreationParameters.cpp:
     20        (WebKit::WebProcessCreationParameters::decode):
     21        * Shared/WebsiteDataStoreParameters.cpp:
     22        (WebKit::WebsiteDataStoreParameters::decode):
     23        * Shared/WebsiteDataStoreParameters.h:
     24        * Shared/mac/SandboxExtensionMac.mm:
     25        (WebKit::SandboxExtension::Handle::decode):
     26        (WebKit::SandboxExtension::HandleArray::HandleArray):
     27        (WebKit::SandboxExtension::HandleArray::encode const):
     28        (WebKit::SandboxExtension::HandleArray::decode):
     29        (WebKit::SandboxExtension::SandboxExtension):
     30
    1312017-12-12  John Wilander  <wilander@apple.com>
    232

  • trunk/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.cpp

    r225006 r225826  
    125125    if (!decoder.decode(result.cacheStoragePerOriginQuota))
    126126        return false;
    127     if (!decoder.decode(result.cacheStorageDirectoryExtensionHandle))
    128         return false;
     127   
     128    std::optional<SandboxExtension::Handle> cacheStorageDirectoryExtensionHandle;
     129    decoder >> cacheStorageDirectoryExtensionHandle;
     130    if (!cacheStorageDirectoryExtensionHandle)
     131        return false;
     132    result.cacheStorageDirectoryExtensionHandle = WTFMove(*cacheStorageDirectoryExtensionHandle);
     133
    129134    if (!decoder.decode(result.diskCacheDirectory))
    130135        return false;
    131     if (!decoder.decode(result.diskCacheDirectoryExtensionHandle))
    132         return false;
     136   
     137    std::optional<SandboxExtension::Handle> diskCacheDirectoryExtensionHandle;
     138    decoder >> diskCacheDirectoryExtensionHandle;
     139    if (!diskCacheDirectoryExtensionHandle)
     140        return false;
     141    result.diskCacheDirectoryExtensionHandle = WTFMove(*diskCacheDirectoryExtensionHandle);
     142
    133143    if (!decoder.decode(result.shouldEnableNetworkCache))
    134144        return false;
    … …  
    144154#endif
    145155#if PLATFORM(IOS)
    146     if (!decoder.decode(result.cookieStorageDirectoryExtensionHandle))
    147         return false;
    148     if (!decoder.decode(result.containerCachesDirectoryExtensionHandle))
    149         return false;
    150     if (!decoder.decode(result.parentBundleDirectoryExtensionHandle))
    151         return false;
     156    std::optional<SandboxExtension::Handle> cookieStorageDirectoryExtensionHandle;
     157    decoder >> cookieStorageDirectoryExtensionHandle;
     158    if (!cookieStorageDirectoryExtensionHandle)
     159        return false;
     160    result.cookieStorageDirectoryExtensionHandle = WTFMove(*cookieStorageDirectoryExtensionHandle);
     161
     162    std::optional<SandboxExtension::Handle> containerCachesDirectoryExtensionHandle;
     163    decoder >> containerCachesDirectoryExtensionHandle;
     164    if (!containerCachesDirectoryExtensionHandle)
     165        return false;
     166    result.containerCachesDirectoryExtensionHandle = WTFMove(*containerCachesDirectoryExtensionHandle);
     167
     168    std::optional<SandboxExtension::Handle> parentBundleDirectoryExtensionHandle;
     169    decoder >> parentBundleDirectoryExtensionHandle;
     170    if (!parentBundleDirectoryExtensionHandle)
     171        return false;
     172    result.parentBundleDirectoryExtensionHandle = WTFMove(*parentBundleDirectoryExtensionHandle);
    152173#endif
    153174    if (!decoder.decode(result.shouldSuppressMemoryPressureHandler))

  • trunk/Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.cpp

    r224299 r225826  
    135135
    136136    if (result.request.url().isLocalFile()) {
    137         SandboxExtension::Handle resourceSandboxExtensionHandle;
    138         if (!decoder.decode(resourceSandboxExtensionHandle))
     137        std::optional<SandboxExtension::Handle> resourceSandboxExtensionHandle;
     138        decoder >> resourceSandboxExtensionHandle;
     139        if (!resourceSandboxExtensionHandle)
    139140            return false;
    140         result.resourceSandboxExtension = SandboxExtension::create(resourceSandboxExtensionHandle);
     141        result.resourceSandboxExtension = SandboxExtension::create(WTFMove(*resourceSandboxExtensionHandle));
    141142    }
    142143

  • trunk/Source/WebKit/Shared/LoadParameters.cpp

    r210825 r225826  
    7373    }
    7474
    75     if (!decoder.decode(data.sandboxExtensionHandle))
     75    std::optional<SandboxExtension::Handle> sandboxExtensionHandle;
     76    decoder >> sandboxExtensionHandle;
     77    if (!sandboxExtensionHandle)
    7678        return false;
     79    data.sandboxExtensionHandle = WTFMove(*sandboxExtensionHandle);
    7780
    7881    if (!decoder.decode(data.data))

  • trunk/Source/WebKit/Shared/SandboxExtension.h

    r222183 r225826  
    2424 */
    2525
    26 #ifndef SandboxExtension_h
    27 #define SandboxExtension_h
     26#pragma once
    2827
    2928#include <wtf/Forward.h>
    … …  
    5655#if ENABLE(SANDBOX_EXTENSIONS)
    5756        Handle(Handle&&);
     57        Handle& operator=(Handle&&);
    5858#else
    5959        Handle(Handle&&) = default;
     60        Handle& operator=(Handle&&) = default;
    6061#endif
    6162        ~Handle();
    6263
    6364        void encode(IPC::Encoder&) const;
    64         static bool decode(IPC::Decoder&, Handle&);
     65        static std::optional<Handle> decode(IPC::Decoder&);
    6566
    6667    private:
    … …  
    8788#if ENABLE(SANDBOX_EXTENSIONS)
    8889        std::unique_ptr<Handle[]> m_data;
    89         size_t m_size;
     90        size_t m_size { 0 };
    9091#else
    9192        Handle m_emptyHandle;
    … …  
    112113#if ENABLE(SANDBOX_EXTENSIONS)
    113114    mutable std::unique_ptr<SandboxExtensionImpl> m_sandboxExtension;
    114     size_t m_useCount;
     115    size_t m_useCount { 0 };
    115116#endif
    116117};
    … …  
    120121inline SandboxExtension::Handle::~Handle() { }
    121122inline void SandboxExtension::Handle::encode(IPC::Encoder&) const { }
    122 inline bool SandboxExtension::Handle::decode(IPC::Decoder&, Handle&) { return true; }
     123inline std::optional<SandboxExtension::Handle> SandboxExtension::Handle::decode(IPC::Decoder&) { return {{ }}; }
    123124inline SandboxExtension::HandleArray::HandleArray() { }
    124125inline SandboxExtension::HandleArray::~HandleArray() { }
    … …  
    150151
    151152} // namespace WebKit
    152 
    153 
    154 #endif // SandboxExtension_h

  • trunk/Source/WebKit/Shared/Storage/StorageProcessCreationParameters.cpp

    r225490 r225826  
    5353    if (!decoder.decode(result.indexedDatabaseDirectory))
    5454        return false;
    55     if (!decoder.decode(result.indexedDatabaseDirectoryExtensionHandle))
     55
     56    std::optional<SandboxExtension::Handle> indexedDatabaseDirectoryExtensionHandle;
     57    decoder >> indexedDatabaseDirectoryExtensionHandle;
     58    if (!indexedDatabaseDirectoryExtensionHandle)
    5659        return false;
     60    result.indexedDatabaseDirectoryExtensionHandle = WTFMove(*indexedDatabaseDirectoryExtensionHandle);
    5761#endif
    5862#if ENABLE(SERVICE_WORKER)
    5963    if (!decoder.decode(result.serviceWorkerRegistrationDirectory))
    6064        return false;
    61     if (!decoder.decode(result.serviceWorkerRegistrationDirectoryExtensionHandle))
     65   
     66    std::optional<SandboxExtension::Handle> serviceWorkerRegistrationDirectoryExtensionHandle;
     67    decoder >> serviceWorkerRegistrationDirectoryExtensionHandle;
     68    if (!serviceWorkerRegistrationDirectoryExtensionHandle)
    6269        return false;
     70    result.serviceWorkerRegistrationDirectoryExtensionHandle = WTFMove(*serviceWorkerRegistrationDirectoryExtensionHandle);
    6371#endif
    6472

  • trunk/Source/WebKit/Shared/WebProcessCreationParameters.cpp

    r225655 r225826  
    152152    if (!decoder.decode(parameters.injectedBundlePath))
    153153        return false;
    154     if (!decoder.decode(parameters.injectedBundlePathExtensionHandle))
    155         return false;
     154   
     155    std::optional<SandboxExtension::Handle> injectedBundlePathExtensionHandle;
     156    decoder >> injectedBundlePathExtensionHandle;
     157    if (!injectedBundlePathExtensionHandle)
     158        return false;
     159    parameters.injectedBundlePathExtensionHandle = WTFMove(*injectedBundlePathExtensionHandle);
     160
    156161    if (!decoder.decode(parameters.additionalSandboxExtensionHandles))
    157162        return false;
    … …  
    162167    if (!decoder.decode(parameters.applicationCacheFlatFileSubdirectoryName))
    163168        return false;
    164     if (!decoder.decode(parameters.applicationCacheDirectoryExtensionHandle))
    165         return false;
     169   
     170    std::optional<SandboxExtension::Handle> applicationCacheDirectoryExtensionHandle;
     171    decoder >> applicationCacheDirectoryExtensionHandle;
     172    if (!applicationCacheDirectoryExtensionHandle)
     173        return false;
     174    parameters.applicationCacheDirectoryExtensionHandle = WTFMove(*applicationCacheDirectoryExtensionHandle);
     175
    166176    if (!decoder.decode(parameters.webSQLDatabaseDirectory))
    167177        return false;
    168     if (!decoder.decode(parameters.webSQLDatabaseDirectoryExtensionHandle))
    169         return false;
     178
     179    std::optional<SandboxExtension::Handle> webSQLDatabaseDirectoryExtensionHandle;
     180    decoder >> webSQLDatabaseDirectoryExtensionHandle;
     181    if (!webSQLDatabaseDirectoryExtensionHandle)
     182        return false;
     183    parameters.webSQLDatabaseDirectoryExtensionHandle = WTFMove(*webSQLDatabaseDirectoryExtensionHandle);
     184
    170185    if (!decoder.decode(parameters.mediaCacheDirectory))
    171186        return false;
    172     if (!decoder.decode(parameters.mediaCacheDirectoryExtensionHandle))
    173         return false;
     187   
     188    std::optional<SandboxExtension::Handle> mediaCacheDirectoryExtensionHandle;
     189    decoder >> mediaCacheDirectoryExtensionHandle;
     190    if (!mediaCacheDirectoryExtensionHandle)
     191        return false;
     192    parameters.mediaCacheDirectoryExtensionHandle = WTFMove(*mediaCacheDirectoryExtensionHandle);
     193
    174194    if (!decoder.decode(parameters.javaScriptConfigurationDirectory))
    175195        return false;
    176     if (!decoder.decode(parameters.javaScriptConfigurationDirectoryExtensionHandle))
    177         return false;
     196   
     197    std::optional<SandboxExtension::Handle> javaScriptConfigurationDirectoryExtensionHandle;
     198    decoder >> javaScriptConfigurationDirectoryExtensionHandle;
     199    if (!javaScriptConfigurationDirectoryExtensionHandle)
     200        return false;
     201    parameters.javaScriptConfigurationDirectoryExtensionHandle = WTFMove(*javaScriptConfigurationDirectoryExtensionHandle);
     202
    178203#if PLATFORM(MAC)
    179204    if (!decoder.decode(parameters.uiProcessCookieStorageIdentifier))
    … …  
    181206#endif
    182207#if PLATFORM(IOS)
    183     if (!decoder.decode(parameters.cookieStorageDirectoryExtensionHandle))
    184         return false;
    185     if (!decoder.decode(parameters.containerCachesDirectoryExtensionHandle))
    186         return false;
    187     if (!decoder.decode(parameters.containerTemporaryDirectoryExtensionHandle))
    188         return false;
     208   
     209    std::optional<SandboxExtension::Handle> cookieStorageDirectoryExtensionHandle;
     210    decoder >> cookieStorageDirectoryExtensionHandle;
     211    if (!cookieStorageDirectoryExtensionHandle)
     212        return false;
     213    parameters.cookieStorageDirectoryExtensionHandle = WTFMove(*cookieStorageDirectoryExtensionHandle);
     214
     215    std::optional<SandboxExtension::Handle> containerCachesDirectoryExtensionHandle;
     216    decoder >> containerCachesDirectoryExtensionHandle;
     217    if (!containerCachesDirectoryExtensionHandle)
     218        return false;
     219    parameters.containerCachesDirectoryExtensionHandle = WTFMove(*containerCachesDirectoryExtensionHandle);
     220
     221    std::optional<SandboxExtension::Handle> containerTemporaryDirectoryExtensionHandle;
     222    decoder >> containerTemporaryDirectoryExtensionHandle;
     223    if (!containerTemporaryDirectoryExtensionHandle)
     224        return false;
     225    parameters.containerTemporaryDirectoryExtensionHandle = WTFMove(*containerTemporaryDirectoryExtensionHandle);
     226
    189227#endif
    190228    if (!decoder.decode(parameters.mediaKeyStorageDirectory))
    … …  
    194232    if (!decoder.decode(parameters.webKitLoggingChannels))
    195233        return false;
    196     if (!decoder.decode(parameters.mediaKeyStorageDirectoryExtensionHandle))
    197         return false;
     234   
     235    std::optional<SandboxExtension::Handle> mediaKeyStorageDirectoryExtensionHandle;
     236    decoder >> mediaKeyStorageDirectoryExtensionHandle;
     237    if (!mediaKeyStorageDirectoryExtensionHandle)
     238        return false;
     239    parameters.mediaKeyStorageDirectoryExtensionHandle = WTFMove(*mediaKeyStorageDirectoryExtensionHandle);
     240
    198241#if ENABLE(MEDIA_STREAM)
    199     if (!decoder.decode(parameters.audioCaptureExtensionHandle))
    200         return false;
     242
     243    std::optional<SandboxExtension::Handle> audioCaptureExtensionHandle;
     244    decoder >> audioCaptureExtensionHandle;
     245    if (!audioCaptureExtensionHandle)
     246        return false;
     247    parameters.audioCaptureExtensionHandle = WTFMove(*audioCaptureExtensionHandle);
     248
    201249    if (!decoder.decode(parameters.shouldCaptureAudioInUIProcess))
    202250        return false;
    … …  
    261309    if (!decoder.decode(parameters.uiProcessBundleResourcePath))
    262310        return false;
    263     if (!decoder.decode(parameters.uiProcessBundleResourcePathExtensionHandle))
    264         return false;
     311   
     312    std::optional<SandboxExtension::Handle> uiProcessBundleResourcePathExtensionHandle;
     313    decoder >> uiProcessBundleResourcePathExtensionHandle;
     314    if (!uiProcessBundleResourcePathExtensionHandle)
     315        return false;
     316    parameters.uiProcessBundleResourcePathExtensionHandle = WTFMove(*uiProcessBundleResourcePathExtensionHandle);
     317
    265318    if (!decoder.decode(parameters.shouldEnableJIT))
    266319        return false;

  • trunk/Source/WebKit/Shared/WebsiteDataStoreParameters.cpp

    r224791 r225826  
    4747}
    4848
    49 bool WebsiteDataStoreParameters::decode(IPC::Decoder& decoder, WebsiteDataStoreParameters& parameters)
     49std::optional<WebsiteDataStoreParameters> WebsiteDataStoreParameters::decode(IPC::Decoder& decoder)
    5050{
    5151    std::optional<NetworkSessionCreationParameters> networkSessionParameters;
    5252    decoder >> networkSessionParameters;
    5353    if (!networkSessionParameters)
    54         return false;
    55     parameters.networkSessionParameters = WTFMove(*networkSessionParameters);
     54        return std::nullopt;
    5655
    57     if (!decoder.decode(parameters.uiProcessCookieStorageIdentifier))
    58         return false;
     56    std::optional<Vector<uint8_t>> uiProcessCookieStorageIdentifier;
     57    decoder >> uiProcessCookieStorageIdentifier;
     58    if (!uiProcessCookieStorageIdentifier)
     59        return std::nullopt;
    5960
    60     if (!decoder.decode(parameters.cookieStoragePathExtensionHandle))
    61         return false;
     61    std::optional<SandboxExtension::Handle> cookieStoragePathExtensionHandle;
     62    decoder >> cookieStoragePathExtensionHandle;
     63    if (!cookieStoragePathExtensionHandle)
     64        return std::nullopt;
    6265
    6366    std::optional<Vector<WebCore::Cookie>> pendingCookies;
    6467    decoder >> pendingCookies;
    6568    if (!pendingCookies)
    66         return false;
    67     parameters.pendingCookies = WTFMove(*pendingCookies);
     69        return std::nullopt;
    6870
    69     if (!decoder.decode(parameters.cacheStorageDirectory))
    70         return false;
     71    std::optional<String> cacheStorageDirectory;
     72    decoder >> cacheStorageDirectory;
     73    if (!cacheStorageDirectory)
     74        return std::nullopt;
    7175
    72     if (!decoder.decode(parameters.cacheStoragePerOriginQuota))
    73         return false;
     76    std::optional<uint64_t> cacheStoragePerOriginQuota;
     77    decoder >> cacheStoragePerOriginQuota;
     78    if (!cacheStoragePerOriginQuota)
     79        return std::nullopt;
    7480
    75     if (!decoder.decode(parameters.cacheStorageDirectoryExtensionHandle))
    76         return false;
    77 
    78     return true;
     81    std::optional<SandboxExtension::Handle> cacheStorageDirectoryExtensionHandle;
     82    decoder >> cacheStorageDirectoryExtensionHandle;
     83    if (!cacheStorageDirectoryExtensionHandle)
     84        return std::nullopt;
     85   
     86    return {{ WTFMove(*uiProcessCookieStorageIdentifier), WTFMove(*cookieStoragePathExtensionHandle), WTFMove(*pendingCookies), WTFMove(*cacheStorageDirectory), WTFMove(*cacheStoragePerOriginQuota), WTFMove(*cacheStorageDirectoryExtensionHandle), WTFMove(*networkSessionParameters)}};
    7987}
    8088

  • trunk/Source/WebKit/Shared/WebsiteDataStoreParameters.h

    r224791 r225826  
    4343    WebsiteDataStoreParameters() = default;
    4444    WebsiteDataStoreParameters(WebsiteDataStoreParameters&&) = default;
     45    WebsiteDataStoreParameters& operator=(WebsiteDataStoreParameters&&) = default;
    4546    ~WebsiteDataStoreParameters();
    4647    static WebsiteDataStoreParameters legacyPrivateSessionParameters();
    4748   
    4849    void encode(IPC::Encoder&) const;
    49     static bool decode(IPC::Decoder&, WebsiteDataStoreParameters&);
     50    static std::optional<WebsiteDataStoreParameters> decode(IPC::Decoder&);
    5051
    5152    Vector<uint8_t> uiProcessCookieStorageIdentifier;

  • trunk/Source/WebKit/Shared/mac/SandboxExtensionMac.mm

    r225373 r225826  
    112112
    113113SandboxExtension::Handle::Handle(Handle&&) = default;
     114SandboxExtension::Handle& SandboxExtension::Handle::operator=(Handle&&) = default;
    114115
    115116SandboxExtension::Handle::~Handle()
    … …  
    136137}
    137138
    138 bool SandboxExtension::Handle::decode(IPC::Decoder& decoder, Handle& result)
    139 {
    140     ASSERT(!result.m_sandboxExtension);
    141 
     139auto SandboxExtension::Handle::decode(IPC::Decoder& decoder) -> std::optional<Handle>
     140{
    142141    IPC::DataReference dataReference;
    143142    if (!decoder.decode(dataReference))
    144         return false;
     143        return std::nullopt;
    145144
    146145    if (dataReference.isEmpty())
    147         return true;
    148 
    149     result.m_sandboxExtension = std::make_unique<SandboxExtensionImpl>(reinterpret_cast<const char*>(dataReference.data()), dataReference.size());
    150     return true;
     146        return {{ }};
     147
     148    Handle handle;
     149    handle.m_sandboxExtension = std::make_unique<SandboxExtensionImpl>(reinterpret_cast<const char*>(dataReference.data()), dataReference.size());
     150    return WTFMove(handle);
    151151}
    152152
    153153SandboxExtension::HandleArray::HandleArray()
    154     : m_size(0)
    155154{
    156155}
    … …  
    193192    for (size_t i = 0; i < m_size; ++i)
    194193        encoder << m_data[i];
    195    
    196194}
    197195
    … …  
    203201    handles.allocate(size);
    204202    for (size_t i = 0; i < size; i++) {
    205         if (!decoder.decode(handles[i]))
     203        std::optional<SandboxExtension::Handle> handle;
     204        decoder >> handle;
     205        if (!handle)
    206206            return false;
     207        handles[i] = WTFMove(*handle);
    207208    }
    208209    return true;
    … …  
    363364SandboxExtension::SandboxExtension(const Handle& handle)
    364365    : m_sandboxExtension(WTFMove(handle.m_sandboxExtension))
    365     , m_useCount(0)
    366366{
    367367}
Note: See TracChangeset for help on using the changeset viewer.