Switch to standard integer types in ui/gfx/.

ui/gfx/render_text_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 "ui/gfx/render_text.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 
 #include "base/format_macros.h"
 #include "base/i18n/break_iterator.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "ui/gfx/break_list.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/range/range.h"
 #include "ui/gfx/range/range_f.h"
@@ skipping 123 matching lines @@
   }
 
   void GetDecorationLogAndReset(std::vector<DecorationLog>* decoration_log) {
     decoration_log_.swap(*decoration_log);
     decoration_log_.clear();
   }
 
  private:
   // internal::SkiaTextRenderer:
   void DrawPosText(const SkPoint* pos,
-                   const uint16* glyphs,
+                   const uint16_t* glyphs,
                    size_t glyph_count) override {
     TextLog log_entry;
     log_entry.glyph_count = glyph_count;
     if (glyph_count > 0) {
       log_entry.origin =
           PointF(SkScalarToFloat(pos[0].x()), SkScalarToFloat(pos[0].y()));
       for (size_t i = 1U; i < glyph_count; ++i) {
         log_entry.origin.SetToMin(
             PointF(SkScalarToFloat(pos[i].x()), SkScalarToFloat(pos[i].y())));
       }
@@ skipping 2436 matching lines @@
               text_log[0].glyph_count);
     EXPECT_EQ(run_list->runs()[run_list->logical_to_visual(1)]->glyph_count,
               text_log[1].glyph_count);
     EXPECT_LT(text_log[0].origin.x(), text_log[1].origin.x());
   }
 }
 
 // Test TextRunHarfBuzz's cluster finding logic.
 TEST_F(RenderTextTest, HarfBuzz_Clusters) {
   struct {
-    uint32 glyph_to_char[4];
+    uint32_t glyph_to_char[4];
     Range chars[4];
     Range glyphs[4];
     bool is_rtl;
   } cases[] = {
     { // From string "A B C D" to glyphs "a b c d".
       { 0, 1, 2, 3 },
       { Range(0, 1), Range(1, 2), Range(2, 3), Range(3, 4) },
       { Range(0, 1), Range(1, 2), Range(2, 3), Range(3, 4) },
       false
     },
@@ skipping 67 matching lines @@
     auto first_grapheme_bounds = run->GetGraphemeBounds(iter, 0);
     EXPECT_EQ(first_grapheme_bounds, run->GetGraphemeBounds(iter, 1));
     auto second_grapheme_bounds = run->GetGraphemeBounds(iter, 2);
     EXPECT_EQ(first_grapheme_bounds.end(), second_grapheme_bounds.start());
   }
 }
 
 // Test the partition of a multi-grapheme cluster into grapheme ranges.
 TEST_F(RenderTextTest, HarfBuzz_SubglyphGraphemePartition) {
   struct {
-    uint32 glyph_to_char[2];
+    uint32_t glyph_to_char[2];
     Range bounds[4];
     bool is_rtl;
   } cases[] = {
     { // From string "A B C D" to glyphs "a bcd".
       { 0, 1 },
       { Range(0, 10), Range(10, 13), Range(13, 17), Range(17, 20) },
       false
     },
     { // From string "A B C D" to glyphs "ab cd".
       { 0, 2 },
@@ skipping 313 matching lines @@
     render_text->ApplyBaselineStyle(SUBSCRIPT, Range(7, 8));
     render_text->SetStyle(BOLD, true);
     render_text->SetDisplayRect(
         Rect(kTestSize, kTestSize, string_size.width(), string_size.height()));
     // Allow the RenderText to paint outside of its display rect.
     render_text->set_clip_to_display_rect(false);
     ASSERT_LE(string_size.width() + kTestSize * 2, kCanvasSize.width());
 
     render_text->Draw(&canvas);
     ASSERT_LT(string_size.width() + kTestSize, kCanvasSize.width());
-    const uint32* buffer =
-        static_cast<const uint32*>(surface->peekPixels(nullptr, nullptr));
+    const uint32_t* buffer =
+        static_cast<const uint32_t*>(surface->peekPixels(nullptr, nullptr));
     ASSERT_NE(nullptr, buffer);
     TestRectangleBuffer rect_buffer(string, buffer, kCanvasSize.width(),
                                     kCanvasSize.height());
     {
 #if !defined(OS_CHROMEOS)
       // TODO(dschuyler): On ChromeOS text draws above the GetStringSize rect.
       SCOPED_TRACE("TextDoesntClip Top Side");
       rect_buffer.EnsureSolidRect(SK_ColorWHITE, 0, 0, kCanvasSize.width(),
                                   kTestSize);
 #endif
@@ skipping 54 matching lines @@
     surface->getCanvas()->clear(SK_ColorWHITE);
     render_text->SetText(WideToUTF16(string));
     const Size string_size = render_text->GetStringSize();
     int fake_width = string_size.width() / 2;
     int fake_height = string_size.height() / 2;
     render_text->SetDisplayRect(
         Rect(kTestSize, kTestSize, fake_width, fake_height));
     render_text->set_clip_to_display_rect(true);
     render_text->Draw(&canvas);
     ASSERT_LT(string_size.width() + kTestSize, kCanvasSize.width());
-    const uint32* buffer =
-        static_cast<const uint32*>(surface->peekPixels(nullptr, nullptr));
+    const uint32_t* buffer =
+        static_cast<const uint32_t*>(surface->peekPixels(nullptr, nullptr));
     ASSERT_NE(nullptr, buffer);
     TestRectangleBuffer rect_buffer(string, buffer, kCanvasSize.width(),
                                     kCanvasSize.height());
     {
       SCOPED_TRACE("TextDoesClip Top Side");
       rect_buffer.EnsureSolidRect(SK_ColorWHITE, 0, 0, kCanvasSize.width(),
                                   kTestSize);
     }
 
     {
@@ skipping 68 matching lines @@
     backend[i]->SetColor(SK_ColorRED);
     test_api.DrawVisualText(&renderer);
 
     renderer.GetTextLogAndReset(&text_log);
     EXPECT_EQ(1u, text_log.size());
     EXPECT_EQ(SK_ColorRED, text_log[0].color);
   }
 }
 
 }  // namespace gfx