Bug 542731: SMIL misc code cleanup: remove trailing '.' from warning messages, to prevent the '.:' in output like 'ASSERTION: blah blah.: /path/to/file:NN'. (no changes outside of assertion/warning message text)
authorDaniel Holbert <dholbert@cs.stanford.edu>
Thu, 28 Jan 2010 01:50:30 -0800
changeset 37602 cff84777576d7a0cee4eb2608247951b72289f58
parent 37601 027ad991923707d3e5a56dbff97eb4d186c9fafe
child 37603 49b45b82988f1221b16bb64ddeb513db26a0ec3c
push id11387
push userdholbert@mozilla.com
push dateThu, 28 Jan 2010 10:07:37 +0000
treeherdermozilla-central@6712bed154ed [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs542731
milestone1.9.3a1pre
Bug 542731: SMIL misc code cleanup: remove trailing '.' from warning messages, to prevent the '.:' in output like 'ASSERTION: blah blah.: /path/to/file:NN'. (no changes outside of assertion/warning message text)
content/smil/SMILBoolType.cpp
content/smil/SMILEnumType.cpp
content/smil/nsSMILAnimationController.cpp
content/smil/nsSMILAnimationFunction.cpp
content/smil/nsSMILCSSValueType.cpp
content/smil/nsSMILFloatType.cpp
content/smil/nsSMILNullType.cpp
content/smil/nsSMILRepeatCount.h
content/smil/nsSMILSetAnimationFunction.cpp
content/smil/nsSMILTimedElement.cpp
content/smil/nsSMILValue.cpp
content/svg/content/src/nsSVGTransformSMILAttr.cpp
content/svg/content/src/nsSVGTransformSMILType.cpp
--- a/content/smil/SMILBoolType.cpp
+++ b/content/smil/SMILBoolType.cpp
@@ -51,26 +51,26 @@ SMILBoolType::Init(nsSMILValue& aValue) 
   aValue.mU.mBool = PR_FALSE;
   aValue.mType = this;
   return NS_OK;
 }
 
 void
 SMILBoolType::Destroy(nsSMILValue& aValue) const
 {
-  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value.");
+  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value");
   aValue.mU.mBool = PR_FALSE;
   aValue.mType = &nsSMILNullType::sSingleton;
 }
 
 nsresult
 SMILBoolType::Assign(nsSMILValue& aDest, const nsSMILValue& aSrc) const
 {
-  NS_PRECONDITION(aDest.mType == aSrc.mType, "Incompatible SMIL types.");
-  NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL value.");
+  NS_PRECONDITION(aDest.mType == aSrc.mType, "Incompatible SMIL types");
+  NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL value");
   aDest.mU.mBool = aSrc.mU.mBool;
   return NS_OK;
 }
 
 nsresult
 SMILBoolType::Add(nsSMILValue& aDest, const nsSMILValue& aValueToAdd,
                   PRUint32 aCount) const
 {
@@ -94,14 +94,14 @@ nsresult
 SMILBoolType::Interpolate(const nsSMILValue& aStartVal,
                           const nsSMILValue& aEndVal,
                           double aUnitDistance,
                           nsSMILValue& aResult) const
 {
   NS_PRECONDITION(aStartVal.mType == aEndVal.mType,
       "Trying to interpolate different types");
   NS_PRECONDITION(aStartVal.mType == this,
-      "Unexpected types for interpolation.");
-  NS_PRECONDITION(aResult.mType   == this, "Unexpected result type.");
+      "Unexpected types for interpolation");
+  NS_PRECONDITION(aResult.mType   == this, "Unexpected result type");
   return NS_ERROR_FAILURE; // bool values do not interpolate
 }
 
 } // namespace mozilla
--- a/content/smil/SMILEnumType.cpp
+++ b/content/smil/SMILEnumType.cpp
@@ -51,26 +51,26 @@ SMILEnumType::Init(nsSMILValue& aValue) 
   aValue.mU.mUint = 0;
   aValue.mType = this;
   return NS_OK;
 }
 
 void
 SMILEnumType::Destroy(nsSMILValue& aValue) const
 {
-  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value.");
+  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value");
   aValue.mU.mUint = 0;
   aValue.mType = &nsSMILNullType::sSingleton;
 }
 
 nsresult
 SMILEnumType::Assign(nsSMILValue& aDest, const nsSMILValue& aSrc) const
 {
-  NS_PRECONDITION(aDest.mType == aSrc.mType, "Incompatible SMIL types.");
-  NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL value.");
+  NS_PRECONDITION(aDest.mType == aSrc.mType, "Incompatible SMIL types");
+  NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL value");
   aDest.mU.mUint = aSrc.mU.mUint;
   return NS_OK;
 }
 
 nsresult
 SMILEnumType::Add(nsSMILValue& aDest, const nsSMILValue& aValueToAdd,
                   PRUint32 aCount) const
 {
@@ -94,14 +94,14 @@ nsresult
 SMILEnumType::Interpolate(const nsSMILValue& aStartVal,
                           const nsSMILValue& aEndVal,
                           double aUnitDistance,
                           nsSMILValue& aResult) const
 {
   NS_PRECONDITION(aStartVal.mType == aEndVal.mType,
       "Trying to interpolate different types");
   NS_PRECONDITION(aStartVal.mType == this,
-      "Unexpected types for interpolation.");
-  NS_PRECONDITION(aResult.mType   == this, "Unexpected result type.");
+      "Unexpected types for interpolation");
+  NS_PRECONDITION(aResult.mType   == this, "Unexpected result type");
   return NS_ERROR_FAILURE; // enum values do not interpolate
 }
 
 } // namespace mozilla
