LCOV - code coverage report
Current view: directory - content/base/src - nsDOMAttributeMap.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 218 119 54.6 %
Date: 2012-06-02 Functions: 34 22 64.7 %

       1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
       2                 : /* ***** BEGIN LICENSE BLOCK *****
       3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
       4                 :  *
       5                 :  * The contents of this file are subject to the Mozilla Public License Version
       6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
       7                 :  * the License. You may obtain a copy of the License at
       8                 :  * http://www.mozilla.org/MPL/
       9                 :  *
      10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
      11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
      12                 :  * for the specific language governing rights and limitations under the
      13                 :  * License.
      14                 :  *
      15                 :  * The Original Code is Mozilla Communicator client code.
      16                 :  *
      17                 :  * The Initial Developer of the Original Code is
      18                 :  * Netscape Communications Corporation.
      19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
      20                 :  * the Initial Developer. All Rights Reserved.
      21                 :  *
      22                 :  * Contributor(s):
      23                 :  *   Allan Beaufour <allan@beaufour.dk>
      24                 :  *
      25                 :  * Alternatively, the contents of this file may be used under the terms of
      26                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
      27                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
      28                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
      29                 :  * of those above. If you wish to allow use of your version of this file only
      30                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
      31                 :  * use your version of this file under the terms of the MPL, indicate your
      32                 :  * decision by deleting the provisions above and replace them with the notice
      33                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
      34                 :  * the provisions above, a recipient may use your version of this file under
      35                 :  * the terms of any one of the MPL, the GPL or the LGPL.
      36                 :  *
      37                 :  * ***** END LICENSE BLOCK ***** */
      38                 : 
      39                 : /*
      40                 :  * Implementation of the |attributes| property of DOM Core's nsIDOMNode object.
      41                 :  */
      42                 : 
      43                 : #include "nsDOMAttributeMap.h"
      44                 : #include "nsDOMAttribute.h"
      45                 : #include "nsIDOMDocument.h"
      46                 : #include "nsGenericElement.h"
      47                 : #include "nsIContent.h"
      48                 : #include "nsIDocument.h"
      49                 : #include "nsINameSpaceManager.h"
      50                 : #include "nsDOMError.h"
      51                 : #include "nsContentUtils.h"
      52                 : #include "nsNodeInfoManager.h"
      53                 : #include "nsAttrName.h"
      54                 : #include "nsUnicharUtils.h"
      55                 : 
      56                 : //----------------------------------------------------------------------
      57                 : 
      58             232 : nsDOMAttributeMap::nsDOMAttributeMap(Element* aContent)
      59             232 :   : mContent(aContent)
      60                 : {
      61                 :   // We don't add a reference to our content. If it goes away,
      62                 :   // we'll be told to drop our reference
      63             232 : }
      64                 : 
      65                 : bool
      66             232 : nsDOMAttributeMap::Init()
      67                 : {
      68             232 :   return mAttributeCache.Init();
      69                 : }
      70                 : 
      71                 : /**
      72                 :  * Clear map pointer for attributes.
      73                 :  */
      74                 : PLDHashOperator
      75             945 : RemoveMapRef(nsAttrHashKey::KeyType aKey, nsRefPtr<nsDOMAttribute>& aData,
      76                 :              void* aUserArg)
      77                 : {
      78             945 :   aData->SetMap(nsnull);
      79                 : 
      80             945 :   return PL_DHASH_REMOVE;
      81                 : }
      82                 : 
      83             696 : nsDOMAttributeMap::~nsDOMAttributeMap()
      84                 : {
      85             232 :   mAttributeCache.Enumerate(RemoveMapRef, nsnull);
      86             928 : }
      87                 : 
      88                 : void
      89             464 : nsDOMAttributeMap::DropReference()
      90                 : {
      91             464 :   mAttributeCache.Enumerate(RemoveMapRef, nsnull);
      92             464 :   mContent = nsnull;
      93             464 : }
      94                 : 
      95            1464 : NS_IMPL_CYCLE_COLLECTION_CLASS(nsDOMAttributeMap)
      96                 : 
      97             232 : NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsDOMAttributeMap)
      98             232 :   tmp->DropReference();
      99             232 : NS_IMPL_CYCLE_COLLECTION_UNLINK_END
     100                 : 
     101                 : 
     102                 : PLDHashOperator
     103             945 : TraverseMapEntry(nsAttrHashKey::KeyType aKey, nsRefPtr<nsDOMAttribute>& aData,
     104                 :                  void* aUserArg)
     105                 : {
     106                 :   nsCycleCollectionTraversalCallback *cb = 
     107             945 :     static_cast<nsCycleCollectionTraversalCallback*>(aUserArg);
     108                 : 
     109             945 :   cb->NoteXPCOMChild(static_cast<nsINode*>(aData.get()));
     110                 : 
     111             945 :   return PL_DHASH_NEXT;
     112                 : }
     113                 : 
     114             232 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsDOMAttributeMap)
     115             232 :   tmp->mAttributeCache.Enumerate(TraverseMapEntry, &cb);
     116             232 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
     117                 : 
     118                 : DOMCI_DATA(NamedNodeMap, nsDOMAttributeMap)
     119                 : 
     120                 : // QueryInterface implementation for nsDOMAttributeMap
     121           14366 : NS_INTERFACE_TABLE_HEAD(nsDOMAttributeMap)
     122                 :   NS_OFFSET_AND_INTERFACE_TABLE_BEGIN(nsDOMAttributeMap)
     123                 :     NS_INTERFACE_TABLE_ENTRY(nsDOMAttributeMap, nsIDOMNamedNodeMap)
     124           14366 :   NS_OFFSET_AND_INTERFACE_TABLE_END
     125           12252 :   NS_OFFSET_AND_INTERFACE_TABLE_TO_MAP_SEGUE
     126            8222 :   NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(nsDOMAttributeMap)
     127            2594 :   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(NamedNodeMap)
     128            2362 : NS_INTERFACE_MAP_END
     129                 : 
     130            6394 : NS_IMPL_CYCLE_COLLECTING_ADDREF(nsDOMAttributeMap)
     131            6394 : NS_IMPL_CYCLE_COLLECTING_RELEASE(nsDOMAttributeMap)
     132                 : 
     133                 : PLDHashOperator
     134               0 : SetOwnerDocumentFunc(nsAttrHashKey::KeyType aKey,
     135                 :                      nsRefPtr<nsDOMAttribute>& aData,
     136                 :                      void* aUserArg)
     137                 : {
     138               0 :   nsresult rv = aData->SetOwnerDocument(static_cast<nsIDocument*>(aUserArg));
     139                 : 
     140               0 :   return NS_FAILED(rv) ? PL_DHASH_STOP : PL_DHASH_NEXT;
     141                 : }
     142                 : 
     143                 : nsresult
     144               0 : nsDOMAttributeMap::SetOwnerDocument(nsIDocument* aDocument)
     145                 : {
     146               0 :   PRUint32 n = mAttributeCache.Enumerate(SetOwnerDocumentFunc, aDocument);
     147               0 :   NS_ENSURE_TRUE(n == mAttributeCache.Count(), NS_ERROR_FAILURE);
     148                 : 
     149               0 :   return NS_OK;
     150                 : }
     151                 : 
     152                 : void
     153               0 : nsDOMAttributeMap::DropAttribute(PRInt32 aNamespaceID, nsIAtom* aLocalName)
     154                 : {
     155               0 :   nsAttrKey attr(aNamespaceID, aLocalName);
     156               0 :   nsDOMAttribute *node = mAttributeCache.GetWeak(attr);
     157               0 :   if (node) {
     158                 :     // Break link to map
     159               0 :     node->SetMap(nsnull);
     160                 : 
     161                 :     // Remove from cache
     162               0 :     mAttributeCache.Remove(attr);
     163                 :   }
     164               0 : }
     165                 : 
     166                 : nsresult
     167               0 : nsDOMAttributeMap::RemoveAttribute(nsINodeInfo* aNodeInfo, nsIDOMNode** aReturn)
     168                 : {
     169               0 :   NS_ASSERTION(aNodeInfo, "RemoveAttribute() called with aNodeInfo == nsnull!");
     170               0 :   NS_ASSERTION(aReturn, "RemoveAttribute() called with aReturn == nsnull");
     171                 : 
     172               0 :   *aReturn = nsnull;
     173                 : 
     174               0 :   nsAttrKey attr(aNodeInfo->NamespaceID(), aNodeInfo->NameAtom());
     175                 : 
     176               0 :   nsRefPtr<nsDOMAttribute> node;
     177               0 :   if (!mAttributeCache.Get(attr, getter_AddRefs(node))) {
     178               0 :     nsAutoString value;
     179                 :     // As we are removing the attribute we need to set the current value in
     180                 :     // the attribute node.
     181               0 :     mContent->GetAttr(aNodeInfo->NamespaceID(), aNodeInfo->NameAtom(), value);
     182               0 :     nsCOMPtr<nsINodeInfo> ni = aNodeInfo;
     183                 :     nsCOMPtr<nsIDOMNode> newAttr =
     184               0 :       new nsDOMAttribute(nsnull, ni.forget(), value, true);
     185               0 :     if (!newAttr) {
     186               0 :       return NS_ERROR_OUT_OF_MEMORY;
     187                 :     }
     188               0 :     newAttr.swap(*aReturn);
     189                 :   }
     190                 :   else {
     191                 :     // Break link to map
     192               0 :     node->SetMap(nsnull);
     193                 : 
     194                 :     // Remove from cache
     195               0 :     mAttributeCache.Remove(attr);
     196                 : 
     197               0 :     node.forget(aReturn);
     198                 :   }
     199                 : 
     200               0 :   return NS_OK;
     201                 : }
     202                 : 
     203                 : nsDOMAttribute*
     204             977 : nsDOMAttributeMap::GetAttribute(nsINodeInfo* aNodeInfo, bool aNsAware)
     205                 : {
     206             977 :   NS_ASSERTION(aNodeInfo, "GetAttribute() called with aNodeInfo == nsnull!");
     207                 : 
     208             977 :   nsAttrKey attr(aNodeInfo->NamespaceID(), aNodeInfo->NameAtom());
     209                 : 
     210             977 :   nsDOMAttribute* node = mAttributeCache.GetWeak(attr);
     211             977 :   if (!node) {
     212            1886 :     nsCOMPtr<nsINodeInfo> ni = aNodeInfo;
     213                 :     nsRefPtr<nsDOMAttribute> newAttr =
     214            2829 :       new nsDOMAttribute(this, ni.forget(), EmptyString(), aNsAware);
     215             943 :     if (newAttr && mAttributeCache.Put(attr, newAttr)) {
     216             943 :       node = newAttr;
     217                 :     }
     218                 :   }
     219                 : 
     220             977 :   return node;
     221                 : }
     222                 : 
     223                 : nsDOMAttribute*
     224               0 : nsDOMAttributeMap::GetNamedItem(const nsAString& aAttrName, nsresult *aResult)
     225                 : {
     226               0 :   *aResult = NS_OK;
     227                 : 
     228               0 :   if (mContent) {
     229                 :     nsCOMPtr<nsINodeInfo> ni =
     230               0 :       mContent->GetExistingAttrNameFromQName(aAttrName);
     231               0 :     if (ni) {
     232               0 :       return GetAttribute(ni, false);
     233                 :     }
     234                 :   }
     235                 : 
     236               0 :   return nsnull;
     237                 : }
     238                 : 
     239                 : NS_IMETHODIMP
     240               0 : nsDOMAttributeMap::GetNamedItem(const nsAString& aAttrName,
     241                 :                                 nsIDOMNode** aAttribute)
     242                 : {
     243               0 :   NS_ENSURE_ARG_POINTER(aAttribute);
     244                 : 
     245                 :   nsresult rv;
     246               0 :   NS_IF_ADDREF(*aAttribute = GetNamedItem(aAttrName, &rv));
     247                 : 
     248               0 :   return rv;
     249                 : }
     250                 : 
     251                 : NS_IMETHODIMP
     252               2 : nsDOMAttributeMap::SetNamedItem(nsIDOMNode *aNode, nsIDOMNode **aReturn)
     253                 : {
     254               2 :   return SetNamedItemInternal(aNode, aReturn, false);
     255                 : }
     256                 : 
     257                 : NS_IMETHODIMP
     258               0 : nsDOMAttributeMap::SetNamedItemNS(nsIDOMNode *aNode, nsIDOMNode **aReturn)
     259                 : {
     260               0 :   return SetNamedItemInternal(aNode, aReturn, true);
     261                 : }
     262                 : 
     263                 : nsresult
     264               2 : nsDOMAttributeMap::SetNamedItemInternal(nsIDOMNode *aNode,
     265                 :                                         nsIDOMNode **aReturn,
     266                 :                                         bool aWithNS)
     267                 : {
     268               2 :   NS_ENSURE_ARG_POINTER(aNode);
     269               2 :   NS_ENSURE_ARG_POINTER(aReturn);
     270                 : 
     271               2 :   nsresult rv = NS_OK;
     272               2 :   *aReturn = nsnull;
     273               4 :   nsCOMPtr<nsIDOMNode> tmpReturn;
     274                 : 
     275               2 :   if (mContent) {
     276                 :     // XXX should check same-origin between mContent and aNode however
     277                 :     // nsContentUtils::CheckSameOrigin can't deal with attributenodes yet
     278                 :     
     279               4 :     nsCOMPtr<nsIAttribute> iAttribute(do_QueryInterface(aNode));
     280               2 :     if (!iAttribute) {
     281               0 :       return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
     282                 :     }
     283                 : 
     284               2 :     nsDOMAttribute *attribute = static_cast<nsDOMAttribute*>(iAttribute.get());
     285                 : 
     286                 :     // Check that attribute is not owned by somebody else
     287               2 :     nsDOMAttributeMap* owner = iAttribute->GetMap();
     288               2 :     if (owner) {
     289               0 :       if (owner != this) {
     290               0 :         return NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR;
     291                 :       }
     292                 : 
     293                 :       // setting a preexisting attribute is a no-op, just return the same
     294                 :       // node.
     295               0 :       NS_ADDREF(*aReturn = aNode);
     296                 :       
     297               0 :       return NS_OK;
     298                 :     }
     299                 : 
     300               2 :     if (!mContent->HasSameOwnerDoc(iAttribute)) {
     301                 :       nsCOMPtr<nsIDOMDocument> domDoc =
     302               0 :         do_QueryInterface(mContent->OwnerDoc(), &rv);
     303               0 :       NS_ENSURE_SUCCESS(rv, rv);
     304                 : 
     305               0 :       nsCOMPtr<nsIDOMNode> adoptedNode;
     306               0 :       rv = domDoc->AdoptNode(aNode, getter_AddRefs(adoptedNode));
     307               0 :       NS_ENSURE_SUCCESS(rv, rv);
     308                 : 
     309               0 :       NS_ASSERTION(adoptedNode == aNode, "Uh, adopt node changed nodes?");
     310                 :     }
     311                 : 
     312                 :     // Get nodeinfo and preexisting attribute (if it exists)
     313               4 :     nsAutoString name;
     314               4 :     nsCOMPtr<nsINodeInfo> ni;
     315                 : 
     316                 :     // SetNamedItemNS()
     317               2 :     if (aWithNS) {
     318                 :       // Return existing attribute, if present
     319               0 :       ni = iAttribute->NodeInfo();
     320                 : 
     321               0 :       if (mContent->HasAttr(ni->NamespaceID(), ni->NameAtom())) {
     322               0 :         rv = RemoveAttribute(ni, getter_AddRefs(tmpReturn));
     323               0 :         NS_ENSURE_SUCCESS(rv, rv);
     324                 :       }
     325                 :     }
     326                 :     else { // SetNamedItem()
     327               2 :       attribute->GetName(name);
     328                 : 
     329                 :       // get node-info of old attribute
     330               2 :       ni = mContent->GetExistingAttrNameFromQName(name);
     331               2 :       if (ni) {
     332               0 :         rv = RemoveAttribute(ni, getter_AddRefs(tmpReturn));
     333               0 :         NS_ENSURE_SUCCESS(rv, rv);
     334                 :       }
     335                 :       else {
     336               2 :         if (mContent->IsInHTMLDocument() &&
     337               0 :             mContent->IsHTML()) {
     338               0 :           nsContentUtils::ASCIIToLower(name);
     339                 :         }
     340                 : 
     341                 :         rv = mContent->NodeInfo()->NodeInfoManager()->
     342                 :           GetNodeInfo(name, nsnull, kNameSpaceID_None,
     343               2 :                       nsIDOMNode::ATTRIBUTE_NODE, getter_AddRefs(ni));
     344               2 :         NS_ENSURE_SUCCESS(rv, rv);
     345                 :         // value is already empty
     346                 :       }
     347                 :     }
     348                 : 
     349               4 :     nsAutoString value;
     350               2 :     attribute->GetValue(value);
     351                 : 
     352                 :     // Add the new attribute to the attribute map before updating
     353                 :     // its value in the element. @see bug 364413.
     354               2 :     nsAttrKey attrkey(ni->NamespaceID(), ni->NameAtom());
     355               2 :     rv = mAttributeCache.Put(attrkey, attribute);
     356               2 :     NS_ENSURE_SUCCESS(rv, rv);
     357               2 :     iAttribute->SetMap(this);
     358                 : 
     359                 :     rv = mContent->SetAttr(ni->NamespaceID(), ni->NameAtom(),
     360               2 :                            ni->GetPrefixAtom(), value, true);
     361               2 :     if (NS_FAILED(rv)) {
     362               0 :       DropAttribute(ni->NamespaceID(), ni->NameAtom());
     363                 :     }
     364                 :   }
     365                 : 
     366               2 :   tmpReturn.swap(*aReturn); // transfers ref.
     367                 : 
     368               2 :   return rv;
     369                 : }
     370                 : 
     371                 : NS_IMETHODIMP
     372               0 : nsDOMAttributeMap::RemoveNamedItem(const nsAString& aName,
     373                 :                                    nsIDOMNode** aReturn)
     374                 : {
     375               0 :   NS_ENSURE_ARG_POINTER(aReturn);
     376               0 :   *aReturn = nsnull;
     377                 : 
     378               0 :   nsresult rv = NS_OK;
     379                 : 
     380               0 :   if (mContent) {
     381               0 :     nsCOMPtr<nsINodeInfo> ni = mContent->GetExistingAttrNameFromQName(aName);
     382               0 :     if (!ni) {
     383               0 :       return NS_ERROR_DOM_NOT_FOUND_ERR;
     384                 :     }
     385                 : 
     386               0 :     NS_ADDREF(*aReturn = GetAttribute(ni, true));
     387                 : 
     388                 :     // This removes the attribute node from the attribute map.
     389               0 :     rv = mContent->UnsetAttr(ni->NamespaceID(), ni->NameAtom(), true);
     390                 :   }
     391                 : 
     392               0 :   return rv;
     393                 : }
     394                 : 
     395                 : 
     396                 : nsDOMAttribute*
     397             943 : nsDOMAttributeMap::GetItemAt(PRUint32 aIndex, nsresult *aResult)
     398                 : {
     399             943 :   *aResult = NS_OK;
     400                 : 
     401             943 :   nsDOMAttribute* node = nsnull;
     402                 : 
     403                 :   const nsAttrName* name;
     404             943 :   if (mContent && (name = mContent->GetAttrNameAt(aIndex))) {
     405                 :     // Don't use the nodeinfo even if one exists since it can
     406                 :     // have the wrong owner document.
     407            1886 :     nsCOMPtr<nsINodeInfo> ni;
     408                 :     ni = mContent->NodeInfo()->NodeInfoManager()->
     409                 :       GetNodeInfo(name->LocalName(), name->GetPrefix(), name->NamespaceID(),
     410             943 :                   nsIDOMNode::ATTRIBUTE_NODE);
     411             943 :     if (ni) {
     412             943 :       node = GetAttribute(ni, true);
     413                 :     }
     414                 :     else {
     415               0 :       *aResult = NS_ERROR_OUT_OF_MEMORY;
     416                 :     }
     417                 :   }
     418                 : 
     419             943 :   return node;
     420                 : }
     421                 : 
     422                 : NS_IMETHODIMP
     423             943 : nsDOMAttributeMap::Item(PRUint32 aIndex, nsIDOMNode** aReturn)
     424                 : {
     425                 :   nsresult rv;
     426             943 :   NS_IF_ADDREF(*aReturn = GetItemAt(aIndex, &rv));
     427             943 :   return rv;
     428                 : }
     429                 : 
     430                 : nsresult
     431            1171 : nsDOMAttributeMap::GetLength(PRUint32 *aLength)
     432                 : {
     433            1171 :   NS_ENSURE_ARG_POINTER(aLength);
     434                 : 
     435            1171 :   if (mContent) {
     436            1171 :     *aLength = mContent->GetAttrCount();
     437                 :   }
     438                 :   else {
     439               0 :     *aLength = 0;
     440                 :   }
     441                 : 
     442            1171 :   return NS_OK;
     443                 : }
     444                 : 
     445                 : NS_IMETHODIMP
     446              34 : nsDOMAttributeMap::GetNamedItemNS(const nsAString& aNamespaceURI,
     447                 :                                   const nsAString& aLocalName,
     448                 :                                   nsIDOMNode** aReturn)
     449                 : {
     450              34 :   return GetNamedItemNSInternal(aNamespaceURI, aLocalName, aReturn);
     451                 : }
     452                 : 
     453                 : nsresult
     454              34 : nsDOMAttributeMap::GetNamedItemNSInternal(const nsAString& aNamespaceURI,
     455                 :                                           const nsAString& aLocalName,
     456                 :                                           nsIDOMNode** aReturn,
     457                 :                                           bool aRemove)
     458                 : {
     459              34 :   NS_ENSURE_ARG_POINTER(aReturn);
     460              34 :   *aReturn = nsnull;
     461                 : 
     462              34 :   if (!mContent) {
     463               0 :     return NS_OK;
     464                 :   }
     465                 : 
     466              34 :   PRInt32 nameSpaceID = kNameSpaceID_None;
     467                 : 
     468              34 :   if (!aNamespaceURI.IsEmpty()) {
     469                 :     nameSpaceID =
     470              32 :       nsContentUtils::NameSpaceManager()->GetNameSpaceID(aNamespaceURI);
     471                 : 
     472              32 :     if (nameSpaceID == kNameSpaceID_Unknown) {
     473               0 :       return NS_OK;
     474                 :     }
     475                 :   }
     476                 : 
     477              34 :   PRUint32 i, count = mContent->GetAttrCount();
     478             212 :   for (i = 0; i < count; ++i) {
     479             212 :     const nsAttrName* name = mContent->GetAttrNameAt(i);
     480             212 :     PRInt32 attrNS = name->NamespaceID();
     481             212 :     nsIAtom* nameAtom = name->LocalName();
     482                 : 
     483             272 :     if (nameSpaceID == attrNS &&
     484              60 :         nameAtom->Equals(aLocalName)) {
     485              68 :       nsCOMPtr<nsINodeInfo> ni;
     486                 :       ni = mContent->NodeInfo()->NodeInfoManager()->
     487                 :         GetNodeInfo(nameAtom, name->GetPrefix(), nameSpaceID,
     488              34 :                     nsIDOMNode::ATTRIBUTE_NODE);
     489              34 :       NS_ENSURE_TRUE(ni, NS_ERROR_OUT_OF_MEMORY);
     490                 : 
     491              34 :       if (aRemove) {
     492               0 :         return RemoveAttribute(ni, aReturn);
     493                 :       }
     494                 : 
     495              34 :       NS_ADDREF(*aReturn = GetAttribute(ni, true));
     496                 : 
     497              34 :       return NS_OK;
     498                 :     }
     499                 :   }
     500                 : 
     501               0 :   return NS_OK;
     502                 : }
     503                 : 
     504                 : NS_IMETHODIMP
     505               0 : nsDOMAttributeMap::RemoveNamedItemNS(const nsAString& aNamespaceURI,
     506                 :                                      const nsAString& aLocalName,
     507                 :                                      nsIDOMNode** aReturn)
     508                 : {
     509               0 :   NS_ENSURE_ARG_POINTER(aReturn);
     510               0 :   *aReturn = nsnull;
     511                 : 
     512                 :   nsresult rv = GetNamedItemNSInternal(aNamespaceURI,
     513                 :                                        aLocalName,
     514                 :                                        aReturn,
     515               0 :                                        true);
     516               0 :   NS_ENSURE_SUCCESS(rv, rv);
     517                 : 
     518               0 :   if (!*aReturn) {
     519               0 :     return NS_ERROR_DOM_NOT_FOUND_ERR;
     520                 :   }
     521                 : 
     522               0 :   nsCOMPtr<nsIAttribute> attr = do_QueryInterface(*aReturn);
     523               0 :   NS_ASSERTION(attr, "attribute returned from nsDOMAttributeMap::GetNameItemNS "
     524                 :                "didn't implement nsIAttribute");
     525               0 :   NS_ENSURE_TRUE(attr, NS_ERROR_UNEXPECTED);
     526                 : 
     527               0 :   nsINodeInfo *ni = attr->NodeInfo();
     528               0 :   mContent->UnsetAttr(ni->NamespaceID(), ni->NameAtom(), true);
     529                 : 
     530               0 :   return NS_OK;
     531                 : }
     532                 : 
     533                 : PRUint32
     534               0 : nsDOMAttributeMap::Count() const
     535                 : {
     536               0 :   return mAttributeCache.Count();
     537                 : }
     538                 : 
     539                 : PRUint32
     540               0 : nsDOMAttributeMap::Enumerate(AttrCache::EnumReadFunction aFunc,
     541                 :                              void *aUserArg) const
     542                 : {
     543               0 :   return mAttributeCache.EnumerateRead(aFunc, aUserArg);
     544            4392 : }

Generated by: LCOV version 1.7