The correct type for the size of a chunk of memory is size_t.

base/shared_memory_posix.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 "base/shared_memory.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
@@ skipping 80 matching lines @@
   return SharedMemoryHandle();
 }
 
 // static
 void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
   DCHECK_GE(handle.fd, 0);
   if (HANDLE_EINTR(close(handle.fd)) < 0)
     DPLOG(ERROR) << "close";
 }
 
-bool SharedMemory::CreateAndMapAnonymous(uint32 size) {
+bool SharedMemory::CreateAndMapAnonymous(size_t size) {
   return CreateAnonymous(size) && Map(size);
 }
 
 #if !defined(OS_ANDROID)
 // Chromium mostly only uses the unique/private shmem as specified by
 // "name == L"". The exception is in the StatsTable.
 // TODO(jrg): there is no way to "clean up" all unused named shmem if
 // we restart from a crash.  (That isn't a new problem, but it is a problem.)
 // In case we want to delete it later, it may be useful to save the value
 // of mem_filename after FilePathForMemoryName().
 bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
   DCHECK_EQ(-1, mapped_file_);
   if (options.size == 0) return false;
 
+  if (options.size > static_cast<size_t>(std::numeric_limits<int>::max()))
+    return false;
+
   // This function theoretically can block on the disk, but realistically
   // the temporary files we create will just go into the buffer cache
   // and be deleted before they ever make it out to disk.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   FILE *fp;
   bool fix_size = true;
 
   FilePath path;
   if (options.name == NULL || options.name->empty()) {
@@ skipping 20 matching lines @@
       fix_size = false;
     }
   }
   if (fp && fix_size) {
     // Get current size.
     struct stat stat;
     if (fstat(fileno(fp), &stat) != 0) {
       file_util::CloseFile(fp);
       return false;
     }
-    const uint32 current_size = stat.st_size;
+    const size_t current_size = stat.st_size;
     if (current_size != options.size) {
       if (HANDLE_EINTR(ftruncate(fileno(fp), options.size)) != 0) {
         file_util::CloseFile(fp);
         return false;
       }
       if (fseeko(fp, options.size, SEEK_SET) != 0) {
         file_util::CloseFile(fp);
         return false;
       }
     }
@@ skipping 42 matching lines @@
 
   read_only_ = read_only;
 
   const char *mode = read_only ? "r" : "r+";
   FILE *fp = file_util::OpenFile(path, mode);
   return PrepareMapFile(fp);
 }
 
 #endif  // !defined(OS_ANDROID)
 
-bool SharedMemory::Map(uint32 bytes) {
+bool SharedMemory::Map(size_t bytes) {
   if (mapped_file_ == -1)
     return false;
 
+  if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
+    return false;
+
 #if defined(OS_ANDROID)
   if (bytes == 0) {
     int ashmem_bytes = ashmem_get_size_region(mapped_file_);
     if (ashmem_bytes < 0)
       return false;
 
     DCHECK_GE(static_cast<uint32>(ashmem_bytes), bytes);
     // The caller wants to determine the map region size from ashmem.
     bytes = ashmem_bytes;
     // TODO(port): we set the created size here so that it is available in
@@ skipping 141 matching lines @@
   new_handle->fd = new_fd;
   new_handle->auto_close = true;
 
   if (close_self)
     Close();
 
   return true;
 }
 
 }  // namespace base