Changeset 66679 in webkit


Ignore:
Timestamp:
Sep 2, 2010 12:11:27 PM (14 years ago)
Author:
weinig@apple.com
Message:

Simplify ownership semantics of some WebKit2 types
https://bugs.webkit.org/show_bug.cgi?id=45120

Reviewed by Anders Carlsson.

  • Make ImmutableArray and MutableArray use a Vector<RefPtr<APIObject> > and therefore ref any items it takes in.
  • Make the PostMessageDecoder operate on a RefPtr<APIObject>& to avoid the odd leaking semantics.
  • Shared/ImmutableArray.cpp:

(WebKit::ImmutableArray::ImmutableArray): This constructor now uses a for-loop
instead of memcpy to ref each item.
(WebKit::ImmutableArray::~ImmutableArray): No longer necessary to manually deref.

  • Shared/ImmutableArray.h:

(WebKit::ImmutableArray::adopt):
(WebKit::ImmutableArray::at):
Changes to accommodate entries being changed to a Vector<RefPtr<APIObject> >.

  • Shared/ImmutableDictionary.cpp:

(WebKit::ImmutableDictionary::keys):
Build a Vector<RefPtr<APIObject> >.

  • UIProcess/WebBackForwardList.cpp:

(WebKit::WebBackForwardList::backListAsImmutableArrayWithLimit):
(WebKit::WebBackForwardList::forwardListAsImmutableArrayWithLimit):
Ditto.

  • UIProcess/WebContext.cpp:

(WebKit::PostMessageEncoder::PostMessageDecoder::PostMessageDecoder):
(WebKit::PostMessageEncoder::PostMessageDecoder::decode):
(WebKit::WebContext::didReceiveMessage):
APIObject>& to avoid the odd leaking semantics.

  • WebProcess/InjectedBundle/InjectedBundle.cpp:

(WebKit::PostMessageEncoder::PostMessageDecoder::PostMessageDecoder):
(WebKit::PostMessageEncoder::PostMessageDecoder::decode):
(WebKit::InjectedBundle::didReceiveMessage):
Ditto.

  • WebProcess/WebPage/WebFrame.cpp:

(WebKit::WebFrame::childFrames):
Build a Vector<RefPtr<APIObject> >.

