Switch to standard integer types in skia/.

skia/ext/convolver_unittest.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.
 
+#include <stdint.h>
 #include <string.h>
 #include <time.h>
 #include <algorithm>
 #include <numeric>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/time/time.h"
 #include "skia/ext/convolver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkTypes.h"
 
 namespace skia {
 
@@ skipping 228 matching lines @@
 
   // Test both cases with different has_alpha.
   for (int alpha = 0; alpha < 2; alpha++) {
     // Convolve using C code.
     base::TimeTicks resize_start;
     base::TimeDelta delta_c, delta_sse;
     unsigned char* r1 = static_cast<unsigned char*>(result_c.getPixels());
     unsigned char* r2 = static_cast<unsigned char*>(result_sse.getPixels());
 
     resize_start = base::TimeTicks::Now();
-    BGRAConvolve2D(static_cast<const uint8*>(source.getPixels()),
-                   static_cast<int>(source.rowBytes()),
-                   (alpha != 0), x_filter, y_filter,
-                   static_cast<int>(result_c.rowBytes()), r1, false);
+    BGRAConvolve2D(static_cast<const uint8_t*>(source.getPixels()),
+                   static_cast<int>(source.rowBytes()), (alpha != 0), x_filter,
+                   y_filter, static_cast<int>(result_c.rowBytes()), r1, false);
     delta_c = base::TimeTicks::Now() - resize_start;
 
     resize_start = base::TimeTicks::Now();
     // Convolve using SSE2 code
-    BGRAConvolve2D(static_cast<const uint8*>(source.getPixels()),
-                   static_cast<int>(source.rowBytes()),
-                   (alpha != 0), x_filter, y_filter,
-                   static_cast<int>(result_sse.rowBytes()), r2, true);
+    BGRAConvolve2D(static_cast<const uint8_t*>(source.getPixels()),
+                   static_cast<int>(source.rowBytes()), (alpha != 0), x_filter,
+                   y_filter, static_cast<int>(result_sse.rowBytes()), r2, true);
     delta_sse = base::TimeTicks::Now() - resize_start;
 
     // Unfortunately I could not enable the performance check now.
     // Most bots use debug version, and there are great difference between
     // the code generation for intrinsic, etc. In release version speed
     // difference was 150%-200% depend on alpha channel presence;
     // while in debug version speed difference was 96%-120%.
     // TODO(jiesun): optimize further until we could enable this for
     // debug version too.
     // EXPECT_LE(delta_sse, delta_c);
 
-    int64 c_us = delta_c.InMicroseconds();
-    int64 sse_us = delta_sse.InMicroseconds();
+    int64_t c_us = delta_c.InMicroseconds();
+    int64_t sse_us = delta_sse.InMicroseconds();
     VLOG(1) << "from:" << source_width << "x" << source_height
             << " to:" << dest_width << "x" << dest_height
             << (alpha ? " with alpha" : " w/o alpha");
     VLOG(1) << "c:" << c_us << " sse:" << sse_us;
     VLOG(1) << "ratio:" << static_cast<float>(c_us) / sse_us;
 
     // Comparing result.
     for (unsigned int i = 0; i < dest_height; i++) {
       EXPECT_FALSE(memcmp(r1, r2, dest_width * 4)); // RGBA always
       r1 += result_c.rowBytes();
@@ skipping 227 matching lines @@
                               fp_gradient_kernel.end()), -1.5f);
   EXPECT_LT(*std::min_element(fp_gradient_kernel.begin(),
                               fp_gradient_kernel.end()), 0.0f);
   EXPECT_LT(*std::max_element(fp_gradient_kernel.begin(),
                               fp_gradient_kernel.end()), 1.5f);
   EXPECT_GT(*std::max_element(fp_gradient_kernel.begin(),
                               fp_gradient_kernel.end()), 0.0f);
 }
 
 }  // namespace skia