--- a/content/smil/nsSMILAnimationController.cpp
+++ b/content/smil/nsSMILAnimationController.cpp
@@ -77,17 +77,17 @@ nsSMILAnimationController::~nsSMILAnimat
 {
   if (mTimer) {
     mTimer->Cancel();
     mTimer = nsnull;
   }
 
   NS_ASSERTION(mAnimationElementTable.Count() == 0,
                "Animation controller shouldn't be tracking any animation"
-               " elements when it dies.");
+               " elements when it dies");
 }
 
 nsSMILAnimationController* NS_NewSMILAnimationController(nsIDocument* aDoc)
 {
   nsSMILAnimationController* animationController =
     new nsSMILAnimationController();
   NS_ENSURE_TRUE(animationController, nsnull);
 
@@ -224,17 +224,17 @@ nsSMILAnimationController::Notify(nsITim
 
   controller->Sample();
 }
 
 nsresult
 nsSMILAnimationController::StartTimer()
 {
   NS_ENSURE_TRUE(mTimer, NS_ERROR_FAILURE);
-  NS_ASSERTION(mPauseState == 0, "Starting timer but controller is paused.");
+  NS_ASSERTION(mPauseState == 0, "Starting timer but controller is paused");
 
   // Run the first sample manually
   Sample();
 
   //
   // XXX Make this self-tuning. Sounds like control theory to me and not
   // something I'm familiar with.
   //
--- a/content/smil/nsSMILAnimationFunction.cpp
+++ b/content/smil/nsSMILAnimationFunction.cpp
@@ -300,17 +300,17 @@ nsSMILAnimationFunction::ComposeResult(c
   }
 }
 
 PRInt8
 nsSMILAnimationFunction::CompareTo(const nsSMILAnimationFunction* aOther) const
 {
   NS_ENSURE_TRUE(aOther, 0);
 
-  NS_ASSERTION(aOther != this, "Trying to compare to self.");
+  NS_ASSERTION(aOther != this, "Trying to compare to self");
 
   // Inactive animations sort first
   if (!IsActiveOrFrozen() && aOther->IsActiveOrFrozen())
     return -1;
 
   if (IsActiveOrFrozen() && !aOther->IsActiveOrFrozen())
     return 1;
 
@@ -371,23 +371,23 @@ nsSMILAnimationFunction::InterpolateResu
   nsresult rv = NS_OK;
   const nsSMILTime& dur = mSimpleDuration.GetMillis();
 
   // Sanity Checks
   NS_ABORT_IF_FALSE(mSampleTime >= 0.0f, "Sample time should not be negative");
   NS_ABORT_IF_FALSE(dur >= 0.0f, "Simple duration should not be negative");
 
   if (mSampleTime >= dur || mSampleTime < 0.0f) {
-    NS_ERROR("Animation sampled outside interval.");
+    NS_ERROR("Animation sampled outside interval");
     return NS_ERROR_FAILURE;
   }
 
   if ((!IsToAnimation() && aValues.Length() < 2) ||
       (IsToAnimation()  && aValues.Length() != 1)) {
-    NS_ERROR("Unexpected number of values.");
+    NS_ERROR("Unexpected number of values");
     return NS_ERROR_FAILURE;
   }
   // End Sanity Checks
 
   double fTime = double(mSampleTime);
   double fDur = double(dur);
 
   // Get the normalised progress through the simple duration
@@ -439,18 +439,18 @@ nsSMILAnimationFunction::InterpolateResu
                                          (aValues.Length() - 1));
         from = &aValues[index];
         to = &aValues[index + 1];
         intervalProgress = simpleProgress * (aValues.Length() - 1) - index;
         ScaleIntervalProgress(intervalProgress, index, aValues.Length() - 1);
       }
     }
     if (NS_SUCCEEDED(rv)) {
-      NS_ABORT_IF_FALSE(from, "NULL from-value during interpolation.");
-      NS_ABORT_IF_FALSE(to, "NULL to-value during interpolation.");
+      NS_ABORT_IF_FALSE(from, "NULL from-value during interpolation");
+      NS_ABORT_IF_FALSE(to, "NULL to-value during interpolation");
       NS_ABORT_IF_FALSE(0.0f <= intervalProgress && intervalProgress < 1.0f,
                       "Interval progress should be in the range [0, 1)");
       rv = from->Interpolate(*to, intervalProgress, aResult);
     }
   }
 
   // Discrete-CalcMode case
   // Note: If interpolation failed (isn't supported for this type), the SVG
