Move dispatch_data use behind NetworkCache::Data abstraction
authorantti@apple.com <antti@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 6 Mar 2015 17:25:54 +0000 (17:25 +0000)
committerantti@apple.com <antti@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 6 Mar 2015 17:25:54 +0000 (17:25 +0000)
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.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@181160 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebKit2/ChangeLog
Source/WebKit2/NetworkProcess/cache/NetworkCacheData.h
Source/WebKit2/NetworkProcess/cache/NetworkCacheDataCocoa.mm
Source/WebKit2/NetworkProcess/cache/NetworkCacheIOChannelCocoa.mm
Source/WebKit2/NetworkProcess/cache/NetworkCacheStorageCocoa.mm

index 625f74549236eab12c15d47e8c07c2417c2a2b14..da889b9ce745e8650502bb20294b2372c61c359c 100644 (file)
@@ -1,3 +1,30 @@
+2015-03-06  Antti Koivisto  <antti@apple.com>
+
+        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.
+
 2015-03-06  Antti Koivisto  <antti@apple.com>
 
         Use WTF abstraction for page size in NetworkCacheStorage
index 4908fa42467d6c7c2466e7dd2a17511f7dfe6baf..f0bbb4004fc3256b17437473f9f8a03fd805770d 100644 (file)
@@ -47,7 +47,7 @@ public:
         : m_ptr(nullptr)
     {
     }
-    DispatchPtr(T ptr)
+    explicit DispatchPtr(T ptr)
         : m_ptr(ptr)
     {
         if (m_ptr)
@@ -108,6 +108,10 @@ public:
     size_t size() const { return m_size; }
     bool isMap() const { return m_isMap; }
 
+    Data subrange(size_t offset, size_t) const;
+
+    bool apply(const std::function<bool (const uint8_t*, size_t)>&&) const;
+
 #if PLATFORM(COCOA)
     dispatch_data_t dispatchData() const { return m_dispatchData.get(); }
 #endif
@@ -120,6 +124,9 @@ private:
     bool m_isMap { false };
 };
 
+Data concatenate(const Data&, const Data&);
+Data mapFile(int fd, size_t offset, size_t);
+
 }
 }
 
index 92bf4acde8fac79c99391ce4e53336c637cba5a7..ff90148f9569f850da6e605429c82e6293850395 100644 (file)
@@ -29,6 +29,7 @@
 #if ENABLE(NETWORK_CACHE)
 
 #include <dispatch/dispatch.h>
+#include <sys/mman.h>
 
 namespace WebKit {
 namespace NetworkCache {
@@ -40,13 +41,10 @@ Data::Data(const uint8_t* data, size_t size)
 }
 
 Data::Data(DispatchPtr<dispatch_data_t> dispatchData, Backing backing)
+    : m_dispatchData(dispatchData)
+    , m_size(m_dispatchData ? dispatch_data_get_size(m_dispatchData.get()) : 0)
+    , m_isMap(m_size && backing == Backing::Map)
 {
-    if (!dispatchData)
-        return;
-    const void* data;
-    m_dispatchData = adoptDispatch(dispatch_data_create_map(dispatchData.get(), &data, &m_size));
-    m_data = static_cast<const uint8_t*>(data);
-    m_isMap = m_size && backing == Backing::Map;
 }
 
 const uint8_t* Data::data() const
@@ -66,6 +64,40 @@ bool Data::isNull() const
     return !m_dispatchData;
 }
 
+bool Data::apply(const std::function<bool (const uint8_t*, size_t)>&& applier) const
+{
+    if (!m_size)
+        return false;
+    return dispatch_data_apply(m_dispatchData.get(), [&applier](dispatch_data_t, size_t, const void* data, size_t size) {
+        return applier(static_cast<const uint8_t*>(data), size);
+    });
+}
+
+Data Data::subrange(size_t offset, size_t size) const
+{
+    return { adoptDispatch(dispatch_data_create_subrange(dispatchData(), offset, size)) };
+}
+
+Data concatenate(const Data& a, const Data& b)
+{
+    if (a.isNull())
+        return b;
+    if (b.isNull())
+        return a;
+    return { adoptDispatch(dispatch_data_create_concat(a.dispatchData(), b.dispatchData())) };
+}
+
+Data mapFile(int fd, size_t offset, size_t size)
+{
+    void* map = mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fd, offset);
+    if (map == MAP_FAILED)
+        return { };
+    auto bodyMap = adoptDispatch(dispatch_data_create(map, size, dispatch_get_main_queue(), [map, size] {
+        munmap(map, size);
+    }));
+    return { bodyMap, Data::Backing::Map };
+}
+
 }
 }
 
