Changeset 70520 in webkit


Ignore:
Timestamp:
Oct 26, 2010 8:02:21 AM (14 years ago)
Author:
zoltan@webkit.org
Message:

[Qt] Implement SharedMemory for WebKit2
​https://bugs.webkit.org/show_bug.cgi?id=47345

Reviewed by Kenneth Rohde Christiansen.

Implement unimplemented functions in SharedMemoryQt.cpp.
Rename MappedMemory.h to MappedMemoryPool.h, move MappedMemoryPool.{h|cpp} from
Shared/qt to Platform/qt. Modify affected lines of WebKit2.pro.
Move MappedMemory implementation into MappedMemoryPool. Remove unnecessary
methods of MappedMemoryPool.

  • Platform/SharedMemory.h: Add a handle member for Qt.
  • Platform/qt/MappedMemoryPool.cpp: Copied from WebKit2/Shared/qt/MappedMemoryPool.cpp.

(WebKit::MappedMemoryPool::searchForMappedMemory):
(WebKit::MappedMemoryPool::mapMemory):
(WebKit::MappedMemoryPool::mapFile):

  • Platform/qt/MappedMemoryPool.h: Copied from WebKit2/Shared/qt/MappedMemory.h.

(WebKit::MappedMemoryPool::MappedMemory::mapSize):
(WebKit::MappedMemoryPool::MappedMemory::markUsed):
(WebKit::MappedMemoryPool::MappedMemory::markFree):
(WebKit::MappedMemoryPool::MappedMemory::isFree):
(WebKit::MappedMemoryPool::MappedMemory::data):
(WebKit::MappedMemoryPool::MappedMemoryPool):
Move MappedMemory implementation into MappedMemoryPool.

  • Platform/qt/SharedMemoryQt.cpp:

(WebKit::SharedMemory::Handle::Handle): Implement.
(WebKit::SharedMemory::Handle::~Handle):
(WebKit::SharedMemory::Handle::isNull): Implement.
(WebKit::SharedMemory::Handle::encode): Implement.
(WebKit::SharedMemory::Handle::decode): Implement.
(WebKit::SharedMemory::create): Implement.
(WebKit::mapProtection): Added.
(WebKit::SharedMemory::~SharedMemory): Implement.
(WebKit::SharedMemory::createHandle): Implement.
(WebKit::SharedMemory::systemPageSize): Implement.

  • Shared/qt/MappedMemory.h: Removed.
  • Shared/qt/MappedMemoryPool.cpp: Removed.
  • Shared/qt/UpdateChunk.cpp:

(WebKit::UpdateChunk::UpdateChunk):
(WebKit::UpdateChunk::decode):
Modify to use MappedMemoryPool.

  • Shared/qt/UpdateChunk.h:
  • WebKit2.pro:

Modify affected lines.

