Switch to standard integer types in skia/.

skia/ext/image_operations.cc

 // Copyright (c) 2012 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.
 
 #define _USE_MATH_DEFINES
+
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
 #include "skia/ext/image_operations.h"
 
 // TODO(pkasting): skia/ext should not depend on base/!
 #include "base/containers/stack_container.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "skia/ext/convolver.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkRect.h"
 
 namespace skia {
 
@@ skipping 190 matching lines @@
   float clamped_scale = std::min(1.0f, scale);
 
   // This is how many source pixels from the center we need to count
   // to support the filtering function.
   float src_support = GetFilterSupport(clamped_scale) / clamped_scale;
 
   // Speed up the divisions below by turning them into multiplies.
   float inv_scale = 1.0f / scale;
 
   base::StackVector<float, 64> filter_values;
-  base::StackVector<int16, 64> fixed_filter_values;
+  base::StackVector<int16_t, 64> fixed_filter_values;
 
   // Loop over all pixels in the output range. We will generate one set of
   // filter values for each one. Those values will tell us how to blend the
   // source pixels to compute the destination pixel.
   for (int dest_subset_i = dest_subset_lo; dest_subset_i < dest_subset_hi;
        dest_subset_i++) {
     // Reset the arrays. We don't declare them inside so they can re-use the
     // same malloc-ed buffer.
     filter_values->clear();
     fixed_filter_values->clear();
@@ skipping 30 matching lines @@
       // Compute the filter value at that location.
       float filter_value = ComputeFilter(dest_filter_dist);
       filter_values->push_back(filter_value);
 
       filter_sum += filter_value;
     }
     DCHECK(!filter_values->empty()) << "We should always get a filter!";
 
     // The filter must be normalized so that we don't affect the brightness of
     // the image. Convert to normalized fixed point.
-    int16 fixed_sum = 0;
+    int16_t fixed_sum = 0;
     for (size_t i = 0; i < filter_values->size(); i++) {
-      int16 cur_fixed = output->FloatToFixed(filter_values[i] / filter_sum);
+      int16_t cur_fixed = output->FloatToFixed(filter_values[i] / filter_sum);
       fixed_sum += cur_fixed;
       fixed_filter_values->push_back(cur_fixed);
     }
 
     // The conversion to fixed point will leave some rounding errors, which
     // we add back in to avoid affecting the brightness of the image. We
     // arbitrarily add this to the center of the filter array (this won't always
     // be the center of the filter function since it could get clipped on the
     // edges, but it doesn't matter enough to worry about that case).
-    int16 leftovers = output->FloatToFixed(1.0f) - fixed_sum;
+    int16_t leftovers = output->FloatToFixed(1.0f) - fixed_sum;
     fixed_filter_values[fixed_filter_values->size() / 2] += leftovers;
 
     // Now it's ready to go.
     output->AddFilter(src_begin, &fixed_filter_values[0],
                       static_cast<int>(fixed_filter_values->size()));
   }
 
   output->PaddingForSIMD();
 }
 
@@ skipping 66 matching lines @@
   SkAutoLockPixels locker(source);
   if (!source.readyToDraw() || source.colorType() != kN32_SkColorType)
     return SkBitmap();
 
   ResizeFilter filter(method, source.width(), source.height(),
                       dest_width, dest_height, dest_subset);
 
   // Get a source bitmap encompassing this touched area. We construct the
   // offsets and row strides such that it looks like a new bitmap, while
   // referring to the old data.
-  const uint8* source_subset =
-      reinterpret_cast<const uint8*>(source.getPixels());
+  const uint8_t* source_subset =
+      reinterpret_cast<const uint8_t*>(source.getPixels());
 
   // Convolve into the result.
   SkBitmap result;
   result.setInfo(SkImageInfo::MakeN32(dest_subset.width(), dest_subset.height(), source.alphaType()));
   result.allocPixels(allocator, NULL);
   if (!result.readyToDraw())
     return SkBitmap();
 
   BGRAConvolve2D(source_subset, static_cast<int>(source.rowBytes()),
                  !source.isOpaque(), filter.x_filter(), filter.y_filter(),
@@ skipping 11 matching lines @@
 SkBitmap ImageOperations::Resize(const SkBitmap& source,
                                  ResizeMethod method,
                                  int dest_width, int dest_height,
                                  SkBitmap::Allocator* allocator) {
   SkIRect dest_subset = { 0, 0, dest_width, dest_height };
   return Resize(source, method, dest_width, dest_height, dest_subset,
                 allocator);
 }
 
 }  // namespace skia