Switch to standard integer types in components/, part 1 of 4.

components/cloud_devices/common/printer_description.cc

 // Copyright 2014 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 "components/cloud_devices/common/printer_description.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
+#include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "components/cloud_devices/common/cloud_device_description_consts.h"
 #include "components/cloud_devices/common/description_items_inl.h"
 
 namespace cloud_devices {
 
 namespace printer {
 
 namespace {
 
-const int32 kMaxPageNumber = 1000000;
+const int32_t kMaxPageNumber = 1000000;
 
 const char kSectionPrint[] = "print";
 const char kSectionPrinter[] = "printer";
 
 const char kCustomName[] = "custom_display_name";
 const char kKeyContentType[] = "content_type";
 const char kKeyName[] = "name";
 const char kKeyType[] = "type";
 const char kKeyVendorId[] = "vendor_id";
 
@@ skipping 112 matching lines @@
 
 const struct DocumentSheetBackNames {
   DocumentSheetBack id;
   const char* const json_name;
 } kDocumentSheetBackNames[] = {
       {NORMAL, kTypeDocumentSheetBackNormal},
       {ROTATED, kTypeDocumentSheetBackRotated},
       {MANUAL_TUMBLE, kTypeDocumentSheetBackManualTumble},
       {FLIPPED, kTypeDocumentSheetBackFlipped}};
 
-const int32 kInchToUm = 25400;
-const int32 kMmToUm = 1000;
-const int32 kSizeTrasholdUm = 1000;
+const int32_t kInchToUm = 25400;
+const int32_t kMmToUm = 1000;
+const int32_t kSizeTrasholdUm = 1000;
 
 #define MAP_CLOUD_PRINT_MEDIA_TYPE(type, width, height, unit_um) \
   {                                                              \
     type, #type, static_cast<int>(width* unit_um + 0.5),         \
         static_cast<int>(height* unit_um + 0.5)                  \
   }
 
 const struct MediaDefinition {
   MediaType id;
   const char* const json_name;
@@ skipping 169 matching lines @@
 
 const MediaDefinition& FindMediaByType(MediaType type) {
   for (size_t i = 0; i < arraysize(kMediaDefinitions); ++i) {
     if (kMediaDefinitions[i].id == type)
       return kMediaDefinitions[i];
   }
   NOTREACHED();
   return kMediaDefinitions[0];
 }
 
-const MediaDefinition* FindMediaBySize(int32 width_um, int32 height_um) {
+const MediaDefinition* FindMediaBySize(int32_t width_um, int32_t height_um) {
   const MediaDefinition* result = NULL;
   for (size_t i = 0; i < arraysize(kMediaDefinitions); ++i) {
-    int32 diff = std::max(std::abs(width_um - kMediaDefinitions[i].width_um),
-                          std::abs(height_um - kMediaDefinitions[i].height_um));
+    int32_t diff =
+        std::max(std::abs(width_um - kMediaDefinitions[i].width_um),
+                 std::abs(height_um - kMediaDefinitions[i].height_um));
     if (diff < kSizeTrasholdUm)
       result = &kMediaDefinitions[i];
   }
   return result;
 }
 
 template <class T, class IdType>
 std::string TypeToString(const T& names, IdType id) {
   for (size_t i = 0; i < arraysize(names); ++i) {
     if (id == names[i].id)
@@ skipping 37 matching lines @@
   if (type != CUSTOM_COLOR && type != CUSTOM_MONOCHROME)
     return true;
   return !vendor_id.empty() && !custom_display_name.empty();
 }
 
 Margins::Margins()
     : type(STANDARD_MARGINS), top_um(0), right_um(0), bottom_um(0), left_um(0) {
 }
 
 Margins::Margins(MarginsType type,
-                 int32 top_um,
-                 int32 right_um,
-                 int32 bottom_um,
-                 int32 left_um)
+                 int32_t top_um,
+                 int32_t right_um,
+                 int32_t bottom_um,
+                 int32_t left_um)
     : type(type),
       top_um(top_um),
       right_um(right_um),
       bottom_um(bottom_um),
-      left_um(left_um) {
-}
+      left_um(left_um) {}
 
 bool Margins::operator==(const Margins& other) const {
   return type == other.type && top_um == other.top_um &&
          right_um == other.right_um && bottom_um == other.bottom_um;
 }
 
 Dpi::Dpi() : horizontal(0), vertical(0) {
 }
 
-Dpi::Dpi(int32 horizontal, int32 vertical)
-    : horizontal(horizontal), vertical(vertical) {
-}
+Dpi::Dpi(int32_t horizontal, int32_t vertical)
+    : horizontal(horizontal), vertical(vertical) {}
 
 bool Dpi::IsValid() const {
   return horizontal > 0 && vertical > 0;
 }
 
 bool Dpi::operator==(const Dpi& other) const {
   return horizontal == other.horizontal && vertical == other.vertical;
 }
 
 Media::Media()
     : type(CUSTOM_MEDIA), width_um(0), height_um(0), is_continuous_feed(false) {
 }
 
 Media::Media(MediaType type)
     : type(type),
       width_um(0),
       height_um(0),
       is_continuous_feed(false) {
   const MediaDefinition& media = FindMediaByType(type);
   width_um = media.width_um;
   height_um = media.height_um;
   is_continuous_feed = width_um <= 0 || height_um <= 0;
 }
 
-Media::Media(MediaType type, int32 width_um, int32 height_um)
+Media::Media(MediaType type, int32_t width_um, int32_t height_um)
     : type(type),
       width_um(width_um),
       height_um(height_um),
-      is_continuous_feed(width_um <= 0 || height_um <= 0) {
-}
+      is_continuous_feed(width_um <= 0 || height_um <= 0) {}
 
 Media::Media(const std::string& custom_display_name,
              const std::string& vendor_id,
-             int32 width_um,
-             int32 height_um)
+             int32_t width_um,
+             int32_t height_um)
     : type(CUSTOM_MEDIA),
       width_um(width_um),
       height_um(height_um),
       is_continuous_feed(width_um <= 0 || height_um <= 0),
       custom_display_name(custom_display_name),
-      vendor_id(vendor_id) {
-}
+      vendor_id(vendor_id) {}
 
 bool Media::MatchBySize() {
   const MediaDefinition* media = FindMediaBySize(width_um, height_um);
   if (!media)
     return false;
   type = media->id;
   return true;
 }
 
 bool Media::IsValid() const {
   if (is_continuous_feed) {
     if (width_um <= 0 && height_um <= 0)
       return false;
   } else {
     if (width_um <= 0 || height_um <= 0)
       return false;
   }
   return true;
 }
 
 bool Media::operator==(const Media& other) const {
   return type == other.type && width_um == other.width_um &&
          height_um == other.height_um &&
          is_continuous_feed == other.is_continuous_feed;
 }
 
 Interval::Interval() : start(0), end(0) {
 }
 
-Interval::Interval(int32 start, int32 end) : start(start), end(end) {
-}
+Interval::Interval(int32_t start, int32_t end) : start(start), end(end) {}
 
-Interval::Interval(int32 start) : start(start), end(kMaxPageNumber) {
-}
+Interval::Interval(int32_t start) : start(start), end(kMaxPageNumber) {}
 
 bool Interval::operator==(const Interval& other) const {
   return start == other.start && end == other.end;
 }
 
 template <const char* kName>
 class ItemsTraits {
  public:
   static std::string GetCapabilityPath() {
     std::string result = kSectionPrinter;
@@ skipping 111 matching lines @@
            TypeFromString(kOrientationNames, type_str, option);
   }
 
   static void Save(OrientationType option, base::DictionaryValue* dict) {
     dict->SetString(kKeyType, TypeToString(kOrientationNames, option));
   }
 };
 
 class CopiesTraits : public ItemsTraits<kOptionCopies> {
  public:
-  static bool IsValid(int32 option) { return option >= 1; }
+  static bool IsValid(int32_t option) { return option >= 1; }
 
-  static bool Load(const base::DictionaryValue& dict, int32* option) {
+  static bool Load(const base::DictionaryValue& dict, int32_t* option) {
     return dict.GetInteger(kOptionCopies, option);
   }
 
-  static void Save(int32 option, base::DictionaryValue* dict) {
+  static void Save(int32_t option, base::DictionaryValue* dict) {
     dict->SetInteger(kOptionCopies, option);
   }
 };
 
 class MarginsTraits : public NoValueValidation,
                       public ItemsTraits<kOptionMargins> {
  public:
   static bool Load(const base::DictionaryValue& dict, Margins* option) {
     std::string type_str;
     if (!dict.GetString(kKeyType, &type_str))
@@ skipping 171 matching lines @@
 template class BooleanCapability<class ReverseTraits>;
 
 template class TicketItem<PwgRasterConfig, PwgRasterConfigTraits>;
 template class TicketItem<Color, ColorTraits>;
 template class TicketItem<DuplexType, DuplexTraits>;
 template class TicketItem<OrientationType, OrientationTraits>;
 template class TicketItem<Margins, MarginsTraits>;
 template class TicketItem<Dpi, DpiTraits>;
 template class TicketItem<FitToPageType, FitToPageTraits>;
 template class TicketItem<Media, MediaTraits>;
-template class TicketItem<int32, CopiesTraits>;
+template class TicketItem<int32_t, CopiesTraits>;
 template class TicketItem<PageRange, PageRangeTraits>;
 template class TicketItem<bool, CollateTraits>;
 template class TicketItem<bool, ReverseTraits>;
 
 }  // namespace cloud_devices