Add compile time checks against longs being used in IPC structs on 32 bit Android.

ipc/ipc_message_utils.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 "ipc/ipc_message_utils.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/files/file_path.h"
@@ skipping 396 matching lines @@
 }
 
 void ParamTraits<int>::Log(const param_type& p, std::string* l) {
   l->append(base::IntToString(p));
 }
 
 void ParamTraits<unsigned int>::Log(const param_type& p, std::string* l) {
   l->append(base::UintToString(p));
 }
 
+#if defined(OS_WIN) || defined(ARCH_CPU_ARM64) || defined(OS_LINUX)
 void ParamTraits<long>::Log(const param_type& p, std::string* l) {
   l->append(base::Int64ToString(static_cast<int64_t>(p)));
 }
 
 void ParamTraits<unsigned long>::Log(const param_type& p, std::string* l) {
   l->append(base::Uint64ToString(static_cast<uint64_t>(p)));
 }
+#endif
 
 void ParamTraits<long long>::Log(const param_type& p, std::string* l) {
   l->append(base::Int64ToString(static_cast<int64_t>(p)));
 }
 
 void ParamTraits<unsigned long long>::Log(const param_type& p, std::string* l) {
   l->append(base::Uint64ToString(p));
 }
 
 void ParamTraits<float>::Log(const param_type& p, std::string* l) {
@@ skipping 249 matching lines @@
   switch (p.GetType()) {
     case base::SharedMemoryHandle::POSIX:
       ParamTraits<base::FileDescriptor>::Write(m, p.GetFileDescriptor());
       break;
     case base::SharedMemoryHandle::MACH:
       MachPortMac mach_port_mac(p.GetMemoryObject());
       ParamTraits<MachPortMac>::Write(m, mach_port_mac);
       size_t size = 0;
       bool result = p.GetSize(&size);
       DCHECK(result);
-      ParamTraits<size_t>::Write(m, size);
+      ParamTraits<uint32_t>::Write(m, static_cast<uint32_t>(size));
 
       // If the caller intended to pass ownership to the IPC stack, release a
       // reference.
       if (p.OwnershipPassesToIPC())
         p.Close();
 
       break;
   }
 }
 
@@ skipping 27 matching lines @@
 
       *r = base::SharedMemoryHandle(file_descriptor.fd,
                                     file_descriptor.auto_close);
       return true;
     }
     case base::SharedMemoryHandle::MACH: {
       MachPortMac mach_port_mac;
       if (!ParamTraits<MachPortMac>::Read(m, iter, &mach_port_mac))
         return false;
 
-      size_t size;
-      if (!ParamTraits<size_t>::Read(m, iter, &size))
+      uint32_t size;
+      if (!ParamTraits<uint32_t>::Read(m, iter, &size))
         return false;
 
-      *r = base::SharedMemoryHandle(mach_port_mac.get_mach_port(), size,
+      *r = base::SharedMemoryHandle(mach_port_mac.get_mach_port(),
+                                    static_cast<size_t>(size),
                                     base::GetCurrentProcId());
       return true;
     }
   }
 }
 
 void ParamTraits<base::SharedMemoryHandle>::Log(const param_type& p,
                                                 std::string* l) {
   switch (p.GetType()) {
     case base::SharedMemoryHandle::POSIX:
@@ skipping 456 matching lines @@
   return result;
 }
 
 void ParamTraits<MSG>::Log(const param_type& p, std::string* l) {
   l->append("<MSG>");
 }
 
 #endif  // OS_WIN
 
 }  // namespace IPC