Changeset 181160 in webkit


Ignore:
Timestamp:
Mar 6, 2015 9:25:54 AM (9 years ago)
Author:
Antti Koivisto
Message:

Move dispatch_data use behind NetworkCache::Data abstraction
​https://bugs.webkit.org/show_bug.cgi?id=142392

Reviewed by Anders Carlsson.

  • NetworkProcess/cache/NetworkCacheData.h:

(WebKit::NetworkCache::DispatchPtr::DispatchPtr):

  • NetworkProcess/cache/NetworkCacheDataCocoa.mm:

(WebKit::NetworkCache::Data::Data):
(WebKit::NetworkCache::Data::apply):
(WebKit::NetworkCache::Data::subrange):
(WebKit::NetworkCache::concatenate):
(WebKit::NetworkCache::mapFile):

  • NetworkProcess/cache/NetworkCacheIOChannelCocoa.mm:

(WebKit::NetworkCache::IOChannel::read):

  • NetworkProcess/cache/NetworkCacheStorageCocoa.mm:

(WebKit::NetworkCache::hashData):
(WebKit::NetworkCache::decodeEntryMetaData):
(WebKit::NetworkCache::decodeEntryHeader):
(WebKit::NetworkCache::decodeEntry):
(WebKit::NetworkCache::encodeEntryMetaData):
(WebKit::NetworkCache::encodeEntryHeader):
(WebKit::NetworkCache::Storage::dispatchFullWriteOperation):
(WebKit::NetworkCache::mapFile): Deleted.

