Switch to standard integer types in tools/.

tools/ipc_fuzzer/fuzzer/fuzzer.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 <iostream>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "base/macros.h"
 #include "base/strings/string_util.h"
+#include "build/build_config.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_utils.h"
 #include "ipc/ipc_switches.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/ipc_sync_message.h"
 #include "tools/ipc_fuzzer/fuzzer/fuzzer.h"
 #include "tools/ipc_fuzzer/fuzzer/rand_util.h"
 #include "tools/ipc_fuzzer/message_lib/message_cracker.h"
 #include "tools/ipc_fuzzer/message_lib/message_file.h"
 
@@ skipping 93 matching lines @@
 struct FuzzTraits<unsigned long> {
   static bool Fuzz(unsigned long* p, Fuzzer* fuzzer) {
     fuzzer->FuzzLong(reinterpret_cast<long*>(p));
     return true;
   }
 };
 
 template <>
 struct FuzzTraits<long long> {
   static bool Fuzz(long long* p, Fuzzer* fuzzer) {
-    fuzzer->FuzzInt64(reinterpret_cast<int64*>(p));
+    fuzzer->FuzzInt64(reinterpret_cast<int64_t*>(p));
     return true;
   }
 };
 
 template <>
 struct FuzzTraits<unsigned long long> {
   static bool Fuzz(unsigned long long* p, Fuzzer* fuzzer) {
-    fuzzer->FuzzInt64(reinterpret_cast<int64*>(p));
+    fuzzer->FuzzInt64(reinterpret_cast<int64_t*>(p));
     return true;
   }
 };
 
 template <>
 struct FuzzTraits<short> {
   static bool Fuzz(short* p, Fuzzer* fuzzer) {
-    fuzzer->FuzzUInt16(reinterpret_cast<uint16*>(p));
+    fuzzer->FuzzUInt16(reinterpret_cast<uint16_t*>(p));
     return true;
   }
 };
 
 template <>
 struct FuzzTraits<unsigned short> {
   static bool Fuzz(unsigned short* p, Fuzzer* fuzzer) {
-    fuzzer->FuzzUInt16(reinterpret_cast<uint16*>(p));
+    fuzzer->FuzzUInt16(reinterpret_cast<uint16_t*>(p));
     return true;
   }
 };
 
 template <>
 struct FuzzTraits<char> {
   static bool Fuzz(char* p, Fuzzer* fuzzer) {
     fuzzer->FuzzUChar(reinterpret_cast<unsigned char*>(p));
     return true;
   }
@@ skipping 286 matching lines @@
     if (!FuzzParam(&is_null, fuzzer))
       return false;
     *p = base::NullableString16(string, is_null);
     return true;
   }
 };
 
 template <>
 struct FuzzTraits<base::Time> {
   static bool Fuzz(base::Time* p, Fuzzer* fuzzer) {
-    int64 internal_value = p->ToInternalValue();
+    int64_t internal_value = p->ToInternalValue();
     if (!FuzzParam(&internal_value, fuzzer))
       return false;
     *p = base::Time::FromInternalValue(internal_value);
     return true;
   }
 };
 
 template <>
 struct FuzzTraits<base::TimeDelta> {
   static bool Fuzz(base::TimeDelta* p, Fuzzer* fuzzer) {
-    int64 internal_value = p->ToInternalValue();
+    int64_t internal_value = p->ToInternalValue();
     if (!FuzzParam(&internal_value, fuzzer))
       return false;
     *p = base::TimeDelta::FromInternalValue(internal_value);
     return true;
   }
 };
 
 template <>
 struct FuzzTraits<base::TimeTicks> {
   static bool Fuzz(base::TimeTicks* p, Fuzzer* fuzzer) {
-    int64 internal_value = p->ToInternalValue();
+    int64_t internal_value = p->ToInternalValue();
     if (!FuzzParam(&internal_value, fuzzer))
       return false;
     *p = base::TimeTicks::FromInternalValue(internal_value);
     return true;
   }
 };
 
 template <>
 struct FuzzTraits<base::ListValue> {
   static bool Fuzz(base::ListValue* p, Fuzzer* fuzzer) {
@@ skipping 944 matching lines @@
            FuzzParam(&p->send_start, fuzzer) &&
            FuzzParam(&p->send_end, fuzzer) &&
            FuzzParam(&p->receive_headers_end, fuzzer);
   }
 };
 
 template <>
 struct FuzzTraits<net::HostPortPair> {
   static bool Fuzz(net::HostPortPair* p, Fuzzer* fuzzer) {
     std::string host = p->host();
-    uint16 port = p->port();
+    uint16_t port = p->port();
     if (!FuzzParam(&host, fuzzer))
       return false;
     if (!FuzzParam(&port, fuzzer))
       return false;
     p->set_host(host);
     p->set_port(port);
     return true;
   }
 };
 
