Changeset 89283 in webkit


Ignore:
Timestamp:
Jun 20, 2011 1:21:56 PM (13 years ago)
Author:
andersca@apple.com
Message:

2011-06-18 Anders Carlsson <​andersca@apple.com>

Reviewed by Darin Adler.

Disallow assigning into PassOwnArrayPtr, PassOwnPtr and PassRefPtr
​https://bugs.webkit.org/show_bug.cgi?id=62940

Remove clear() and all assignment operators except one which now has a COMPILE_ASSERT.

  • wtf/PassOwnArrayPtr.h: (WTF::PassOwnArrayPtr::operator=):
  • wtf/PassOwnPtr.h: (WTF::PassOwnPtr::operator=):
  • wtf/PassRefPtr.h: (WTF::PassRefPtr::operator=): (WTF::NonNullPassRefPtr::operator=):

2011-06-18 Anders Carlsson <​andersca@apple.com>

Reviewed by Darin Adler.

Disallow assigning into PassOwnArrayPtr, PassOwnPtr and PassRefPtr
​https://bugs.webkit.org/show_bug.cgi?id=62940

Make sure that we never assign into any already existing PassRefPtr.

  • accessibility/AccessibilityMediaControls.cpp: (WebCore::AccessibilityMediaControl::create): Remove local PassRefPtr variable.
  • dom/Document.cpp: (WebCore::Document::setBody): Rename the PassRefPtr parameter and create a RefPtr variable.

(WebCore::Document::setFocusedNode):
Ditto.

  • editing/ApplyStyleCommand.cpp: (WebCore::ApplyStyleCommand::removeInlineStyle): There's no reason to use a PassRefPtr here. Use a RefPtr, and don't initialize it since it's implicitly initialized.
  • editing/CompositeEditCommand.cpp: (WebCore::CompositeEditCommand::prune): Rename the PassRefPtr parameter and create a RefPtr variable.
  • editing/ReplaceSelectionCommand.cpp: (WebCore::ReplaceSelectionCommand::insertAsListItems): Ditto.
  • editing/htmlediting.cpp: (WebCore::createTabSpanElement): Ditto.
  • html/canvas/CanvasRenderingContext2D.cpp: (WebCore::CanvasRenderingContext2D::setStrokeStyle): (WebCore::CanvasRenderingContext2D::setFillStyle): Ditto.
  • platform/network/mac/FormDataStreamMac.mm: (WebCore::formFinalize): Ditto.

(WebCore::setHTTPBody):
Use an OwnPtr instead of explicitly deleting the form variable.