Location:
trunk/Source/WebKit2
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r181158 r181160  
     12015-03-06  Antti Koivisto  <antti@apple.com>
     2
     3        Move dispatch_data use behind NetworkCache::Data abstraction
     4        https://bugs.webkit.org/show_bug.cgi?id=142392
     5
     6        Reviewed by Anders Carlsson.
     7
     8        * NetworkProcess/cache/NetworkCacheData.h:
     9        (WebKit::NetworkCache::DispatchPtr::DispatchPtr):
     10        * NetworkProcess/cache/NetworkCacheDataCocoa.mm:
     11        (WebKit::NetworkCache::Data::Data):
     12        (WebKit::NetworkCache::Data::apply):
     13        (WebKit::NetworkCache::Data::subrange):
     14        (WebKit::NetworkCache::concatenate):
     15        (WebKit::NetworkCache::mapFile):
     16        * NetworkProcess/cache/NetworkCacheIOChannelCocoa.mm:
     17        (WebKit::NetworkCache::IOChannel::read):
     18        * NetworkProcess/cache/NetworkCacheStorageCocoa.mm:
     19        (WebKit::NetworkCache::hashData):
     20        (WebKit::NetworkCache::decodeEntryMetaData):
     21        (WebKit::NetworkCache::decodeEntryHeader):
     22        (WebKit::NetworkCache::decodeEntry):
     23        (WebKit::NetworkCache::encodeEntryMetaData):
     24        (WebKit::NetworkCache::encodeEntryHeader):
     25        (WebKit::NetworkCache::Storage::dispatchFullWriteOperation):
     26        (WebKit::NetworkCache::mapFile): Deleted.
     27
    1282015-03-06  Antti Koivisto  <antti@apple.com>
    229

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheData.h

    r181140 r181160  
    4848    {
    4949    }
    50     DispatchPtr(T ptr)
     50    explicit DispatchPtr(T ptr)
    5151        : m_ptr(ptr)
    5252    {
    … …  
    109109    bool isMap() const { return m_isMap; }
    110110
     111    Data subrange(size_t offset, size_t) const;
     112
     113    bool apply(const std::function<bool (const uint8_t*, size_t)>&&) const;
     114
    111115#if PLATFORM(COCOA)
    112116    dispatch_data_t dispatchData() const { return m_dispatchData.get(); }
    … …  
    121125};
    122126
     127Data concatenate(const Data&, const Data&);
     128Data mapFile(int fd, size_t offset, size_t);
     129
    123130}
    124131}

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheDataCocoa.mm

    r181140 r181160  
    3030
    3131#include <dispatch/dispatch.h>
     32#include <sys/mman.h>
    3233
    3334namespace WebKit {
    … …  
    4142
    4243Data::Data(DispatchPtr<dispatch_data_t> dispatchData, Backing backing)
     44    : m_dispatchData(dispatchData)
     45    , m_size(m_dispatchData ? dispatch_data_get_size(m_dispatchData.get()) : 0)
     46    , m_isMap(m_size && backing == Backing::Map)
    4347{
    44     if (!dispatchData)
    45         return;
    46     const void* data;
    47     m_dispatchData = adoptDispatch(dispatch_data_create_map(dispatchData.get(), &data, &m_size));
    48     m_data = static_cast<const uint8_t*>(data);
    49     m_isMap = m_size && backing == Backing::Map;
    5048}
    5149
    … …  
    6765}
    6866
     67bool Data::apply(const std::function<bool (const uint8_t*, size_t)>&& applier) const
     68{
     69    if (!m_size)
     70        return false;
     71    return dispatch_data_apply(m_dispatchData.get(), [&applier](dispatch_data_t, size_t, const void* data, size_t size) {
     72        return applier(static_cast<const uint8_t*>(data), size);
     73    });
     74}
     75
     76Data Data::subrange(size_t offset, size_t size) const
     77{
     78    return { adoptDispatch(dispatch_data_create_subrange(dispatchData(), offset, size)) };
     79}
     80
     81Data concatenate(const Data& a, const Data& b)
     82{
     83    if (a.isNull())
     84        return b;
     85    if (b.isNull())
     86        return a;
     87    return { adoptDispatch(dispatch_data_create_concat(a.dispatchData(), b.dispatchData())) };
     88}
     89
     90Data mapFile(int fd, size_t offset, size_t size)
     91{
     92    void* map = mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fd, offset);
     93    if (map == MAP_FAILED)
     94        return { };
     95    auto bodyMap = adoptDispatch(dispatch_data_create(map, size, dispatch_get_main_queue(), [map, size] {
     96        munmap(map, size);
     97    }));
     98    return { bodyMap, Data::Backing::Map };
     99}
     100
    69101}
    70102}

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheIOChannelCocoa.mm

    r181140 r181160  
    8989        }
    9090        ASSERT(!didCallCompletionHandler);
    91         Data data(fileData);
     91        DispatchPtr<dispatch_data_t> fileDataPtr(fileData);
     92        Data data(fileDataPtr);
    9293        completionHandler(data, error);
    9394        didCallCompletionHandler = true;

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheStorageCocoa.mm

    r181158 r181160  
    3434#include "NetworkCacheIOChannel.h"
    3535#include <dispatch/dispatch.h>
    36 #include <mach/vm_param.h>
    37 #include <sys/mman.h>
    38 #include <sys/stat.h>
    3936#include <wtf/PageBlock.h>
    4037#include <wtf/RandomNumber.h>
    … …  
    124121}
    125122
    126 static unsigned hashData(dispatch_data_t data)
    127 {
    128     if (!data || !dispatch_data_get_size(data))
    129         return 0;
     123static unsigned hashData(const Data& data)
     124{
    130125    StringHasher hasher;
    131     dispatch_data_apply(data, [&hasher](dispatch_data_t, size_t, const void* data, size_t size) {
    132         hasher.addCharacters(static_cast<const uint8_t*>(data), size);
     126    data.apply([&hasher](const uint8_t* data, size_t size) {
     127        hasher.addCharacters(data, size);
    133128        return true;
    134129    });
    … …  
    157152{
    158153    bool success = false;
    159     dispatch_data_apply(fileData.dispatchData(), [&metaData, &success](dispatch_data_t, size_t, const void* data, size_t size) {
    160         Decoder decoder(reinterpret_cast<const uint8_t*>(data), size);
     154    fileData.apply([&metaData, &success](const uint8_t* data, size_t size) {
     155        Decoder decoder(data, size);
    161156        if (!decoder.decode(metaData.cacheStorageVersion))
    162157            return false;
    … …  
    181176    });
    182177    return success;
    183 }
    184 
    185 static DispatchPtr<dispatch_data_t> mapFile(int fd, size_t offset, size_t size)
    186 {
    187     void* map = mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fd, offset);
    188     if (map == MAP_FAILED)
    189         return nullptr;
    190     auto bodyMap = adoptDispatch(dispatch_data_create(map, size, dispatch_get_main_queue(), [map, size] {
    191         munmap(map, size);
    192     }));
    193     return bodyMap;
    194178}
    195179
    … …  
    203187        return false;
    204188
    205     auto headerData = adoptDispatch(dispatch_data_create_subrange(fileData.dispatchData(), metaData.headerOffset, metaData.headerSize));
    206     if (metaData.headerChecksum != hashData(headerData.get())) {
     189    auto headerData = fileData.subrange(metaData.headerOffset, metaData.headerSize);
     190    if (metaData.headerChecksum != hashData(headerData)) {
    207191        LOG(NetworkCacheStorage, "(NetworkProcess) header checksum mismatch");
    208192        return false;
    … …  
    225209
    226210    auto bodyData = mapFile(fd, metaData.bodyOffset, metaData.bodySize);
    227     if (!bodyData) {
     211    if (bodyData.isNull()) {
    228212        LOG(NetworkCacheStorage, "(NetworkProcess) map failed");
    229213        return nullptr;
    230214    }
    231215
    232     if (metaData.bodyChecksum != hashData(bodyData.get())) {
     216    if (metaData.bodyChecksum != hashData(bodyData)) {
    233217        LOG(NetworkCacheStorage, "(NetworkProcess) data checksum mismatch");
    234218        return nullptr;
    235219    }
    236220
    237     return std::unique_ptr<Storage::Entry>(new Storage::Entry {
     221    return std::make_unique<Storage::Entry>(Storage::Entry {
    238222        metaData.key,
    239223        metaData.timeStamp,
    240224        headerData,
    241         { bodyData, Data::Backing::Map }
    242     });
    243 }
    244 
    245 static DispatchPtr<dispatch_data_t> encodeEntryMetaData(const EntryMetaData& entry)
     225        bodyData
     226    });
     227}
     228
     229static Data encodeEntryMetaData(const EntryMetaData& entry)
    246230{
    247231    Encoder encoder;
    … …  
    257241    encoder.encodeChecksum();
    258242
    259     return adoptDispatch(dispatch_data_create(encoder.buffer(), encoder.bufferSize(), nullptr, DISPATCH_DATA_DESTRUCTOR_DEFAULT));
     243    return Data(encoder.buffer(), encoder.bufferSize());
    260244}
    261245
    … …  
    264248    EntryMetaData metaData(entry.key);
    265249    metaData.timeStamp = entry.timeStamp;
    266     metaData.headerChecksum = hashData(entry.header.dispatchData());
     250    metaData.headerChecksum = hashData(entry.header);
    267251    metaData.headerSize = entry.header.size();
    268     metaData.bodyChecksum = hashData(entry.body.dispatchData());
     252    metaData.bodyChecksum = hashData(entry.body);
    269253    metaData.bodySize = entry.body.size();
    270254
    271255    auto encodedMetaData = encodeEntryMetaData(metaData);
    272     auto headerData = adoptDispatch(dispatch_data_create_concat(encodedMetaData.get(), entry.header.dispatchData()));
     256    auto headerData = concatenate(encodedMetaData, entry.header);
    273257    if (!entry.body.size())
    274258        return { headerData };
    275259
    276     size_t headerSize = dispatch_data_get_size(headerData.get());
    277     size_t dataOffset = round_page(headerSize);
    278     Vector<uint8_t, 4096> filler(dataOffset - headerSize, 0);
    279     auto alignmentData = adoptDispatch(dispatch_data_create(filler.data(), filler.size(), nullptr, DISPATCH_DATA_DESTRUCTOR_DEFAULT));
    280     return { adoptDispatch(dispatch_data_create_concat(headerData.get(), alignmentData.get())) };
     260    size_t dataOffset = WTF::roundUpToMultipleOf(pageSize(), headerData.size());
     261    Vector<uint8_t, 4096> filler(dataOffset - headerData.size(), 0);
     262    Data alignmentData(filler.data(), filler.size());
     263
     264    return concatenate(headerData, alignmentData);
    281265}
    282266
    … …  
    482466    backgroundIOQueue().dispatch([this, &write, cachePathCapture] {
    483467        auto encodedHeader = encodeEntryHeader(write.entry);
    484         auto headerAndBodyData = adoptDispatch(dispatch_data_create_concat(encodedHeader.dispatchData(), write.entry.body.dispatchData()));
    485 
    486         Data writeData(headerAndBodyData);
     468        auto headerAndBodyData = concatenate(encodedHeader, write.entry.body);
    487469
    488470        auto channel = openFileForKey(write.entry.key, IOChannel::Type::Create, cachePathCapture.string());
    … …  
    490472        size_t bodyOffset = encodedHeader.size();
    491473
    492         channel->write(0, writeData, [this, &write, bodyOffset, fd](int error) {
     474        channel->write(0, headerAndBodyData, [this, &write, bodyOffset, fd](int error) {
    493475            LOG(NetworkCacheStorage, "(NetworkProcess) write complete error=%d", error);
    494476            if (error) {
    … …  
    502484
    503485            bool shouldMapBody = !error && bodySize >= pageSize();
    504             auto bodyMap = shouldMapBody ? mapFile(fd, bodyOffset, bodySize) : nullptr;
    505 
    506             Data bodyData(bodyMap, Data::Backing::Map);
    507             write.completionHandler(!error, bodyData);
     486            auto bodyMap = shouldMapBody ? mapFile(fd, bodyOffset, bodySize) : Data();
     487
     488            write.completionHandler(!error, bodyMap);
    508489
    509490            ASSERT(m_activeWriteOperations.contains(&write));
Note: See TracChangeset for help on using the changeset viewer.