@@ -497,17 +497,17 @@ nsSMILAnimationFunction::AccumulateResul
 nsresult
 nsSMILAnimationFunction::ComputePacedPosition(const nsSMILValueArray& aValues,
                                               double aSimpleProgress,
                                               double& aIntervalProgress,
                                               const nsSMILValue*& aFrom,
                                               const nsSMILValue*& aTo)
 {
   NS_ASSERTION(0.0f <= aSimpleProgress && aSimpleProgress < 1.0f,
-               "aSimpleProgress is out of bounds.");
+               "aSimpleProgress is out of bounds");
   NS_ASSERTION(GetCalcMode() == CALC_PACED,
                "Calling paced-specific function, but not in paced mode");
 
   double totalDistance = ComputePacedTotalDistance(aValues);
   if (totalDistance == COMPUTE_DISTANCE_ERROR)
     return NS_ERROR_FAILURE;
 
   // total distance we should have moved at this point in time.
@@ -553,17 +553,17 @@ nsSMILAnimationFunction::ComputePacedPos
       aFrom = &aValues[i];
       aTo = &aValues[i+1];
       aIntervalProgress = remainingDist / curIntervalDist;
       return NS_OK;
     }
   }
 
   NS_NOTREACHED("shouldn't complete loop & get here -- if we do, "
-                "then aSimpleProgress was probably out of bounds.");
+                "then aSimpleProgress was probably out of bounds");
   return NS_ERROR_FAILURE;
 }
 
 /*
  * Computes the total distance to be travelled by a paced animation.
  *
  * Returns the total distance, or returns COMPUTE_DISTANCE_ERROR if
  * our values don't support distance computation.
@@ -635,18 +635,18 @@ nsSMILAnimationFunction::ScaleIntervalPr
 {
   if (GetCalcMode() != CALC_SPLINE)
     return;
 
   if (!HasAttr(nsGkAtoms::keySplines))
     return;
 
   NS_ASSERTION(aIntervalIndex < (PRUint32)mKeySplines.Length(),
-               "Invalid interval index.");
-  NS_ASSERTION(aNumIntervals >= 1, "Invalid number of intervals.");
+               "Invalid interval index");
+  NS_ASSERTION(aNumIntervals >= 1, "Invalid number of intervals");
 
   if (aIntervalIndex >= (PRUint32)mKeySplines.Length() ||
       aNumIntervals < 1)
     return;
 
   nsSMILKeySpline const &spline = mKeySplines[aIntervalIndex];
   aProgress = spline.GetSplineValue(aProgress);
 }
--- a/content/smil/nsSMILCSSValueType.cpp
+++ b/content/smil/nsSMILCSSValueType.cpp
@@ -73,17 +73,17 @@ static const nsStyleAnimation::Value
   sZeroColor(NS_RGB(0,0,0), nsStyleAnimation::Value::ColorConstructor);
 
 // Helper Methods
 // --------------
 static const nsStyleAnimation::Value*
 GetZeroValueForUnit(nsStyleAnimation::Unit aUnit)
 {
   NS_ABORT_IF_FALSE(aUnit != nsStyleAnimation::eUnit_Null,
-                    "Need non-null unit for a zero value.");
+                    "Need non-null unit for a zero value");
   switch (aUnit) {
     case nsStyleAnimation::eUnit_Coord:
       return &sZeroCoord;
     case nsStyleAnimation::eUnit_Percent:
       return &sZeroPercent;
     case nsStyleAnimation::eUnit_Float:
       return &sZeroFloat;
     case nsStyleAnimation::eUnit_Color:
--- a/content/smil/nsSMILFloatType.cpp
+++ b/content/smil/nsSMILFloatType.cpp
@@ -51,26 +51,26 @@ nsSMILFloatType::Init(nsSMILValue& aValu
   aValue.mU.mDouble = 0.0;
   aValue.mType = this;
   return NS_OK;
 }
 
 void
 nsSMILFloatType::Destroy(nsSMILValue& aValue) const
 {
-  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value.");
+  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value");
   aValue.mU.mDouble = 0.0;
   aValue.mType      = &nsSMILNullType::sSingleton;
 }
 
 nsresult
 nsSMILFloatType::Assign(nsSMILValue& aDest, const nsSMILValue& aSrc) const
 {
-  NS_PRECONDITION(aDest.mType == aSrc.mType, "Incompatible SMIL types.");
-  NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL value.");
+  NS_PRECONDITION(aDest.mType == aSrc.mType, "Incompatible SMIL types");
+  NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL value");
   aDest.mU.mDouble = aSrc.mU.mDouble;
   return NS_OK;
 }
 
 nsresult
 nsSMILFloatType::Add(nsSMILValue& aDest, const nsSMILValue& aValueToAdd,
                      PRUint32 aCount) const
 {
@@ -101,18 +101,18 @@ nsresult
 nsSMILFloatType::Interpolate(const nsSMILValue& aStartVal,
                              const nsSMILValue& aEndVal,
                              double aUnitDistance,
                              nsSMILValue& aResult) const
 {
   NS_PRECONDITION(aStartVal.mType == aEndVal.mType,
       "Trying to interpolate different types");
   NS_PRECONDITION(aStartVal.mType == this,
-      "Unexpected types for interpolation.");
-  NS_PRECONDITION(aResult.mType   == this, "Unexpected result type.");
+      "Unexpected types for interpolation");
+  NS_PRECONDITION(aResult.mType   == this, "Unexpected result type");
 
   const double &startVal = aStartVal.mU.mDouble;
   const double &endVal   = aEndVal.mU.mDouble;
 
   aResult.mU.mDouble = (startVal + (endVal - startVal) * aUnitDistance);
 
   return NS_OK;
 }
--- a/content/smil/nsSMILNullType.cpp
+++ b/content/smil/nsSMILNullType.cpp
@@ -40,41 +40,41 @@
 #include "nsSMILValue.h"
 #include "nsDebug.h"
 
 /*static*/ nsSMILNullType nsSMILNullType::sSingleton;
 
 nsresult
 nsSMILNullType::Assign(nsSMILValue& aDest, const nsSMILValue& aSrc) const
 {
-  NS_PRECONDITION(aDest.mType == aSrc.mType, "Incompatible SMIL types.");
+  NS_PRECONDITION(aDest.mType == aSrc.mType, "Incompatible SMIL types");
   NS_PRECONDITION(aSrc.mType == this, "Unexpected source type");
   aDest.mU    = aSrc.mU;
   aDest.mType = &sSingleton;
   return NS_OK;
 }
 
 nsresult
 nsSMILNullType::Add(nsSMILValue& aDest, const nsSMILValue& aValueToAdd,
                     PRUint32 aCount) const
 {
-  NS_NOTREACHED("Adding NULL type.");
+  NS_NOTREACHED("Adding NULL type");
   return NS_ERROR_FAILURE;
 }
 
 nsresult
 nsSMILNullType::ComputeDistance(const nsSMILValue& aFrom,
                                 const nsSMILValue& aTo,
                                 double& aDistance) const
 {
-  NS_NOTREACHED("Computing distance for NULL type.");
+  NS_NOTREACHED("Computing distance for NULL type");
   return NS_ERROR_FAILURE;
 }
 
 nsresult
 nsSMILNullType::Interpolate(const nsSMILValue& aStartVal,
                             const nsSMILValue& aEndVal,
                             double aUnitDistance,
                             nsSMILValue& aResult) const
 {
-  NS_NOTREACHED("Interpolating NULL type.");
+  NS_NOTREACHED("Interpolating NULL type");
   return NS_ERROR_FAILURE;
 }