Location:
trunk/WebKit2
Files:
6 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/WebKit2/ChangeLog

    r70510 r70520  
     12010-10-26  Zoltan Horvath  <zoltan@webkit.org>
     2
     3        Reviewed by Kenneth Rohde Christiansen.
     4
     5        [Qt] Implement SharedMemory for WebKit2
     6        https://bugs.webkit.org/show_bug.cgi?id=47345
     7
     8        Implement unimplemented functions in SharedMemoryQt.cpp.
     9        Rename MappedMemory.h to MappedMemoryPool.h, move MappedMemoryPool.{h|cpp} from
     10        Shared/qt to Platform/qt. Modify affected lines of WebKit2.pro.
     11        Move MappedMemory implementation into MappedMemoryPool. Remove unnecessary
     12        methods of MappedMemoryPool.
     13
     14        * Platform/SharedMemory.h: Add a handle member for Qt.
     15        * Platform/qt/MappedMemoryPool.cpp: Copied from WebKit2/Shared/qt/MappedMemoryPool.cpp.
     16        (WebKit::MappedMemoryPool::searchForMappedMemory):
     17        (WebKit::MappedMemoryPool::mapMemory):
     18        (WebKit::MappedMemoryPool::mapFile):
     19        * Platform/qt/MappedMemoryPool.h: Copied from WebKit2/Shared/qt/MappedMemory.h.
     20        (WebKit::MappedMemoryPool::MappedMemory::mapSize):
     21        (WebKit::MappedMemoryPool::MappedMemory::markUsed):
     22        (WebKit::MappedMemoryPool::MappedMemory::markFree):
     23        (WebKit::MappedMemoryPool::MappedMemory::isFree):
     24        (WebKit::MappedMemoryPool::MappedMemory::data):
     25        (WebKit::MappedMemoryPool::MappedMemoryPool):
     26        Move MappedMemory implementation into MappedMemoryPool.
     27        * Platform/qt/SharedMemoryQt.cpp:
     28        (WebKit::SharedMemory::Handle::Handle): Implement.
     29        (WebKit::SharedMemory::Handle::~Handle):
     30        (WebKit::SharedMemory::Handle::isNull): Implement.
     31        (WebKit::SharedMemory::Handle::encode): Implement.
     32        (WebKit::SharedMemory::Handle::decode): Implement.
     33        (WebKit::SharedMemory::create): Implement.
     34        (WebKit::mapProtection): Added.
     35        (WebKit::SharedMemory::~SharedMemory): Implement.
     36        (WebKit::SharedMemory::createHandle): Implement.
     37        (WebKit::SharedMemory::systemPageSize): Implement.
     38        * Shared/qt/MappedMemory.h: Removed.
     39        * Shared/qt/MappedMemoryPool.cpp: Removed.
     40        * Shared/qt/UpdateChunk.cpp:
     41        (WebKit::UpdateChunk::UpdateChunk):
     42        (WebKit::UpdateChunk::decode):
     43        Modify to use MappedMemoryPool.
     44        * Shared/qt/UpdateChunk.h:
     45        * WebKit2.pro:
     46        Modify affected lines.
     47
    1482010-10-25  Anders Carlsson  <andersca@apple.com>
    249

  • trunk/WebKit2/Platform/SharedMemory.h

    r70453 r70520  
    3131#include <wtf/RefCounted.h>
    3232
     33#if PLATFORM(QT)
     34#include <wtf/text/WTFString.h>
     35#endif
     36
    3337namespace CoreIPC {
    3438    class ArgumentDecoder;
    … …  
    6165#elif PLATFORM(WIN)
    6266        mutable HANDLE m_handle;
     67#elif PLATFORM(QT)
     68        mutable String m_fileName;
    6369#endif
    6470        size_t m_size;

  • trunk/WebKit2/Platform/qt/MappedMemoryPool.cpp

    r70519 r70520  
    11/*
    22 * Copyright (C) 2010 University of Szeged
     3 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
    34 * All rights reserved.
    45 *
    … …  
    2526 */
    2627
    27 #include "MappedMemory.h"
     28#include "MappedMemoryPool.h"
    2829
    2930#include "StdLibExtras.h"
     31#include <QDir>
     32#include <QIODevice>
     33#include <QTemporaryFile>
    3034
    3135namespace WebKit {
    32 
    33 MappedMemoryPool::MappedMemoryPool()
    34 {
    35     connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), SLOT(cleanUp()));
    36 }
    3736
    3837MappedMemoryPool* MappedMemoryPool::instance()
    … …  
    4241}
    4342
    44 size_t MappedMemoryPool::size() const
     43MappedMemory* MappedMemoryPool::searchForMappedMemory(uchar* p)
    4544{
    46     return m_pool.size();
     45    for (unsigned n = 0; n < m_pool.size(); ++n) {
     46        MappedMemory& current = m_pool.at(n);
     47        if (current.data() == p)
     48            return reinterpret_cast<MappedMemory*>(&current);
     49    }
     50    return 0;
    4751}
    4852
    49 MappedMemory& MappedMemoryPool::at(size_t i)
     53MappedMemory* MappedMemoryPool::mapMemory(size_t size, QIODevice::OpenMode openMode)
    5054{
    51     return m_pool.at(i);
     55    for (unsigned n = 0; n < m_pool.size(); ++n) {
     56        MappedMemory& current = m_pool.at(n);
     57        if (current.dataSize >= size && current.isFree()) {
     58            current.markUsed();
     59            return &current;
     60        }
     61    }
     62    MappedMemory newMap;
     63    newMap.dataSize = size;
     64    newMap.file = new QTemporaryFile(QDir::tempPath() + "/WebKit2UpdateChunk");
     65    newMap.file->open(openMode);
     66    newMap.file->resize(newMap.mapSize());
     67    newMap.mappedBytes = newMap.file->map(0, newMap.mapSize());
     68    newMap.file->close();
     69    newMap.markUsed();
     70    m_pool.append(newMap);
     71    return &m_pool.last();
    5272}
    5373
    54 MappedMemory& MappedMemoryPool::append(const MappedMemory& newMap)
     74MappedMemory* MappedMemoryPool::mapFile(QString fileName, size_t size, QIODevice::OpenMode openMode)
    5575{
     76    for (unsigned n = 0; n < m_pool.size(); ++n) {
     77        MappedMemory& current = m_pool.at(n);
     78        if (current.file->fileName() == fileName) {
     79            ASSERT(!current.isFree());
     80            return &current;
     81        }
     82    }
     83    MappedMemory newMap;
     84    newMap.file = new QFile(fileName);
     85    if (!newMap.file->open(openMode))
     86        return 0;
     87    newMap.dataSize = size;
     88    newMap.mappedBytes = newMap.file->map(0, newMap.mapSize());
     89    ASSERT(!newMap.isFree());
     90    newMap.file->close();
     91    newMap.file->remove(); // The map stays alive even when the file is unlinked.
    5692    m_pool.append(newMap);
    57     return m_pool.last();
    58 }
    59 
    60 void MappedMemoryPool::cleanUp()
    61 {
    62     size_t size = m_pool.size();
    63 
    64     for (size_t i = 0; i < size; ++i) {
    65         MappedMemory& chunk = m_pool.at(i);
    66         if (!chunk.isFree())
    67             chunk.file->unmap(chunk.mappedBytes);
    68         chunk.file->remove();
    69     }
    70 
    71     delete this;
     93    return &m_pool.last();
    7294}
    7395

  • trunk/WebKit2/Platform/qt/MappedMemoryPool.h

    r70519 r70520  
    2626 */
    2727
    28 #ifndef MappedMemory_h
    29 #define MappedMemory_h
     28#ifndef MappedMemoryPool_h
     29#define MappedMemoryPool_h
    3030
    31 #include <QCoreApplication>
    3231#include <QFile>
    3332#include <wtf/Vector.h>
    3433
    3534namespace WebKit {
    36 struct MappedMemory {
    37     QFile* file;
    38     struct Data {
    39         uint32_t isFree; // keep bytes aligned
    40         uchar bytes;
    41     };
    42     union {
    43         uchar* mappedBytes;
    44         Data* dataPtr;
    45     };
    46     size_t dataSize;
    4735
    48     size_t mapSize() const { return dataSize + sizeof(Data); }
    49     void markUsed() { dataPtr->isFree = false; }
    50     void markFree() { dataPtr->isFree = true; }
    51     bool isFree() const { return dataPtr->isFree; }
    52     uchar* data() const { return &dataPtr->bytes; }
    53 };
    54 
    55 class MappedMemoryPool : public QObject {
    56     Q_OBJECT
     36class MappedMemoryPool {
    5737public:
    5838    static MappedMemoryPool* instance();
    59     size_t size() const;
    60     MappedMemory& at(size_t i);
    61     MappedMemory& append(const MappedMemory&);
     39
     40    struct MappedMemory {
     41        QFile* file;
     42        struct Data {
     43            uint32_t isFree; // keep bytes aligned
     44            uchar bytes;
     45        };
     46        union {
     47            uchar* mappedBytes;
     48            Data* dataPtr;
     49        };
     50        size_t dataSize;
     51
     52        size_t mapSize() const { return dataSize + sizeof(Data); }
     53        void markUsed() { dataPtr->isFree = false; }
     54        void markFree() { dataPtr->isFree = true; }
     55        bool isFree() const { return dataPtr->isFree; }
     56        uchar* data() const { return &dataPtr->bytes; }
     57    };
     58
     59    MappedMemory* mapMemory(size_t size, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
     60    MappedMemory* mapFile(QString fileName, size_t size, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
     61    MappedMemory* searchForMappedMemory(uchar* p);
    6262
    6363private:
    64     MappedMemoryPool();
    65     Q_SLOT void cleanUp();
     64    MappedMemoryPool() { };
    6665
    6766    Vector<MappedMemory> m_pool;
    6867};
     68
     69typedef MappedMemoryPool::MappedMemory MappedMemory;
     70
    6971} // namespace WebKit
    70 #endif // MappedMemory_h
     72
     73#endif // MappedMemoryPool_h

  • trunk/WebKit2/Platform/qt/SharedMemoryQt.cpp

    r70453 r70520  
    11/*
    22 * Copyright (C) 2010 Apple Inc. All rights reserved.
     3 * Copyright (c) 2010 University of Szeged
     4 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
    35 *
    46 * Redistribution and use in source and binary forms, with or without
    … …  
    2628#include "SharedMemory.h"
    2729
    28 #include "NotImplemented.h"
     30#include "ArgumentDecoder.h"
     31#include "ArgumentEncoder.h"
     32#include "MappedMemoryPool.h"
     33#include "WebCoreArgumentCoders.h"
     34#include <QIODevice>
     35#include <unistd.h>
     36#include <wtf/text/WTFString.h>
    2937
    3038namespace WebKit {
    3139
     40static MappedMemoryPool* mappedMemoryPool = MappedMemoryPool::instance();
     41
    3242SharedMemory::Handle::Handle()
     43    : m_fileName()
     44    , m_size(0)
    3345{
    34     notImplemented();
    3546}
    3647
    3748SharedMemory::Handle::~Handle()
    3849{
    39     notImplemented();
     50}
     51
     52bool SharedMemory::Handle::isNull() const
     53{
     54    return m_fileName.isNull();
    4055}
    4156
    4257void SharedMemory::Handle::encode(CoreIPC::ArgumentEncoder* encoder) const
    4358{
    44     notImplemented();
     59    encoder->encodeUInt64(m_size);
     60    encoder->encode(m_fileName);
     61    m_fileName = String();
    4562}
    4663
    4764bool SharedMemory::Handle::decode(CoreIPC::ArgumentDecoder* decoder, Handle& handle)
    4865{
    49     notImplemented();
    50     return false;
     66    ASSERT(!handle.m_size);
     67    ASSERT(handle.m_fileName.isEmpty());
     68
     69    uint64_t size;
     70    if (!decoder->decodeUInt64(size))
     71        return false;
     72
     73    String fileName;
     74    if (!decoder->decode(fileName))
     75       return false;
     76
     77    handle.m_size = size;
     78    handle.m_fileName = fileName;
     79
     80    return true;
    5181}
    5282
    5383PassRefPtr<SharedMemory> SharedMemory::create(size_t size)
    5484{
    55     notImplemented();
    56     return 0;
     85    MappedMemory* mm = mappedMemoryPool->mapMemory(size, QIODevice::ReadWrite);
     86
     87    RefPtr<SharedMemory> sharedMemory(adoptRef(new SharedMemory));
     88    sharedMemory->m_size = size;
     89    sharedMemory->m_data = reinterpret_cast<void*>(mm->data());
     90
     91    return sharedMemory.release();
     92}
     93
     94static inline QIODevice::OpenMode mapProtection(SharedMemory::Protection protection)
     95{
     96    switch (protection) {
     97    case SharedMemory::ReadOnly:
     98        return QIODevice::ReadOnly;
     99    case SharedMemory::ReadWrite:
     100        return QIODevice::ReadWrite;
     101    }
     102
     103    ASSERT_NOT_REACHED();
     104    return QIODevice::NotOpen;
    57105}
    58106
    59107PassRefPtr<SharedMemory> SharedMemory::create(const Handle& handle, Protection protection)
    60108{
    61     notImplemented();
    62     return 0;   
     109    if (handle.isNull())
     110        return 0;
     111
     112    QIODevice::OpenMode openMode = mapProtection(protection);
     113
     114    MappedMemory* mm = mappedMemoryPool->mapFile(QString(handle.m_fileName), handle.m_size, openMode);
     115
     116    RefPtr<SharedMemory> sharedMemory(adoptRef(new SharedMemory));
     117    sharedMemory->m_size = handle.m_size;
     118    sharedMemory->m_data = reinterpret_cast<void*>(mm->data());
     119
     120    return sharedMemory.release();
    63121}
    64122
    65123SharedMemory::~SharedMemory()
    66124{
    67     notImplemented();
     125    MappedMemory* mappedMemory = mappedMemoryPool->searchForMappedMemory(reinterpret_cast<uchar*>(m_data));
     126    if (mappedMemory)
     127        mappedMemory->markFree();
    68128}
    69    
     129
    70130bool SharedMemory::createHandle(Handle& handle, Protection protection)
    71131{
    72     notImplemented();
    73     return false;
     132    ASSERT(handle.m_fileName.isNull());
     133    ASSERT(!handle.m_size);
     134
     135    MappedMemory* mm = mappedMemoryPool->searchForMappedMemory(reinterpret_cast<uchar*>(m_data));
     136
     137    if (!mm)
     138        return false;
     139
     140    handle.m_fileName = mm->file->fileName();
     141    handle.m_size = m_size;
     142
     143    return true;
    74144}
    75145
    … …  
    78148    static unsigned pageSize = 0;
    79149
     150    if (!pageSize)
     151        pageSize = getpagesize();
     152
    80153    return pageSize;
    81154}

  • trunk/WebKit2/Shared/qt/UpdateChunk.cpp

    r70453 r70520  
    3030#include "ArgumentDecoder.h"
    3131#include "ArgumentEncoder.h"
    32 #include "Attachment.h"
    3332#include "WebCoreArgumentCoders.h"
    34 #include <QDebug>
    35 #include <QDir>
     33#include <QIODevice>
    3634#include <QImage>
    37 #include <QTemporaryFile>
    3835#include <WebCore/FloatRect.h>
    3936#include <wtf/text/WTFString.h>
    … …  
    4441namespace WebKit {
    4542
    46 static MappedMemory* mapMemory(size_t size)
    47 {
    48     MappedMemoryPool* pool = MappedMemoryPool::instance();
    49     for (unsigned n = 0; n < pool->size(); ++n) {
    50         MappedMemory& current = pool->at(n);
    51         if (current.dataSize >= size && current.isFree()) {
    52             current.markUsed();
    53             return &current;
    54         }
    55     }
    56     MappedMemory newMap;
    57     newMap.dataSize = size;
    58     newMap.file = new QTemporaryFile(QDir::tempPath() + "/WebKit2UpdateChunk");
    59     newMap.file->open(QIODevice::ReadWrite);
    60     newMap.file->resize(newMap.mapSize());
    61     newMap.mappedBytes = newMap.file->map(0, newMap.mapSize());
    62     newMap.file->close();
    63     newMap.markUsed();
    64     return &pool->append(newMap);
    65 }
    66 
    67 static MappedMemory* mapFile(QString fileName, size_t size)
    68 {
    69     MappedMemoryPool* pool = MappedMemoryPool::instance();
    70     for (unsigned n = 0; n < pool->size(); ++n) {
    71         MappedMemory& current = pool->at(n);
    72         if (current.file->fileName() == fileName) {
    73             ASSERT(!current.isFree());
    74             return &current;
    75         }
    76     }
    77     MappedMemory newMap;
    78     newMap.file = new QFile(fileName);
    79     if (!newMap.file->open(QIODevice::ReadWrite))
    80         return 0;
    81     newMap.dataSize = size;
    82     newMap.mappedBytes = newMap.file->map(0, newMap.mapSize());
    83     ASSERT(!newMap.isFree());
    84     newMap.file->close();
    85     newMap.file->remove(); // The map stays alive even when the file is unlinked.
    86     return &pool->append(newMap);
    87 }
     43static MappedMemoryPool* mappedMemoryPool = MappedMemoryPool::instance();
    8844
    8945UpdateChunk::UpdateChunk()
    … …  
    9450UpdateChunk::UpdateChunk(const IntRect& rect)
    9551    : m_rect(rect)
    96     , m_mappedMemory(mapMemory(size()))
     52    , m_mappedMemory(mappedMemoryPool->mapMemory(size()))
    9753{
    9854}
    … …  
    12581        return false;
    12682    chunk.m_rect = rect;
    127    
     83
    12884    String fileName;
    12985    if (!decoder->decode(fileName))
    13086        return false;
    13187
    132     chunk.m_mappedMemory = mapFile(fileName, chunk.size());
     88    chunk.m_mappedMemory = mappedMemoryPool->mapFile(fileName, chunk.size());
    13389
    13490    return chunk.m_mappedMemory->mappedBytes;

  • trunk/WebKit2/Shared/qt/UpdateChunk.h

    r70453 r70520  
    2828#define UpdateChunk_h
    2929
    30 #include "MappedMemory.h"
     30#include "MappedMemoryPool.h"
    3131#include <QImage>
    3232#include <WebCore/IntRect.h>

  • trunk/WebKit2/WebKit2.pro

    r70504 r70520  
    107107    Platform \
    108108    Platform/CoreIPC \
     109    Platform/qt \
    109110    Shared \
    110111    Shared/API/c \
    … …  
    175176    Platform/Module.h \
    176177    Platform/PlatformProcessIdentifier.h \
     178    Platform/qt/MappedMemoryPool.h \
    177179    Platform/RunLoop.h \
    178180    Platform/SharedMemory.h \
    … …  
    204206    Shared/NotImplemented.h \
    205207    Shared/StringPairVector.h \
    206     Shared/qt/MappedMemory.h \
    207208    Shared/qt/PlatformCertificateInfo.h \
    208209    Shared/qt/UpdateChunk.h \
    … …  
    341342    Platform/RunLoop.cpp \
    342343    Platform/WorkQueue.cpp \
     344    Platform/qt/MappedMemoryPool.cpp \
    343345    Platform/qt/ModuleQt.cpp \
    344346    Platform/qt/RunLoopQt.cpp \
    … …  
    361363    Shared/MutableDictionary.cpp \
    362364    Shared/qt/BackingStoreQt.cpp \
    363     Shared/qt/MappedMemoryPool.cpp \
    364365    Shared/qt/NativeWebKeyboardEventQt.cpp \
    365366    Shared/qt/UpdateChunk.cpp \
Note: See TracChangeset for help on using the changeset viewer.