Update createImageData/getImageData/putImageData from float to long

third_party/WebKit/Source/modules/canvas2d/BaseRenderingContext2D.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/canvas2d/BaseRenderingContext2D.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/css/cssom/CSSURLImageValue.h"
@@ skipping 1488 matching lines @@
 ImageData* BaseRenderingContext2D::createImageData(
     ImageData* imageData,
     ExceptionState& exceptionState) const {
   ImageData* result = ImageData::create(imageData->size());
   if (!result)
     exceptionState.throwRangeError("Out of memory at ImageData creation");
   return result;
 }
 
 ImageData* BaseRenderingContext2D::createImageData(
-    double sw,
-    double sh,
+    int sw,
+    int sh,
     ExceptionState& exceptionState) const {
   if (!sw || !sh) {
     exceptionState.throwDOMException(
         IndexSizeError,
         String::format("The source %s is 0.", sw ? "height" : "width"));
     return nullptr;
   }
 
-  FloatSize logicalSize(fabs(sw), fabs(sh));
-  if (!logicalSize.isExpressibleAsIntSize())
-    return nullptr;
-
-  IntSize size = expandedIntSize(logicalSize);
-  if (size.width() < 1)
-    size.setWidth(1);
-  if (size.height() < 1)
-    size.setHeight(1);
+  IntSize size(abs(sw), abs(sh));
 
   ImageData* result = ImageData::create(size);
   if (!result)
     exceptionState.throwRangeError("Out of memory at ImageData creation");
   return result;
 }
 
 ImageData* BaseRenderingContext2D::getImageData(
-    double sx,
-    double sy,
-    double sw,
-    double sh,
+    int sx,
+    int sy,
+    int sw,
+    int sh,
     ExceptionState& exceptionState) const {
   m_usageCounters.numGetImageDataCalls++;
   m_usageCounters.areaGetImageDataCalls += sw * sh;
   if (!originClean())
     exceptionState.throwSecurityError(
         "The canvas has been tainted by cross-origin data.");
   else if (!sw || !sh)
     exceptionState.throwDOMException(
         IndexSizeError,
         String::format("The source %s is 0.", sw ? "height" : "width"));
 
   if (exceptionState.hadException())
     return nullptr;
 
   if (sw < 0) {
     sx += sw;
     sw = -sw;
   }
   if (sh < 0) {
     sy += sh;
     sh = -sh;
   }
 
-  FloatRect logicalRect(sx, sy, sw, sh);
-  if (logicalRect.width() < 1)
-    logicalRect.setWidth(1);
-  if (logicalRect.height() < 1)
-    logicalRect.setHeight(1);
-  if (!logicalRect.isExpressibleAsIntRect())
-    return nullptr;
-
   Optional<ScopedUsHistogramTimer> timer;
   if (imageBuffer() && imageBuffer()->isAccelerated()) {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(
         CustomCountHistogram, scopedUsCounterGPU,
         new CustomCountHistogram("Blink.Canvas.GetImageData.GPU", 0, 10000000,
                                  50));
     timer.emplace(scopedUsCounterGPU);
   } else if (imageBuffer() && imageBuffer()->isRecording()) {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(
         CustomCountHistogram, scopedUsCounterDisplayList,
         new CustomCountHistogram("Blink.Canvas.GetImageData.DisplayList", 0,
                                  10000000, 50));
     timer.emplace(scopedUsCounterDisplayList);
   } else {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(
         CustomCountHistogram, scopedUsCounterCPU,
         new CustomCountHistogram("Blink.Canvas.GetImageData.CPU", 0, 10000000,
                                  50));
     timer.emplace(scopedUsCounterCPU);
   }
 
-  IntRect imageDataRect = enclosingIntRect(logicalRect);
+  IntRect imageDataRect(sx, sy, sw, sh);
+  DVLOG(1) << sx << ", " << sy << ", " << sw << ", " << sh;
   ImageBuffer* buffer = imageBuffer();
   if (!buffer || isContextLost()) {
     ImageData* result = ImageData::create(imageDataRect.size());
     if (!result)
       exceptionState.throwRangeError("Out of memory at ImageData creation");
     return result;
   }
 
   WTF::ArrayBufferContents contents;
   if (!buffer->getImageData(Unmultiplied, imageDataRect, contents)) {
     exceptionState.throwRangeError("Out of memory at ImageData creation");
     return nullptr;
   }
 
   DOMArrayBuffer* arrayBuffer = DOMArrayBuffer::create(contents);
   return ImageData::create(
       imageDataRect.size(),
       DOMUint8ClampedArray::create(arrayBuffer, 0, arrayBuffer->byteLength()));
 }
 
 void BaseRenderingContext2D::putImageData(ImageData* data,
-                                          double dx,
-                                          double dy,
+                                          int dx,
+                                          int dy,
                                           ExceptionState& exceptionState) {
   putImageData(data, dx, dy, 0, 0, data->width(), data->height(),
                exceptionState);
 }
 
 void BaseRenderingContext2D::putImageData(ImageData* data,
-                                          double dx,
-                                          double dy,
-                                          double dirtyX,
-                                          double dirtyY,
-                                          double dirtyWidth,
-                                          double dirtyHeight,
+                                          int dx,
+                                          int dy,
+                                          int dirtyX,
+                                          int dirtyY,
+                                          int dirtyWidth,
+                                          int dirtyHeight,
                                           ExceptionState& exceptionState) {
   m_usageCounters.numPutImageDataCalls++;
   m_usageCounters.areaPutImageDataCalls += dirtyWidth * dirtyHeight;
   if (data->data()->bufferBase()->isNeutered()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      "The source data has been neutered.");
     return;
   }
   ImageBuffer* buffer = imageBuffer();
   if (!buffer)
     return;
 
   if (dirtyWidth < 0) {
     dirtyX += dirtyWidth;
     dirtyWidth = -dirtyWidth;
   }
 
   if (dirtyHeight < 0) {
     dirtyY += dirtyHeight;
     dirtyHeight = -dirtyHeight;
   }
 
-  FloatRect clipRect(dirtyX, dirtyY, dirtyWidth, dirtyHeight);
-  clipRect.intersect(IntRect(0, 0, data->width(), data->height()));
+  IntRect destRect(dirtyX, dirtyY, dirtyWidth, dirtyHeight);
+  destRect.intersect(IntRect(0, 0, data->width(), data->height()));
   IntSize destOffset(static_cast<int>(dx), static_cast<int>(dy));
-  IntRect destRect = enclosingIntRect(clipRect);
   destRect.move(destOffset);
   destRect.intersect(IntRect(IntPoint(), buffer->size()));
   if (destRect.isEmpty())
     return;
 
   Optional<ScopedUsHistogramTimer> timer;
   if (imageBuffer() && imageBuffer()->isAccelerated()) {
     DEFINE_THREAD_SAFE_STATIC_LOCAL(
         CustomCountHistogram, scopedUsCounterGPU,
         new CustomCountHistogram("Blink.Canvas.PutImageData.GPU", 0, 10000000,
@@ skipping 366 matching lines @@
       ExpensiveCanvasHeuristicParameters::ShadowFixedCost[index] *
           m_usageCounters.numBlurredShadows +
       ExpensiveCanvasHeuristicParameters::
               ShadowVariableCostPerAreaTimesShadowBlurSquared[index] *
           m_usageCounters.boundingBoxAreaTimesShadowBlurSquared;
 
   return basicCostOfDrawCalls + fillTypeAdjustment + shadowAdjustment;
 }
 
 }  // namespace blink