--- a/content/smil/nsSMILRepeatCount.h
+++ b/content/smil/nsSMILRepeatCount.h
@@ -65,17 +65,17 @@ public:
 
   nsSMILRepeatCount& operator=(double aCount)
   {
     SetCount(aCount);
     return *this;
   }
   void SetCount(double aCount)
   {
-    NS_ASSERTION(aCount > 0.0, "Negative or zero repeat count.");
+    NS_ASSERTION(aCount > 0.0, "Negative or zero repeat count");
     mCount = aCount > 0.0 ? aCount : kNotSet;
   }
   void SetIndefinite() { mCount = kIndefinite; }
   void Unset() { mCount = kNotSet; }
 
 private:
   static const double kNotSet;
   static const double kIndefinite;
--- a/content/smil/nsSMILSetAnimationFunction.cpp
+++ b/content/smil/nsSMILSetAnimationFunction.cpp
@@ -104,21 +104,21 @@ nsSMILSetAnimationFunction::InterpolateR
 {
   // Sanity Checks
   const nsSMILTime& dur = mSimpleDuration.GetMillis();
   NS_ABORT_IF_FALSE(mSampleTime >= 0.0f, "Sample time should not be negative");
   NS_ABORT_IF_FALSE(dur >= 0.0f, "Simple duration should not be negative");
   NS_ABORT_IF_FALSE(IsToAnimation(), "Set element only supports to-animation");
 
   if (mSampleTime >= dur || mSampleTime < 0) {
-    NS_ERROR("Animation sampled outside interval.");
+    NS_ERROR("Animation sampled outside interval");
     return NS_ERROR_FAILURE;
   }
   if (aValues.Length() != 1) {
-    NS_ERROR("Unexpected number of values.");
+    NS_ERROR("Unexpected number of values");
     return NS_ERROR_FAILURE;
   }
   // End Sanity Checks
 
   // Always use the 'to' value (which should be first & only elem in |aValues|)
   aResult = aValues[0];
   return NS_OK;
 }