Location:
trunk/Source
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r89281 r89283  
     12011-06-18  Anders Carlsson  <andersca@apple.com>
     2
     3        Reviewed by Darin Adler.
     4
     5        Disallow assigning into PassOwnArrayPtr, PassOwnPtr and PassRefPtr
     6        https://bugs.webkit.org/show_bug.cgi?id=62940
     7
     8        Remove clear() and all assignment operators except one which now has a COMPILE_ASSERT.
     9
     10        * wtf/PassOwnArrayPtr.h:
     11        (WTF::PassOwnArrayPtr::operator=):
     12        * wtf/PassOwnPtr.h:
     13        (WTF::PassOwnPtr::operator=):
     14        * wtf/PassRefPtr.h:
     15        (WTF::PassRefPtr::operator=):
     16        (WTF::NonNullPassRefPtr::operator=):
     17
     18<<<<<<< .mine
     192011-06-20  Anders Carlsson  <andersca@apple.com>
     20
     21        Reviewed by Darin Adler.
     22
     23        Disallow assigning into PassOwnArrayPtr, PassOwnPtr and PassRefPtr
     24        https://bugs.webkit.org/show_bug.cgi?id=62940
     25
     26        Remove clear() and all assignment operators except one which now has a COMPILE_ASSERT.
     27
     28        * wtf/PassOwnArrayPtr.h:
     29        (WTF::PassOwnArrayPtr::operator=):
     30        * wtf/PassOwnPtr.h:
     31        (WTF::PassOwnPtr::operator=):
     32        * wtf/PassRefPtr.h:
     33        (WTF::PassRefPtr::operator=):
     34        (WTF::NonNullPassRefPtr::operator=):
     35
     36=======
    1372011-06-20  Oliver Hunt  <oliver@apple.com>
    238
    … …  
    1349        (WTF::parseDateFromNullTerminatedCharacters):
    1450
     51>>>>>>> .r89282
    15522011-06-20  Juan C. Montemayor  <jmont@apple.com>
    1653

  • trunk/Source/JavaScriptCore/wtf/PassOwnArrayPtr.h

    r88988 r89283  
    5555    PtrType get() const { return m_ptr; }
    5656
    57     void clear();
    5857    PtrType leakPtr() const WARN_UNUSED_RETURN;
    5958
    … …  
    7170#endif
    7271
    73     PassOwnArrayPtr& operator=(const PassOwnArrayPtr<T>&);
    74     PassOwnArrayPtr& operator=(std::nullptr_t) { clear(); return *this; }
    75     template<typename U> PassOwnArrayPtr& operator=(const PassOwnArrayPtr<U>&);
     72    PassOwnArrayPtr& operator=(const PassOwnArrayPtr&) { COMPILE_ASSERT(!sizeof(T*), PassOwnArrayPtr_should_never_be_assigned_to); return *this; }
    7673
    7774    template<typename U> friend PassOwnArrayPtr<U> adoptArrayPtr(U*);
    … …  
    8380};
    8481
    85 template<typename T> inline void PassOwnArrayPtr<T>::clear()
    86 {
    87     PtrType ptr = m_ptr;
    88     m_ptr = 0;
    89     deleteOwnedArrayPtr(ptr);
    90 }
    91 
    9282template<typename T> inline typename PassOwnArrayPtr<T>::PtrType PassOwnArrayPtr<T>::leakPtr() const
    9383{
    … …  
    9585    m_ptr = 0;
    9686    return ptr;
    97 }
    98 
    99 template<typename T> inline PassOwnArrayPtr<T>& PassOwnArrayPtr<T>::operator=(const PassOwnArrayPtr<T>& optr)
    100 {
    101     PtrType ptr = m_ptr;
    102     m_ptr = optr.leakPtr();
    103     ASSERT(!ptr || m_ptr != ptr);
    104     if (ptr)
    105         deleteOwnedArrayPtr(ptr);
    106     return *this;
    107 }
    108 
    109 template<typename T> template<typename U> inline PassOwnArrayPtr<T>& PassOwnArrayPtr<T>::operator=(const PassOwnArrayPtr<U>& optr)
    110 {
    111     PtrType ptr = m_ptr;
    112     m_ptr = optr.leakPtr();
    113     ASSERT(!ptr || m_ptr != ptr);
    114     if (ptr)
    115         deleteOwnedArrayPtr(ptr);
    116     return *this;
    11787}
    11888

  • trunk/Source/JavaScriptCore/wtf/PassOwnPtr.h

    r88988 r89283  
    5858        PtrType get() const { return m_ptr; }
    5959
    60         void clear();
    6160        PtrType leakPtr() const WARN_UNUSED_RETURN;
    6261
    … …  
    7069        operator UnspecifiedBoolType() const { return m_ptr ? &PassOwnPtr::m_ptr : 0; }
    7170
    72         PassOwnPtr& operator=(const PassOwnPtr<T>&);
    73         PassOwnPtr& operator=(std::nullptr_t) { clear(); return *this; }
    74         template<typename U> PassOwnPtr& operator=(const PassOwnPtr<U>&);
     71        PassOwnPtr& operator=(const PassOwnPtr&) { COMPILE_ASSERT(!sizeof(T*), PassOwnPtr_should_never_be_assigned_to); return *this; }
    7572
    7673        template<typename U> friend PassOwnPtr<U> adoptPtr(U*);
    … …  
    8986    };
    9087
    91     template<typename T> inline void PassOwnPtr<T>::clear()
    92     {
    93         PtrType ptr = m_ptr;
    94         m_ptr = 0;
    95         deleteOwnedPtr(ptr);
    96     }
    97 
    9888    template<typename T> inline typename PassOwnPtr<T>::PtrType PassOwnPtr<T>::leakPtr() const
    9989    {
    … …  
    10191        m_ptr = 0;
    10292        return ptr;
    103     }
    104 
    105     template<typename T> inline PassOwnPtr<T>& PassOwnPtr<T>::operator=(const PassOwnPtr<T>& optr)
    106     {
    107         PtrType ptr = m_ptr;
    108         m_ptr = optr.leakPtr();
    109         ASSERT(!ptr || m_ptr != ptr);
    110         if (ptr)
    111             deleteOwnedPtr(ptr);
    112         return *this;
    113     }
    114 
    115     template<typename T> template<typename U> inline PassOwnPtr<T>& PassOwnPtr<T>::operator=(const PassOwnPtr<U>& optr)
    116     {
    117         PtrType ptr = m_ptr;
    118         m_ptr = optr.leakPtr();
    119         ASSERT(!ptr || m_ptr != ptr);
    120         if (ptr)
    121             deleteOwnedPtr(ptr);
    122         return *this;
    12393    }
    12494

  • trunk/Source/JavaScriptCore/wtf/PassRefPtr.h

    r74695 r89283  
    7878        T* get() const { return m_ptr; }
    7979
    80         void clear();
    8180        T* leakRef() const WARN_UNUSED_RETURN;
    8281
    … …  
    9089        operator UnspecifiedBoolType() const { return m_ptr ? &PassRefPtr::m_ptr : 0; }
    9190
    92         PassRefPtr& operator=(T*);
    93         PassRefPtr& operator=(const PassRefPtr&);
    94 #if !HAVE(NULLPTR)
    95         PassRefPtr& operator=(std::nullptr_t) { clear(); return *this; }
    96 #endif
    97         template<typename U> PassRefPtr& operator=(const PassRefPtr<U>&);
    98         template<typename U> PassRefPtr& operator=(const RefPtr<U>&);
     91        PassRefPtr& operator=(const PassRefPtr&) { COMPILE_ASSERT(!sizeof(T*), PassRefPtr_should_never_be_assigned_to); return *this; }
    9992
    10093        friend PassRefPtr adoptRef<T>(T*);
    … …  
    156149        T* get() const { return m_ptr; }
    157150
    158         void clear();
    159151        T* leakRef() const WARN_UNUSED_RETURN { T* tmp = m_ptr; m_ptr = 0; return tmp; }
    160152
    161153        T& operator*() const { return *m_ptr; }
    162154        T* operator->() const { return m_ptr; }
     155
     156        NonNullPassRefPtr& operator=(const NonNullPassRefPtr&) { COMPILE_ASSERT(!sizeof(T*), NonNullPassRefPtr_should_never_be_assigned_to); return *this; }
    163157
    164158        // FIXME: Remove releaseRef once we change all callers to call leakRef instead.
    … …  
    176170    }
    177171
    178     template<typename T> inline void PassRefPtr<T>::clear()
    179     {
    180         T* ptr = m_ptr;
    181         m_ptr = 0;
    182         derefIfNotNull(ptr);
    183     }
    184 
    185172    template<typename T> inline T* PassRefPtr<T>::leakRef() const
    186173    {
    … …  
    190177    }
    191178
    192     template<typename T> template<typename U> inline PassRefPtr<T>& PassRefPtr<T>::operator=(const RefPtr<U>& o)
    193     {
    194         T* optr = o.get();
    195         refIfNotNull(optr);
    196         T* ptr = m_ptr;
    197         m_ptr = optr;
    198         derefIfNotNull(ptr);
    199         return *this;
    200     }
    201    
    202     template<typename T> inline PassRefPtr<T>& PassRefPtr<T>::operator=(T* optr)
    203     {
    204         refIfNotNull(optr);
    205         T* ptr = m_ptr;
    206         m_ptr = optr;
    207         derefIfNotNull(ptr);
    208         return *this;
    209     }
    210 
    211     template<typename T> inline PassRefPtr<T>& PassRefPtr<T>::operator=(const PassRefPtr<T>& ref)
    212     {
    213         T* ptr = m_ptr;
    214         m_ptr = ref.leakRef();
    215         derefIfNotNull(ptr);
    216         return *this;
    217     }
    218    
    219     template<typename T> template<typename U> inline PassRefPtr<T>& PassRefPtr<T>::operator=(const PassRefPtr<U>& ref)
    220     {
    221         T* ptr = m_ptr;
    222         m_ptr = ref.leakRef();
    223         derefIfNotNull(ptr);
    224         return *this;
    225     }
    226    
    227179    template<typename T, typename U> inline bool operator==(const PassRefPtr<T>& a, const PassRefPtr<U>& b)
    228180    {
    … …  
    294246    {
    295247        return p.get();
    296     }
    297 
    298     template<typename T> inline void NonNullPassRefPtr<T>::clear()
    299     {
    300         T* ptr = m_ptr;
    301         m_ptr = 0;
    302         derefIfNotNull(ptr);
    303248    }
    304249

  • trunk/Source/WebCore/ChangeLog

    r89273 r89283  
     12011-06-18  Anders Carlsson  <andersca@apple.com>
     2
     3        Reviewed by Darin Adler.
     4
     5        Disallow assigning into PassOwnArrayPtr, PassOwnPtr and PassRefPtr
     6        https://bugs.webkit.org/show_bug.cgi?id=62940
     7
     8        Make sure that we never assign into any already existing PassRefPtr.
     9
     10        * accessibility/AccessibilityMediaControls.cpp:
     11        (WebCore::AccessibilityMediaControl::create):
     12        Remove local PassRefPtr variable.
     13
     14        * dom/Document.cpp:
     15        (WebCore::Document::setBody):
     16        Rename the PassRefPtr parameter and create a RefPtr variable.
     17
     18        (WebCore::Document::setFocusedNode):
     19        Ditto.
     20
     21        * editing/ApplyStyleCommand.cpp:
     22        (WebCore::ApplyStyleCommand::removeInlineStyle):
     23        There's no reason to use a PassRefPtr here. Use a RefPtr, and don't initialize it since it's implicitly initialized.
     24
     25        * editing/CompositeEditCommand.cpp:
     26        (WebCore::CompositeEditCommand::prune):
     27        Rename the PassRefPtr parameter and create a RefPtr variable.
     28
     29        * editing/ReplaceSelectionCommand.cpp:
     30        (WebCore::ReplaceSelectionCommand::insertAsListItems):
     31        Ditto.
     32
     33        * editing/htmlediting.cpp:
     34        (WebCore::createTabSpanElement):
     35        Ditto.
     36
     37        * html/canvas/CanvasRenderingContext2D.cpp:
     38        (WebCore::CanvasRenderingContext2D::setStrokeStyle):
     39        (WebCore::CanvasRenderingContext2D::setFillStyle):
     40        Ditto.
     41
     42        * platform/network/mac/FormDataStreamMac.mm:
     43        (WebCore::formFinalize):
     44        Ditto.
     45
     46        (WebCore::setHTTPBody):
     47        Use an OwnPtr instead of explicitly deleting the form variable.
     48
     49<<<<<<< .mine
     502011-06-20  Anders Carlsson  <andersca@apple.com>
     51
     52        Reviewed by Darin Adler.
     53
     54        Disallow assigning into PassOwnArrayPtr, PassOwnPtr and PassRefPtr
     55        https://bugs.webkit.org/show_bug.cgi?id=62940
     56
     57        Make sure that we never assign into any already existing PassRefPtr.
     58
     59        * accessibility/AccessibilityMediaControls.cpp:
     60        (WebCore::AccessibilityMediaControl::create):
     61        Remove local PassRefPtr variable.
     62
     63        * dom/Document.cpp:
     64        (WebCore::Document::setBody):
     65        Rename the PassRefPtr parameter and create a RefPtr variable.
     66
     67        (WebCore::Document::setFocusedNode):
     68        Ditto.
     69
     70        * editing/ApplyStyleCommand.cpp:
     71        (WebCore::ApplyStyleCommand::removeInlineStyle):
     72        There's no reason to use a PassRefPtr here. Use a RefPtr, and don't initialize it since it's implicitly initialized.
     73
     74        * editing/CompositeEditCommand.cpp:
     75        (WebCore::CompositeEditCommand::prune):
     76        Rename the PassRefPtr parameter and create a RefPtr variable.
     77
     78        * editing/ReplaceSelectionCommand.cpp:
     79        (WebCore::ReplaceSelectionCommand::insertAsListItems):
     80        Ditto.
     81
     82        * editing/htmlediting.cpp:
     83        (WebCore::createTabSpanElement):
     84        Ditto.
     85
     86        * html/canvas/CanvasRenderingContext2D.cpp:
     87        (WebCore::CanvasRenderingContext2D::setStrokeStyle):
     88        (WebCore::CanvasRenderingContext2D::setFillStyle):
     89        Ditto.
     90
     91        * platform/network/mac/FormDataStreamMac.mm:
     92        (WebCore::formFinalize):
     93        Ditto.
     94
     95        (WebCore::setHTTPBody):
     96        Use an OwnPtr instead of explicitly deleting the form variable.
     97
     98=======
    1992011-06-20  Alex Milowski  <alex@milowski.com>
    2100
    … …  
    71169        (-[WebWindowFadeAnimation initWithDuration:window:initialAlpha:finalAlpha:]):
    72170
     171>>>>>>> .r89282
    731722011-06-20  Mark Pilgrim  <pilgrim@chromium.org>
    74173

  • trunk/Source/WebCore/accessibility/AccessibilityMediaControls.cpp

    r57093 r89283  
    6464        controlType = static_cast<MediaControlElement*>(node)->displayType();
    6565
    66     PassRefPtr<AccessibilityObject> obj;
    6766    switch (controlType) {
    6867    case MediaSlider:
    69         obj = AccessibilityMediaTimeline::create(renderer);
    70         break;
     68        return AccessibilityMediaTimeline::create(renderer);
    7169
    7270    case MediaCurrentTimeDisplay:
    7371    case MediaTimeRemainingDisplay:
    74         obj = AccessibilityMediaTimeDisplay::create(renderer);
    75         break;
     72        return AccessibilityMediaTimeDisplay::create(renderer);
    7673
    7774    case MediaControlsPanel:
    78         obj = AccessibilityMediaControlsContainer::create(renderer);
    79         break;
     75        return AccessibilityMediaControlsContainer::create(renderer);
    8076
    8177    default:
    82         obj = adoptRef(new AccessibilityMediaControl(renderer));
    83         break;
     78        return adoptRef(new AccessibilityMediaControl(renderer));
    8479    }
    85 
    86     return obj;
    8780}
    8881

  • trunk/Source/WebCore/dom/Document.cpp

    r89212 r89283  
    20142014}
    20152015
    2016 void Document::setBody(PassRefPtr<HTMLElement> newBody, ExceptionCode& ec)
    2017 {
     2016void Document::setBody(PassRefPtr<HTMLElement> prpNewBody, ExceptionCode& ec)
     2017{
     2018    RefPtr<HTMLElement> newBody = prpNewBody;
     2019
    20182020    if (!newBody || !documentElement() || !newBody->hasTagName(bodyTag)) {
    20192021        ec = HIERARCHY_REQUEST_ERR;
    … …  
    20322034    HTMLElement* b = body();
    20332035    if (!b)
    2034         documentElement()->appendChild(newBody, ec);
     2036        documentElement()->appendChild(newBody.release(), ec);
    20352037    else
    2036         documentElement()->replaceChild(newBody, b, ec);
     2038        documentElement()->replaceChild(newBody.release(), b, ec);
    20372039}
    20382040
    … …  
    30693071#endif
    30703072
    3071 bool Document::setFocusedNode(PassRefPtr<Node> newFocusedNode)
    3072 {   
     3073bool Document::setFocusedNode(PassRefPtr<Node> prpNewFocusedNode)
     3074{
     3075    RefPtr<Node> newFocusedNode = prpNewFocusedNode;
     3076
    30733077    // Make sure newFocusedNode is actually in this document
    30743078    if (newFocusedNode && (newFocusedNode->document() != this))
    … …  
    31433147        }
    31443148        // Set focus on the new node
    3145         m_focusedNode = newFocusedNode.get();
     3149        m_focusedNode = newFocusedNode;
    31463150
    31473151        // Dispatch the focus event and let the node do any other focus related activities (important for text fields)

  • trunk/Source/WebCore/editing/ApplyStyleCommand.cpp

    r87952 r89283  
    10591059            RefPtr<Node> next = elem->traverseNextNode();
    10601060            RefPtr<EditingStyle> styleToPushDown;
    1061             PassRefPtr<Node> childNode = 0;
     1061            RefPtr<Node> childNode;
    10621062            if (isStyledInlineElementToRemove(elem.get())) {
    10631063                styleToPushDown = EditingStyle::create();

  • trunk/Source/WebCore/editing/CompositeEditCommand.cpp

    r89224 r89283  
    248248}
    249249
    250 void CompositeEditCommand::prune(PassRefPtr<Node> node)
    251 {
     250void CompositeEditCommand::prune(PassRefPtr<Node> prpNode)
     251{
     252    RefPtr<Node> node = prpNode;
     253
    252254    while (node) {
    253255        // If you change this rule you may have to add an updateLayout() here.

  • trunk/Source/WebCore/editing/ReplaceSelectionCommand.cpp

    r87937 r89283  
    12361236// If the user is inserting a list into an existing list, instead of nesting the list,
    12371237// we put the list items into the existing list.
    1238 Node* ReplaceSelectionCommand::insertAsListItems(PassRefPtr<Node> listElement, Node* insertionBlock, const Position& insertPos)
    1239 {
     1238Node* ReplaceSelectionCommand::insertAsListItems(PassRefPtr<Node> prpListElement, Node* insertionBlock, const Position& insertPos)
     1239{
     1240    RefPtr<Node> listElement = prpListElement;
     1241
    12401242    while (listElement->hasChildNodes() && isListElement(listElement->firstChild()) && listElement->childNodeCount() == 1)
    12411243        listElement = listElement->firstChild();

  • trunk/Source/WebCore/editing/htmlediting.cpp

    r88476 r89283  
    883883}
    884884
    885 PassRefPtr<Element> createTabSpanElement(Document* document, PassRefPtr<Node> tabTextNode)
    886 {
     885PassRefPtr<Element> createTabSpanElement(Document* document, PassRefPtr<Node> prpTabTextNode)
     886{
     887    RefPtr<Node> tabTextNode = prpTabTextNode;
     888
    887889    // Make the span to hold the tab.
    888890    RefPtr<Element> spanElement = document->createElement(spanTag, false);
    … …  
    895897
    896898    ExceptionCode ec = 0;
    897     spanElement->appendChild(tabTextNode, ec);
     899    spanElement->appendChild(tabTextNode.release(), ec);
    898900    ASSERT(ec == 0);
    899901

  • trunk/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp

    r88896 r89283  
    367367}
    368368
    369 void CanvasRenderingContext2D::setStrokeStyle(PassRefPtr<CanvasStyle> style)
    370 {
     369void CanvasRenderingContext2D::setStrokeStyle(PassRefPtr<CanvasStyle> prpStyle)
     370{
     371    RefPtr<CanvasStyle> style = prpStyle;
     372
    371373    if (!style)
    372374        return;
    … …  
    383385        checkOrigin(style->canvasPattern());
    384386
    385     state().m_strokeStyle = style;
     387    state().m_strokeStyle = style.release();
    386388    GraphicsContext* c = drawingContext();
    387389    if (!c)
    … …  
    396398}
    397399
    398 void CanvasRenderingContext2D::setFillStyle(PassRefPtr<CanvasStyle> style)
    399 {
     400void CanvasRenderingContext2D::setFillStyle(PassRefPtr<CanvasStyle> prpStyle)
     401{
     402    RefPtr<CanvasStyle> style = prpStyle;
     403
    400404    if (!style)
    401405        return;
    … …  
    412416        checkOrigin(style->canvasPattern());
    413417
    414     state().m_fillStyle = style;
     418    state().m_fillStyle = style.release();
    415419    GraphicsContext* c = drawingContext();
    416420    if (!c)

  • trunk/Source/WebCore/platform/network/mac/FormDataStreamMac.mm

    r81452 r89283  
    255255static void formFinalize(CFReadStreamRef stream, void* context)
    256256{
    257     FormStreamFields* form = static_cast<FormStreamFields*>(context);
     257    OwnPtr<FormStreamFields> form = adoptPtr(static_cast<FormStreamFields*>(context));
    258258
    259259    getStreamFormDataMap().remove(stream);
    260260
    261     closeCurrentStream(form);
    262     delete form;
     261    closeCurrentStream(form.get());
    263262}
    264263
    … …  
    384383}
    385384
    386 void setHTTPBody(NSMutableURLRequest *request, PassRefPtr<FormData> formData)
    387 {
     385void setHTTPBody(NSMutableURLRequest *request, PassRefPtr<FormData> prpFormData)
     386{
     387    RefPtr<FormData> formData = prpFormData;
     388
    388389    if (!formData)
    389390        return;
    … …  
    440441            }
    441442        }
    442         formData = newFormData;
     443        formData = newFormData.release();
    443444        count = formData->elements().size();
    444445    }
    … …  
    471472
    472473    // Pass the length along with the formData so it does not have to be recomputed.
    473     FormContext formContext = { formData.releaseRef(), length };
     474    FormContext formContext = { formData.release().leakRef(), length };
    474475
    475476    RetainPtr<CFReadStreamRef> stream(AdoptCF, wkCreateCustomCFReadStream(formCreate, formFinalize,
Note: See TracChangeset for help on using the changeset viewer.