layout/style/nsCSSStyleRule.cpp

   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.org 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  *   David Hyatt <hyatt@netscape.com>
  24  *   Daniel Glazman <glazman@netscape.com>
  25  *   L. David Baron <dbaron@dbaron.org>, Mozilla Corporation
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either of the GNU General Public License Version 2 or later (the "GPL"),
  29  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  * ***** END LICENSE BLOCK ***** */
  40
  41 /*
  42  * representation of CSS style rules (selectors+declaration), CSS
  43  * selectors, and DOM objects for style rules, selectors, and
  44  * declarations
  45  */
  46
  47 #include "nsCOMPtr.h"
  48 #include "nsCSSRule.h"
  49 #include "nsICSSStyleRule.h"
  50 #include "nsICSSGroupRule.h"
  51 #include "nsCSSDeclaration.h"
  52 #include "nsICSSStyleSheet.h"
  53 #include "nsICSSParser.h"
  54 #include "nsICSSLoader.h"
  55 #include "nsIURL.h"
  56 #include "nsPresContext.h"
  57 #include "nsIDocument.h"
  58 #include "nsIDeviceContext.h"
  59 #include "nsIAtom.h"
  60 #include "nsCRT.h"
  61 #include "nsString.h"
  62 #include "nsStyleConsts.h"
  63 #include "nsStyleUtil.h"
  64 #include "nsIFontMetrics.h"
  65 #include "nsIDOMCSSStyleSheet.h"
  66 #include "nsICSSStyleRuleDOMWrapper.h"
  67 #include "nsIDOMCSSStyleDeclaration.h"
  68 #include "nsDOMCSSDeclaration.h"
  69 #include "nsINameSpaceManager.h"
  70 #include "nsXMLNameSpaceMap.h"
  71 #include "nsILookAndFeel.h"
  72 #include "nsRuleNode.h"
  73 #include "nsUnicharUtils.h"
  74 #include "nsCSSPseudoElements.h"
  75 #include "nsIPrincipal.h"
  76 #include "nsComponentManagerUtils.h"
  77 #include "nsCSSPseudoClasses.h"
  78
  79 #include "nsContentUtils.h"
  80 #include "nsContentErrors.h"
  81 #include "mozAutoDocUpdate.h"
  82
  83 #define NS_IF_CLONE(member_)                                                  \
  84   PR_BEGIN_MACRO                                                              \
  85     if (member_) {                                                            \
  86       result->member_ = member_->Clone();                                     \
  87       if (!result->member_) {                                                 \
  88         delete result;                                                        \
  89         return nsnull;                                                        \
  90       }                                                                       \
  91     }                                                                         \
  92   PR_END_MACRO
  93
  94 #define NS_IF_DELETE(ptr)                                                     \
  95   PR_BEGIN_MACRO                                                              \
  96     delete ptr;                                                               \
  97     ptr = nsnull;                                                             \
  98   PR_END_MACRO
  99
 100 /* ************************************************************************** */
 101
 102 nsAtomList::nsAtomList(nsIAtom* aAtom)
 103   : mAtom(aAtom),
 104     mNext(nsnull)
 105 {
 106   MOZ_COUNT_CTOR(nsAtomList);
 107 }
 108
 109 nsAtomList::nsAtomList(const nsString& aAtomValue)
 110   : mAtom(nsnull),
 111     mNext(nsnull)
 112 {
 113   MOZ_COUNT_CTOR(nsAtomList);
 114   mAtom = do_GetAtom(aAtomValue);
 115 }
 116
 117 nsAtomList*
 118 nsAtomList::Clone(PRBool aDeep) const
 119 {
 120   nsAtomList *result = new nsAtomList(mAtom);
 121   if (!result)
 122     return nsnull;
 123
 124   if (aDeep)
 125     NS_CSS_CLONE_LIST_MEMBER(nsAtomList, this, mNext, result, (PR_FALSE));
 126   return result;
 127 }
 128
 129 nsAtomList::~nsAtomList(void)
 130 {
 131   MOZ_COUNT_DTOR(nsAtomList);
 132   NS_CSS_DELETE_LIST_MEMBER(nsAtomList, this, mNext);
 133 }
 134
 135 nsPseudoClassList::nsPseudoClassList(nsIAtom* aAtom)
 136   : mAtom(aAtom),
 137     mNext(nsnull)
 138 {
 139   NS_ASSERTION(!nsCSSPseudoClasses::HasStringArg(aAtom) &&
 140                !nsCSSPseudoClasses::HasNthPairArg(aAtom),
 141                "unexpected pseudo-class");
 142   MOZ_COUNT_CTOR(nsPseudoClassList);
 143   u.mMemory = nsnull;
 144 }
 145
 146 nsPseudoClassList::nsPseudoClassList(nsIAtom* aAtom, const PRUnichar* aString)
 147   : mAtom(aAtom),
 148     mNext(nsnull)
 149 {
 150   NS_ASSERTION(nsCSSPseudoClasses::HasStringArg(aAtom),
 151                "unexpected pseudo-class");
 152   NS_ASSERTION(aString, "string expected");
 153   MOZ_COUNT_CTOR(nsPseudoClassList);
 154   u.mString = NS_strdup(aString);
 155 }
 156
 157 nsPseudoClassList::nsPseudoClassList(nsIAtom* aAtom, const PRInt32* aIntPair)
 158   : mAtom(aAtom),
 159     mNext(nsnull)
 160 {
 161   NS_ASSERTION(nsCSSPseudoClasses::HasNthPairArg(aAtom),
 162                "unexpected pseudo-class");
 163   NS_ASSERTION(aIntPair, "integer pair expected");
 164   MOZ_COUNT_CTOR(nsPseudoClassList);
 165   u.mNumbers =
 166     static_cast<PRInt32*>(nsMemory::Clone(aIntPair, sizeof(PRInt32) * 2));
 167 }
 168
 169 nsPseudoClassList*
 170 nsPseudoClassList::Clone(PRBool aDeep) const
 171 {
 172   nsPseudoClassList *result;
 173   if (!u.mMemory) {
 174     result = new nsPseudoClassList(mAtom);
 175   } else if (nsCSSPseudoClasses::HasStringArg(mAtom)) {
 176     result = new nsPseudoClassList(mAtom, u.mString);
 177   } else {
 178     NS_ASSERTION(nsCSSPseudoClasses::HasNthPairArg(mAtom),
 179                  "unexpected pseudo-class");
 180     result = new nsPseudoClassList(mAtom, u.mNumbers);
 181   }
 182
 183   if (aDeep)
 184     NS_CSS_CLONE_LIST_MEMBER(nsPseudoClassList, this, mNext, result,
 185                              (PR_FALSE));
 186
 187   return result;
 188 }
 189
 190 nsPseudoClassList::~nsPseudoClassList(void)
 191 {
 192   MOZ_COUNT_DTOR(nsPseudoClassList);
 193   if (u.mMemory)
 194     NS_Free(u.mMemory);
 195   NS_CSS_DELETE_LIST_MEMBER(nsPseudoClassList, this, mNext);
 196 }
 197
 198 nsAttrSelector::nsAttrSelector(PRInt32 aNameSpace, const nsString& aAttr)
 199   : mNameSpace(aNameSpace),
 200     mAttr(nsnull),
 201     mFunction(NS_ATTR_FUNC_SET),
 202     mCaseSensitive(1),
 203     mValue(),
 204     mNext(nsnull)
 205 {
 206   MOZ_COUNT_CTOR(nsAttrSelector);
 207
 208   mAttr = do_GetAtom(aAttr);
 209 }
 210
 211 nsAttrSelector::nsAttrSelector(PRInt32 aNameSpace, const nsString& aAttr, PRUint8 aFunction,
 212                                const nsString& aValue, PRBool aCaseSensitive)
 213   : mNameSpace(aNameSpace),
 214     mAttr(nsnull),
 215     mFunction(aFunction),
 216     mCaseSensitive(aCaseSensitive),
 217     mValue(aValue),
 218     mNext(nsnull)
 219 {
 220   MOZ_COUNT_CTOR(nsAttrSelector);
 221
 222   mAttr = do_GetAtom(aAttr);
 223 }
 224
 225 nsAttrSelector::nsAttrSelector(PRInt32 aNameSpace, nsIAtom* aAttr,
 226                                PRUint8 aFunction, const nsString& aValue,
 227                                PRBool aCaseSensitive)
 228   : mNameSpace(aNameSpace),
 229     mAttr(aAttr),
 230     mFunction(aFunction),
 231     mCaseSensitive(aCaseSensitive),
 232     mValue(aValue),
 233     mNext(nsnull)
 234 {
 235   MOZ_COUNT_CTOR(nsAttrSelector);
 236 }
 237
 238 nsAttrSelector*
 239 nsAttrSelector::Clone(PRBool aDeep) const
 240 {
 241   nsAttrSelector *result =
 242     new nsAttrSelector(mNameSpace, mAttr, mFunction, mValue, mCaseSensitive);
 243
 244   if (aDeep)
 245     NS_CSS_CLONE_LIST_MEMBER(nsAttrSelector, this, mNext, result, (PR_FALSE));
 246
 247   return result;
 248 }
 249
 250 nsAttrSelector::~nsAttrSelector(void)
 251 {
 252   MOZ_COUNT_DTOR(nsAttrSelector);
 253
 254   NS_CSS_DELETE_LIST_MEMBER(nsAttrSelector, this, mNext);
 255 }
 256
 257 // -- nsCSSSelector -------------------------------
 258
 259 nsCSSSelector::nsCSSSelector(void)
 260   : mNameSpace(kNameSpaceID_Unknown), mTag(nsnull),
 261     mIDList(nsnull),
 262     mClassList(nsnull),
 263     mPseudoClassList(nsnull),
 264     mAttrList(nsnull),
 265     mOperator(0),
 266     mNegations(nsnull),
 267     mNext(nsnull)
 268 {
 269   MOZ_COUNT_CTOR(nsCSSSelector);
 270 }
 271
 272 nsCSSSelector*
 273 nsCSSSelector::Clone(PRBool aDeepNext, PRBool aDeepNegations) const
 274 {
 275   nsCSSSelector *result = new nsCSSSelector();
 276   if (!result)
 277     return nsnull;
 278
 279   result->mNameSpace = mNameSpace;
 280   result->mTag = mTag;
 281
 282   NS_IF_CLONE(mIDList);
 283   NS_IF_CLONE(mClassList);
 284   NS_IF_CLONE(mPseudoClassList);
 285   NS_IF_CLONE(mAttrList);
 286
 287   // No need to worry about multiple levels of recursion since an
 288   // mNegations can't have an mNext.
 289   NS_ASSERTION(!mNegations || !mNegations->mNext,
 290                "mNegations can't have non-null mNext");
 291   if (aDeepNegations) {
 292     NS_CSS_CLONE_LIST_MEMBER(nsCSSSelector, this, mNegations, result,
 293                              (PR_TRUE, PR_FALSE));
 294   }
 295
 296   if (aDeepNext) {
 297     NS_CSS_CLONE_LIST_MEMBER(nsCSSSelector, this, mNext, result,
 298                              (PR_FALSE, PR_TRUE));
 299   }
 300
 301   return result;
 302 }
 303
 304 nsCSSSelector::~nsCSSSelector(void)
 305 {
 306   MOZ_COUNT_DTOR(nsCSSSelector);
 307   Reset();
 308   // No need to worry about multiple levels of recursion since an
 309   // mNegations can't have an mNext.
 310   NS_CSS_DELETE_LIST_MEMBER(nsCSSSelector, this, mNext);
 311 }
 312
 313 void nsCSSSelector::Reset(void)
 314 {
 315   mNameSpace = kNameSpaceID_Unknown;
 316   mTag = nsnull;
 317   NS_IF_DELETE(mIDList);
 318   NS_IF_DELETE(mClassList);
 319   NS_IF_DELETE(mPseudoClassList);
 320   NS_IF_DELETE(mAttrList);
 321   // No need to worry about multiple levels of recursion since an
 322   // mNegations can't have an mNext.
 323   NS_ASSERTION(!mNegations || !mNegations->mNext,
 324                "mNegations can't have non-null mNext");
 325   NS_CSS_DELETE_LIST_MEMBER(nsCSSSelector, this, mNegations);
 326   mOperator = PRUnichar(0);
 327 }
 328
 329 void nsCSSSelector::SetNameSpace(PRInt32 aNameSpace)
 330 {
 331   mNameSpace = aNameSpace;
 332 }
 333
 334 void nsCSSSelector::SetTag(const nsString& aTag)
 335 {
 336   if (aTag.IsEmpty())
 337     mTag = nsnull;
 338   else
 339     mTag = do_GetAtom(aTag);
 340 }
 341
 342 void nsCSSSelector::AddID(const nsString& aID)
 343 {
 344   if (!aID.IsEmpty()) {
 345     nsAtomList** list = &mIDList;
 346     while (nsnull != *list) {
 347       list = &((*list)->mNext);
 348     }
 349     *list = new nsAtomList(aID);
 350   }
 351 }
 352
 353 void nsCSSSelector::AddClass(const nsString& aClass)
 354 {
 355   if (!aClass.IsEmpty()) {
 356     nsAtomList** list = &mClassList;
 357     while (nsnull != *list) {
 358       list = &((*list)->mNext);
 359     }
 360     *list = new nsAtomList(aClass);
 361   }
 362 }
 363
 364 void nsCSSSelector::AddPseudoClass(nsIAtom* aPseudoClass)
 365 {
 366   AddPseudoClassInternal(new nsPseudoClassList(aPseudoClass));
 367 }
 368
 369 void nsCSSSelector::AddPseudoClass(nsIAtom* aPseudoClass,
 370                                    const PRUnichar* aString)
 371 {
 372   AddPseudoClassInternal(new nsPseudoClassList(aPseudoClass, aString));
 373 }
 374
 375 void nsCSSSelector::AddPseudoClass(nsIAtom* aPseudoClass,
 376                                    const PRInt32* aIntPair)
 377 {
 378   AddPseudoClassInternal(new nsPseudoClassList(aPseudoClass, aIntPair));
 379 }
 380
 381 void nsCSSSelector::AddPseudoClassInternal(nsPseudoClassList *aPseudoClass)
 382 {
 383   nsPseudoClassList** list = &mPseudoClassList;
 384   while (nsnull != *list) {
 385     list = &((*list)->mNext);
 386   }
 387   *list = aPseudoClass;
 388 }
 389
 390 void nsCSSSelector::AddAttribute(PRInt32 aNameSpace, const nsString& aAttr)
 391 {
 392   if (!aAttr.IsEmpty()) {
 393     nsAttrSelector** list = &mAttrList;
 394     while (nsnull != *list) {
 395       list = &((*list)->mNext);
 396     }
 397     *list = new nsAttrSelector(aNameSpace, aAttr);
 398   }
 399 }
 400
 401 void nsCSSSelector::AddAttribute(PRInt32 aNameSpace, const nsString& aAttr, PRUint8 aFunc,
 402                                  const nsString& aValue, PRBool aCaseSensitive)
 403 {
 404   if (!aAttr.IsEmpty()) {
 405     nsAttrSelector** list = &mAttrList;
 406     while (nsnull != *list) {
 407       list = &((*list)->mNext);
 408     }
 409     *list = new nsAttrSelector(aNameSpace, aAttr, aFunc, aValue, aCaseSensitive);
 410   }
 411 }
 412
 413 void nsCSSSelector::SetOperator(PRUnichar aOperator)
 414 {
 415   mOperator = aOperator;
 416 }
 417
 418 PRInt32 nsCSSSelector::CalcWeight(void) const
 419 {
 420   PRInt32 weight = 0;
 421
 422   if (nsnull != mTag) {
 423     weight += 0x000001;
 424   }
 425   nsAtomList* list = mIDList;
 426   while (nsnull != list) {
 427     weight += 0x010000;
 428     list = list->mNext;
 429   }
 430   list = mClassList;
 431   while (nsnull != list) {
 432     weight += 0x000100;
 433     list = list->mNext;
 434   }
 435   nsPseudoClassList *plist = mPseudoClassList;
 436   while (nsnull != plist) {
 437     weight += 0x000100;
 438     plist = plist->mNext;
 439   }
 440   nsAttrSelector* attr = mAttrList;
 441   while (nsnull != attr) {
 442     weight += 0x000100;
 443     attr = attr->mNext;
 444   }
 445   if (nsnull != mNegations) {
 446     weight += mNegations->CalcWeight();
 447   }
 448   return weight;
 449 }
 450
 451 // pseudo-elements are stored in the selectors' chain using fictional elements;
 452 // these fictional elements have mTag starting with a colon
 453 static PRBool IsPseudoElement(nsIAtom* aAtom)
 454 {
 455   if (aAtom) {
 456     const char* str;
 457     aAtom->GetUTF8String(&str);
 458     return str && (*str == ':');
 459   }
 460
 461   return PR_FALSE;
 462 }
 463
 464 void nsCSSSelector::AppendNegationToString(nsAString& aString)
 465 {
 466   aString.AppendLiteral(":not(");
 467 }
 468
 469 //
 470 // Builds the textual representation of a selector. Called by DOM 2 CSS
 471 // StyleRule:selectorText
 472 //
 473 void
 474 nsCSSSelector::ToString(nsAString& aString, nsICSSStyleSheet* aSheet,
 475                         PRBool aAppend) const
 476 {
 477   if (!aAppend)
 478    aString.Truncate();
 479
 480   ToStringInternal(aString, aSheet, IsPseudoElement(mTag), PR_FALSE);
 481 }
 482
 483 void nsCSSSelector::ToStringInternal(nsAString& aString,
 484                                      nsICSSStyleSheet* aSheet,
 485                                      PRBool aIsPseudoElem,
 486                                      PRBool aIsNegated) const
 487 {
 488   nsAutoString temp;
 489   PRBool isPseudoElement = IsPseudoElement(mTag);
 490
 491   // selectors are linked from right-to-left, so the next selector in the linked list
 492   // actually precedes this one in the resulting string
 493   if (mNext) {
 494     mNext->ToStringInternal(aString, aSheet, IsPseudoElement(mTag), 0);
 495     if (!aIsNegated && !isPseudoElement) {
 496       // don't add a leading whitespace if we have a pseudo-element
 497       // or a negated simple selector
 498       aString.Append(PRUnichar(' '));
 499     }
 500   }
 501
 502   // For non-pseudo-element selectors or for lone pseudo-elements, deal with
 503   // namespace prefixes.
 504   PRBool wroteNamespace = PR_FALSE;
 505   if (!isPseudoElement || !mNext) {
 506     // append the namespace prefix if needed
 507     if (mNameSpace == kNameSpaceID_None) {
 508       // The only way to do this in CSS is to have an explicit namespace
 509       // of "none" specified in the sheet by having a '|' with nothing
 510       // before it.
 511       aString.Append(PRUnichar('|'));
 512       wroteNamespace = PR_TRUE;
 513     } else {
 514       if (aSheet) {
 515         nsXMLNameSpaceMap *sheetNS = aSheet->GetNameSpaceMap();
 516
 517         // sheetNS is non-null if and only if we had an @namespace rule.  If it's
 518         // null, that means that the only namespaces we could have are the
 519         // wildcard namespace (which can be implicit in this case) and the "none"
 520         // namespace, which we handled above.  So no need to output anything when
 521         // sheetNS is null.
 522         if (sheetNS) {
 523           if (mNameSpace != kNameSpaceID_Unknown) {
 524             if (sheetNS->FindNameSpaceID(nsnull) != mNameSpace) {
 525               nsIAtom *prefixAtom = sheetNS->FindPrefix(mNameSpace);
 526               NS_ASSERTION(prefixAtom, "how'd we get a non-default namespace "
 527                                        "without a prefix?");
 528               nsAutoString prefix;
 529               prefixAtom->ToString(prefix);
 530               aString.Append(prefix);
 531               aString.Append(PRUnichar('|'));
 532               wroteNamespace = PR_TRUE;
 533             }
 534             // otherwise it must be the default namespace
 535           } else {
 536             // A selector for an element in any namespace.
 537             if (// Use explicit "*|" only when it's not implied
 538                 sheetNS->FindNameSpaceID(nsnull) != kNameSpaceID_None &&
 539                 // :not() is special in that the default namespace is
 540                 // not implied for non-type selectors
 541                 (!aIsNegated || (!mIDList && !mClassList &&
 542                                  !mPseudoClassList && !mAttrList))) {
 543               aString.AppendLiteral("*|");
 544               wroteNamespace = PR_TRUE;
 545             }
 546           }
 547         }
 548       }
 549     }
 550   }
 551
 552   if (!mTag) {
 553     // Universal selector:  avoid writing the universal selector when we
 554     // can avoid it, especially since we're required to avoid it for the
 555     // inside of :not()
 556     if (wroteNamespace ||
 557         (!mIDList && !mClassList && !mPseudoClassList && !mAttrList &&
 558          (aIsNegated || !mNegations))) {
 559       aString.Append(PRUnichar('*'));
 560     }
 561   } else {
 562     // Append the tag name
 563     if (isPseudoElement) {
 564       if (!mNext) {
 565         // Lone pseudo-element selector -- toss in a wildcard type selector
 566         // XXXldb Why?
 567         aString.Append(PRUnichar('*'));
 568       }
 569       if (!nsCSSPseudoElements::IsCSS2PseudoElement(mTag)) {
 570         aString.Append(PRUnichar(':'));
 571       }
 572     }
 573     nsAutoString prefix;
 574     mTag->ToString(prefix);
 575     aString.Append(prefix);
 576   }
 577
 578   // Append the id, if there is one
 579   if (mIDList) {
 580     nsAtomList* list = mIDList;
 581     while (list != nsnull) {
 582       list->mAtom->ToString(temp);
 583       aString.Append(PRUnichar('#'));
 584       aString.Append(temp);
 585       list = list->mNext;
 586     }
 587   }
 588
 589   // Append each class in the linked list
 590   if (mClassList) {
 591     nsAtomList* list = mClassList;
 592     while (list != nsnull) {
 593       list->mAtom->ToString(temp);
 594       aString.Append(PRUnichar('.'));
 595       aString.Append(temp);
 596       list = list->mNext;
 597     }
 598   }
 599
 600   // Append each attribute selector in the linked list
 601   if (mAttrList) {
 602     nsAttrSelector* list = mAttrList;
 603     while (list != nsnull) {
 604       aString.Append(PRUnichar('['));
 605       // Append the namespace prefix
 606       if (list->mNameSpace > 0) {
 607         if (aSheet) {
 608           nsXMLNameSpaceMap *sheetNS = aSheet->GetNameSpaceMap();
 609           // will return null if namespace was the default
 610           nsIAtom *prefixAtom = sheetNS->FindPrefix(list->mNameSpace);
 611           if (prefixAtom) {
 612             nsAutoString prefix;
 613             prefixAtom->ToString(prefix);
 614             aString.Append(prefix);
 615             aString.Append(PRUnichar('|'));
 616           }
 617         }
 618       }
 619       // Append the attribute name
 620       list->mAttr->ToString(temp);
 621       aString.Append(temp);
 622
 623       if (list->mFunction != NS_ATTR_FUNC_SET) {
 624         // Append the function
 625         if (list->mFunction == NS_ATTR_FUNC_INCLUDES)
 626           aString.Append(PRUnichar('~'));
 627         else if (list->mFunction == NS_ATTR_FUNC_DASHMATCH)
 628           aString.Append(PRUnichar('|'));
 629         else if (list->mFunction == NS_ATTR_FUNC_BEGINSMATCH)
 630           aString.Append(PRUnichar('^'));
 631         else if (list->mFunction == NS_ATTR_FUNC_ENDSMATCH)
 632           aString.Append(PRUnichar('$'));
 633         else if (list->mFunction == NS_ATTR_FUNC_CONTAINSMATCH)
 634           aString.Append(PRUnichar('*'));
 635
 636         aString.Append(PRUnichar('='));
 637
 638         // Append the value
 639         nsAutoString escaped;
 640         nsStyleUtil::EscapeCSSString(list->mValue, escaped);
 641
 642         aString.Append(PRUnichar('\"'));
 643         aString.Append(escaped);
 644         aString.Append(PRUnichar('\"'));
 645       }
 646
 647       aString.Append(PRUnichar(']'));
 648
 649       list = list->mNext;
 650     }
 651   }
 652
 653   // Append each pseudo-class in the linked list
 654   if (mPseudoClassList) {
 655     nsPseudoClassList* list = mPseudoClassList;
 656     while (list != nsnull) {
 657       list->mAtom->ToString(temp);
 658       aString.Append(temp);
 659       if (list->u.mMemory) {
 660         aString.Append(PRUnichar('('));
 661         if (nsCSSPseudoClasses::HasStringArg(list->mAtom)) {
 662           aString.Append(list->u.mString);
 663         } else {
 664           NS_ASSERTION(nsCSSPseudoClasses::HasNthPairArg(list->mAtom),
 665                        "unexpected pseudo-class");
 666           PRInt32 a = list->u.mNumbers[0],
 667                   b = list->u.mNumbers[1];
 668           temp.Truncate();
 669           if (a != 0) {
 670             if (a == -1) {
 671               temp.Append(PRUnichar('-'));
 672             } else if (a != 1) {
 673               temp.AppendInt(a);
 674             }
 675             temp.Append(PRUnichar('n'));
 676           }
 677           if (b != 0 || a == 0) {
 678             if (b >= 0 && a != 0) // check a != 0 for whether we printed above
 679               temp.Append(PRUnichar('+'));
 680             temp.AppendInt(b);
 681           }
 682           aString.Append(temp);
 683         }
 684         aString.Append(PRUnichar(')'));
 685       }
 686       list = list->mNext;
 687     }
 688   }
 689
 690   if (!aIsNegated) {
 691     for (nsCSSSelector* negation = mNegations; negation;
 692          negation = negation->mNegations) {
 693       aString.AppendLiteral(":not(");
 694       negation->ToStringInternal(aString, aSheet, PR_FALSE, PR_TRUE);
 695       aString.Append(PRUnichar(')'));
 696     }
 697   }
 698
 699   // Append the operator only if the selector is not negated and is not
 700   // a pseudo-element
 701   if (!aIsNegated && mOperator && !aIsPseudoElem) {
 702     aString.Append(PRUnichar(' '));
 703     aString.Append(mOperator);
 704   }
 705 }
 706
 707 // -- nsCSSSelectorList -------------------------------
 708
 709 nsCSSSelectorList::nsCSSSelectorList(void)
 710   : mSelectors(nsnull),
 711     mWeight(0),
 712     mNext(nsnull)
 713 {
 714   MOZ_COUNT_CTOR(nsCSSSelectorList);
 715 }
 716
 717 nsCSSSelectorList::~nsCSSSelectorList()
 718 {
 719   MOZ_COUNT_DTOR(nsCSSSelectorList);
 720   delete mSelectors;
 721   NS_CSS_DELETE_LIST_MEMBER(nsCSSSelectorList, this, mNext);
 722 }
 723
 724 void nsCSSSelectorList::AddSelector(nsAutoPtr<nsCSSSelector>& aSelector)
 725 { // prepend to list
 726   nsCSSSelector* newSel = aSelector.forget();
 727   if (newSel) {
 728     newSel->mNext = mSelectors;
 729     mSelectors = newSel;
 730   }
 731 }
 732
 733 void
 734 nsCSSSelectorList::ToString(nsAString& aResult, nsICSSStyleSheet* aSheet)
 735 {
 736   aResult.Truncate();
 737   nsCSSSelectorList *p = this;
 738   for (;;) {
 739     p->mSelectors->ToString(aResult, aSheet, PR_TRUE);
 740     p = p->mNext;
 741     if (!p)
 742       break;
 743     aResult.AppendLiteral(", ");
 744   }
 745 }
 746
 747 nsCSSSelectorList*
 748 nsCSSSelectorList::Clone(PRBool aDeep) const
 749 {
 750   nsCSSSelectorList *result = new nsCSSSelectorList();
 751   result->mWeight = mWeight;
 752   NS_IF_CLONE(mSelectors);
 753
 754   if (aDeep) {
 755     NS_CSS_CLONE_LIST_MEMBER(nsCSSSelectorList, this, mNext, result,
 756                              (PR_FALSE));
 757   }
 758   return result;
 759 }
 760
 761 // -- CSSImportantRule -------------------------------
 762
 763 class CSSStyleRuleImpl;
 764
 765 class CSSImportantRule : public nsIStyleRule {
 766 public:
 767   CSSImportantRule(nsCSSDeclaration* aDeclaration);
 768
 769   NS_DECL_ISUPPORTS
 770
 771   // nsIStyleRule interface
 772   NS_IMETHOD MapRuleInfoInto(nsRuleData* aRuleData);
 773 #ifdef DEBUG
 774   NS_IMETHOD List(FILE* out = stdout, PRInt32 aIndent = 0) const;
 775 #endif
 776
 777 protected:
 778   virtual ~CSSImportantRule(void);
 779
 780   nsCSSDeclaration*  mDeclaration;
 781
 782   friend class CSSStyleRuleImpl;
 783 };
 784
 785 CSSImportantRule::CSSImportantRule(nsCSSDeclaration* aDeclaration)
 786   : mDeclaration(aDeclaration)
 787 {
 788 }
 789
 790 CSSImportantRule::~CSSImportantRule(void)
 791 {
 792   mDeclaration = nsnull;
 793 }
 794
 795 NS_IMPL_ISUPPORTS1(CSSImportantRule, nsIStyleRule)
 796
 797 NS_IMETHODIMP
 798 CSSImportantRule::MapRuleInfoInto(nsRuleData* aRuleData)
 799 {
 800   // Check this at runtime because it might be hit in some out-of-memory cases.
 801   NS_ENSURE_TRUE(mDeclaration->HasImportantData(), NS_ERROR_UNEXPECTED);
 802
 803   return mDeclaration->MapImportantRuleInfoInto(aRuleData);
 804 }
 805
 806 #ifdef DEBUG
 807 NS_IMETHODIMP
 808 CSSImportantRule::List(FILE* out, PRInt32 aIndent) const
 809 {
 810   // Indent
 811   for (PRInt32 index = aIndent; --index >= 0; ) fputs("  ", out);
 812
 813   fputs("! Important rule ", out);
 814   if (nsnull != mDeclaration) {
 815     mDeclaration->List(out);
 816   }
 817   else {
 818     fputs("{ null declaration }", out);
 819   }
 820   fputs("\n", out);
 821
 822   return NS_OK;
 823 }
 824 #endif
 825
 826 // --------------------------------------------------------
 827
 828 class DOMCSSStyleRuleImpl;
 829
 830 class DOMCSSDeclarationImpl : public nsDOMCSSDeclaration
 831 {
 832 public:
 833   DOMCSSDeclarationImpl(nsICSSStyleRule *aRule);
 834   virtual ~DOMCSSDeclarationImpl(void);
 835
 836   NS_IMETHOD GetParentRule(nsIDOMCSSRule **aParent);
 837   virtual void DropReference(void);
 838   virtual nsresult GetCSSDeclaration(nsCSSDeclaration **aDecl,
 839                                      PRBool aAllocate);
 840   virtual nsresult GetCSSParsingEnvironment(nsIURI** aSheetURI,
 841                                             nsIURI** aBaseURI,
 842                                             nsIPrincipal** aSheetPrincipal,
 843                                             nsICSSLoader** aCSSLoader,
 844                                             nsICSSParser** aCSSParser);
 845   virtual nsresult DeclarationChanged();
 846
 847   // Override |AddRef| and |Release| for being a member of
 848   // |DOMCSSStyleRuleImpl|.
 849   NS_IMETHOD_(nsrefcnt) AddRef(void);
 850   NS_IMETHOD_(nsrefcnt) Release(void);
 851
 852   friend class DOMCSSStyleRuleImpl;
 853
 854 protected:
 855   // This reference is not reference-counted. The rule object tells us
 856   // when it's about to go away.
 857   nsICSSStyleRule *mRule;
 858
 859   inline DOMCSSStyleRuleImpl* DomRule();
 860
 861 private:
 862   // NOT TO BE IMPLEMENTED
 863   // This object cannot be allocated on its own.  It must be a member of
 864   // DOMCSSStyleRuleImpl.
 865   void* operator new(size_t size) CPP_THROW_NEW;
 866 };
 867
 868 class DOMCSSStyleRuleImpl : public nsICSSStyleRuleDOMWrapper
 869 {
 870 public:
 871   DOMCSSStyleRuleImpl(nsICSSStyleRule *aRule);
 872   virtual ~DOMCSSStyleRuleImpl();
 873
 874   NS_DECL_ISUPPORTS
 875   NS_DECL_NSIDOMCSSRULE
 876   NS_DECL_NSIDOMCSSSTYLERULE
 877
 878   // nsICSSStyleRuleDOMWrapper
 879   NS_IMETHOD GetCSSStyleRule(nsICSSStyleRule **aResult);
 880
 881   DOMCSSDeclarationImpl* DOMDeclaration() { return &mDOMDeclaration; }
 882
 883   friend class DOMCSSDeclarationImpl;
 884
 885 protected:
 886   DOMCSSDeclarationImpl mDOMDeclaration;
 887
 888   nsICSSStyleRule* Rule() {
 889     return mDOMDeclaration.mRule;
 890   }
 891 };
 892
 893 DOMCSSDeclarationImpl::DOMCSSDeclarationImpl(nsICSSStyleRule *aRule)
 894   : mRule(aRule)
 895 {
 896   MOZ_COUNT_CTOR(DOMCSSDeclarationImpl);
 897 }
 898
 899 DOMCSSDeclarationImpl::~DOMCSSDeclarationImpl(void)
 900 {
 901   NS_ASSERTION(!mRule, "DropReference not called.");
 902
 903   MOZ_COUNT_DTOR(DOMCSSDeclarationImpl);
 904 }
 905
 906 inline DOMCSSStyleRuleImpl* DOMCSSDeclarationImpl::DomRule()
 907 {
 908   return reinterpret_cast<DOMCSSStyleRuleImpl*>
 909                          (reinterpret_cast<char*>(this) -
 910            offsetof(DOMCSSStyleRuleImpl, mDOMDeclaration));
 911 }
 912
 913 NS_IMPL_ADDREF_USING_AGGREGATOR(DOMCSSDeclarationImpl, DomRule())
 914 NS_IMPL_RELEASE_USING_AGGREGATOR(DOMCSSDeclarationImpl, DomRule())
 915
 916 void
 917 DOMCSSDeclarationImpl::DropReference(void)
 918 {
 919   mRule = nsnull;
 920 }
 921
 922 nsresult
 923 DOMCSSDeclarationImpl::GetCSSDeclaration(nsCSSDeclaration **aDecl,
 924                                          PRBool aAllocate)
 925 {
 926   if (mRule) {
 927     *aDecl = mRule->GetDeclaration();
 928   }
 929   else {
 930     *aDecl = nsnull;
 931   }
 932
 933   return NS_OK;
 934 }
 935
 936 /*
 937  * This is a utility function.  It will only fail if it can't get a
 938  * parser.  This means it can return NS_OK without aURI or aCSSLoader
 939  * being initialized.
 940  */
 941 nsresult
 942 DOMCSSDeclarationImpl::GetCSSParsingEnvironment(nsIURI** aSheetURI,
 943                                                 nsIURI** aBaseURI,
 944                                                 nsIPrincipal** aSheetPrincipal,
 945                                                 nsICSSLoader** aCSSLoader,
 946                                                 nsICSSParser** aCSSParser)
 947 {
 948   // null out the out params since some of them may not get initialized below
 949   *aSheetURI = nsnull;
 950   *aBaseURI = nsnull;
 951   *aSheetPrincipal = nsnull;
 952   *aCSSLoader = nsnull;
 953   *aCSSParser = nsnull;
 954   nsresult result;
 955   nsCOMPtr<nsIStyleSheet> sheet;
 956   if (mRule) {
 957     mRule->GetStyleSheet(*getter_AddRefs(sheet));
 958     if (sheet) {
 959       sheet->GetSheetURI(aSheetURI);
 960       sheet->GetBaseURI(aBaseURI);
 961
 962       nsCOMPtr<nsICSSStyleSheet> cssSheet(do_QueryInterface(sheet));
 963       if (cssSheet) {
 964         NS_ADDREF(*aSheetPrincipal = cssSheet->Principal());
 965       }
 966
 967       nsCOMPtr<nsIDocument> document;
 968       sheet->GetOwningDocument(*getter_AddRefs(document));
 969       if (document) {
 970         NS_ADDREF(*aCSSLoader = document->CSSLoader());
 971       }
 972     }
 973   }
 974   // XXXldb Why bother if |mRule| is null?
 975   if (*aCSSLoader) {
 976     result = (*aCSSLoader)->GetParserFor(nsnull, aCSSParser);
 977   } else {
 978     result = NS_NewCSSParser(aCSSParser);
 979   }
 980
 981   if (NS_SUCCEEDED(result) && !*aSheetPrincipal) {
 982     result = CallCreateInstance("@mozilla.org/nullprincipal;1",
 983                                 aSheetPrincipal);
 984   }
 985
 986   return result;
 987 }
 988
 989 NS_IMETHODIMP
 990 DOMCSSDeclarationImpl::GetParentRule(nsIDOMCSSRule **aParent)
 991 {
 992   NS_ENSURE_ARG_POINTER(aParent);
 993
 994   if (!mRule) {
 995     *aParent = nsnull;
 996     return NS_OK;
 997   }
 998
 999   return mRule->GetDOMRule(aParent);
1000 }
1001
1002 nsresult
1003 DOMCSSDeclarationImpl::DeclarationChanged()
1004 {
1005   NS_PRECONDITION(mRule,
1006          "can only be called when |GetCSSDeclaration| returned a declaration");
1007
1008   nsCOMPtr<nsIDocument> owningDoc;
1009   nsCOMPtr<nsIStyleSheet> sheet;
1010   mRule->GetStyleSheet(*getter_AddRefs(sheet));
1011   if (sheet) {
1012     sheet->GetOwningDocument(*getter_AddRefs(owningDoc));
1013   }
1014
1015   mozAutoDocUpdate updateBatch(owningDoc, UPDATE_STYLE, PR_TRUE);
1016
1017   nsCOMPtr<nsICSSStyleRule> oldRule = mRule;
1018   mRule = oldRule->DeclarationChanged(PR_TRUE).get();
1019   if (!mRule)
1020     return NS_ERROR_OUT_OF_MEMORY;
1021   nsrefcnt cnt = mRule->Release();
1022   if (cnt == 0) {
1023     NS_NOTREACHED("container didn't take ownership");
1024     mRule = nsnull;
1025     return NS_ERROR_UNEXPECTED;
1026   }
1027
1028   if (owningDoc) {
1029     owningDoc->StyleRuleChanged(sheet, oldRule, mRule);
1030   }
1031   return NS_OK;
1032 }
1033
1034 DOMCSSStyleRuleImpl::DOMCSSStyleRuleImpl(nsICSSStyleRule* aRule)
1035   : mDOMDeclaration(aRule)
1036 {
1037 }
1038
1039 DOMCSSStyleRuleImpl::~DOMCSSStyleRuleImpl()
1040 {
1041 }
1042
1043 NS_INTERFACE_MAP_BEGIN(DOMCSSStyleRuleImpl)
1044   NS_INTERFACE_MAP_ENTRY(nsICSSStyleRuleDOMWrapper)
1045   NS_INTERFACE_MAP_ENTRY(nsIDOMCSSStyleRule)
1046   NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule)
1047   NS_INTERFACE_MAP_ENTRY(nsISupports)
1048   NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(CSSStyleRule)
1049 NS_INTERFACE_MAP_END
1050
1051 NS_IMPL_ADDREF(DOMCSSStyleRuleImpl)
1052 NS_IMPL_RELEASE(DOMCSSStyleRuleImpl)
1053
1054 NS_IMETHODIMP
1055 DOMCSSStyleRuleImpl::GetType(PRUint16* aType)
1056 {
1057   *aType = nsIDOMCSSRule::STYLE_RULE;
1058
1059   return NS_OK;
1060 }
1061
1062 NS_IMETHODIMP
1063 DOMCSSStyleRuleImpl::GetCssText(nsAString& aCssText)
1064 {
1065   if (!Rule()) {
1066     aCssText.Truncate();
1067     return NS_OK;
1068   }
1069   return Rule()->GetCssText(aCssText);
1070 }
1071
1072 NS_IMETHODIMP
1073 DOMCSSStyleRuleImpl::SetCssText(const nsAString& aCssText)
1074 {
1075   if (!Rule()) {
1076     return NS_OK;
1077   }
1078   return Rule()->SetCssText(aCssText);
1079 }
1080
1081 NS_IMETHODIMP
1082 DOMCSSStyleRuleImpl::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet)
1083 {
1084   if (!Rule()) {
1085     *aSheet = nsnull;
1086     return NS_OK;
1087   }
1088   nsCOMPtr<nsICSSStyleSheet> sheet;
1089   Rule()->GetParentStyleSheet(getter_AddRefs(sheet));
1090   if (!sheet) {
1091     *aSheet = nsnull;
1092     return NS_OK;
1093   }
1094   return CallQueryInterface(sheet, aSheet);
1095 }
1096
1097 NS_IMETHODIMP
1098 DOMCSSStyleRuleImpl::GetParentRule(nsIDOMCSSRule** aParentRule)
1099 {
1100   if (!Rule()) {
1101     *aParentRule = nsnull;
1102     return NS_OK;
1103   }
1104   nsCOMPtr<nsICSSGroupRule> rule;
1105   Rule()->GetParentRule(getter_AddRefs(rule));
1106   if (!rule) {
1107     *aParentRule = nsnull;
1108     return NS_OK;
1109   }
1110   return rule->GetDOMRule(aParentRule);
1111 }
1112
1113 NS_IMETHODIMP
1114 DOMCSSStyleRuleImpl::GetSelectorText(nsAString& aSelectorText)
1115 {
1116   if (!Rule()) {
1117     aSelectorText.Truncate();
1118     return NS_OK;
1119   }
1120   return Rule()->GetSelectorText(aSelectorText);
1121 }
1122
1123 NS_IMETHODIMP
1124 DOMCSSStyleRuleImpl::SetSelectorText(const nsAString& aSelectorText)
1125 {
1126   if (!Rule()) {
1127     return NS_OK;
1128   }
1129   return Rule()->SetSelectorText(aSelectorText);
1130 }
1131
1132 NS_IMETHODIMP
1133 DOMCSSStyleRuleImpl::GetStyle(nsIDOMCSSStyleDeclaration** aStyle)
1134 {
1135   *aStyle = &mDOMDeclaration;
1136   NS_ADDREF(*aStyle);
1137   return NS_OK;
1138 }
1139
1140 NS_IMETHODIMP
1141 DOMCSSStyleRuleImpl::GetCSSStyleRule(nsICSSStyleRule **aResult)
1142 {
1143   *aResult = Rule();
1144   NS_IF_ADDREF(*aResult);
1145   return NS_OK;
1146 }
1147
1148 // -- nsCSSStyleRule -------------------------------
1149
1150 class CSSStyleRuleImpl : public nsCSSRule,
1151                          public nsICSSStyleRule
1152 {
1153 public:
1154   CSSStyleRuleImpl(nsCSSSelectorList* aSelector,
1155                    nsCSSDeclaration *aDeclaration);
1156 private:
1157   // for |Clone|
1158   CSSStyleRuleImpl(const CSSStyleRuleImpl& aCopy);
1159   // for |DeclarationChanged|
1160   CSSStyleRuleImpl(CSSStyleRuleImpl& aCopy,
1161                    nsCSSDeclaration *aDeclaration);
1162 public:
1163
1164   NS_DECL_ISUPPORTS_INHERITED
1165
1166   virtual nsCSSSelectorList* Selector(void);
1167
1168   virtual PRUint32 GetLineNumber(void) const;
1169   virtual void SetLineNumber(PRUint32 aLineNumber);
1170
1171   virtual nsCSSDeclaration* GetDeclaration(void) const;
1172
1173   virtual already_AddRefed<nsIStyleRule> GetImportantRule(void);
1174
1175   NS_IMETHOD GetStyleSheet(nsIStyleSheet*& aSheet) const;
1176   NS_IMETHOD SetStyleSheet(nsICSSStyleSheet* aSheet);
1177
1178   NS_IMETHOD SetParentRule(nsICSSGroupRule* aRule);
1179
1180   virtual nsresult GetCssText(nsAString& aCssText);
1181   virtual nsresult SetCssText(const nsAString& aCssText);
1182   virtual nsresult GetParentStyleSheet(nsICSSStyleSheet** aSheet);
1183   virtual nsresult GetParentRule(nsICSSGroupRule** aParentRule);
1184   virtual nsresult GetSelectorText(nsAString& aSelectorText);
1185   virtual nsresult SetSelectorText(const nsAString& aSelectorText);
1186
1187   NS_IMETHOD GetType(PRInt32& aType) const;
1188   NS_IMETHOD Clone(nsICSSRule*& aClone) const;
1189
1190   nsIDOMCSSRule* GetDOMRuleWeak(nsresult* aResult);
1191
1192   virtual already_AddRefed<nsICSSStyleRule>
1193     DeclarationChanged(PRBool aHandleContainer);
1194
1195   // The new mapping function.
1196   NS_IMETHOD MapRuleInfoInto(nsRuleData* aRuleData);
1197
1198 #ifdef DEBUG
1199   NS_IMETHOD List(FILE* out = stdout, PRInt32 aIndent = 0) const;
1200 #endif
1201
1202 private:
1203   // These are not supported and are not implemented!
1204   CSSStyleRuleImpl& operator=(const CSSStyleRuleImpl& aCopy);
1205
1206 protected:
1207   virtual ~CSSStyleRuleImpl(void);
1208
1209 protected:
1210   nsCSSSelectorList*      mSelector; // null for style attribute
1211   nsCSSDeclaration*       mDeclaration;
1212   CSSImportantRule*       mImportantRule;
1213   DOMCSSStyleRuleImpl*    mDOMRule;
1214   PRUint32                mLineNumber;
1215 };
1216
1217 CSSStyleRuleImpl::CSSStyleRuleImpl(nsCSSSelectorList* aSelector,
1218                                    nsCSSDeclaration* aDeclaration)
1219   : nsCSSRule(),
1220     mSelector(aSelector),
1221     mDeclaration(aDeclaration),
1222     mImportantRule(nsnull),
1223     mDOMRule(nsnull),
1224     mLineNumber(0)
1225 {
1226   mDeclaration->AddRef();
1227 }
1228
1229 // for |Clone|
1230 CSSStyleRuleImpl::CSSStyleRuleImpl(const CSSStyleRuleImpl& aCopy)
1231   : nsCSSRule(aCopy),
1232     mSelector(aCopy.mSelector ? aCopy.mSelector->Clone() : nsnull),
1233     mDeclaration(aCopy.mDeclaration->Clone()),
1234     mImportantRule(nsnull),
1235     mDOMRule(nsnull),
1236     mLineNumber(aCopy.mLineNumber)
1237 {
1238   if (mDeclaration)
1239     mDeclaration->AddRef();
1240   // rest is constructed lazily on existing data
1241 }
1242
1243 // for |DeclarationChanged|
1244 CSSStyleRuleImpl::CSSStyleRuleImpl(CSSStyleRuleImpl& aCopy,
1245                                    nsCSSDeclaration* aDeclaration)
1246   : nsCSSRule(aCopy),
1247     mSelector(aCopy.mSelector),
1248     mDeclaration(aDeclaration),
1249     mImportantRule(nsnull),
1250     mDOMRule(aCopy.mDOMRule),
1251     mLineNumber(aCopy.mLineNumber)
1252 {
1253   // The DOM rule is replacing |aCopy| with |this|, so transfer
1254   // the reverse pointer as well (and transfer ownership).
1255   aCopy.mDOMRule = nsnull;
1256
1257   NS_ASSERTION(aDeclaration == aCopy.mDeclaration, "declaration mismatch");
1258   // Transfer ownership of selector and declaration:
1259   aCopy.mSelector = nsnull;
1260 #if 0
1261   aCopy.mDeclaration = nsnull;
1262 #else
1263   // We ought to be able to transfer ownership of the selector and the
1264   // declaration since this rule should now be unused, but unfortunately
1265   // SetInlineStyleRule might use it before setting the new rule (see
1266   // stack in bug 209575).  So leave the declaration pointer on the old
1267   // rule.
1268   mDeclaration->AddRef();
1269 #endif
1270 }
1271
1272
1273 CSSStyleRuleImpl::~CSSStyleRuleImpl(void)
1274 {
1275   if (mSelector) {
1276     delete mSelector;
1277     mSelector = nsnull;
1278   }
1279   if (nsnull != mDeclaration) {
1280     mDeclaration->Release();
1281     mDeclaration = nsnull;
1282   }
1283   if (nsnull != mImportantRule) {
1284     NS_RELEASE(mImportantRule);
1285     mImportantRule = nsnull;
1286   }
1287   if (mDOMRule) {
1288     mDOMRule->DOMDeclaration()->DropReference();
1289     NS_RELEASE(mDOMRule);
1290   }
1291 }
1292
1293 // QueryInterface implementation for CSSStyleRuleImpl
1294 NS_INTERFACE_MAP_BEGIN(CSSStyleRuleImpl)
1295   NS_INTERFACE_MAP_ENTRY(nsICSSStyleRule)
1296   NS_INTERFACE_MAP_ENTRY(nsICSSRule)
1297   NS_INTERFACE_MAP_ENTRY(nsIStyleRule)
1298   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsICSSStyleRule)
1299 NS_INTERFACE_MAP_END
1300
1301 NS_IMPL_ADDREF_INHERITED(CSSStyleRuleImpl, nsCSSRule)
1302 NS_IMPL_RELEASE_INHERITED(CSSStyleRuleImpl, nsCSSRule)
1303
1304 nsCSSSelectorList* CSSStyleRuleImpl::Selector(void)
1305 {
1306   return mSelector;
1307 }
1308
1309 PRUint32 CSSStyleRuleImpl::GetLineNumber(void) const
1310 {
1311   return mLineNumber;
1312 }
1313
1314 void CSSStyleRuleImpl::SetLineNumber(PRUint32 aLineNumber)
1315 {
1316   mLineNumber = aLineNumber;
1317 }
1318
1319 nsCSSDeclaration* CSSStyleRuleImpl::GetDeclaration(void) const
1320 {
1321   return mDeclaration;
1322 }
1323
1324 already_AddRefed<nsIStyleRule> CSSStyleRuleImpl::GetImportantRule(void)
1325 {
1326   if (!mDeclaration->HasImportantData()) {
1327     NS_ASSERTION(!mImportantRule, "immutable, so should be no important rule");
1328     return nsnull;
1329   }
1330
1331   if (!mImportantRule) {
1332     mImportantRule = new CSSImportantRule(mDeclaration);
1333     if (!mImportantRule)
1334       return nsnull;
1335     NS_ADDREF(mImportantRule);
1336   }
1337   NS_ADDREF(mImportantRule);
1338   return mImportantRule;
1339 }
1340
1341 NS_IMETHODIMP
1342 CSSStyleRuleImpl::GetStyleSheet(nsIStyleSheet*& aSheet) const
1343 {
1344 // XXX What about inner, etc.
1345   return nsCSSRule::GetStyleSheet(aSheet);
1346 }
1347
1348 NS_IMETHODIMP
1349 CSSStyleRuleImpl::SetStyleSheet(nsICSSStyleSheet* aSheet)
1350 {
1351   return nsCSSRule::SetStyleSheet(aSheet);
1352 }
1353
1354 NS_IMETHODIMP
1355 CSSStyleRuleImpl::SetParentRule(nsICSSGroupRule* aRule)
1356 {
1357   return nsCSSRule::SetParentRule(aRule);
1358 }
1359
1360 NS_IMETHODIMP
1361 CSSStyleRuleImpl::GetType(PRInt32& aType) const
1362 {
1363   aType = nsICSSRule::STYLE_RULE;
1364   return NS_OK;
1365 }
1366
1367 NS_IMETHODIMP
1368 CSSStyleRuleImpl::Clone(nsICSSRule*& aClone) const
1369 {
1370   CSSStyleRuleImpl* clone = new CSSStyleRuleImpl(*this);
1371   if (!clone || !clone->mDeclaration || (!clone->mSelector != !mSelector)) {
1372     delete clone;
1373     aClone = nsnull;
1374     return NS_ERROR_OUT_OF_MEMORY;
1375   }
1376   return CallQueryInterface(clone, &aClone);
1377 }
1378
1379 nsIDOMCSSRule*
1380 CSSStyleRuleImpl::GetDOMRuleWeak(nsresult *aResult)
1381 {
1382   *aResult = NS_OK;
1383   if (!mSheet) {
1384     // inline style rules aren't supposed to have a DOM rule object, only
1385     // a declaration.
1386     return nsnull;
1387   }
1388   if (!mDOMRule) {
1389     mDOMRule = new DOMCSSStyleRuleImpl(this);
1390     if (!mDOMRule) {
1391       *aResult = NS_ERROR_OUT_OF_MEMORY;
1392       return nsnull;
1393     }
1394     NS_ADDREF(mDOMRule);
1395   }
1396   return mDOMRule;
1397 }
1398
1399 /* virtual */ already_AddRefed<nsICSSStyleRule>
1400 CSSStyleRuleImpl::DeclarationChanged(PRBool aHandleContainer)
1401 {
1402   CSSStyleRuleImpl* clone = new CSSStyleRuleImpl(*this, mDeclaration);
1403   if (!clone) {
1404     return nsnull;
1405   }
1406
1407   NS_ADDREF(clone); // for return
1408
1409   if (aHandleContainer) {
1410     NS_ASSERTION(mSheet, "rule must be in a sheet");
1411     if (mParentRule) {
1412       mSheet->ReplaceRuleInGroup(mParentRule, this, clone);
1413     } else {
1414       mSheet->ReplaceStyleRule(this, clone);
1415     }
1416   }
1417
1418   return clone;
1419 }
1420
1421 NS_IMETHODIMP
1422 CSSStyleRuleImpl::MapRuleInfoInto(nsRuleData* aRuleData)
1423 {
1424   return mDeclaration->MapRuleInfoInto(aRuleData);
1425 }
1426
1427 #ifdef DEBUG
1428 NS_IMETHODIMP
1429 CSSStyleRuleImpl::List(FILE* out, PRInt32 aIndent) const
1430 {
1431   // Indent
1432   for (PRInt32 index = aIndent; --index >= 0; ) fputs("  ", out);
1433
1434   nsAutoString buffer;
1435   if (mSelector)
1436     mSelector->ToString(buffer, mSheet);
1437
1438   buffer.AppendLiteral(" ");
1439   fputs(NS_LossyConvertUTF16toASCII(buffer).get(), out);
1440   if (nsnull != mDeclaration) {
1441     mDeclaration->List(out);
1442   }
1443   else {
1444     fputs("{ null declaration }", out);
1445   }
1446   fputs("\n", out);
1447
1448   return NS_OK;
1449 }
1450 #endif
1451
1452 /* virtual */ nsresult
1453 CSSStyleRuleImpl::GetCssText(nsAString& aCssText)
1454 {
1455   if (mSelector) {
1456     mSelector->ToString(aCssText, mSheet);
1457     aCssText.Append(PRUnichar(' '));
1458   }
1459   aCssText.Append(PRUnichar('{'));
1460   aCssText.Append(PRUnichar(' '));
1461   if (mDeclaration)
1462   {
1463     nsAutoString   tempString;
1464     mDeclaration->ToString( tempString );
1465     aCssText.Append( tempString );
1466   }
1467   aCssText.Append(PRUnichar(' '));
1468   aCssText.Append(PRUnichar('}'));
1469   return NS_OK;
1470 }
1471
1472 /* virtual */ nsresult
1473 CSSStyleRuleImpl::SetCssText(const nsAString& aCssText)
1474 {
1475   // XXX TBI - need to re-parse rule & declaration
1476   return NS_OK;
1477 }
1478
1479 /* virtual */ nsresult
1480 CSSStyleRuleImpl::GetParentStyleSheet(nsICSSStyleSheet** aSheet)
1481 {
1482   *aSheet = mSheet;
1483   NS_IF_ADDREF(*aSheet);
1484   return NS_OK;
1485 }
1486
1487 /* virtual */ nsresult
1488 CSSStyleRuleImpl::GetParentRule(nsICSSGroupRule** aParentRule)
1489 {
1490   *aParentRule = mParentRule;
1491   NS_IF_ADDREF(*aParentRule);
1492   return NS_OK;
1493 }
1494
1495 /* virtual */ nsresult
1496 CSSStyleRuleImpl::GetSelectorText(nsAString& aSelectorText)
1497 {
1498   if (mSelector)
1499     mSelector->ToString(aSelectorText, mSheet);
1500   else
1501     aSelectorText.Truncate();
1502   return NS_OK;
1503 }
1504
1505 /* virtual */ nsresult
1506 CSSStyleRuleImpl::SetSelectorText(const nsAString& aSelectorText)
1507 {
1508   // XXX TBI - get a parser and re-parse the selectors,
1509   // XXX then need to re-compute the cascade
1510   // XXX and dirty sheet
1511   return NS_OK;
1512 }
1513
1514 nsresult
1515 NS_NewCSSStyleRule(nsICSSStyleRule** aInstancePtrResult,
1516                    nsCSSSelectorList* aSelector,
1517                    nsCSSDeclaration* aDeclaration)
1518 {
1519   NS_PRECONDITION(aDeclaration, "must have a declaration");
1520   CSSStyleRuleImpl *it = new CSSStyleRuleImpl(aSelector, aDeclaration);
1521   if (!it) {
1522     return NS_ERROR_OUT_OF_MEMORY;
1523   }
1524
1525   return CallQueryInterface(it, aInstancePtrResult);
1526 }