--- a/layout/svg/nsFilterInstance.cpp
+++ b/layout/svg/nsFilterInstance.cpp
@@ -181,18 +181,17 @@ nsFilterInstance::nsFilterInstance(nsIFr
   if (aOverrideBBox) {
     mTargetBBox = *aOverrideBBox;
   } else {
     MOZ_ASSERT(mTargetFrame, "Need to supply a frame when there's no aOverrideBBox");
     mTargetBBox = nsSVGUtils::GetBBox(mTargetFrame);
   }
 
   // Compute user space to filter space transforms.
-  nsresult rv = ComputeUserSpaceToFilterSpaceScale();
-  if (NS_FAILED(rv)) {
+  if (!ComputeUserSpaceToFilterSpaceScale()) {
     return;
   }
 
   gfxRect targetBBoxInFilterSpace = UserSpaceToFilterSpace(mTargetBBox);
   targetBBoxInFilterSpace.RoundOut();
   if (!gfxUtils::GfxRectToIntRect(targetBBoxInFilterSpace, &mTargetBBoxInFilterSpace)) {
     // The target's bbox is way too big if there is float->int overflow.
     return;
@@ -217,47 +216,46 @@ nsFilterInstance::nsFilterInstance(nsIFr
       FrameSpaceToFilterSpace(aPreFilterVisualOverflowRectOverride);
   } else if (mTargetFrame) {
     nsRect preFilterVOR = mTargetFrame->GetPreEffectsVisualOverflowRect();
     targetBounds = FrameSpaceToFilterSpace(&preFilterVOR);
   }
   mTargetBounds.UnionRect(mTargetBBoxInFilterSpace, targetBounds);
 
   // Build the filter graph.
-  rv = BuildPrimitives(aFilterChain, aTargetFrame, aFilterInputIsTainted);
-  if (NS_FAILED(rv)) {
+  if (!BuildPrimitives(aFilterChain, aTargetFrame, aFilterInputIsTainted)) {
     return;
   }
 
   // Convert the passed in rects from frame space to filter space:
   mPostFilterDirtyRegion = FrameSpaceToFilterSpace(aPostFilterDirtyRegion);
   mPreFilterDirtyRegion = FrameSpaceToFilterSpace(aPreFilterDirtyRegion);
 
   mInitialized = true;
 }
 
-nsresult
+bool
 nsFilterInstance::ComputeUserSpaceToFilterSpaceScale()
 {
   gfxMatrix canvasTransform;
   if (mTargetFrame) {
     mUserSpaceToFilterSpaceScale = mPaintTransform.ScaleFactors(true);
     if (mUserSpaceToFilterSpaceScale.width <= 0.0f ||
         mUserSpaceToFilterSpaceScale.height <= 0.0f) {
       // Nothing should be rendered.
-      return NS_ERROR_FAILURE;
+      return false;
     }
   } else {
     mUserSpaceToFilterSpaceScale = gfxSize(1.0, 1.0);
   }
 
   mFilterSpaceToUserSpaceScale =
     gfxSize(1.0f / mUserSpaceToFilterSpaceScale.width,
             1.0f / mUserSpaceToFilterSpaceScale.height);
-  return NS_OK;
+  return true;
 }
 
 gfxRect
 nsFilterInstance::UserSpaceToFilterSpace(const gfxRect& aUserSpaceRect) const
 {
   gfxRect filterSpaceRect = aUserSpaceRect;
   filterSpaceRect.Scale(mUserSpaceToFilterSpaceScale.width,
                         mUserSpaceToFilterSpaceScale.height);
@@ -268,74 +266,79 @@ gfxRect
 nsFilterInstance::FilterSpaceToUserSpace(const gfxRect& aFilterSpaceRect) const
 {
   gfxRect userSpaceRect = aFilterSpaceRect;
   userSpaceRect.Scale(mFilterSpaceToUserSpaceScale.width,
                       mFilterSpaceToUserSpaceScale.height);
   return userSpaceRect;
 }
 
-nsresult
+bool
 nsFilterInstance::BuildPrimitives(const nsTArray<nsStyleFilter>& aFilterChain,
                                   nsIFrame* aTargetFrame,
                                   bool aFilterInputIsTainted)
 {
   NS_ASSERTION(!mPrimitiveDescriptions.Length(),
                "expected to start building primitives from scratch");
 
   for (uint32_t i = 0; i < aFilterChain.Length(); i++) {
     bool inputIsTainted =
       mPrimitiveDescriptions.IsEmpty() ? aFilterInputIsTainted :
         mPrimitiveDescriptions.LastElement().IsTainted();
-    nsresult rv = BuildPrimitivesForFilter(aFilterChain[i], aTargetFrame, inputIsTainted);
-    if (NS_FAILED(rv)) {
-      return rv;
+    if (!BuildPrimitivesForFilter(aFilterChain[i], aTargetFrame,
+                                  inputIsTainted)) {
+      return false;
     }
   }
 
   mFilterDescription = FilterDescription(mPrimitiveDescriptions);
 
-  return NS_OK;
+  return true;
 }
 
-nsresult
+bool
 nsFilterInstance::BuildPrimitivesForFilter(const nsStyleFilter& aFilter,
                                            nsIFrame* aTargetFrame,
                                            bool aInputIsTainted)
 {
   NS_ASSERTION(mUserSpaceToFilterSpaceScale.width > 0.0f &&
                mFilterSpaceToUserSpaceScale.height > 0.0f,
                "scale factors between spaces should be positive values");
 
   if (aFilter.GetType() == NS_STYLE_FILTER_URL) {
     // Build primitives for an SVG filter.
     nsSVGFilterInstance svgFilterInstance(aFilter, aTargetFrame,
                                           mTargetContent,
                                           mMetrics, mTargetBBox,
                                           mUserSpaceToFilterSpaceScale,
                                           mFilterSpaceToUserSpaceScale);
     if (!svgFilterInstance.IsInitialized()) {
-      return NS_ERROR_FAILURE;
+      return false;
     }
 
-    return svgFilterInstance.BuildPrimitives(mPrimitiveDescriptions, mInputImages,
-                                             aInputIsTainted);
+    nsresult rv =
+      svgFilterInstance.BuildPrimitives(mPrimitiveDescriptions, mInputImages,
+                                        aInputIsTainted);
+
+    return NS_FAILED(rv) ? false : true;
   }
 
   // Build primitives for a CSS filter.
 
   // If we don't have a frame, use opaque black for shadows with unspecified
   // shadow colors.
   nscolor shadowFallbackColor =
     mTargetFrame ? mTargetFrame->StyleColor()->mColor : NS_RGB(0,0,0);
 
   nsCSSFilterInstance cssFilterInstance(aFilter, shadowFallbackColor,
                                         mTargetBounds,
                                         mFrameSpaceInCSSPxToFilterSpaceTransform);
-  return cssFilterInstance.BuildPrimitives(mPrimitiveDescriptions, aInputIsTainted);
+  nsresult rv =
+    cssFilterInstance.BuildPrimitives(mPrimitiveDescriptions, aInputIsTainted);
+  return NS_FAILED(rv) ? false : true;
 }
 
 void
 nsFilterInstance::ComputeNeededBoxes()
 {
   if (mPrimitiveDescriptions.IsEmpty())
     return;
 

--- a/layout/svg/nsFilterInstance.h
+++ b/layout/svg/nsFilterInstance.h
@@ -236,46 +236,46 @@ private:
   DrawResult BuildSourceImage();
 
   /**
    * Build the list of FilterPrimitiveDescriptions that describes the filter's
    * filter primitives and their connections. This populates
    * mPrimitiveDescriptions and mInputImages. aFilterInputIsTainted describes
    * whether the SourceGraphic is tainted.
    */
-  nsresult BuildPrimitives(const nsTArray<nsStyleFilter>& aFilterChain,
-                           nsIFrame* aTargetFrame,
-                           bool aFilterInputIsTainted);
+  bool BuildPrimitives(const nsTArray<nsStyleFilter>& aFilterChain,
+                       nsIFrame* aTargetFrame,
+                       bool aFilterInputIsTainted);
 
   /**
    * Add to the list of FilterPrimitiveDescriptions for a particular SVG
    * reference filter or CSS filter. This populates mPrimitiveDescriptions and
    * mInputImages. aInputIsTainted describes whether the input to aFilter is
    * tainted.
    */
-  nsresult BuildPrimitivesForFilter(const nsStyleFilter& aFilter,
-                                    nsIFrame* aTargetFrame,
-                                    bool aInputIsTainted);
+  bool BuildPrimitivesForFilter(const nsStyleFilter& aFilter,
+                                nsIFrame* aTargetFrame,
+                                bool aInputIsTainted);
 
   /**
    * Computes the filter space bounds of the areas that we actually *need* from
    * the filter sources, based on the value of mPostFilterDirtyRegion.
    * This sets mNeededBounds on the corresponding SourceInfo structs.
    */
   void ComputeNeededBoxes();
 
   /**
    * Returns the output bounds of the final FilterPrimitiveDescription.
    */
   nsIntRect OutputFilterSpaceBounds() const;
 
   /**
    * Compute the scale factors between user space and filter space.
    */
-  nsresult ComputeUserSpaceToFilterSpaceScale();
+  bool ComputeUserSpaceToFilterSpaceScale();
 
   /**
    * Transform a rect between user space and filter space.
    */
   gfxRect UserSpaceToFilterSpace(const gfxRect& aUserSpace) const;
   gfxRect FilterSpaceToUserSpace(const gfxRect& aFilterSpaceRect) const;
 
   /**