Changeset 181020 in webkit


Ignore:
Timestamp:
Mar 4, 2015 1:35:11 PM (9 years ago)
Author:
Antti Koivisto
Message:

Factor platform I/O out from NetworkCacheStorage
​https://bugs.webkit.org/show_bug.cgi?id=142279

Reviewed by Chris Dumez.

  • NetworkProcess/cache/NetworkCacheData.h: Added.
  • NetworkProcess/cache/NetworkCacheDataCocoa.mm: Added.

NetworkCacheStorage::Data -> NetworkCacheData
Move to files of its own.

  • NetworkProcess/cache/NetworkCacheIOChannel.h: Added.
  • NetworkProcess/cache/NetworkCacheIOChannelCocoa.mm: Added.

Add abstraction for dispatch IO channels.

Location:
trunk/Source/WebKit2
Files:
4 added
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r181004 r181020  
     12015-03-04  Antti Koivisto  <antti@apple.com>
     2
     3        Factor platform I/O out from NetworkCacheStorage
     4        https://bugs.webkit.org/show_bug.cgi?id=142279
     5
     6        Reviewed by Chris Dumez.
     7
     8        * NetworkProcess/cache/NetworkCacheData.h: Added.
     9        * NetworkProcess/cache/NetworkCacheDataCocoa.mm: Added.
     10
     11            NetworkCacheStorage::Data -> NetworkCacheData
     12            Move to files of its own.
     13
     14        * NetworkProcess/cache/NetworkCacheIOChannel.h: Added.
     15        * NetworkProcess/cache/NetworkCacheIOChannelCocoa.mm: Added.
     16
     17            Add abstraction for dispatch IO channels.
     18
    1192015-03-04  Joseph Pecoraro  <pecoraro@apple.com>
    220

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp

    r180949 r181020  
    9494    if (partition.isEmpty())
    9595        partition = ASCIILiteral("No partition");
    96     return NetworkCacheKey(request.httpMethod(), partition, request.url().string());
     96    return { request.httpMethod(), partition, request.url().string()  };
    9797}
    9898
    … …  
    121121
    122122    auto timeStamp = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch());
    123     NetworkCacheStorage::Data header(encoder.buffer(), encoder.bufferSize());
    124     NetworkCacheStorage::Data body;
     123    NetworkCacheData header(encoder.buffer(), encoder.bufferSize());
     124    NetworkCacheData body;
    125125    if (responseData)
    126         body = NetworkCacheStorage::Data(reinterpret_cast<const uint8_t*>(responseData->data()), responseData->size());
    127 
    128     return NetworkCacheStorage::Entry { makeCacheKey(request), timeStamp, header, body };
     126        body = { reinterpret_cast<const uint8_t*>(responseData->data()), responseData->size() };
     127
     128    return { makeCacheKey(request), timeStamp, header, body };
    129129}
    130130
    … …  
    344344    auto storageEntry = encodeStorageEntry(originalRequest, response, WTF::move(responseData));
    345345
    346     m_storage->store(storageEntry, [completionHandler](bool success, const NetworkCacheStorage::Data& bodyData) {
     346    m_storage->store(storageEntry, [completionHandler](bool success, const NetworkCacheData& bodyData) {
    347347        MappedBody mappedBody;
    348348#if ENABLE(SHAREABLE_RESOURCE)
    … …  
    368368    auto updateEntry = encodeStorageEntry(originalRequest, response, entry.buffer);
    369369
    370     m_storage->update(updateEntry, entry.storageEntry, [](bool success, const NetworkCacheStorage::Data&) {
     370    m_storage->update(updateEntry, entry.storageEntry, [](bool success, const NetworkCacheData&) {
    371371        LOG(NetworkCache, "(NetworkProcess) updated, success=%d", success);
    372372    });

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

    r180949 r181020  
    2929#if ENABLE(NETWORK_CACHE)
    3030
     31#include "NetworkCacheData.h"
    3132#include "NetworkCacheKey.h"
    3233#include <wtf/BloomFilter.h>
    … …  
    4748namespace WebKit {
    4849
    49 #if PLATFORM(COCOA)
    50 template <typename T> class DispatchPtr;
    51 template <typename T> DispatchPtr<T> adoptDispatch(T dispatchObject);
    52 
    53 // FIXME: Use OSObjectPtr instead when it works with dispatch_data_t on all platforms.
    54 template<typename T> class DispatchPtr {
    55 public:
    56     DispatchPtr()
    57         : m_ptr(nullptr)
    58     {
    59     }
    60     DispatchPtr(T ptr)
    61         : m_ptr(ptr)
    62     {
    63         if (m_ptr)
    64             dispatch_retain(m_ptr);
    65     }
    66     DispatchPtr(const DispatchPtr& other)
    67         : m_ptr(other.m_ptr)
    68     {
    69         if (m_ptr)
    70             dispatch_retain(m_ptr);
    71     }
    72     ~DispatchPtr()
    73     {
    74         if (m_ptr)
    75             dispatch_release(m_ptr);
    76     }
    77 
    78     DispatchPtr& operator=(const DispatchPtr& other)
    79     {
    80         auto copy = other;
    81         std::swap(m_ptr, copy.m_ptr);
    82         return *this;
    83     }
    84 
    85     T get() const { return m_ptr; }
    86     explicit operator bool() const { return m_ptr; }
    87 
    88     friend DispatchPtr adoptDispatch<T>(T);
    89 
    90 private:
    91     struct Adopt { };
    92     DispatchPtr(Adopt, T data)
    93         : m_ptr(data)
    94     {
    95     }
    96 
    97     T m_ptr;
    98 };
    99 
    100 template <typename T> DispatchPtr<T> adoptDispatch(T dispatchObject)
    101 {
    102     return DispatchPtr<T>(typename DispatchPtr<T>::Adopt { }, dispatchObject);
    103 }
    104 #endif
    105 
    10650class NetworkCacheStorage {
    10751    WTF_MAKE_NONCOPYABLE(NetworkCacheStorage);
    … …  
    10953    static std::unique_ptr<NetworkCacheStorage> open(const String& cachePath);
    11054
    111     class Data {
    112     public:
    113         Data() { }
    114         Data(const uint8_t*, size_t);
    115 
    116         enum class Backing { Buffer, Map };
    117 #if PLATFORM(COCOA)
    118         explicit Data(DispatchPtr<dispatch_data_t>, Backing = Backing::Buffer);
    119 #endif
    120         bool isNull() const;
    121 
    122         const uint8_t* data() const;
    123         size_t size() const { return m_size; }
    124         bool isMap() const { return m_isMap; }
    125 
    126 #if PLATFORM(COCOA)
    127         dispatch_data_t dispatchData() const { return m_dispatchData.get(); }
    128 #endif
    129     private:
    130 #if PLATFORM(COCOA)
    131         mutable DispatchPtr<dispatch_data_t> m_dispatchData;
    132 #endif
    133         mutable const uint8_t* m_data { nullptr };
    134         size_t m_size { 0 };
    135         bool m_isMap { false };
    136     };
    137 
    13855    struct Entry {
    13956        NetworkCacheKey key;
    14057        std::chrono::milliseconds timeStamp;
    141         Data header;
    142         Data body;
     58        NetworkCacheData header;
     59        NetworkCacheData body;
    14360    };
    14461    // This may call completion handler synchronously on failure.
    … …  
    14663    void retrieve(const NetworkCacheKey&, unsigned priority, RetrieveCompletionHandler&&);
    14764
    148     typedef std::function<void (bool success, const Data& mappedBody)> StoreCompletionHandler;
     65    typedef std::function<void (bool success, const NetworkCacheData& mappedBody)> StoreCompletionHandler;
    14966    void store(const Entry&, StoreCompletionHandler&&);
    15067    void update(const Entry& updateEntry, const Entry& existingEntry, StoreCompletionHandler&&);

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

    r180949 r181020  
    3232#include "NetworkCacheCoders.h"
    3333#include "NetworkCacheFileSystemPosix.h"
     34#include "NetworkCacheIOChannel.h"
    3435#include <dispatch/dispatch.h>
    3536#include <mach/vm_param.h>
    … …  
    4950static const char networkCacheSubdirectory[] = "WebKitCache";
    5051static const char versionDirectoryPrefix[] = "Version ";
    51 
    52 NetworkCacheStorage::Data::Data(const uint8_t* data, size_t size)
    53     : m_dispatchData(adoptDispatch(dispatch_data_create(data, size, nullptr, DISPATCH_DATA_DESTRUCTOR_DEFAULT)))
    54     , m_size(size)
    55 {
    56 }
    57 
    58 NetworkCacheStorage::Data::Data(DispatchPtr<dispatch_data_t> dispatchData, Backing backing)
    59 {
    60     if (!dispatchData)
    61         return;
    62     const void* data;
    63     m_dispatchData = adoptDispatch(dispatch_data_create_map(dispatchData.get(), &data, &m_size));
    64     m_data = static_cast<const uint8_t*>(data);
    65     m_isMap = m_size && backing == Backing::Map;
    66 }
    67 
    68 const uint8_t* NetworkCacheStorage::Data::data() const
    69 {
    70     if (!m_data) {
    71         const void* data;
    72         size_t size;
    73         m_dispatchData = adoptDispatch(dispatch_data_create_map(m_dispatchData.get(), &data, &size));
    74         ASSERT(size == m_size);
    75         m_data = static_cast<const uint8_t*>(data);
    76     }
    77     return m_data;
    78 }
    79 
    80 bool NetworkCacheStorage::Data::isNull() const
    81 {
    82     return !m_dispatchData;
    83 }
    8452
    8553std::unique_ptr<NetworkCacheStorage> NetworkCacheStorage::open(const String& cachePath)
    … …  
    151119}
    152120
    153 enum class FileOpenType { Read, Write, Create };
    154 static DispatchPtr<dispatch_io_t> openFile(const String& fileName, const String& directoryPath, FileOpenType type, int& fd)
    155 {
    156     int oflag;
    157     mode_t mode;
    158 
    159     switch (type) {
    160     case FileOpenType::Create:
    161         oflag = O_RDWR | O_CREAT | O_TRUNC | O_NONBLOCK;
    162         mode = S_IRUSR | S_IWUSR;
     121static Ref<NetworkCacheIOChannel> openFileForKey(const NetworkCacheKey& key, NetworkCacheIOChannel::Type type, const String& cachePath)
     122{
     123    auto directoryPath = directoryPathForKey(key, cachePath);
     124    auto filePath = WebCore::pathByAppendingComponent(directoryPath, fileNameForKey(key));
     125    if (type == NetworkCacheIOChannel::Type::Create)
    163126        WebCore::makeAllDirectories(directoryPath);
    164         break;
    165     case FileOpenType::Write:
    166         oflag = O_WRONLY | O_NONBLOCK;
    167         mode = S_IRUSR | S_IWUSR;
    168         break;
    169     case FileOpenType::Read:
    170         oflag = O_RDONLY | O_NONBLOCK;
    171         mode = 0;
    172     }
    173 
    174     CString path = WebCore::fileSystemRepresentation(WebCore::pathByAppendingComponent(directoryPath, fileName));
    175     fd = ::open(path.data(), oflag, mode);
    176 
    177     LOG(NetworkCacheStorage, "(NetworkProcess) opening %s type=%d", path.data(), type);
    178 
    179     auto channel = adoptDispatch(dispatch_io_create(DISPATCH_IO_RANDOM, fd, dispatch_get_main_queue(), [fd, type](int error) {
    180         close(fd);
    181         if (error)
    182             LOG(NetworkCacheStorage, "(NetworkProcess) error creating io channel %d", error);
    183     }));
    184 
    185     ASSERT(channel);
    186     dispatch_io_set_low_water(channel.get(), std::numeric_limits<size_t>::max());
    187 
    188     return channel;
    189 }
    190 
    191 static DispatchPtr<dispatch_io_t> openFileForKey(const NetworkCacheKey& key, FileOpenType type, const String& cachePath, int& fd)
    192 {
    193     return openFile(fileNameForKey(key), directoryPathForKey(key, cachePath), type, fd);
     127    return NetworkCacheIOChannel::open(filePath, type);
    194128}
    195129
    … …  
    221155};
    222156
    223 static bool decodeEntryMetaData(EntryMetaData& metaData, dispatch_data_t fileData)
     157static bool decodeEntryMetaData(EntryMetaData& metaData, const NetworkCacheData& fileData)
    224158{
    225159    bool success = false;
    226     dispatch_data_apply(fileData, [&metaData, &success](dispatch_data_t, size_t, const void* data, size_t size) {
     160    dispatch_data_apply(fileData.dispatchData(), [&metaData, &success](dispatch_data_t, size_t, const void* data, size_t size) {
    227161        NetworkCacheDecoder decoder(reinterpret_cast<const uint8_t*>(data), size);
    228162        if (!decoder.decode(metaData.cacheStorageVersion))
    … …  
    261195}
    262196
    263 static bool decodeEntryHeader(dispatch_data_t fileData, EntryMetaData& metaData, NetworkCacheStorage::Data& data)
     197static bool decodeEntryHeader(const NetworkCacheData& fileData, EntryMetaData& metaData, NetworkCacheData& data)
    264198{
    265199    if (!decodeEntryMetaData(metaData, fileData))
    … …  
    270204        return false;
    271205
    272     auto headerData = adoptDispatch(dispatch_data_create_subrange(fileData, metaData.headerOffset, metaData.headerSize));
     206    auto headerData = adoptDispatch(dispatch_data_create_subrange(fileData.dispatchData(), metaData.headerOffset, metaData.headerSize));
    273207    if (metaData.headerChecksum != hashData(headerData.get())) {
    274208        LOG(NetworkCacheStorage, "(NetworkProcess) header checksum mismatch");
    275209        return false;
    276210    }
    277     data =  NetworkCacheStorage::Data { headerData };
     211    data = { headerData };
    278212    return true;
    279213}
    280214
    281 static std::unique_ptr<NetworkCacheStorage::Entry> decodeEntry(dispatch_data_t fileData, int fd, const NetworkCacheKey& key)
     215static std::unique_ptr<NetworkCacheStorage::Entry> decodeEntry(const NetworkCacheData& fileData, int fd, const NetworkCacheKey& key)
    282216{
    283217    EntryMetaData metaData;
    284     NetworkCacheStorage::Data headerData;
     218    NetworkCacheData headerData;
    285219    if (!decodeEntryHeader(fileData, metaData, headerData))
    286220        return nullptr;
    … …  
    288222    if (metaData.key != key)
    289223        return nullptr;
    290     if (metaData.bodyOffset + metaData.bodySize != dispatch_data_get_size(fileData))
     224    if (metaData.bodyOffset + metaData.bodySize != fileData.size())
    291225        return nullptr;
    292226
    … …  
    306240        metaData.timeStamp,
    307241        headerData,
    308         NetworkCacheStorage::Data { bodyData, NetworkCacheStorage::Data::Backing::Map }
     242        { bodyData, NetworkCacheData::Backing::Map }
    309243    });
    310244}
    … …  
    327261}
    328262
    329 static DispatchPtr<dispatch_data_t> encodeEntryHeader(const NetworkCacheStorage::Entry& entry)
     263static NetworkCacheData encodeEntryHeader(const NetworkCacheStorage::Entry& entry)
    330264{
    331265    EntryMetaData metaData(entry.key);
    … …  
    339273    auto headerData = adoptDispatch(dispatch_data_create_concat(encodedMetaData.get(), entry.header.dispatchData()));
    340274    if (!entry.body.size())
    341         return headerData;
     275        return { headerData };
    342276
    343277    size_t headerSize = dispatch_data_get_size(headerData.get());
    … …  
    345279    Vector<uint8_t, 4096> filler(dataOffset - headerSize, 0);
    346280    auto alignmentData = adoptDispatch(dispatch_data_create(filler.data(), filler.size(), nullptr, DISPATCH_DATA_DESTRUCTOR_DEFAULT));
    347     return adoptDispatch(dispatch_data_create_concat(headerData.get(), alignmentData.get()));
     281    return { adoptDispatch(dispatch_data_create_concat(headerData.get(), alignmentData.get())) };
    348282}
    349283
    … …  
    371305    StringCapture cachePathCapture(m_directoryPath);
    372306    dispatch_async(m_ioQueue.get(), [this, &read, cachePathCapture] {
    373         int fd;
    374         auto channel = openFileForKey(read.key, FileOpenType::Read, cachePathCapture.string(), fd);
    375 
    376         bool didCallCompletionHandler = false;
    377         dispatch_io_read(channel.get(), 0, std::numeric_limits<size_t>::max(), dispatch_get_main_queue(), [this, fd, &read, didCallCompletionHandler](bool done, dispatch_data_t fileData, int error) mutable {
    378             if (done) {
    379                 if (error)
     307        auto channel = openFileForKey(read.key, NetworkCacheIOChannel::Type::Read, cachePathCapture.string());
     308        int fd = channel->fileDescriptor();
     309
     310        channel->read(0, std::numeric_limits<size_t>::max(), [this, &read, fd](NetworkCacheData& fileData, int error) {
     311            if (error) {
     312                removeEntry(read.key);
     313                read.completionHandler(nullptr);
     314            } else {
     315                auto entry = decodeEntry(fileData, fd, read.key);
     316                bool success = read.completionHandler(WTF::move(entry));
     317                if (!success)
    380318                    removeEntry(read.key);
    381 
    382                 if (!didCallCompletionHandler)
    383                     read.completionHandler(nullptr);
    384 
    385                 ASSERT(m_activeReadOperations.contains(&read));
    386                 m_activeReadOperations.remove(&read);
    387                 dispatchPendingReadOperations();
    388                 return;
    389319            }
    390             ASSERT(!didCallCompletionHandler); // We are requesting maximum sized chunk so we should never get called more than once with data.
    391 
    392             auto entry = decodeEntry(fileData, fd, read.key);
    393             bool success = read.completionHandler(WTF::move(entry));
    394             didCallCompletionHandler = true;
    395             if (!success)
    396                 removeEntry(read.key);
     320
     321            ASSERT(m_activeReadOperations.contains(&read));
     322            m_activeReadOperations.remove(&read);
     323            dispatchPendingReadOperations();
     324
     325            LOG(NetworkCacheStorage, "(NetworkProcess) read complete error=%d", error);
    397326        });
    398327    });
    … …  
    466395
    467396    if (!m_maximumSize) {
    468         completionHandler(false, Data());
     397        completionHandler(false, { });
    469398        return;
    470399    }
    … …  
    485414
    486415    if (!m_maximumSize) {
    487         completionHandler(false, Data());
     416        completionHandler(false, { });
    488417        return;
    489418    }
    … …  
    501430        auto semaphore = adoptDispatch(dispatch_semaphore_create(0));
    502431        traverseCacheFiles(cachePath, [this, &semaphore, &traverseHandler](const String& fileName, const String& partitionPath) {
    503             int fd;
    504             auto channel = openFile(fileName, partitionPath, FileOpenType::Read, fd);
     432            auto filePath = WebCore::pathByAppendingComponent(partitionPath, fileName);
     433            auto channel = NetworkCacheIOChannel::open(filePath, NetworkCacheIOChannel::Type::Read);
    505434            const size_t headerReadSize = 16 << 10;
    506             dispatch_io_read(channel.get(), 0, headerReadSize, dispatch_get_main_queue(), [this, fd, &semaphore, &traverseHandler](bool done, dispatch_data_t fileData, int) {
     435            channel->read(0, headerReadSize, [this, &semaphore, &traverseHandler](NetworkCacheData& fileData, int) {
    507436                EntryMetaData metaData;
    508                 NetworkCacheStorage::Data headerData;
     437                NetworkCacheData headerData;
    509438                if (decodeEntryHeader(fileData, metaData, headerData)) {
    510                     Entry entry { metaData.key, metaData.timeStamp, headerData, Data() };
     439                    Entry entry { metaData.key, metaData.timeStamp, headerData, { } };
    511440                    traverseHandler(&entry);
    512441                }
    513                 if (done)
    514                     dispatch_semaphore_signal(semaphore.get());
     442                dispatch_semaphore_signal(semaphore.get());
    515443            });
    516444            dispatch_semaphore_wait(semaphore.get(), DISPATCH_TIME_FOREVER);
    … …  
    556484    dispatch_async(m_backgroundIOQueue.get(), [this, &write, cachePathCapture] {
    557485        auto encodedHeader = encodeEntryHeader(write.entry);
    558         auto writeData = adoptDispatch(dispatch_data_create_concat(encodedHeader.get(), write.entry.body.dispatchData()));
    559 
    560         size_t bodyOffset = dispatch_data_get_size(encodedHeader.get());
    561 
    562         int fd;
    563         auto channel = openFileForKey(write.entry.key, FileOpenType::Create, cachePathCapture.string(), fd);
    564         dispatch_io_write(channel.get(), 0, writeData.get(), dispatch_get_main_queue(), [this, &write, fd, bodyOffset](bool done, dispatch_data_t, int error) {
    565             ASSERT_UNUSED(done, done);
     486        auto headerAndBodyData = adoptDispatch(dispatch_data_create_concat(encodedHeader.dispatchData(), write.entry.body.dispatchData()));
     487
     488        NetworkCacheData writeData(headerAndBodyData);
     489
     490        auto channel = openFileForKey(write.entry.key, NetworkCacheIOChannel::Type::Create, cachePathCapture.string());
     491        int fd = channel->fileDescriptor();
     492        size_t bodyOffset = encodedHeader.size();
     493
     494        channel->write(0, writeData, [this, &write, bodyOffset, fd](int error) {
    566495            LOG(NetworkCacheStorage, "(NetworkProcess) write complete error=%d", error);
    567496            if (error) {
    … …  
    577506            auto bodyMap = shouldMapBody ? mapFile(fd, bodyOffset, bodySize) : nullptr;
    578507
    579             Data bodyData(bodyMap, Data::Backing::Map);
     508            NetworkCacheData bodyData(bodyMap, NetworkCacheData::Backing::Map);
    580509            write.completionHandler(!error, bodyData);
    581510
    … …  
    602531        auto existingHeaderData = encodeEntryHeader(write.existingEntry.value());
    603532
    604         bool pageRoundedHeaderSizeChanged = dispatch_data_get_size(headerData.get()) != dispatch_data_get_size(existingHeaderData.get());
     533        bool pageRoundedHeaderSizeChanged = headerData.size() != existingHeaderData.size();
    605534        if (pageRoundedHeaderSizeChanged) {
    606535            LOG(NetworkCacheStorage, "(NetworkProcess) page-rounded header size changed, storing full entry");
    … …  
    611540        }
    612541
    613         int fd;
    614         auto channel = openFileForKey(write.entry.key, FileOpenType::Write, cachePathCapture.string(), fd);
    615         dispatch_io_write(channel.get(), 0, headerData.get(), dispatch_get_main_queue(), [this, &write](bool done, dispatch_data_t, int error) {
    616             ASSERT_UNUSED(done, done);
     542        auto channel = openFileForKey(write.entry.key, NetworkCacheIOChannel::Type::Write, cachePathCapture.string());
     543        channel->write(0, headerData, [this, &write](int error) {
    617544            LOG(NetworkCacheStorage, "(NetworkProcess) update complete error=%d", error);
    618545
    … …  
    620547                removeEntry(write.entry.key);
    621548
    622             write.completionHandler(!error, Data());
     549            write.completionHandler(!error, { });
    623550
    624551            ASSERT(m_activeWriteOperations.contains(&write));

  • trunk/Source/WebKit2/WebKit2.xcodeproj/project.pbxproj

    r180837 r181020  
    17541754                E1EE53E311F8CFC000CCBEE4 /* InjectedBundlePageEditorClient.h in Headers */ = {isa = PBXBuildFile; fileRef = E1EE53DC11F8CF9F00CCBEE4 /* InjectedBundlePageEditorClient.h */; };
    17551755                E1EE53E711F8CFFB00CCBEE4 /* InjectedBundlePageEditorClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E1EE53E611F8CFFB00CCBEE4 /* InjectedBundlePageEditorClient.cpp */; };
     1756                E42E060F1AA7523400B11699 /* NetworkCacheIOChannelCocoa.mm in Sources */ = {isa = PBXBuildFile; fileRef = E42E060D1AA750E500B11699 /* NetworkCacheIOChannelCocoa.mm */; };
     1757                E42E06101AA7523B00B11699 /* NetworkCacheIOChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = E42E060B1AA7440D00B11699 /* NetworkCacheIOChannel.h */; };
     1758                E42E06121AA75ABD00B11699 /* NetworkCacheData.h in Headers */ = {isa = PBXBuildFile; fileRef = E42E06111AA75ABD00B11699 /* NetworkCacheData.h */; };
     1759                E42E06141AA75B7000B11699 /* NetworkCacheDataCocoa.mm in Sources */ = {isa = PBXBuildFile; fileRef = E42E06131AA75B7000B11699 /* NetworkCacheDataCocoa.mm */; };
    17561760                E4436ECA1A0D03FA00EAD204 /* NetworkCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4436EBE1A0CFDB200EAD204 /* NetworkCache.cpp */; };
    17571761                E4436ECC1A0D040B00EAD204 /* NetworkCache.h in Headers */ = {isa = PBXBuildFile; fileRef = E4436EBF1A0CFDB200EAD204 /* NetworkCache.h */; };
    … …  
    39863990                E1FEF39A190F76F300731658 /* com.apple.WebKit.Databases.sb.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = com.apple.WebKit.Databases.sb.in; sourceTree = "<group>"; };
    39873991                E1FEF39C190F791C00731658 /* DatabaseProcessIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = DatabaseProcessIOS.mm; sourceTree = "<group>"; };
     3992                E42E060B1AA7440D00B11699 /* NetworkCacheIOChannel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkCacheIOChannel.h; sourceTree = "<group>"; };
     3993                E42E060D1AA750E500B11699 /* NetworkCacheIOChannelCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = NetworkCacheIOChannelCocoa.mm; sourceTree = "<group>"; };
     3994                E42E06111AA75ABD00B11699 /* NetworkCacheData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkCacheData.h; sourceTree = "<group>"; };
     3995                E42E06131AA75B7000B11699 /* NetworkCacheDataCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = NetworkCacheDataCocoa.mm; sourceTree = "<group>"; };
    39883996                E4436EBE1A0CFDB200EAD204 /* NetworkCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetworkCache.cpp; sourceTree = "<group>"; };
    39893997                E4436EBF1A0CFDB200EAD204 /* NetworkCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkCache.h; sourceTree = "<group>"; };
    … …  
    74187426                                E489D2841A0A2DB80078C06A /* NetworkCacheCoders.cpp */,
    74197427                                E489D2851A0A2DB80078C06A /* NetworkCacheCoders.h */,
     7428                                E42E06111AA75ABD00B11699 /* NetworkCacheData.h */,
     7429                                E42E06131AA75B7000B11699 /* NetworkCacheDataCocoa.mm */,
    74207430                                E489D2861A0A2DB80078C06A /* NetworkCacheDecoder.cpp */,
    74217431                                E489D2871A0A2DB80078C06A /* NetworkCacheDecoder.h */,
    … …  
    74237433                                E489D2891A0A2DB80078C06A /* NetworkCacheEncoder.h */,
    74247434                                834B250E1A831A8D00CFB150 /* NetworkCacheFileSystemPosix.h */,
     7435                                E42E060B1AA7440D00B11699 /* NetworkCacheIOChannel.h */,
     7436                                E42E060D1AA750E500B11699 /* NetworkCacheIOChannelCocoa.mm */,
    74257437                                E4436EC01A0CFDB200EAD204 /* NetworkCacheKey.cpp */,
    74267438                                E4436EC11A0CFDB200EAD204 /* NetworkCacheKey.h */,
    … …  
    75377549                                7C89D2B61A6B0DD9003A5FDE /* WKUserContentControllerPrivate.h in Headers */,
    75387550                                7CE4D2071A46776100C7F152 /* APILegacyContextHistoryClient.h in Headers */,
     7551                                E42E06121AA75ABD00B11699 /* NetworkCacheData.h in Headers */,
    75397552                                1A2464F31891E45100234C5B /* APILoaderClient.h in Headers */,
    75407553                                7CD3A4831A5D02FA009623B8 /* APINavigation.h in Headers */,
    … …  
    78507863                                51654EFE184EF33F007DC837 /* UniqueIDBDatabaseBackingStoreSQLite.h in Headers */,
    78517864                                515E773418402D510007203F /* UniqueIDBDatabaseIdentifier.h in Headers */,
     7865                                E42E06101AA7523B00B11699 /* NetworkCacheIOChannel.h in Headers */,
    78527866                                1A64245E12DE29A100CAAE2C /* UpdateInfo.h in Headers */,
    78537867                                1AC1336818565B5700F3EC05 /* UserData.h in Headers */,
    … …  
    96089622                                1ZZ417EF12C00D87002BE67B /* TextCheckerCompletion.cpp in Sources */,
    96099623                                2DA944AD1884E9BA00ED86DB /* TextCheckerIOS.mm in Sources */,
     9624                                E42E06141AA75B7000B11699 /* NetworkCacheDataCocoa.mm in Sources */,
    96109625                                1AA417EF12C00D87002BE67B /* TextCheckerMac.mm in Sources */,
    96119626                                1AAF263814687C39004A1E8A /* TiledCoreAnimationDrawingArea.mm in Sources */,
    … …  
    98559870                                0FCB4E4918BBE044000FCFC9 /* WKActionSheet.mm in Sources */,
    98569871                                0FCB4E4B18BBE044000FCFC9 /* WKActionSheetAssistant.mm in Sources */,
     9872                                E42E060F1AA7523400B11699 /* NetworkCacheIOChannelCocoa.mm in Sources */,
    98579873                                C5FA1ED418E1062200B3F402 /* WKAirPlayRoutePicker.mm in Sources */,
    98589874                                512E34E4130B4D0500ABD19A /* WKApplicationCacheManager.cpp in Sources */,
Note: See TracChangeset for help on using the changeset viewer.