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

base/shared_memory.h

 // 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.
 
 #ifndef BASE_SHARED_MEMORY_H_
 #define BASE_SHARED_MEMORY_H_
 
 #include "build/build_config.h"
 
 #include <string>
@@ skipping 35 matching lines @@
 struct SharedMemoryCreateOptions {
   SharedMemoryCreateOptions() : name(NULL), size(0), open_existing(false),
                                 executable(false) {}
 
   // If NULL, the object is anonymous.  This pointer is owned by the caller
   // and must live through the call to Create().
   const std::string* name;
 
   // Size of the shared memory object to be created.
   // When opening an existing object, this has no effect.
-  uint32 size;
+  size_t size;
 
   // If true, and the shared memory already exists, Create() will open the
   // existing shared memory and ignore the size parameter.  If false,
   // shared memory must not exist.  This flag is meaningless unless name is
   // non-NULL.
   bool open_existing;
 
   // If true, mappings might need to be made executable later.
   bool executable;
 };
@@ skipping 33 matching lines @@
 
   // Closes a shared memory handle.
   static void CloseHandle(const SharedMemoryHandle& handle);
 
   // Creates a shared memory object as described by the options struct.
   // Returns true on success and false on failure.
   bool Create(const SharedMemoryCreateOptions& options);
 
   // Creates and maps an anonymous shared memory segment of size size.
   // Returns true on success and false on failure.
-  bool CreateAndMapAnonymous(uint32 size);
+  bool CreateAndMapAnonymous(size_t size);
 
   // Creates an anonymous shared memory segment of size size.
   // Returns true on success and false on failure.
-  bool CreateAnonymous(uint32 size) {
+  bool CreateAnonymous(size_t size) {
     SharedMemoryCreateOptions options;
     options.size = size;
     return Create(options);
   }
 
   // Creates or opens a shared memory segment based on a name.
   // If open_existing is true, and the shared memory already exists,
   // opens the existing shared memory and ignores the size parameter.
   // If open_existing is false, shared memory must not exist.
   // size is the size of the block to be created.
   // Returns true on success, false on failure.
-  bool CreateNamed(const std::string& name, bool open_existing, uint32 size) {
+  bool CreateNamed(const std::string& name, bool open_existing, size_t size) {
     SharedMemoryCreateOptions options;
     options.name = &name;
     options.open_existing = open_existing;
     options.size = size;
     return Create(options);
   }
 
   // Deletes resources associated with a shared memory segment based on name.
   // Not all platforms require this call.
   bool Delete(const std::string& name);
 
   // Opens a shared memory segment based on a name.
   // If read_only is true, opens for read-only access.
   // Returns true on success, false on failure.
   bool Open(const std::string& name, bool read_only);
 
   // Maps the shared memory into the caller's address space.
   // Returns true on success, false otherwise.  The memory address
   // is accessed via the memory() accessor.  The mapped address is guaranteed to
   // have an alignment of at least MAP_MINIMUM_ALIGNMENT.
-  bool Map(uint32 bytes);
+  bool Map(size_t bytes);
   enum { MAP_MINIMUM_ALIGNMENT = 32 };
 
   // Unmaps the shared memory from the caller's address space.
   // Returns true if successful; returns false on error or if the
   // memory is not mapped.
   bool Unmap();
 
   // Get the size of the shared memory backing file.
   // Note:  This size is only available to the creator of the
   // shared memory, and not to those that opened shared memory
   // created externally.
   // Returns 0 if not created or unknown.
   // Deprecated method, please keep track of the size yourself if you created
   // it.
   // http://crbug.com/60821
-  uint32 created_size() const { return created_size_; }
+  size_t created_size() const { return created_size_; }
 
   // Gets a pointer to the opened memory space if it has been
   // Mapped via Map().  Returns NULL if it is not mapped.
   void *memory() const { return memory_; }
 
   // Returns the underlying OS handle for this segment.
   // Use of this handle for anything other than an opaque
   // identifier is not portable.
   SharedMemoryHandle handle() const;
 
@@ skipping 58 matching lines @@
 #endif
   bool ShareToProcessCommon(ProcessHandle process,
                             SharedMemoryHandle* new_handle,
                             bool close_self);
 
 #if defined(OS_WIN)
   std::wstring       name_;
   HANDLE             mapped_file_;
 #elif defined(OS_POSIX)
   int                mapped_file_;
-  uint32             mapped_size_;
+  size_t             mapped_size_;
   ino_t              inode_;
 #endif
   void*              memory_;
   bool               read_only_;
-  uint32             created_size_;
+  size_t             created_size_;
 #if !defined(OS_POSIX)
   SharedMemoryLock   lock_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(SharedMemory);
 };
 
 // A helper class that acquires the shared memory lock while
 // the SharedMemoryAutoLock is in scope.
 class SharedMemoryAutoLock {
  public:
   explicit SharedMemoryAutoLock(SharedMemory* shared_memory)
       : shared_memory_(shared_memory) {
     shared_memory_->Lock();
   }
 
   ~SharedMemoryAutoLock() {
     shared_memory_->Unlock();
   }
 
  private:
   SharedMemory* shared_memory_;
   DISALLOW_COPY_AND_ASSIGN(SharedMemoryAutoLock);
 };
 
 }  // namespace base
 
 #endif  // BASE_SHARED_MEMORY_H_