--- a/content/smil/nsSMILTimedElement.cpp
+++ b/content/smil/nsSMILTimedElement.cpp
@@ -1161,20 +1161,20 @@ nsSMILTimedElement::GetNextGreaterOrEqua
  */
 nsSMILTimeValue
 nsSMILTimedElement::CalcActiveEnd(const nsSMILTimeValue& aBegin,
                                   const nsSMILTimeValue& aEnd) const
 {
   nsSMILTimeValue result;
 
   NS_ASSERTION(mSimpleDur.IsResolved() || mSimpleDur.IsIndefinite(),
-    "Unresolved simple duration in CalcActiveEnd.");
+    "Unresolved simple duration in CalcActiveEnd");
 
   if (!aBegin.IsResolved() && !aBegin.IsIndefinite()) {
-    NS_ERROR("Unresolved begin time passed to CalcActiveEnd.");
+    NS_ERROR("Unresolved begin time passed to CalcActiveEnd");
     result.SetIndefinite();
     return result;
   }
 
   if (mRepeatDur.IsIndefinite() || aBegin.IsIndefinite()) {
     result.SetIndefinite();
   } else {
     result = GetRepeatDuration();
--- a/content/smil/nsSMILValue.cpp
+++ b/content/smil/nsSMILValue.cpp
@@ -42,103 +42,103 @@
 nsSMILValue::nsSMILValue(const nsISMILType* aType)
 : mU(),
   mType(&nsSMILNullType::sSingleton)
 {
   if (!aType) return;
 
   nsresult rv = aType->Init(*this);
   NS_POSTCONDITION(mType == aType || (NS_FAILED(rv) && IsNull()),
-    "Post-condition of Init failed. nsSMILValue is invalid.");
+    "Post-condition of Init failed. nsSMILValue is invalid");
 }
 
 nsSMILValue::nsSMILValue(const nsSMILValue& aVal)
 :
   mU(),
   mType(&nsSMILNullType::sSingleton)
 {
   nsresult rv = aVal.mType->Init(*this);
   NS_POSTCONDITION(mType == aVal.mType || (NS_FAILED(rv) && IsNull()),
-    "Post-condition of Init failed. nsSMILValue is invalid.");
+    "Post-condition of Init failed. nsSMILValue is invalid");
   if (NS_FAILED(rv)) return;
   mType->Assign(*this, aVal);
 }
 
 const nsSMILValue&
 nsSMILValue::operator=(const nsSMILValue& aVal)
 {
   if (&aVal == this)
     return *this;
 
   if (mType != aVal.mType) {
     mType->Destroy(*this);
     NS_POSTCONDITION(IsNull(), "nsSMILValue not null after destroying");
     nsresult rv = aVal.mType->Init(*this);
     NS_POSTCONDITION(mType == aVal.mType || (NS_FAILED(rv) && IsNull()),
-      "Post-condition of Init failed. nsSMILValue is invalid.");
+      "Post-condition of Init failed. nsSMILValue is invalid");
     if (NS_FAILED(rv)) return *this;
   }
 
   mType->Assign(*this, aVal);
 
   return *this;
 }
 
 nsresult
 nsSMILValue::Add(const nsSMILValue& aValueToAdd, PRUint32 aCount)
 {
   if (aValueToAdd.IsNull()) return NS_OK;
 
   if (aValueToAdd.mType != mType) {
-    NS_ERROR("Trying to add incompatible types.");
+    NS_ERROR("Trying to add incompatible types");
     return NS_ERROR_FAILURE;
   }
 
   return mType->Add(*this, aValueToAdd, aCount);
 }
 
 nsresult
 nsSMILValue::SandwichAdd(const nsSMILValue& aValueToAdd)
 {
   if (aValueToAdd.IsNull())
     return NS_OK;
 
   if (aValueToAdd.mType != mType) {
-    NS_ERROR("Trying to add incompatible types.");
+    NS_ERROR("Trying to add incompatible types");
     return NS_ERROR_FAILURE;
   }
 
   return mType->SandwichAdd(*this, aValueToAdd);
 }
 
 nsresult
 nsSMILValue::ComputeDistance(const nsSMILValue& aTo, double& aDistance) const
 {
   if (aTo.mType != mType) {
-    NS_ERROR("Trying to calculate distance between incompatible types.");
+    NS_ERROR("Trying to calculate distance between incompatible types");
     return NS_ERROR_FAILURE;
   }
 
   return mType->ComputeDistance(*this, aTo, aDistance);
 }
 
 nsresult
 nsSMILValue::Interpolate(const nsSMILValue& aEndVal,
                          double aUnitDistance,
                          nsSMILValue& aResult) const
 {
   if (aEndVal.mType != mType) {
-    NS_ERROR("Trying to interpolate between incompatible types.");
+    NS_ERROR("Trying to interpolate between incompatible types");
     return NS_ERROR_FAILURE;
   }
 
   if (aResult.mType != mType) {
     aResult.mType->Destroy(aResult);
     NS_POSTCONDITION(aResult.IsNull(), "nsSMILValue not null after destroying");
     nsresult rv = mType->Init(aResult);
     NS_POSTCONDITION(aResult.mType == mType
       || (NS_FAILED(rv) && aResult.IsNull()),
-      "Post-condition of Init failed. nsSMILValue is invalid.");
+      "Post-condition of Init failed. nsSMILValue is invalid");
     if (NS_FAILED(rv)) return rv;
   }
 
   return mType->Interpolate(*this, aEndVal, aUnitDistance, aResult);
 }
