Switch to standard integer types in media/.

media/cast/sender/performance_metrics_overlay.cc

 // Copyright 2015 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 "media/cast/sender/performance_metrics_overlay.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 11 matching lines @@
 const int kCharacterHeight = 5;  // Logical pixel height of one character.
 const int kCharacterSpacing = 1;  // Logical pixels between each character.
 const int kLineSpacing = 2;  // Logical pixels between each line of characters.
 const int kPlane = 0;  // Y-plane in YUV formats.
 
 // For each pixel in the |rect| (logical coordinates), either decrease the
 // intensity or increase it so that the resulting pixel has a perceivably
 // different value than it did before.  |p_ul| is a pointer to the pixel at
 // coordinate (0,0) in a single-channel 8bpp bitmap.  |stride| is the number of
 // bytes per row in the output bitmap.
-void DivergePixels(const gfx::Rect& rect, uint8* p_ul, int stride) {
+void DivergePixels(const gfx::Rect& rect, uint8_t* p_ul, int stride) {
   DCHECK(p_ul);
   DCHECK_GT(stride, 0);
 
   // These constants and heuristics were chosen based on experimenting with a
   // wide variety of content, and converging on a readable result.  The amount
   // by which the darker pixels are changed is less because each unit of change
   // has a larger visual impact on the darker end of the spectrum.  Each pixel's
   // intensity value is changed as follows:
   //
   //    [16,31] --> [32,63]   (always a difference of +16)
   //    [32,64] --> 16        (a difference between -16 and -48)
   //   [65,235] --> [17,187]  (always a difference of -48)
   const int kDivergeDownThreshold = 32;
   const int kDivergeDownAmount = 48;
   const int kDivergeUpAmount = 32;
   const int kMinIntensity = 16;
 
   const int top = rect.y() * kScale;
   const int bottom = rect.bottom() * kScale;
   const int left = rect.x() * kScale;
   const int right = rect.right() * kScale;
   for (int y = top; y < bottom; ++y) {
-    uint8* const p_l = p_ul + y * stride;
+    uint8_t* const p_l = p_ul + y * stride;
     for (int x = left; x < right; ++x) {
       int intensity = p_l[x];
       if (intensity >= kDivergeDownThreshold)
         intensity = std::max(kMinIntensity, intensity - kDivergeDownAmount);
       else
         intensity += kDivergeUpAmount;
-      p_l[x] = static_cast<uint8>(intensity);
+      p_l[x] = static_cast<uint8_t>(intensity);
     }
   }
 }
 
 // Render |line| into |frame| at physical pixel row |top| and aligned to the
 // right edge.  Only number digits and a smattering of punctuation characters
 // will be rendered.
 void RenderLineOfText(const std::string& line, int top, VideoFrame* frame) {
   // Compute number of physical pixels wide the rendered |line| would be,
   // including padding.
   const int line_width =
       (((kCharacterWidth + kCharacterSpacing) * static_cast<int>(line.size())) +
            kCharacterSpacing) * kScale;
 
   // Determine if any characters would render past the left edge of the frame,
   // and compute the index of the first character to be rendered.
   const int pixels_per_char = (kCharacterWidth + kCharacterSpacing) * kScale;
   const size_t first_idx = (line_width < frame->visible_rect().width()) ? 0u :
       static_cast<size_t>(
           ((line_width - frame->visible_rect().width()) / pixels_per_char) + 1);
 
   // Compute the pointer to the pixel at the upper-left corner of the first
   // character to be rendered.
   const int stride = frame->stride(kPlane);
-  uint8* p_ul =
+  uint8_t* p_ul =
       // Start at the first pixel in the first row...
       frame->visible_data(kPlane) + (stride * top)
       // ...now move to the right edge of the visible part of the frame...
       + frame->visible_rect().width()
       // ...now move left to where line[0] would be rendered...
       - line_width
       // ...now move right to where line[first_idx] would be rendered.
       + first_idx * pixels_per_char;
 
   // Render each character.
@@ skipping 205 matching lines @@
   RenderLineOfText(base::StringPrintf("%d %3.1d%% %3.1d%%",
                                       frames_ago,
                                       deadline_pct,
                                       lossy_pct),
                    top,
                    frame);
 }
 
 }  // namespace cast
 }  // namespace media