index e023fa83dee4d5de209bfd03262faeacf1d38751..456119400cf1ecdc208611c10824a6e2254635cf 100644 (file)
@@ -88,7 +88,8 @@ void IOChannel::read(size_t offset, size_t size, std::function<void ( Data&, int
             return;
         }
         ASSERT(!didCallCompletionHandler);
-        Data data(fileData);
+        DispatchPtr<dispatch_data_t> fileDataPtr(fileData);
+        Data data(fileDataPtr);
         completionHandler(data, error);
         didCallCompletionHandler = true;
     });
index 3d12e977b3ea5983ad3201bf25480574f484c7ff..f9da869b84e151483ddec3b91fe39e646143d83f 100644 (file)
@@ -33,9 +33,6 @@
 #include "NetworkCacheFileSystemPosix.h"
 #include "NetworkCacheIOChannel.h"
 #include <dispatch/dispatch.h>
-#include <mach/vm_param.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
 #include <wtf/PageBlock.h>
 #include <wtf/RandomNumber.h>
 #include <wtf/RunLoop.h>
@@ -123,13 +120,11 @@ static Ref<IOChannel> openFileForKey(const Key& key, IOChannel::Type type, const
     return IOChannel::open(filePath, type);
 }
 
-static unsigned hashData(dispatch_data_t data)
+static unsigned hashData(const Data& data)
 {
-    if (!data || !dispatch_data_get_size(data))
-        return 0;
     StringHasher hasher;
-    dispatch_data_apply(data, [&hasher](dispatch_data_t, size_t, const void* data, size_t size) {
-        hasher.addCharacters(static_cast<const uint8_t*>(data), size);
+    data.apply([&hasher](const uint8_t* data, size_t size) {
+        hasher.addCharacters(data, size);
         return true;
     });
     return hasher.hash();
@@ -156,8 +151,8 @@ struct EntryMetaData {
 static bool decodeEntryMetaData(EntryMetaData& metaData, const Data& fileData)
 {
     bool success = false;
-    dispatch_data_apply(fileData.dispatchData(), [&metaData, &success](dispatch_data_t, size_t, const void* data, size_t size) {
-        Decoder decoder(reinterpret_cast<const uint8_t*>(data), size);
+    fileData.apply([&metaData, &success](const uint8_t* data, size_t size) {
+        Decoder decoder(data, size);
         if (!decoder.decode(metaData.cacheStorageVersion))
             return false;
         if (!decoder.decode(metaData.key))
@@ -182,17 +177,6 @@ static bool decodeEntryMetaData(EntryMetaData& metaData, const Data& fileData)
     return success;
 }
 
-static DispatchPtr<dispatch_data_t> mapFile(int fd, size_t offset, size_t size)
-{
-    void* map = mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fd, offset);
-    if (map == MAP_FAILED)
-        return nullptr;
-    auto bodyMap = adoptDispatch(dispatch_data_create(map, size, dispatch_get_main_queue(), [map, size] {
-        munmap(map, size);
-    }));
-    return bodyMap;
-}
-
 static bool decodeEntryHeader(const Data& fileData, EntryMetaData& metaData, Data& data)
 {
     if (!decodeEntryMetaData(metaData, fileData))
@@ -202,8 +186,8 @@ static bool decodeEntryHeader(const Data& fileData, EntryMetaData& metaData, Dat
     if (metaData.headerOffset + metaData.headerSize > metaData.bodyOffset)
         return false;
 
-    auto headerData = adoptDispatch(dispatch_data_create_subrange(fileData.dispatchData(), metaData.headerOffset, metaData.headerSize));
-    if (metaData.headerChecksum != hashData(headerData.get())) {
+    auto headerData = fileData.subrange(metaData.headerOffset, metaData.headerSize);
+    if (metaData.headerChecksum != hashData(headerData)) {
         LOG(NetworkCacheStorage, "(NetworkProcess) header checksum mismatch");
         return false;
     }
@@ -224,25 +208,25 @@ static std::unique_ptr<Storage::Entry> decodeEntry(const Data& fileData, int fd,
         return nullptr;
 
     auto bodyData = mapFile(fd, metaData.bodyOffset, metaData.bodySize);
-    if (!bodyData) {
+    if (bodyData.isNull()) {
         LOG(NetworkCacheStorage, "(NetworkProcess) map failed");
         return nullptr;
     }
 
-    if (metaData.bodyChecksum != hashData(bodyData.get())) {
+    if (metaData.bodyChecksum != hashData(bodyData)) {
         LOG(NetworkCacheStorage, "(NetworkProcess) data checksum mismatch");
         return nullptr;
     }
 
-    return std::unique_ptr<Storage::Entry>(new Storage::Entry {
+    return std::make_unique<Storage::Entry>(Storage::Entry {
         metaData.key,
         metaData.timeStamp,
         headerData,
-        { bodyData, Data::Backing::Map }
+        bodyData
     });
 }
 
-static DispatchPtr<dispatch_data_t> encodeEntryMetaData(const EntryMetaData& entry)
+static Data encodeEntryMetaData(const EntryMetaData& entry)
 {
     Encoder encoder;
 
@@ -256,28 +240,28 @@ static DispatchPtr<dispatch_data_t> encodeEntryMetaData(const EntryMetaData& ent
 
     encoder.encodeChecksum();
 
-    return adoptDispatch(dispatch_data_create(encoder.buffer(), encoder.bufferSize(), nullptr, DISPATCH_DATA_DESTRUCTOR_DEFAULT));
+    return Data(encoder.buffer(), encoder.bufferSize());
 }
 
 static Data encodeEntryHeader(const Storage::Entry& entry)
 {
     EntryMetaData metaData(entry.key);
     metaData.timeStamp = entry.timeStamp;
-    metaData.headerChecksum = hashData(entry.header.dispatchData());
+    metaData.headerChecksum = hashData(entry.header);
     metaData.headerSize = entry.header.size();
-    metaData.bodyChecksum = hashData(entry.body.dispatchData());
+    metaData.bodyChecksum = hashData(entry.body);
     metaData.bodySize = entry.body.size();
 
     auto encodedMetaData = encodeEntryMetaData(metaData);
-    auto headerData = adoptDispatch(dispatch_data_create_concat(encodedMetaData.get(), entry.header.dispatchData()));
+    auto headerData = concatenate(encodedMetaData, entry.header);
     if (!entry.body.size())
         return { headerData };
 
-    size_t headerSize = dispatch_data_get_size(headerData.get());
-    size_t dataOffset = round_page(headerSize);
-    Vector<uint8_t, 4096> filler(dataOffset - headerSize, 0);
-    auto alignmentData = adoptDispatch(dispatch_data_create(filler.data(), filler.size(), nullptr, DISPATCH_DATA_DESTRUCTOR_DEFAULT));
-    return { adoptDispatch(dispatch_data_create_concat(headerData.get(), alignmentData.get())) };
+    size_t dataOffset = WTF::roundUpToMultipleOf(pageSize(), headerData.size());
+    Vector<uint8_t, 4096> filler(dataOffset - headerData.size(), 0);
+    Data alignmentData(filler.data(), filler.size());
+
+    return concatenate(headerData, alignmentData);
 }
 
 void Storage::removeEntry(const Key& key)
@@ -481,15 +465,13 @@ void Storage::dispatchFullWriteOperation(const WriteOperation& write)
     StringCapture cachePathCapture(m_directoryPath);
     backgroundIOQueue().dispatch([this, &write, cachePathCapture] {
         auto encodedHeader = encodeEntryHeader(write.entry);
-        auto headerAndBodyData = adoptDispatch(dispatch_data_create_concat(encodedHeader.dispatchData(), write.entry.body.dispatchData()));
-
-        Data writeData(headerAndBodyData);
+        auto headerAndBodyData = concatenate(encodedHeader, write.entry.body);
 
         auto channel = openFileForKey(write.entry.key, IOChannel::Type::Create, cachePathCapture.string());
         int fd = channel->fileDescriptor();
         size_t bodyOffset = encodedHeader.size();
 
-        channel->write(0, writeData, [this, &write, bodyOffset, fd](int error) {
+        channel->write(0, headerAndBodyData, [this, &write, bodyOffset, fd](int error) {
             LOG(NetworkCacheStorage, "(NetworkProcess) write complete error=%d", error);
             if (error) {
                 if (m_contentsFilter.mayContain(write.entry.key.shortHash()))
@@ -501,10 +483,9 @@ void Storage::dispatchFullWriteOperation(const WriteOperation& write)
             m_approximateSize += totalSize;
 
             bool shouldMapBody = !error && bodySize >= pageSize();
-            auto bodyMap = shouldMapBody ? mapFile(fd, bodyOffset, bodySize) : nullptr;
+            auto bodyMap = shouldMapBody ? mapFile(fd, bodyOffset, bodySize) : Data();
 
-            Data bodyData(bodyMap, Data::Backing::Map);
-            write.completionHandler(!error, bodyData);
+            write.completionHandler(!error, bodyMap);
 
             ASSERT(m_activeWriteOperations.contains(&write));
             m_activeWriteOperations.remove(&write);