--- a/content/svg/content/src/nsSVGTransformSMILAttr.cpp
+++ b/content/svg/content/src/nsSVGTransformSMILAttr.cpp
@@ -58,17 +58,17 @@ nsSVGTransformSMILAttr::GetSMILType() co
 
 nsresult
 nsSVGTransformSMILAttr::ValueFromString(const nsAString& aStr,
                                      const nsISMILAnimationElement* aSrcElement,
                                      nsSMILValue& aValue) const
 {
   NS_ENSURE_TRUE(aSrcElement, NS_ERROR_FAILURE);
   NS_ASSERTION(aValue.IsNull(),
-    "aValue should have been cleared before calling ValueFromString.");
+    "aValue should have been cleared before calling ValueFromString");
 
   nsSMILValue val(&nsSVGTransformSMILType::sSingleton);
   if (val.IsNull())
     return NS_ERROR_FAILURE;
 
   const nsAttrValue* typeAttr = aSrcElement->GetAnimAttr(nsGkAtoms::type);
 
   const nsIAtom* transformType = typeAttr
@@ -152,17 +152,17 @@ nsSVGTransformSMILAttr::SetAnimValue(con
 nsresult
 nsSVGTransformSMILAttr::ParseValue(const nsAString& aSpec,
                                    const nsIAtom* aTransformType,
                                    nsSMILValue& aResult) const
 {
   nsSVGTransformSMILType* type = &nsSVGTransformSMILType::sSingleton;
   NS_ASSERTION(
       type == static_cast<nsSVGTransformSMILType const *>(aResult.mType),
-      "Unexpected type for SMIL value result.");
+      "Unexpected type for SMIL value result");
 
   // Reset the result so we can just append to it
   nsresult rv = type->Init(aResult);
   NS_ENSURE_SUCCESS(rv,rv);
 
   float params[3] = { 0.f };
   PRInt32 numParsed = ParseParameterList(aSpec, params, 3);
   nsSVGSMILTransform::TransformType transformType;
@@ -333,17 +333,17 @@ nsSVGTransformSMILAttr::AppendSVGTransfo
       }
       break;
 
     case nsIDOMSVGTransform::SVG_TRANSFORM_UNKNOWN:
       // If it's 'unknown', it's probably not initialised, so just skip it.
       return NS_OK;
 
     default:
-      NS_WARNING("Trying to convert unrecognised SVG transform type.");
+      NS_WARNING("Trying to convert unrecognised SVG transform type");
       return NS_ERROR_FAILURE;
   }
 
   if (transformType != nsSVGSMILTransform::TRANSFORM_MATRIX) {
     rv =
       type->AppendTransform(nsSVGSMILTransform(transformType, params), aValue);
   }
 