Location:
trunk/WebKit2
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/WebKit2/ChangeLog

    r66676 r66679  
     12010-09-02  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Anders Carlsson.
     4
     5        Simplify ownership semantics of some WebKit2 types
     6        https://bugs.webkit.org/show_bug.cgi?id=45120
     7
     8        - Make ImmutableArray and MutableArray use a Vector<RefPtr<APIObject> > and
     9          therefore ref any items it takes in.
     10        - Make the PostMessageDecoder operate on a RefPtr<APIObject>& to avoid the odd
     11          leaking semantics.
     12
     13        * Shared/ImmutableArray.cpp:
     14        (WebKit::ImmutableArray::ImmutableArray): This constructor now uses a for-loop
     15        instead of memcpy to ref each item.
     16        (WebKit::ImmutableArray::~ImmutableArray): No longer necessary to manually deref.
     17        * Shared/ImmutableArray.h:
     18        (WebKit::ImmutableArray::adopt):
     19        (WebKit::ImmutableArray::at):
     20        Changes to accommodate entries being changed to a Vector<RefPtr<APIObject> >.
     21
     22        * Shared/ImmutableDictionary.cpp:
     23        (WebKit::ImmutableDictionary::keys):
     24        Build a Vector<RefPtr<APIObject> >.
     25
     26        * UIProcess/WebBackForwardList.cpp:
     27        (WebKit::WebBackForwardList::backListAsImmutableArrayWithLimit):
     28        (WebKit::WebBackForwardList::forwardListAsImmutableArrayWithLimit):
     29        Ditto.
     30
     31        * UIProcess/WebContext.cpp:
     32        (WebKit::PostMessageEncoder::PostMessageDecoder::PostMessageDecoder):
     33        (WebKit::PostMessageEncoder::PostMessageDecoder::decode):
     34        (WebKit::WebContext::didReceiveMessage):
     35        APIObject>& to avoid the odd leaking semantics.
     36
     37        * WebProcess/InjectedBundle/InjectedBundle.cpp:
     38        (WebKit::PostMessageEncoder::PostMessageDecoder::PostMessageDecoder):
     39        (WebKit::PostMessageEncoder::PostMessageDecoder::decode):
     40        (WebKit::InjectedBundle::didReceiveMessage):
     41        Ditto.
     42
     43        * WebProcess/WebPage/WebFrame.cpp:
     44        (WebKit::WebFrame::childFrames):
     45        Build a Vector<RefPtr<APIObject> >.
     46
    1472010-09-02  Sam Weinig  <sam@webkit.org>
    248
  • trunk/WebKit2/Shared/ImmutableArray.cpp

    r66621 r66679  
    3535    : m_entries(size)
    3636{
    37     memcpy(m_entries.data(), entries, size);
     37    for (size_t i = 0; i < size; ++i)
     38        m_entries[i] = entries[i];
    3839}
    3940
    40 ImmutableArray::ImmutableArray(Vector<APIObject*>& entries)
     41ImmutableArray::ImmutableArray(Vector<RefPtr<APIObject> >& entries)
    4142{
    4243    m_entries.swap(entries);
     
    4546ImmutableArray::~ImmutableArray()
    4647{
    47     for (size_t i = 0; i < m_entries.size(); ++i)
    48         m_entries[i]->deref();
    4948}
    5049
  • trunk/WebKit2/Shared/ImmutableArray.h

    r66638 r66679  
    4848        return adoptRef(new ImmutableArray(entries, size));
    4949    }
    50     static PassRefPtr<ImmutableArray> adopt(Vector<APIObject*>& entries)
     50    static PassRefPtr<ImmutableArray> adopt(Vector<RefPtr<APIObject> >& entries)
    5151    {
    5252        return adoptRef(new ImmutableArray(entries));
     
    5656
    5757    template<typename T>
    58     T* at(size_t i) { if (m_entries[i]->type() != T::APIType) return 0; return static_cast<T*>(m_entries[i]); }
     58    T* at(size_t i) { if (m_entries[i]->type() != T::APIType) return 0; return static_cast<T*>(m_entries[i].get()); }
    5959
    60     APIObject* at(size_t i) { return m_entries[i]; }
     60    APIObject* at(size_t i) { return m_entries[i].get(); }
    6161    size_t size() { return m_entries.size(); }
    6262
     
    6666    ImmutableArray();
    6767    ImmutableArray(APIObject** entries, size_t size);
    68     ImmutableArray(Vector<APIObject*>& entries);
     68    ImmutableArray(Vector<RefPtr<APIObject> >& entries);
    6969
    7070    virtual Type type() const { return APIType; }
    7171
    72     Vector<APIObject*> m_entries;
     72    Vector<RefPtr<APIObject> > m_entries;
    7373};
    7474
  • trunk/WebKit2/Shared/ImmutableDictionary.cpp

    r66621 r66679  
    4949        return ImmutableArray::create();
    5050
    51     Vector<APIObject*> vector;
     51    Vector<RefPtr<APIObject> > vector;
    5252    vector.reserveInitialCapacity(m_map.size());
    5353
     
    5555    MapType::const_iterator::Keys end = m_map.end().keys();
    5656    for (; it != end; ++it)
    57         vector.uncheckedAppend(WebString::create(*it).releaseRef());
     57        vector.uncheckedAppend(WebString::create(*it));
    5858
    5959    return ImmutableArray::adopt(vector);
  • trunk/WebKit2/UIProcess/WebBackForwardList.cpp

    r66621 r66679  
    174174        return ImmutableArray::create();
    175175
    176     Vector<APIObject*> vector;
     176    Vector<RefPtr<APIObject> > vector;
    177177    vector.reserveInitialCapacity(size);
    178178
    179179    ASSERT(backListSize >= size);
    180     for (unsigned i = backListSize - size; i < backListSize; ++i) {
    181         APIObject* item = m_entries[i].get();
    182         item->ref();
    183         vector.uncheckedAppend(item);
    184     }
     180    for (unsigned i = backListSize - size; i < backListSize; ++i)
     181        vector.uncheckedAppend(m_entries[i].get());
    185182
    186183    return ImmutableArray::adopt(vector);
     
    193190        return ImmutableArray::create();
    194191
    195     Vector<APIObject*> vector;
     192    Vector<RefPtr<APIObject> > vector;
    196193    vector.reserveInitialCapacity(size);
    197194
    198195    unsigned last = m_current + size;
    199196    ASSERT(last < m_entries.size());
    200     for (unsigned i = m_current + 1; i <= last; ++i) {
    201         APIObject* item = m_entries[i].get();
    202         item->ref();
    203         vector.uncheckedAppend(item);
    204     }
     197    for (unsigned i = m_current + 1; i <= last; ++i)
     198        vector.uncheckedAppend(m_entries[i].get());
    205199
    206200    return ImmutableArray::adopt(vector);
  • trunk/WebKit2/UIProcess/WebContext.cpp

    r66621 r66679  
    110110class PostMessageDecoder {
    111111public:
    112     PostMessageDecoder(APIObject** root, WebContext* context)
     112    PostMessageDecoder(RefPtr<APIObject>& root, WebContext* context)
    113113        : m_root(root)
    114114        , m_context(context)
     
    128128                return false;
    129129           
    130             Vector<APIObject*> array;
     130            Vector<RefPtr<APIObject> > vector;
    131131            for (size_t i = 0; i < size; ++i) {
    132                 APIObject* element;
    133                 PostMessageDecoder messageCoder(&element, coder.m_context);
     132                RefPtr<APIObject> element;
     133                PostMessageDecoder messageCoder(element, coder.m_context);
    134134                if (!decoder->decode(messageCoder))
    135135                    return false;
    136                 array.append(element);
     136                vector.append(element.release());
    137137            }
    138138
    139             *(coder.m_root) = ImmutableArray::adopt(array).leakRef();
     139            coder.m_root = ImmutableArray::adopt(vector);
    140140            break;
    141141        }
     
    144144            if (!decoder->decode(string))
    145145                return false;
    146             *(coder.m_root) = WebString::create(string).leakRef();
     146            coder.m_root = WebString::create(string);
    147147            break;
    148148        }
     
    151151            if (!decoder->decode(pageID))
    152152                return false;
    153             *(coder.m_root) = coder.m_context->process()->webPage(pageID);
     153            coder.m_root = coder.m_context->process()->webPage(pageID);
    154154            break;
    155155        }
     
    162162
    163163private:
    164     APIObject** m_root;
     164    RefPtr<APIObject>& m_root;
    165165    WebContext* m_context;
    166166};
     
    407407        case WebContextMessage::PostMessage: {
    408408            String messageName;
    409             // FIXME: This should be a RefPtr<APIObject>
    410             APIObject* messageBody = 0;
    411             PostMessageDecoder messageCoder(&messageBody, this);
     409            RefPtr<APIObject> messageBody;
     410            PostMessageDecoder messageCoder(messageBody, this);
    412411            if (!arguments->decode(CoreIPC::Out(messageName, messageCoder)))
    413412                return;
    414413
    415             didReceiveMessageFromInjectedBundle(messageName, messageBody);
    416 
    417             messageBody->deref();
    418 
     414            didReceiveMessageFromInjectedBundle(messageName, messageBody.get());
    419415            return;
    420416        }
  • trunk/WebKit2/WebProcess/InjectedBundle/InjectedBundle.cpp

    r66621 r66679  
    111111class PostMessageDecoder {
    112112public:
    113     PostMessageDecoder(APIObject** root)
     113    PostMessageDecoder(RefPtr<APIObject>& root)
    114114        : m_root(root)
    115115    {
     
    128128                return false;
    129129
    130             Vector<APIObject*> vector;
     130            Vector<RefPtr<APIObject> > vector;
    131131            for (size_t i = 0; i < size; ++i) {
    132                 APIObject* element;
    133                 PostMessageDecoder messageCoder(&element);
     132                RefPtr<APIObject> element;
     133                PostMessageDecoder messageCoder(element);
    134134                if (!decoder->decode(messageCoder))
    135135                    return false;
    136                 vector.append(element);
     136                vector.append(element.release());
    137137            }
    138138
    139             *(coder.m_root) = ImmutableArray::adopt(vector).leakRef();
     139            coder.m_root = ImmutableArray::adopt(vector);
    140140            break;
    141141        }
     
    144144            if (!decoder->decode(string))
    145145                return false;
    146             *(coder.m_root) = WebString::create(string).leakRef();
     146            coder.m_root = WebString::create(string);
    147147            break;
    148148        }
     
    151151            if (!decoder->decode(pageID))
    152152                return false;
    153             *(coder.m_root) = WebProcess::shared().webPage(pageID);
     153            coder.m_root = WebProcess::shared().webPage(pageID);
    154154            break;
    155155        }
     
    162162
    163163private:
    164     APIObject** m_root;
     164    RefPtr<APIObject>& m_root;
    165165};
    166166
     
    306306    switch (messageID.get<InjectedBundleMessage::Kind>()) {
    307307        case InjectedBundleMessage::PostMessage: {
    308             String messageName;
    309             // FIXME: This should be a RefPtr<APIObject>
    310             APIObject* messageBody = 0;
    311             PostMessageDecoder messageCoder(&messageBody);
     308            String messageName;           
     309            RefPtr<APIObject> messageBody;
     310            PostMessageDecoder messageCoder(messageBody);
    312311            if (!arguments->decode(CoreIPC::Out(messageName, messageCoder)))
    313312                return;
    314313
    315             didReceiveMessage(messageName, messageBody);
    316 
    317             messageBody->deref();
    318 
     314            didReceiveMessage(messageName, messageBody.get());
    319315            return;
    320316        }
  • trunk/WebKit2/WebProcess/WebPage/WebFrame.cpp

    r66621 r66679  
    225225        return ImmutableArray::create();
    226226
    227     Vector<APIObject*> vector;
     227    Vector<RefPtr<APIObject> > vector;
    228228    vector.reserveInitialCapacity(size);
    229229
    230230    for (Frame* child = m_coreFrame->tree()->firstChild(); child; child = child->tree()->nextSibling()) {
    231231        WebFrame* webFrame = static_cast<WebFrameLoaderClient*>(child->loader()->client())->webFrame();
    232         webFrame->ref();
    233232        vector.uncheckedAppend(webFrame);
    234233    }
Note: See TracChangeset for help on using the changeset viewer.