Switch to standard integer types in tools/.

tools/imagediff/image_diff.cc

 // Copyright (c) 2011 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.
 
 // This file input format is based loosely on
 // Tools/DumpRenderTree/ImageDiff.m
 
 // The exact format of this tool's output to stdout is important, to match
 // what the run-webkit-tests script expects.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <iostream>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/process/memory.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
 #include "tools/imagediff/image_diff_png.h"
 
 #if defined(OS_WIN)
 #include "windows.h"
 #endif
 
 // Causes the app to remain open, waiting for pairs of filenames on stdin.
 // The caller is then responsible for terminating this app.
 static const char kOptionPollStdin[] = "use-stdin";
 // Causes the app to additionally calculate a diff of the color histograms
 // (which is resistant to shifts in layout).
 static const char kOptionCompareHistograms[] = "histogram";
 // Causes the app to output an image that visualizes the difference.
 static const char kOptionGenerateDiff[] = "diff";
 
 // Return codes used by this utility.
 static const int kStatusSame = 0;
 static const int kStatusDifferent = 1;
 static const int kStatusError = 2;
 
 // Color codes.
-static const uint32 RGBA_RED = 0x000000ff;
-static const uint32 RGBA_ALPHA = 0xff000000;
+static const uint32_t RGBA_RED = 0x000000ff;
+static const uint32_t RGBA_ALPHA = 0xff000000;
 
 class Image {
  public:
   Image() : w_(0), h_(0) {
   }
 
   Image(const Image& image)
       : w_(image.w_),
         h_(image.h_),
         data_(image.data_) {
@@ skipping 57 matching lines @@
     }
     return true;
   }
 
   void Clear() {
     w_ = h_ = 0;
     data_.clear();
   }
 
   // Returns the RGBA value of the pixel at the given location
-  uint32 pixel_at(int x, int y) const {
+  uint32_t pixel_at(int x, int y) const {
     DCHECK(x >= 0 && x < w_);
     DCHECK(y >= 0 && y < h_);
-    return *reinterpret_cast<const uint32*>(&(data_[(y * w_ + x) * 4]));
+    return *reinterpret_cast<const uint32_t*>(&(data_[(y * w_ + x) * 4]));
   }
 
-  void set_pixel_at(int x, int y, uint32 color) const {
+  void set_pixel_at(int x, int y, uint32_t color) const {
     DCHECK(x >= 0 && x < w_);
     DCHECK(y >= 0 && y < h_);
     void* addr = &const_cast<unsigned char*>(&data_.front())[(y * w_ + x) * 4];
-    *reinterpret_cast<uint32*>(addr) = color;
+    *reinterpret_cast<uint32_t*>(addr) = color;
   }
 
  private:
   // pixel dimensions of the image
   int w_, h_;
 
   std::vector<unsigned char> data_;
 };
 
 float PercentageDifferent(const Image& baseline, const Image& actual) {
@@ skipping 21 matching lines @@
   // of the size of the 'actual' bitmap.
   float total_pixels = static_cast<float>(actual.w()) *
                        static_cast<float>(actual.h());
   if (total_pixels == 0) {
     // When the bitmap is empty, they are 100% different.
     return 100.0f;
   }
   return 100.0f * pixels_different / total_pixels;
 }
 
-typedef base::hash_map<uint32, int32> RgbaToCountMap;
+typedef base::hash_map<uint32_t, int32_t> RgbaToCountMap;
 
 float HistogramPercentageDifferent(const Image& baseline, const Image& actual) {
   // TODO(johnme): Consider using a joint histogram instead, as described in
   // "Comparing Images Using Joint Histograms" by Pass & Zabih
   // http://www.cs.cornell.edu/~rdz/papers/pz-jms99.pdf
 
   int w = std::min(baseline.w(), actual.w());
   int h = std::min(baseline.h(), actual.h());
 
   // Count occurences of each RGBA pixel value of baseline in the overlap.
   RgbaToCountMap baseline_histogram;
   for (int y = 0; y < h; y++) {
     for (int x = 0; x < w; x++) {
       // hash_map operator[] inserts a 0 (default constructor) if key not found.
       baseline_histogram[baseline.pixel_at(x, y)]++;
     }
   }
 
   // Compute pixels different in the histogram of the overlap.
   int pixels_different = 0;
   for (int y = 0; y < h; y++) {
     for (int x = 0; x < w; x++) {
-      uint32 actual_rgba = actual.pixel_at(x, y);
+      uint32_t actual_rgba = actual.pixel_at(x, y);
       RgbaToCountMap::iterator it = baseline_histogram.find(actual_rgba);
       if (it != baseline_histogram.end() && it->second > 0)
         it->second--;
       else
         pixels_different++;
     }
   }
 
   // Count pixels that are a difference in size as also being different.
   int max_w = std::max(baseline.w(), actual.w());
@@ skipping 122 matching lines @@
 bool CreateImageDiff(const Image& image1, const Image& image2, Image* out) {
   int w = std::min(image1.w(), image2.w());
   int h = std::min(image1.h(), image2.h());
   *out = Image(image1);
   bool same = (image1.w() == image2.w()) && (image1.h() == image2.h());
 
   // TODO(estade): do something with the extra pixels if the image sizes
   // are different.
   for (int y = 0; y < h; y++) {
     for (int x = 0; x < w; x++) {
-      uint32 base_pixel = image1.pixel_at(x, y);
+      uint32_t base_pixel = image1.pixel_at(x, y);
       if (base_pixel != image2.pixel_at(x, y)) {
         // Set differing pixels red.
         out->set_pixel_at(x, y, RGBA_RED | RGBA_ALPHA);
         same = false;
       } else {
         // Set same pixels as faded.
-        uint32 alpha = base_pixel & RGBA_ALPHA;
-        uint32 new_pixel = base_pixel - ((alpha / 2) & RGBA_ALPHA);
+        uint32_t alpha = base_pixel & RGBA_ALPHA;
+        uint32_t new_pixel = base_pixel - ((alpha / 2) & RGBA_ALPHA);
         out->set_pixel_at(x, y, new_pixel);
       }
     }
   }
 
   return same;
 }
 
 int DiffImages(const base::FilePath& file1, const base::FilePath& file2,
                const base::FilePath& out_file) {
@@ skipping 77 matching lines @@
                         base::FilePath(args[2]));
     }
   } else if (args.size() == 2) {
     return CompareImages(
         base::FilePath(args[0]), base::FilePath(args[1]), histograms);
   }
 
   PrintHelp();
   return kStatusError;
 }