--- a/content/svg/content/src/nsSVGTransformSMILType.cpp
+++ b/content/svg/content/src/nsSVGTransformSMILType.cpp
@@ -46,17 +46,17 @@
 // nsISMILType implementation
 
 nsresult
 nsSVGTransformSMILType::Init(nsSMILValue &aValue) const
 {
   NS_PRECONDITION(aValue.mType == this || aValue.IsNull(),
                   "Unexpected value type");
   NS_ASSERTION(aValue.mType != this || aValue.mU.mPtr,
-               "Invalid nsSMILValue of SVG transform type: NULL data member.");
+               "Invalid nsSMILValue of SVG transform type: NULL data member");
 
   if (aValue.mType != this || !aValue.mU.mPtr) {
     // Different type, or no data member: allocate memory and set type
     TransformArray* transforms = new TransformArray(1);
     NS_ENSURE_TRUE(transforms, NS_ERROR_OUT_OF_MEMORY);
     aValue.mU.mPtr = transforms;
     aValue.mType = this;
   } else {
@@ -66,29 +66,29 @@ nsSVGTransformSMILType::Init(nsSMILValue
   }
 
   return NS_OK;
 }
 
 void
 nsSVGTransformSMILType::Destroy(nsSMILValue& aValue) const
 {
-  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value type.");
+  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value type");
   TransformArray* params = static_cast<TransformArray*>(aValue.mU.mPtr);
   delete params;
   aValue.mU.mPtr = nsnull;
   aValue.mType = &nsSMILNullType::sSingleton;
 }
 
 nsresult
 nsSVGTransformSMILType::Assign(nsSMILValue& aDest,
                                const nsSMILValue& aSrc) const
 {
-  NS_PRECONDITION(aDest.mType == aSrc.mType, "Incompatible SMIL types.");
-  NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL value.");
+  NS_PRECONDITION(aDest.mType == aSrc.mType, "Incompatible SMIL types");
+  NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL value");
 
   const TransformArray* srcTransforms =
     static_cast<const TransformArray*>(aSrc.mU.mPtr);
   TransformArray* dstTransforms = static_cast<TransformArray*>(aDest.mU.mPtr);
 
   // Before we assign, ensure we have sufficient memory
   PRBool result = dstTransforms->SetCapacity(srcTransforms->Length());
   NS_ENSURE_TRUE(result,NS_ERROR_OUT_OF_MEMORY);
@@ -97,118 +97,118 @@ nsSVGTransformSMILType::Assign(nsSMILVal
 
   return NS_OK;
 }
 
 nsresult
 nsSVGTransformSMILType::Add(nsSMILValue& aDest, const nsSMILValue& aValueToAdd,
                             PRUint32 aCount) const
 {
-  NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL type.");
-  NS_PRECONDITION(aDest.mType == aValueToAdd.mType, "Incompatible SMIL types.");
+  NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL type");
+  NS_PRECONDITION(aDest.mType == aValueToAdd.mType, "Incompatible SMIL types");
 
   TransformArray& dstTransforms(*static_cast<TransformArray*>(aDest.mU.mPtr));
   const TransformArray& srcTransforms
     (*static_cast<const TransformArray*>(aValueToAdd.mU.mPtr));
 
   // We're doing a simple add here (as opposed to a sandwich add below).
   // We only do this when we're accumulating a repeat result or calculating
   // a by-animation value.
   //
   // In either case we should have 1 transform in the source array.
   NS_ASSERTION(srcTransforms.Length() == 1,
-    "Invalid source transform list to add.");
+    "Invalid source transform list to add");
 
   // And we should have 0 or 1 transforms in the dest array.
   // (We can have 0 transforms in the case of by-animation when we are
   // calculating the by-value as "0 + by". Zero being represented by an
   // nsSMILValue with an empty transform array.)
   NS_ASSERTION(dstTransforms.Length() < 2,
-    "Invalid dest transform list to add to.");
+    "Invalid dest transform list to add to");
 
   // Get the individual transforms to add
   const nsSVGSMILTransform& srcTransform = srcTransforms[0];
   if (dstTransforms.IsEmpty()) {
     nsSVGSMILTransform* result = dstTransforms.AppendElement(
       nsSVGSMILTransform(srcTransform.mTransformType));
     NS_ENSURE_TRUE(result,NS_ERROR_OUT_OF_MEMORY);
   }
   nsSVGSMILTransform& dstTransform = dstTransforms[0];
 
   // The types must be the same
   NS_ASSERTION(srcTransform.mTransformType == dstTransform.mTransformType,
-    "Trying to perform simple add of different transform types.");
+    "Trying to perform simple add of different transform types");
 
   // And it should be impossible that one of them is of matrix type
   NS_ASSERTION(
     srcTransform.mTransformType != nsSVGSMILTransform::TRANSFORM_MATRIX,
-    "Trying to perform simple add with matrix transform.");
+    "Trying to perform simple add with matrix transform");
 
   // Add the parameters
   for (int i = 0; i <= 2; ++i) {
     dstTransform.mParams[i] += srcTransform.mParams[i] * aCount;
   }
 
   return NS_OK;
 }
 
 nsresult
 nsSVGTransformSMILType::SandwichAdd(nsSMILValue& aDest,
                                     const nsSMILValue& aValueToAdd) const
 {
-  NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL type.");
-  NS_PRECONDITION(aDest.mType == aValueToAdd.mType, "Incompatible SMIL types.");
+  NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL type");
+  NS_PRECONDITION(aDest.mType == aValueToAdd.mType, "Incompatible SMIL types");
 
   // For <animateTransform> a sandwich add means a matrix post-multiplication
   // which just means to put the additional transform on the end of the array
 
   TransformArray& dstTransforms(*static_cast<TransformArray*>(aDest.mU.mPtr));
   const TransformArray& srcTransforms
     (*static_cast<const TransformArray*>(aValueToAdd.mU.mPtr));
 
   // We're only expecting to be adding 1 src transform on to the list
   NS_ASSERTION(srcTransforms.Length() == 1,
-    "Trying to do sandwich add of more than one value.");
+    "Trying to do sandwich add of more than one value");
 
   // Stick the src on the end of the array
   const nsSVGSMILTransform& srcTransform = srcTransforms[0];
   nsSVGSMILTransform* result = dstTransforms.AppendElement(srcTransform);
   NS_ENSURE_TRUE(result,NS_ERROR_OUT_OF_MEMORY);
 
   return NS_OK;
 }
 
 nsresult
 nsSVGTransformSMILType::ComputeDistance(const nsSMILValue& aFrom,
                                         const nsSMILValue& aTo,
                                         double& aDistance) const
 {
   NS_PRECONDITION(aFrom.mType == aTo.mType,
-      "Can't compute difference between different SMIL types.");
-  NS_PRECONDITION(aFrom.mType == this, "Unexpected SMIL type.");
+      "Can't compute difference between different SMIL types");
+  NS_PRECONDITION(aFrom.mType == this, "Unexpected SMIL type");
 
   const TransformArray* fromTransforms =
     static_cast<const TransformArray*>(aFrom.mU.mPtr);
   const TransformArray* toTransforms =
     static_cast<const TransformArray*>(aTo.mU.mPtr);
 
   // ComputeDistance is only used for calculating distances between single
   // values in a values array which necessarily have the same type
   //
   // So we should only have one transform in each array and they should be of
   // the same type
   NS_ASSERTION(fromTransforms->Length() == 1,
-    "Wrong number of elements in from value.");
+    "Wrong number of elements in from value");
   NS_ASSERTION(toTransforms->Length() == 1,
-    "Wrong number of elements in to value.");
+    "Wrong number of elements in to value");
 
   const nsSVGSMILTransform& fromTransform = (*fromTransforms)[0];
   const nsSVGSMILTransform& toTransform = (*toTransforms)[0];
   NS_ASSERTION(fromTransform.mTransformType == toTransform.mTransformType,
-    "Incompatible transform types to calculate distance between.");
+    "Incompatible transform types to calculate distance between");
 
   switch (fromTransform.mTransformType)
   {
     // We adopt the SVGT1.2 notions of distance here
     // See: http://www.w3.org/TR/SVGTiny12/animate.html#complexDistances
     // (As discussed in bug #469040)
     case nsSVGSMILTransform::TRANSFORM_TRANSLATE:
     case nsSVGSMILTransform::TRANSFORM_SCALE:
@@ -227,51 +227,51 @@ nsSVGTransformSMILType::ComputeDistance(
       {
         const float& a = fromTransform.mParams[0];
         const float& b = toTransform.mParams[0];
         aDistance = fabs(a-b);
       }
       break;
 
     default:
-      NS_ERROR("Got bad transform types for calculating distances.");
+      NS_ERROR("Got bad transform types for calculating distances");
       aDistance = 1.0;
       return NS_ERROR_FAILURE;
   }
 
   return NS_OK;
 }
 
 nsresult
 nsSVGTransformSMILType::Interpolate(const nsSMILValue& aStartVal,
                                     const nsSMILValue& aEndVal,
                                     double aUnitDistance,
                                     nsSMILValue& aResult) const
 {
   NS_PRECONDITION(aStartVal.mType == aEndVal.mType,
-      "Can't interpolate between different SMIL types.");
+      "Can't interpolate between different SMIL types");
   NS_PRECONDITION(aStartVal.mType == this,
-      "Unexpected type for interpolation.");
-  NS_PRECONDITION(aResult.mType == this, "Unexpected result type.");
+      "Unexpected type for interpolation");
+  NS_PRECONDITION(aResult.mType == this, "Unexpected result type");
 
   const TransformArray& startTransforms =
     (*static_cast<const TransformArray*>(aStartVal.mU.mPtr));
   const TransformArray& endTransforms
     (*static_cast<const TransformArray*>(aEndVal.mU.mPtr));
 
   // We may have 0..n transforms in the start transform array (the base
   // value) but we should only have 1 transform in the end transform array
   NS_ASSERTION(endTransforms.Length() == 1,
-    "Invalid end-point for interpolating between transform values.");
+    "Invalid end-point for interpolating between transform values");
 
   // The end point should never be a matrix transform
   const nsSVGSMILTransform& endTransform = endTransforms[0];
   NS_ASSERTION(
     endTransform.mTransformType != nsSVGSMILTransform::TRANSFORM_MATRIX,
-    "End point for interpolation should not be a matrix transform.");
+    "End point for interpolation should not be a matrix transform");
 
   // If we have 0 or more than 1 transform in the start transform array then we
   // just interpolate from 0, 0, 0
   // Likewise, even if there's only 1 transform in the start transform array
   // then if the type of the start transform doesn't match the end then we
   // can't interpolate and should just use 0, 0, 0
   static float identityParams[3] = { 0.f };
   const float* startParams = nsnull;