@@ skipping 193 matching lines @@
       return false;
     *p = ppapi::PpapiPermissions(bits);
     return true;
   }
 };
 
 template <>
 struct FuzzTraits<ppapi::SocketOptionData> {
   static bool Fuzz(ppapi::SocketOptionData* p, Fuzzer* fuzzer) {
     // TODO(mbarbella): This can be improved.
-    int32 tmp;
+    int32_t tmp;
     p->GetInt32(&tmp);
     if (!FuzzParam(&tmp, fuzzer))
       return false;
     p->SetInt32(tmp);
     return true;
   }
 };
 
 template <>
 struct FuzzTraits<printing::PdfRenderSettings> {
@@ skipping 48 matching lines @@
         } else {
           char data[256];
           int data_len = RandInRange(sizeof(data));
           fuzzer->FuzzBytes(&data[0], data_len);
           p->SetToBytes(&data[0], data_len);
         }
         return true;
       }
       case storage::DataElement::Type::TYPE_FILE: {
         base::FilePath path;
-        uint64 offset;
-        uint64 length;
+        uint64_t offset;
+        uint64_t length;
         base::Time modification_time;
         if (!FuzzParam(&path, fuzzer))
           return false;
         if (!FuzzParam(&offset, fuzzer))
           return false;
         if (!FuzzParam(&length, fuzzer))
           return false;
         if (!FuzzParam(&modification_time, fuzzer))
           return false;
         p->SetToFilePathRange(path, offset, length, modification_time);
         return true;
       }
       case storage::DataElement::Type::TYPE_BLOB: {
         std::string uuid;
-        uint64 offset;
-        uint64 length;
+        uint64_t offset;
+        uint64_t length;
         if (!FuzzParam(&uuid, fuzzer))
           return false;
         if (!FuzzParam(&offset, fuzzer))
           return false;
         if (!FuzzParam(&length, fuzzer))
           return false;
         p->SetToBlobRange(uuid, offset, length);
         return true;
       }
       case storage::DataElement::Type::TYPE_FILE_FILESYSTEM: {
         GURL url;
-        uint64 offset;
-        uint64 length;
+        uint64_t offset;
+        uint64_t length;
         base::Time modification_time;
         if (!FuzzParam(&url, fuzzer))
           return false;
         if (!FuzzParam(&offset, fuzzer))
           return false;
         if (!FuzzParam(&length, fuzzer))
           return false;
         if (!FuzzParam(&modification_time, fuzzer))
           return false;
         p->SetToFileSystemUrlRange(url, offset, length, modification_time);
         return true;
       }
       default: {
         NOTREACHED();
         return false;
       }
     }
   }
 };
 
 template <>
 struct FuzzTraits<ui::LatencyInfo> {
   static bool Fuzz(ui::LatencyInfo* p, Fuzzer* fuzzer) {
     // TODO(inferno): Add param traits for |latency_components|.
-    int64 trace_id = p->trace_id();
+    int64_t trace_id = p->trace_id();
     bool terminated = p->terminated();
-    uint32 input_coordinates_size = static_cast<uint32>(
+    uint32_t input_coordinates_size = static_cast<uint32_t>(
         RandInRange(ui::LatencyInfo::kMaxInputCoordinates + 1));
     ui::LatencyInfo::InputCoordinate
         input_coordinates[ui::LatencyInfo::kMaxInputCoordinates];
-    uint32 event_timestamps_size = static_cast<uint32>(
+    uint32_t event_timestamps_size = static_cast<uint32_t>(
         RandInRange(ui::LatencyInfo::kMaxCoalescedEventTimestamps + 1));
     double event_timestamps[ui::LatencyInfo::kMaxCoalescedEventTimestamps];
     if (!FuzzParamArray(
         input_coordinates, input_coordinates_size, fuzzer))
       return false;
     if (!FuzzParamArray(event_timestamps, event_timestamps_size, fuzzer))
       return false;
     if (!FuzzParam(&trace_id, fuzzer))
       return false;
     if (!FuzzParam(&terminated, fuzzer))
@@ skipping 22 matching lines @@
       return false;
     return true;
   }
 };
 
 template <>
 struct FuzzTraits<url::Origin> {
   static bool Fuzz(url::Origin* p, Fuzzer* fuzzer) {
     std::string scheme = p->scheme();
     std::string host = p->host();
-    uint16 port = p->port();
+    uint16_t port = p->port();
     if (!FuzzParam(&scheme, fuzzer))
       return false;
     if (!FuzzParam(&host, fuzzer))
       return false;
     if (!FuzzParam(&port, fuzzer))
       return false;
     *p = url::Origin::UnsafelyCreateOriginWithoutNormalization(scheme, host,
                                                                port);
 
     // Force a unique origin 1% of the time:
@@ skipping 279 matching lines @@
 #undef IPC_MESSAGE_DECL
 #define IPC_MESSAGE_DECL(kind, type, name, in, out, ilist, olist) \
   function_vector->push_back(fuzzer_for_##name);
 #include "tools/ipc_fuzzer/message_lib/all_messages.h"
 }
 
 // Redefine macros to register fuzzing functions into map.
 #include "tools/ipc_fuzzer/message_lib/all_message_null_macros.h"
 #undef IPC_MESSAGE_DECL
 #define IPC_MESSAGE_DECL(kind, type, name, in, out, ilist, olist) \
-  (*map)[static_cast<uint32>(name::ID)] = fuzzer_for_##name;
+  (*map)[static_cast<uint32_t>(name::ID)] = fuzzer_for_##name;
 
 void PopulateFuzzerFunctionMap(FuzzerFunctionMap* map) {
 #include "tools/ipc_fuzzer/message_lib/all_messages.h"
 }
 
 }  // namespace ipc_fuzzer