Switch to standard integer types in chrome/browser/, part 4 of 4.

chrome/browser/thumbnails/content_analysis.cc

 // Copyright (c) 2013 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 "chrome/browser/thumbnails/content_analysis.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <cmath>
 #include <deque>
 #include <functional>
 #include <limits>
 #include <numeric>
 #include <vector>
 
 #include "base/logging.h"
 #include "skia/ext/convolver.h"
@@ skipping 294 matching lines @@
         0, intermediate.bytesPerPixel(),
         smoothing_filter,
         image_size,
         input_bitmap->getAddr8(0, 0),
         static_cast<int>(input_bitmap->rowBytes()),
         0, input_bitmap->bytesPerPixel(), false);
     if (smoothed_max < 127) {
       int bit_shift = 8 - static_cast<int>(
           std::log10(static_cast<float>(smoothed_max)) / std::log10(2.0f));
       for (int r = 0; r < image_size.height(); ++r) {
-        uint8* row = input_bitmap->getAddr8(0, r);
+        uint8_t* row = input_bitmap->getAddr8(0, r);
         for (int c = 0; c < image_size.width(); ++c, ++row) {
           *row <<= bit_shift;
         }
       }
     }
 
     skia::RecursiveFilter gradient_filter(
         kernel_sigma, skia::RecursiveFilter::FIRST_DERIVATIVE);
     skia::SingleChannelRecursiveGaussianX(
         input_bitmap->getAddr8(0, 0),
@@ skipping 10 matching lines @@
         0, input_bitmap->bytesPerPixel(),
         gradient_filter,
         image_size,
         intermediate2.getAddr8(0, 0),
         static_cast<int>(intermediate2.rowBytes()),
         0, intermediate2.bytesPerPixel(), true);
   }
 
   unsigned grad_max = 0;
   for (int r = 0; r < image_size.height(); ++r) {
-    const uint8* grad_x_row = intermediate.getAddr8(0, r);
-    const uint8* grad_y_row = intermediate2.getAddr8(0, r);
+    const uint8_t* grad_x_row = intermediate.getAddr8(0, r);
+    const uint8_t* grad_y_row = intermediate2.getAddr8(0, r);
     for (int c = 0; c < image_size.width(); ++c) {
       unsigned grad_x = grad_x_row[c];
       unsigned grad_y = grad_y_row[c];
       grad_max = std::max(grad_max, grad_x * grad_x + grad_y * grad_y);
     }
   }
 
   int bit_shift = 0;
   if (grad_max > 255)
     bit_shift = static_cast<int>(
         std::log10(static_cast<float>(grad_max)) / std::log10(2.0f)) - 7;
   for (int r = 0; r < image_size.height(); ++r) {
-    const uint8* grad_x_row = intermediate.getAddr8(0, r);
-    const uint8* grad_y_row = intermediate2.getAddr8(0, r);
-    uint8* target_row = input_bitmap->getAddr8(0, r);
+    const uint8_t* grad_x_row = intermediate.getAddr8(0, r);
+    const uint8_t* grad_y_row = intermediate2.getAddr8(0, r);
+    uint8_t* target_row = input_bitmap->getAddr8(0, r);
     for (int c = 0; c < image_size.width(); ++c) {
       unsigned grad_x = grad_x_row[c];
       unsigned grad_y = grad_y_row[c];
       target_row[c] = (grad_x * grad_x + grad_y * grad_y) >> bit_shift;
     }
   }
 }
 
 void ExtractImageProfileInformation(const SkBitmap& input_bitmap,
                                     const gfx::Rect& area,
@@ skipping 12 matching lines @@
   DCHECK_LE(area.bottom(), input_bitmap.height());
 
   // Make sure rows and columns are allocated and initialized to 0.
   rows->clear();
   columns->clear();
   rows->resize(area.height(), 0);
   columns->resize(area.width(), 0);
 
   for (int r = 0; r < area.height(); ++r) {
     // Points to the first byte of the row in the rectangle.
-    const uint8* image_row = input_bitmap.getAddr8(area.x(), r + area.y());
+    const uint8_t* image_row = input_bitmap.getAddr8(area.x(), r + area.y());
     unsigned row_sum = 0;
     for (int c = 0; c < area.width(); ++c, ++image_row) {
       row_sum += *image_row;
       (*columns)[c] += *image_row;
     }
     (*rows)[r] = row_sum;
   }
 
   if (apply_log) {
     // Generally for processing we will need to take logarithm of this data.
@@ skipping 267 matching lines @@
 
   // Allocate the target image.
   SkBitmap target;
   target.allocPixels(bitmap.info().makeWH(target_column_count,
                                           target_row_count));
 
   int target_row = 0;
   for (int r = 0; r < bitmap.height(); ++r) {
     if (!rows[r])
       continue;  // We can just skip this one.
-    uint8* src_row =
-        static_cast<uint8*>(bitmap.getPixels()) + r * bitmap.rowBytes();
-    uint8* insertion_target = static_cast<uint8*>(target.getPixels()) +
-        target_row * target.rowBytes();
+    uint8_t* src_row =
+        static_cast<uint8_t*>(bitmap.getPixels()) + r * bitmap.rowBytes();
+    uint8_t* insertion_target = static_cast<uint8_t*>(target.getPixels()) +
+                                target_row * target.rowBytes();
     int left_copy_pixel = -1;
     for (int c = 0; c < bitmap.width(); ++c) {
       if (left_copy_pixel < 0 && columns[c]) {
         left_copy_pixel = c;  // Next time we will start copying from here.
       } else if (left_copy_pixel >= 0 && !columns[c]) {
         // This closes a fragment we want to copy. We do it now.
         size_t bytes_to_copy = (c - left_copy_pixel) * bitmap.bytesPerPixel();
         memcpy(insertion_target,
                src_row + left_copy_pixel * bitmap.bytesPerPixel(),
                bytes_to_copy);
@@ skipping 58 matching lines @@
                                  target_size,
                                  &included_rows,
                                  &included_columns);
 
   // Use the original image and computed inclusion vectors to create a resized
   // image.
   return ComputeDecimatedImage(source_bitmap, included_rows, included_columns);
 }
 
 }  // namespace thumbnailing_utils