@@ -311,46 +311,46 @@ nsSVGTransformSMILType::Interpolate(cons
 }
 
 //----------------------------------------------------------------------
 // Transform array accessors
 
 PRUint32
 nsSVGTransformSMILType::GetNumTransforms(const nsSMILValue& aValue) const
 {
-  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value.");
+  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value");
 
   const TransformArray& transforms =
     *static_cast<const TransformArray*>(aValue.mU.mPtr);
 
   return transforms.Length();
 }
 
 const nsSVGSMILTransform*
 nsSVGTransformSMILType::GetTransformAt(PRUint32 aIndex,
                                        const nsSMILValue& aValue) const
 {
-  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value.");
+  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value");
 
   const TransformArray& transforms =
     *static_cast<const TransformArray*>(aValue.mU.mPtr);
 
   if (aIndex >= transforms.Length()) {
-    NS_ERROR("Attempting to access invalid transform.");
+    NS_ERROR("Attempting to access invalid transform");
     return nsnull;
   }
 
   return &transforms[aIndex];
 }
 
 nsresult
 nsSVGTransformSMILType::AppendTransform(const nsSVGSMILTransform& aTransform,
                                         nsSMILValue& aValue) const
 {
-  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value.");
+  NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value");
 
   TransformArray& transforms = *static_cast<TransformArray*>(aValue.mU.mPtr);
 
   nsSVGSMILTransform* transform = transforms.AppendElement(aTransform);
   NS_ENSURE_TRUE(transform,NS_ERROR_OUT_OF_MEMORY);
 
   return NS_OK;
 }