Fix build after previous commit.

third_party/bigint/BigUnsigned.hh

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code by Matt McCutchen, see the LICENSE file.
 
 #ifndef BIGUNSIGNED_H
 #define BIGUNSIGNED_H
 
 #include "NumberlikeArray.hh"
@@ skipping 249 matching lines @@
         ans.subtract(*this, x);
         return ans;
 }
 inline BigUnsigned BigUnsigned::operator *(const BigUnsigned &x) const {
         BigUnsigned ans;
         ans.multiply(*this, x);
         return ans;
 }
 inline BigUnsigned BigUnsigned::operator /(const BigUnsigned &x) const {
         if (x.isZero())
-#ifdef FOXIT_CHROME_BUILD
         abort();
-#else
-        throw "BigUnsigned::operator /: division by zero";
-#endif
         BigUnsigned q, r;
         r = *this;
         r.divideWithRemainder(x, q);
         return q;
 }
 inline BigUnsigned BigUnsigned::operator %(const BigUnsigned &x) const {
         if (x.isZero())
-#ifdef FOXIT_CHROME_BUILD
         abort();
-#else
-        throw "BigUnsigned::operator %: division by zero";
-#endif
         BigUnsigned q, r;
         r = *this;
         r.divideWithRemainder(x, q);
         return r;
 }
 inline BigUnsigned BigUnsigned::operator &(const BigUnsigned &x) const {
         BigUnsigned ans;
         ans.bitAnd(*this, x);
         return ans;
 }
@@ skipping 22 matching lines @@
         add(*this, x);
 }
 inline void BigUnsigned::operator -=(const BigUnsigned &x) {
         subtract(*this, x);
 }
 inline void BigUnsigned::operator *=(const BigUnsigned &x) {
         multiply(*this, x);
 }
 inline void BigUnsigned::operator /=(const BigUnsigned &x) {
         if (x.isZero())
-#ifdef FOXIT_CHROME_BUILD
         abort();
-#else
-        throw "BigUnsigned::operator /=: division by zero";
-#endif
         /* The following technique is slightly faster than copying *this first
          * when x is large. */
         BigUnsigned q;
         divideWithRemainder(x, q);
         // *this contains the remainder, but we overwrite it with the quotient.
         *this = q;
 }
 inline void BigUnsigned::operator %=(const BigUnsigned &x) {
         if (x.isZero())
-#ifdef FOXIT_CHROME_BUILD
         abort();
-#else
-        throw "BigUnsigned::operator %=: division by zero";
-#endif
         BigUnsigned q;
         // Mods *this by x.  Don't care about quotient left in q.
         divideWithRemainder(x, q);
 }
 inline void BigUnsigned::operator &=(const BigUnsigned &x) {
         bitAnd(*this, x);
 }
 inline void BigUnsigned::operator |=(const BigUnsigned &x) {
         bitOr(*this, x);
 }
@@ skipping 33 matching lines @@
         }
 }
 
 /* Ditto, but first check that x is nonnegative.  I could have put the check in
  * initFromPrimitive and let the compiler optimize it out for unsigned-type
  * instantiations, but I wanted to avoid the warning stupidly issued by g++ for
  * a condition that is constant in *any* instantiation, even if not in all. */
 template <class X>
 void BigUnsigned::initFromSignedPrimitive(X x) {
         if (x < 0)
-#ifdef FOXIT_CHROME_BUILD
         abort();
-#else
-                throw "BigUnsigned constructor: "
-                        "Cannot construct a BigUnsigned from a negative number";
-#endif
         else
                 initFromPrimitive(x);
 }
 
 // CONVERSION TO PRIMITIVE INTEGERS
 
 /* Template with the same idea as initFromPrimitive.  This might be slightly
  * slower than the previous version with the masks, but it's much shorter and
  * clearer, which is the library's stated goal. */
 template <class X>
 X BigUnsigned::convertToPrimitive() const {
         if (len == 0)
                 // The number is zero; return zero.
                 return 0;
         else if (len == 1) {
                 // The single block might fit in an X.  Try the conversion.
                 X x = X(blk[0]);
                 // Make sure the result accurately represents the block.
                 if (Blk(x) == blk[0])
                         // Successful conversion.
                         return x;
                 // Otherwise fall through.
         }
-#ifdef FOXIT_CHROME_BUILD
     abort();
-#else
-        throw "BigUnsigned::to<Primitive>: "
-                "Value is too big to fit in the requested type";
-#endif
 }
 
 /* Wrap the above in an x >= 0 test to make sure we got a nonnegative result,
  * not a negative one that happened to convert back into the correct nonnegative
  * one.  (E.g., catch incorrect conversion of 2^31 to the long -2^31.)  Again,
  * separated to avoid a g++ warning. */
 template <class X>
 X BigUnsigned::convertToSignedPrimitive() const {
         X x = convertToPrimitive<X>();
         if (x >= 0)
                 return x;
         else
-#ifdef FOXIT_CHROME_BUILD
         abort();
-#else
-                throw "BigUnsigned::to(Primitive): "
-                        "Value is too big to fit in the requested type";
-#endif
 }
 
 #endif