Avoid uint64_t overflow in Decimal::operator/() and fix Decimal::ceil()

Source/platform/Decimal.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 470 matching lines @@
         return lhs.isZero() ? nan() : infinity(resultSign);
 
     int resultExponent = lhs.exponent() - rhs.exponent();
 
     if (lhs.isZero())
         return Decimal(resultSign, resultExponent, 0);
 
     uint64_t remainder = lhs.m_data.coefficient();
     const uint64_t divisor = rhs.m_data.coefficient();
     uint64_t result = 0;
-    while (result < MaxCoefficient / 100) {
-        while (remainder < divisor) {
+    for (;;) {
+        while (remainder < divisor && result < MaxCoefficient / 10) {
             remainder *= 10;
             result *= 10;
             --resultExponent;
         }
-        result += remainder / divisor;
+        if (remainder < divisor)
+            break;
+        uint64_t quotient = remainder / divisor;
+        if (result > MaxCoefficient - quotient)
+            break;
+        result += quotient;
         remainder %= divisor;
         if (!remainder)
             break;
     }
 
     if (remainder > divisor / 2)
         ++result;
 
     return Decimal(resultSign, resultExponent, result);
 }
@@ skipping 113 matching lines @@
 {
     if (isSpecial())
         return *this;
 
     if (exponent() >= 0)
         return *this;
 
     uint64_t result = m_data.coefficient();
     const int numberOfDigits = countDigits(result);
     const int numberOfDropDigits = -exponent();
-    if (numberOfDigits < numberOfDropDigits)
+    if (numberOfDigits <= numberOfDropDigits)
         return isPositive() ? Decimal(1) : zero(Positive);
 
     result = scaleDown(result, numberOfDropDigits);
     if (isPositive() && !isMultiplePowersOfTen(m_data.coefficient(), numberOfDropDigits))
         ++result;
     return Decimal(sign(), 0, result);
 }
 
 Decimal Decimal::compareTo(const Decimal& rhs) const
 {
@@ skipping 374 matching lines @@
     }
     return builder.toString();
 }
 
 Decimal Decimal::zero(Sign sign)
 {
     return Decimal(EncodedData(sign, EncodedData::ClassZero));
 }
 
 } // namespace blink